@alexlit/lint-kit 166.0.1 → 167.0.0

package/packages/config-eslint/node_modules/eslint/lib/rules/no-nonoctal-decimal-escape.js

@@ -1,176 +0,0 @@
-/**
- * @fileoverview Rule to disallow `\8` and `\9` escape sequences in string literals.
- * @author Milos Djermanovic
- */
-
-"use strict";
-
-//------------------------------------------------------------------------------
-// Typedefs
-//------------------------------------------------------------------------------
-
-/**
- * @import { SourceRange } from "@eslint/core";
- */
-
-//------------------------------------------------------------------------------
-// Helpers
-//------------------------------------------------------------------------------
-
-const QUICK_TEST_REGEX = /\\[89]/u;
-
-/**
- * Returns unicode escape sequence that represents the given character.
- * @param {string} character A single code unit.
- * @returns {string} "\uXXXX" sequence.
- */
-function getUnicodeEscape(character) {
-	return `\\u${character.charCodeAt(0).toString(16).padStart(4, "0")}`;
-}
-
-//------------------------------------------------------------------------------
-// Rule Definition
-//------------------------------------------------------------------------------
-
-/** @type {import('../types').Rule.RuleModule} */
-module.exports = {
-	meta: {
-		type: "suggestion",
-
-		docs: {
-			description:
-				"Disallow `\\8` and `\\9` escape sequences in string literals",
-			recommended: true,
-			url: "https://eslint.org/docs/latest/rules/no-nonoctal-decimal-escape",
-		},
-
-		hasSuggestions: true,
-
-		schema: [],
-
-		messages: {
-			decimalEscape: "Don't use '{{decimalEscape}}' escape sequence.",
-
-			// suggestions
-			refactor:
-				"Replace '{{original}}' with '{{replacement}}'. This maintains the current functionality.",
-			escapeBackslash:
-				"Replace '{{original}}' with '{{replacement}}' to include the actual backslash character.",
-		},
-	},
-
-	create(context) {
-		const sourceCode = context.sourceCode;
-
-		/**
-		 * Creates a new Suggestion object.
-		 * @param {string} messageId "refactor" or "escapeBackslash".
-		 * @param {SourceRange} range The range to replace.
-		 * @param {string} replacement New text for the range.
-		 * @returns {Object} Suggestion
-		 */
-		function createSuggestion(messageId, range, replacement) {
-			return {
-				messageId,
-				data: {
-					original: sourceCode.getText().slice(...range),
-					replacement,
-				},
-				fix(fixer) {
-					return fixer.replaceTextRange(range, replacement);
-				},
-			};
-		}
-
-		return {
-			Literal(node) {
-				if (typeof node.value !== "string") {
-					return;
-				}
-
-				if (!QUICK_TEST_REGEX.test(node.raw)) {
-					return;
-				}
-
-				const regex =
-					/(?:[^\\]|(?<previousEscape>\\.))*?(?<decimalEscape>\\[89])/suy;
-				let match;
-
-				while ((match = regex.exec(node.raw))) {
-					const { previousEscape, decimalEscape } = match.groups;
-					const decimalEscapeRangeEnd =
-						node.range[0] + match.index + match[0].length;
-					const decimalEscapeRangeStart =
-						decimalEscapeRangeEnd - decimalEscape.length;
-					const decimalEscapeRange = [
-						decimalEscapeRangeStart,
-						decimalEscapeRangeEnd,
-					];
-					const suggest = [];
-
-					// When `regex` is matched, `previousEscape` can only capture characters adjacent to `decimalEscape`
-					if (previousEscape === "\\0") {
-						/*
-						 * Now we have a NULL escape "\0" immediately followed by a decimal escape, e.g.: "\0\8".
-						 * Fixing this to "\08" would turn "\0" into a legacy octal escape. To avoid producing
-						 * an octal escape while fixing a decimal escape, we provide different suggestions.
-						 */
-						suggest.push(
-							createSuggestion(
-								// "\0\8" -> "\u00008"
-								"refactor",
-								[
-									decimalEscapeRangeStart -
-										previousEscape.length,
-									decimalEscapeRangeEnd,
-								],
-								`${getUnicodeEscape("\0")}${decimalEscape[1]}`,
-							),
-							createSuggestion(
-								// "\8" -> "\u0038"
-								"refactor",
-								decimalEscapeRange,
-								getUnicodeEscape(decimalEscape[1]),
-							),
-						);
-					} else {
-						suggest.push(
-							createSuggestion(
-								// "\8" -> "8"
-								"refactor",
-								decimalEscapeRange,
-								decimalEscape[1],
-							),
-						);
-					}
-
-					suggest.push(
-						createSuggestion(
-							// "\8" -> "\\8"
-							"escapeBackslash",
-							decimalEscapeRange,
-							`\\${decimalEscape}`,
-						),
-					);
-
-					context.report({
-						node,
-						loc: {
-							start: sourceCode.getLocFromIndex(
-								decimalEscapeRangeStart,
-							),
-							end: sourceCode.getLocFromIndex(
-								decimalEscapeRangeEnd,
-							),
-						},
-						messageId: "decimalEscape",
-						data: {
-							decimalEscape,
-						},
-						suggest,
-					});
-				}
-			},
-		};
-	},
-};

