Current File : /home/vacivi36/SiteVacivitta/vacivitta/node_modules/eslint/lib/rules/quotes.js
/**
* @fileoverview A rule to choose between single and double quote marks
* @author Matt DuVall <http://www.mattduvall.com/>, Brandon Payton
* @deprecated in ESLint v8.53.0
*/
"use strict";
//------------------------------------------------------------------------------
// Requirements
//------------------------------------------------------------------------------
const astUtils = require("./utils/ast-utils");
//------------------------------------------------------------------------------
// Constants
//------------------------------------------------------------------------------
const QUOTE_SETTINGS = {
double: {
quote: '"',
alternateQuote: "'",
description: "doublequote",
},
single: {
quote: "'",
alternateQuote: '"',
description: "singlequote",
},
backtick: {
quote: "`",
alternateQuote: '"',
description: "backtick",
},
};
// An unescaped newline is a newline preceded by an even number of backslashes.
const UNESCAPED_LINEBREAK_PATTERN = new RegExp(
String.raw`(^|[^\\])(\\\\)*[${Array.from(astUtils.LINEBREAKS).join("")}]`,
"u",
);
/**
* Switches quoting of javascript string between ' " and `
* escaping and unescaping as necessary.
* Only escaping of the minimal set of characters is changed.
* Note: escaping of newlines when switching from backtick to other quotes is not handled.
* @param {string} str A string to convert.
* @returns {string} The string with changed quotes.
* @private
*/
QUOTE_SETTINGS.double.convert =
QUOTE_SETTINGS.single.convert =
QUOTE_SETTINGS.backtick.convert =
function (str) {
const newQuote = this.quote;
const oldQuote = str[0];
if (newQuote === oldQuote) {
return str;
}
return (
newQuote +
str
.slice(1, -1)
.replace(
/\\(\$\{|\r\n?|\n|.)|["'`]|\$\{|(\r\n?|\n)/gu,
(match, escaped, newline) => {
if (
escaped === oldQuote ||
(oldQuote === "`" && escaped === "${")
) {
return escaped; // unescape
}
if (
match === newQuote ||
(newQuote === "`" && match === "${")
) {
return `\\${match}`; // escape
}
if (newline && oldQuote === "`") {
return "\\n"; // escape newlines
}
return match;
},
) +
newQuote
);
};
const AVOID_ESCAPE = "avoid-escape";
//------------------------------------------------------------------------------
// Rule Definition
//------------------------------------------------------------------------------
/** @type {import('../types').Rule.RuleModule} */
module.exports = {
meta: {
deprecated: {
message: "Formatting rules are being moved out of ESLint core.",
url: "https://eslint.org/blog/2023/10/deprecating-formatting-rules/",
deprecatedSince: "8.53.0",
availableUntil: "10.0.0",
replacedBy: [
{
message:
"ESLint Stylistic now maintains deprecated stylistic core rules.",
url: "https://eslint.style/guide/migration",
plugin: {
name: "@stylistic/eslint-plugin-js",
url: "https://eslint.style/packages/js",
},
rule: {
name: "quotes",
url: "https://eslint.style/rules/js/quotes",
},
},
],
},
type: "layout",
docs: {
description:
"Enforce the consistent use of either backticks, double, or single quotes",
recommended: false,
url: "https://eslint.org/docs/latest/rules/quotes",
},
fixable: "code",
schema: [
{
enum: ["single", "double", "backtick"],
},
{
anyOf: [
{
enum: ["avoid-escape"],
},
{
type: "object",
properties: {
avoidEscape: {
type: "boolean",
},
allowTemplateLiterals: {
type: "boolean",
},
},
additionalProperties: false,
},
],
},
],
messages: {
wrongQuotes: "Strings must use {{description}}.",
},
},
create(context) {
const quoteOption = context.options[0],
settings = QUOTE_SETTINGS[quoteOption || "double"],
options = context.options[1],
allowTemplateLiterals =
options && options.allowTemplateLiterals === true,
sourceCode = context.sourceCode;
let avoidEscape = options && options.avoidEscape === true;
// deprecated
if (options === AVOID_ESCAPE) {
avoidEscape = true;
}
/**
* Determines if a given node is part of JSX syntax.
*
* This function returns `true` in the following cases:
*
* - `<div className="foo"></div>` ... If the literal is an attribute value, the parent of the literal is `JSXAttribute`.
* - `<div>foo</div>` ... If the literal is a text content, the parent of the literal is `JSXElement`.
* - `<>foo</>` ... If the literal is a text content, the parent of the literal is `JSXFragment`.
*
* In particular, this function returns `false` in the following cases:
*
* - `<div className={"foo"}></div>`
* - `<div>{"foo"}</div>`
*
* In both cases, inside of the braces is handled as normal JavaScript.
* The braces are `JSXExpressionContainer` nodes.
* @param {ASTNode} node The Literal node to check.
* @returns {boolean} True if the node is a part of JSX, false if not.
* @private
*/
function isJSXLiteral(node) {
return (
node.parent.type === "JSXAttribute" ||
node.parent.type === "JSXElement" ||
node.parent.type === "JSXFragment"
);
}
/**
* Checks whether or not a given node is a directive.
* The directive is a `ExpressionStatement` which has only a string literal not surrounded by
* parentheses.
* @param {ASTNode} node A node to check.
* @returns {boolean} Whether or not the node is a directive.
* @private
*/
function isDirective(node) {
return (
node.type === "ExpressionStatement" &&
node.expression.type === "Literal" &&
typeof node.expression.value === "string" &&
!astUtils.isParenthesised(sourceCode, node.expression)
);
}
/**
* Checks whether a specified node is either part of, or immediately follows a (possibly empty) directive prologue.
* @see {@link http://www.ecma-international.org/ecma-262/6.0/#sec-directive-prologues-and-the-use-strict-directive}
* @param {ASTNode} node A node to check.
* @returns {boolean} Whether a specified node is either part of, or immediately follows a (possibly empty) directive prologue.
* @private
*/
function isExpressionInOrJustAfterDirectivePrologue(node) {
if (!astUtils.isTopLevelExpressionStatement(node.parent)) {
return false;
}
const block = node.parent.parent;
// Check the node is at a prologue.
for (let i = 0; i < block.body.length; ++i) {
const statement = block.body[i];
if (statement === node.parent) {
return true;
}
if (!isDirective(statement)) {
break;
}
}
return false;
}
/**
* Checks whether or not a given node is allowed as non backtick.
* @param {ASTNode} node A node to check.
* @returns {boolean} Whether or not the node is allowed as non backtick.
* @private
*/
function isAllowedAsNonBacktick(node) {
const parent = node.parent;
switch (parent.type) {
// Directive Prologues.
case "ExpressionStatement":
return (
!astUtils.isParenthesised(sourceCode, node) &&
isExpressionInOrJustAfterDirectivePrologue(node)
);
// LiteralPropertyName.
case "Property":
case "PropertyDefinition":
case "MethodDefinition":
return parent.key === node && !parent.computed;
// ModuleSpecifier.
case "ImportDeclaration":
case "ExportNamedDeclaration":
return parent.source === node;
// ModuleExportName or ModuleSpecifier.
case "ExportAllDeclaration":
return parent.exported === node || parent.source === node;
// ModuleExportName.
case "ImportSpecifier":
return parent.imported === node;
// ModuleExportName.
case "ExportSpecifier":
return parent.local === node || parent.exported === node;
// Others don't allow.
default:
return false;
}
}
/**
* Checks whether or not a given TemplateLiteral node is actually using any of the special features provided by template literal strings.
* @param {ASTNode} node A TemplateLiteral node to check.
* @returns {boolean} Whether or not the TemplateLiteral node is using any of the special features provided by template literal strings.
* @private
*/
function isUsingFeatureOfTemplateLiteral(node) {
const hasTag =
node.parent.type === "TaggedTemplateExpression" &&
node === node.parent.quasi;
if (hasTag) {
return true;
}
const hasStringInterpolation = node.expressions.length > 0;
if (hasStringInterpolation) {
return true;
}
const isMultilineString =
node.quasis.length >= 1 &&
UNESCAPED_LINEBREAK_PATTERN.test(node.quasis[0].value.raw);
if (isMultilineString) {
return true;
}
return false;
}
return {
Literal(node) {
const val = node.value,
rawVal = node.raw;
if (settings && typeof val === "string") {
let isValid =
(quoteOption === "backtick" &&
isAllowedAsNonBacktick(node)) ||
isJSXLiteral(node) ||
astUtils.isSurroundedBy(rawVal, settings.quote);
if (!isValid && avoidEscape) {
isValid =
astUtils.isSurroundedBy(
rawVal,
settings.alternateQuote,
) && rawVal.includes(settings.quote);
}
if (!isValid) {
context.report({
node,
messageId: "wrongQuotes",
data: {
description: settings.description,
},
fix(fixer) {
if (
quoteOption === "backtick" &&
astUtils.hasOctalOrNonOctalDecimalEscapeSequence(
rawVal,
)
) {
/*
* An octal or non-octal decimal escape sequence in a template literal would
* produce syntax error, even in non-strict mode.
*/
return null;
}
return fixer.replaceText(
node,
settings.convert(node.raw),
);
},
});
}
}
},
TemplateLiteral(node) {
// Don't throw an error if backticks are expected or a template literal feature is in use.
if (
allowTemplateLiterals ||
quoteOption === "backtick" ||
isUsingFeatureOfTemplateLiteral(node)
) {
return;
}
context.report({
node,
messageId: "wrongQuotes",
data: {
description: settings.description,
},
fix(fixer) {
if (
astUtils.isTopLevelExpressionStatement(
node.parent,
) &&
!astUtils.isParenthesised(sourceCode, node)
) {
/*
* TemplateLiterals aren't actually directives, but fixing them might turn
* them into directives and change the behavior of the code.
*/
return null;
}
return fixer.replaceText(
node,
settings.convert(sourceCode.getText(node)),
);
},
});
},
};
},
};
Mini Shell