package/packages/config-eslint/node_modules/eslint/lib/rules/no-obj-calls.js

@@ -1,99 +0,0 @@
-/**
- * @fileoverview Rule to flag use of an object property of the global object (Math and JSON) as a function
- * @author James Allardice
- */
-
-"use strict";
-
-//------------------------------------------------------------------------------
-// Requirements
-//------------------------------------------------------------------------------
-
-const {
-	CALL,
-	CONSTRUCT,
-	ReferenceTracker,
-} = require("@eslint-community/eslint-utils");
-const getPropertyName = require("./utils/ast-utils").getStaticPropertyName;
-
-//------------------------------------------------------------------------------
-// Helpers
-//------------------------------------------------------------------------------
-
-const nonCallableGlobals = ["Atomics", "JSON", "Math", "Reflect", "Intl"];
-
-/**
- * Returns the name of the node to report
- * @param {ASTNode} node A node to report
- * @returns {string} name to report
- */
-function getReportNodeName(node) {
-	if (node.type === "ChainExpression") {
-		return getReportNodeName(node.expression);
-	}
-	if (node.type === "MemberExpression") {
-		return getPropertyName(node);
-	}
-	return node.name;
-}
-
-//------------------------------------------------------------------------------
-// Rule Definition
-//------------------------------------------------------------------------------
-
-/** @type {import('../types').Rule.RuleModule} */
-module.exports = {
-	meta: {
-		type: "problem",
-
-		docs: {
-			description:
-				"Disallow calling global object properties as functions",
-			recommended: true,
-			url: "https://eslint.org/docs/latest/rules/no-obj-calls",
-		},
-
-		schema: [],
-
-		messages: {
-			unexpectedCall: "'{{name}}' is not a function.",
-			unexpectedRefCall:
-				"'{{name}}' is reference to '{{ref}}', which is not a function.",
-		},
-	},
-
-	create(context) {
-		const sourceCode = context.sourceCode;
-
-		return {
-			Program(node) {
-				const scope = sourceCode.getScope(node);
-				const tracker = new ReferenceTracker(scope);
-				const traceMap = {};
-
-				for (const g of nonCallableGlobals) {
-					traceMap[g] = {
-						[CALL]: true,
-						[CONSTRUCT]: true,
-					};
-				}
-
-				for (const {
-					node: refNode,
-					path,
-				} of tracker.iterateGlobalReferences(traceMap)) {
-					const name = getReportNodeName(refNode.callee);
-					const ref = path[0];
-					const messageId =
-						name === ref ? "unexpectedCall" : "unexpectedRefCall";
-
-					context.report({
-						node: refNode,
-						messageId,
-						data: { name, ref },
-					});
-				}
-			},
-		};
-	},
-};

package/packages/config-eslint/node_modules/eslint/lib/rules/no-object-constructor.js

@@ -1,124 +0,0 @@
-/**
- * @fileoverview Rule to disallow calls to the `Object` constructor without an argument
- * @author Francesco Trotta
- */
-
-"use strict";
-
-//------------------------------------------------------------------------------
-// Requirements
-//------------------------------------------------------------------------------
-
-const {
-	getVariableByName,
-	isArrowToken,
-	isStartOfExpressionStatement,
-	needsPrecedingSemicolon,
-} = require("./utils/ast-utils");
-
-//------------------------------------------------------------------------------
-// Rule Definition
-//------------------------------------------------------------------------------
-
-/** @type {import('../types').Rule.RuleModule} */
-module.exports = {
-	meta: {
-		type: "suggestion",
-
-		docs: {
-			description:
-				"Disallow calls to the `Object` constructor without an argument",
-			recommended: false,
-			url: "https://eslint.org/docs/latest/rules/no-object-constructor",
-		},
-
-		hasSuggestions: true,
-
-		schema: [],
-
-		messages: {
-			preferLiteral: "The object literal notation {} is preferable.",
-			useLiteral: "Replace with '{{replacement}}'.",
-			useLiteralAfterSemicolon:
-				"Replace with '{{replacement}}', add preceding semicolon.",
-		},
-	},
-
-	create(context) {
-		const sourceCode = context.sourceCode;
-
-		/**
-		 * Determines whether or not an object literal that replaces a specified node needs to be enclosed in parentheses.
-		 * @param {ASTNode} node The node to be replaced.
-		 * @returns {boolean} Whether or not parentheses around the object literal are required.
-		 */
-		function needsParentheses(node) {
-			if (isStartOfExpressionStatement(node)) {
-				return true;
-			}
-
-			const prevToken = sourceCode.getTokenBefore(node);
-
-			if (prevToken && isArrowToken(prevToken)) {
-				return true;
-			}
-
-			return false;
-		}
-
-		/**
-		 * Reports on nodes where the `Object` constructor is called without arguments.
-		 * @param {ASTNode} node The node to evaluate.
-		 * @returns {void}
-		 */
-		function check(node) {
-			if (
-				node.callee.type !== "Identifier" ||
-				node.callee.name !== "Object" ||
-				node.arguments.length
-			) {
-				return;
-			}
-
-			const variable = getVariableByName(
-				sourceCode.getScope(node),
-				"Object",
-			);
-
-			if (variable && variable.identifiers.length === 0) {
-				let replacement;
-				let fixText;
-				let messageId = "useLiteral";
-
-				if (needsParentheses(node)) {
-					replacement = "({})";
-					if (needsPrecedingSemicolon(sourceCode, node)) {
-						fixText = ";({})";
-						messageId = "useLiteralAfterSemicolon";
-					} else {
-						fixText = "({})";
-					}
-				} else {
-					replacement = fixText = "{}";
-				}
-
-				context.report({
-					node,
-					messageId: "preferLiteral",
-					suggest: [
-						{
-							messageId,
-							data: { replacement },
-							fix: fixer => fixer.replaceText(node, fixText),
-						},
-					],
-				});
-			}
-		}
-
-		return {
-			CallExpression: check,
-			NewExpression: check,
-		};
-	},
-};

package/packages/config-eslint/node_modules/eslint/lib/rules/no-octal-escape.js

@@ -1,53 +0,0 @@
-/**
- * @fileoverview Rule to flag octal escape sequences in string literals.
- * @author Ian Christian Myers
- */
-
-"use strict";
-
-//------------------------------------------------------------------------------
-// Rule Definition
-//------------------------------------------------------------------------------
-
-/** @type {import('../types').Rule.RuleModule} */
-module.exports = {
-	meta: {
-		type: "suggestion",
-
-		docs: {
-			description: "Disallow octal escape sequences in string literals",
-			recommended: false,
-			url: "https://eslint.org/docs/latest/rules/no-octal-escape",
-		},
-
-		schema: [],
-
-		messages: {
-			octalEscapeSequence:
-				"Don't use octal: '\\{{sequence}}'. Use '\\u....' instead.",
-		},
-	},
-
-	create(context) {
-		return {
-			Literal(node) {
-				if (typeof node.value !== "string") {
-					return;
-				}
-
-				// \0 represents a valid NULL character if it isn't followed by a digit.
-				const match = node.raw.match(
-					/^(?:[^\\]|\\.)*?\\([0-3][0-7]{1,2}|[4-7][0-7]|0(?=[89])|[1-7])/su,
-				);
-
-				if (match) {
-					context.report({
-						node,
-						messageId: "octalEscapeSequence",
-						data: { sequence: match[1] },
-					});
-				}
-			},
-		};
-	},
-};

package/packages/config-eslint/node_modules/eslint/lib/rules/no-octal.js

@@ -1,42 +0,0 @@
-/**
- * @fileoverview Rule to flag when initializing octal literal
- * @author Ilya Volodin
- */
-
-"use strict";
-
-//------------------------------------------------------------------------------
-// Rule Definition
-//------------------------------------------------------------------------------
-
-/** @type {import('../types').Rule.RuleModule} */
-module.exports = {
-	meta: {
-		type: "suggestion",
-
-		docs: {
-			description: "Disallow octal literals",
-			recommended: true,
-			url: "https://eslint.org/docs/latest/rules/no-octal",
-		},
-
-		schema: [],
-
-		messages: {
-			noOctal: "Octal literals should not be used.",
-		},
-	},
-
-	create(context) {
-		return {
-			Literal(node) {
-				if (typeof node.value === "number" && /^0\d/u.test(node.raw)) {
-					context.report({
-						node,
-						messageId: "noOctal",
-					});
-				}
-			},
-		};
-	},
-};