@alexlit/lint-kit 164.15.0 → 165.1.0

package/packages/config-eslint/node_modules/eslint/lib/rules/no-this-before-super.js

@@ -0,0 +1,365 @@
+/**
+ * @fileoverview A rule to disallow using `this`/`super` before `super()`.
+ * @author Toru Nagashima
+ */
+
+"use strict";
+
+//------------------------------------------------------------------------------
+// Requirements
+//------------------------------------------------------------------------------
+
+const astUtils = require("./utils/ast-utils");
+
+//------------------------------------------------------------------------------
+// Helpers
+//------------------------------------------------------------------------------
+
+/**
+ * Checks whether or not a given node is a constructor.
+ * @param {ASTNode} node A node to check. This node type is one of
+ *   `Program`, `FunctionDeclaration`, `FunctionExpression`, and
+ *   `ArrowFunctionExpression`.
+ * @returns {boolean} `true` if the node is a constructor.
+ */
+function isConstructorFunction(node) {
+	return (
+		node.type === "FunctionExpression" &&
+		node.parent.type === "MethodDefinition" &&
+		node.parent.kind === "constructor"
+	);
+}
+
+/*
+ * Information for each code path segment.
+ * - superCalled:  The flag which shows `super()` called in all code paths.
+ * - invalidNodes: The array of invalid ThisExpression and Super nodes.
+ */
+/**
+ *
+ */
+class SegmentInfo {
+	/**
+	 * Indicates whether `super()` is called in all code paths.
+	 * @type {boolean}
+	 */
+	superCalled = false;
+
+	/**
+	 * The array of invalid ThisExpression and Super nodes.
+	 * @type {ASTNode[]}
+	 */
+	invalidNodes = [];
+}
+
+//------------------------------------------------------------------------------
+// Rule Definition
+//------------------------------------------------------------------------------
+
+/** @type {import('../types').Rule.RuleModule} */
+module.exports = {
+	meta: {
+		type: "problem",
+
+		docs: {
+			description:
+				"Disallow `this`/`super` before calling `super()` in constructors",
+			recommended: true,
+			url: "https://eslint.org/docs/latest/rules/no-this-before-super",
+		},
+
+		schema: [],
+
+		messages: {
+			noBeforeSuper: "'{{kind}}' is not allowed before 'super()'.",
+		},
+	},
+
+	create(context) {
+		/*
+		 * Information for each constructor.
+		 * - upper:      Information of the upper constructor.
+		 * - hasExtends: A flag which shows whether the owner class has a valid
+		 *   `extends` part.
+		 * - scope:      The scope of the owner class.
+		 * - codePath:   The code path of this constructor.
+		 */
+		let funcInfo = null;
+
+		/** @type {Record<string, SegmentInfo>} */
+		let segInfoMap = Object.create(null);
+
+		/**
+		 * Gets whether or not `super()` is called in a given code path segment.
+		 * @param {CodePathSegment} segment A code path segment to get.
+		 * @returns {boolean} `true` if `super()` is called.
+		 */
+		function isCalled(segment) {
+			return !segment.reachable || segInfoMap[segment.id]?.superCalled;
+		}
+
+		/**
+		 * Checks whether or not this is in a constructor.
+		 * @returns {boolean} `true` if this is in a constructor.
+		 */
+		function isInConstructorOfDerivedClass() {
+			return Boolean(
+				funcInfo && funcInfo.isConstructor && funcInfo.hasExtends,
+			);
+		}
+
+		/**
+		 * Determines if every segment in a set has been called.
+		 * @param {Set<CodePathSegment>} segments The segments to search.
+		 * @returns {boolean} True if every segment has been called; false otherwise.
+		 */
+		function isEverySegmentCalled(segments) {
+			for (const segment of segments) {
+				if (!isCalled(segment)) {
+					return false;
+				}
+			}
+
+			return true;
+		}
+
+		/**
+		 * Checks whether or not this is before `super()` is called.
+		 * @returns {boolean} `true` if this is before `super()` is called.
+		 */
+		function isBeforeCallOfSuper() {
+			return (
+				isInConstructorOfDerivedClass() &&
+				!isEverySegmentCalled(funcInfo.currentSegments)
+			);
+		}
+
+		/**
+		 * Sets a given node as invalid.
+		 * @param {ASTNode} node A node to set as invalid. This is one of
+		 *      a ThisExpression and a Super.
+		 * @returns {void}
+		 */
+		function setInvalid(node) {
+			const segments = funcInfo.currentSegments;
+
+			for (const segment of segments) {
+				if (segment.reachable) {
+					segInfoMap[segment.id].invalidNodes.push(node);
+				}
+			}
+		}
+
+		/**
+		 * Sets the current segment as `super` was called.
+		 * @returns {void}
+		 */
+		function setSuperCalled() {
+			const segments = funcInfo.currentSegments;
+
+			for (const segment of segments) {
+				if (segment.reachable) {
+					segInfoMap[segment.id].superCalled = true;
+				}
+			}
+		}
+
+		return {
+			/**
+			 * Adds information of a constructor into the stack.
+			 * @param {CodePath} codePath A code path which was started.
+			 * @param {ASTNode} node The current node.
+			 * @returns {void}
+			 */
+			onCodePathStart(codePath, node) {
+				if (isConstructorFunction(node)) {
+					// Class > ClassBody > MethodDefinition > FunctionExpression
+					const classNode = node.parent.parent.parent;
+
+					funcInfo = {
+						upper: funcInfo,
+						isConstructor: true,
+						hasExtends: Boolean(
+							classNode.superClass &&
+								!astUtils.isNullOrUndefined(
+									classNode.superClass,
+								),
+						),
+						codePath,
+						currentSegments: new Set(),
+					};
+				} else {
+					funcInfo = {
+						upper: funcInfo,
+						isConstructor: false,
+						hasExtends: false,
+						codePath,
+						currentSegments: new Set(),
+					};
+				}
+			},
+
+			/**
+			 * Removes the top of stack item.
+			 *
+			 * And this traverses all segments of this code path then reports every
+			 * invalid node.
+			 * @param {CodePath} codePath A code path which was ended.
+			 * @returns {void}
+			 */
+			onCodePathEnd(codePath) {
+				const isDerivedClass = funcInfo.hasExtends;
+
+				funcInfo = funcInfo.upper;
+				if (!isDerivedClass) {
+					return;
+				}
+
+				/**
+				 * A collection of nodes to avoid duplicate reports.
+				 * @type {Set<ASTNode>}
+				 */
+				const reported = new Set();
+
+				codePath.traverseSegments((segment, controller) => {
+					const info = segInfoMap[segment.id];
+					const invalidNodes = info.invalidNodes.filter(
+						/*
+						 * Avoid duplicate reports.
+						 * When there is a `finally`, invalidNodes may contain already reported node.
+						 */
+						node => !reported.has(node),
+					);
+
+					for (const invalidNode of invalidNodes) {
+						reported.add(invalidNode);
+
+						context.report({
+							messageId: "noBeforeSuper",
+							node: invalidNode,
+							data: {
+								kind:
+									invalidNode.type === "Super"
+										? "super"
+										: "this",
+							},
+						});
+					}
+
+					if (info.superCalled) {
+						controller.skip();
+					}
+				});
+			},
+
+			/**
+			 * Initialize information of a given code path segment.
+			 * @param {CodePathSegment} segment A code path segment to initialize.
+			 * @returns {void}
+			 */
+			onCodePathSegmentStart(segment) {
+				funcInfo.currentSegments.add(segment);
+
+				if (!isInConstructorOfDerivedClass()) {
+					return;
+				}
+
+				// Initialize info.
+				segInfoMap[segment.id] = {
+					superCalled:
+						segment.prevSegments.length > 0 &&
+						segment.prevSegments.every(isCalled),
+					invalidNodes: [],
+				};
+			},
+
+			onUnreachableCodePathSegmentStart(segment) {
+				funcInfo.currentSegments.add(segment);
+			},
+
+			onUnreachableCodePathSegmentEnd(segment) {
+				funcInfo.currentSegments.delete(segment);
+			},
+
+			onCodePathSegmentEnd(segment) {
+				funcInfo.currentSegments.delete(segment);
+			},
+
+			/**
+			 * Update information of the code path segment when a code path was
+			 * looped.
+			 * @param {CodePathSegment} fromSegment The code path segment of the
+			 *      end of a loop.
+			 * @param {CodePathSegment} toSegment A code path segment of the head
+			 *      of a loop.
+			 * @returns {void}
+			 */
+			onCodePathSegmentLoop(fromSegment, toSegment) {
+				if (!isInConstructorOfDerivedClass()) {
+					return;
+				}
+
+				// Update information inside of the loop.
+				funcInfo.codePath.traverseSegments(
+					{ first: toSegment, last: fromSegment },
+					(segment, controller) => {
+						const info =
+							segInfoMap[segment.id] ?? new SegmentInfo();
+
+						if (info.superCalled) {
+							controller.skip();
+						} else if (
+							segment.prevSegments.length > 0 &&
+							segment.prevSegments.every(isCalled)
+						) {
+							info.superCalled = true;
+						}
+
+						segInfoMap[segment.id] = info;
+					},
+				);
+			},
+
+			/**
+			 * Reports if this is before `super()`.
+			 * @param {ASTNode} node A target node.
+			 * @returns {void}
+			 */
+			ThisExpression(node) {
+				if (isBeforeCallOfSuper()) {
+					setInvalid(node);
+				}
+			},
+
+			/**
+			 * Reports if this is before `super()`.
+			 * @param {ASTNode} node A target node.
+			 * @returns {void}
+			 */
+			Super(node) {
+				if (!astUtils.isCallee(node) && isBeforeCallOfSuper()) {
+					setInvalid(node);
+				}
+			},
+
+			/**
+			 * Marks `super()` called.
+			 * @param {ASTNode} node A target node.
+			 * @returns {void}
+			 */
+			"CallExpression:exit"(node) {
+				if (node.callee.type === "Super" && isBeforeCallOfSuper()) {
+					setSuperCalled();
+				}
+			},
+
+			/**
+			 * Resets state.
+			 * @returns {void}
+			 */
+			"Program:exit"() {
+				segInfoMap = Object.create(null);
+			},
+		};
+	},
+};

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

@@ -0,0 +1,46 @@
+/**
+ * @fileoverview Rule to restrict what can be thrown as an exception.
+ * @author Dieter Oberkofler
+ */
+
+"use strict";
+
+const astUtils = require("./utils/ast-utils");
+
+//------------------------------------------------------------------------------
+// Rule Definition
+//------------------------------------------------------------------------------
+
+/** @type {import('../types').Rule.RuleModule} */
+module.exports = {
+	meta: {
+		type: "suggestion",
+
+		docs: {
+			description: "Disallow throwing literals as exceptions",
+			recommended: false,
+			url: "https://eslint.org/docs/latest/rules/no-throw-literal",
+		},
+
+		schema: [],
+
+		messages: {
+			object: "Expected an error object to be thrown.",
+			undef: "Do not throw undefined.",
+		},
+	},
+
+	create(context) {
+		return {
+			ThrowStatement(node) {
+				if (!astUtils.couldBeError(node.argument)) {
+					context.report({ node, messageId: "object" });
+				} else if (node.argument.type === "Identifier") {
+					if (node.argument.name === "undefined") {
+						context.report({ node, messageId: "undef" });
+					}
+				}
+			},
+		};
+	},
+};

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

@@ -0,0 +1,227 @@
+/**
+ * @fileoverview Disallow trailing spaces at the end of lines.
+ * @author Nodeca Team <https://github.com/nodeca>
+ * @deprecated in ESLint v8.53.0
+ */
+"use strict";
+
+//------------------------------------------------------------------------------
+// Typedefs
+//------------------------------------------------------------------------------
+
+/**
+ * @import { SourceLocation, SourceRange } from "@eslint/core";
+ */
+
+//------------------------------------------------------------------------------
+// Requirements
+//------------------------------------------------------------------------------
+
+const astUtils = require("./utils/ast-utils");
+
+//------------------------------------------------------------------------------
+// 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: "11.0.0",
+			replacedBy: [
+				{
+					message:
+						"ESLint Stylistic now maintains deprecated stylistic core rules.",
+					url: "https://eslint.style/guide/migration",
+					plugin: {
+						name: "@stylistic/eslint-plugin",
+						url: "https://eslint.style",
+					},
+					rule: {
+						name: "no-trailing-spaces",
+						url: "https://eslint.style/rules/no-trailing-spaces",
+					},
+				},
+			],
+		},
+		type: "layout",
+
+		docs: {
+			description: "Disallow trailing whitespace at the end of lines",
+			recommended: false,
+			url: "https://eslint.org/docs/latest/rules/no-trailing-spaces",
+		},
+
+		fixable: "whitespace",
+
+		schema: [
+			{
+				type: "object",
+				properties: {
+					skipBlankLines: {
+						type: "boolean",
+						default: false,
+					},
+					ignoreComments: {
+						type: "boolean",
+						default: false,
+					},
+				},
+				additionalProperties: false,
+			},
+		],
+
+		messages: {
+			trailingSpace: "Trailing spaces not allowed.",
+		},
+	},
+
+	create(context) {
+		const sourceCode = context.sourceCode;
+
+		const BLANK_CLASS =
+				"[ \t\u00a0\u2000\u2001\u2002\u2003\u2004\u2005\u2006\u2007\u2008\u2009\u200a\u200b\u3000]",
+			SKIP_BLANK = `^${BLANK_CLASS}*$`,
+			NONBLANK = `${BLANK_CLASS}+$`;
+
+		const options = context.options[0] || {},
+			skipBlankLines = options.skipBlankLines || false,
+			ignoreComments = options.ignoreComments || false;
+
+		/**
+		 * Report the error message
+		 * @param {ASTNode} node node to report
+		 * @param {SourceLocation} location range information
+		 * @param {SourceRange} fixRange Range based on the whole program
+		 * @returns {void}
+		 */
+		function report(node, location, fixRange) {
+			/*
+			 * Passing node is a bit dirty, because message data will contain big
+			 * text in `source`. But... who cares :) ?
+			 * One more kludge will not make worse the bloody wizardry of this
+			 * plugin.
+			 */
+			context.report({
+				node,
+				loc: location,
+				messageId: "trailingSpace",
+				fix(fixer) {
+					return fixer.removeRange(fixRange);
+				},
+			});
+		}
+
+		/**
+		 * Given a list of comment nodes, return the line numbers for those comments.
+		 * @param {Array} comments An array of comment nodes.
+		 * @returns {number[]} An array of line numbers containing comments.
+		 */
+		function getCommentLineNumbers(comments) {
+			const lines = new Set();
+
+			comments.forEach(comment => {
+				const endLine =
+					comment.type === "Block"
+						? comment.loc.end.line - 1
+						: comment.loc.end.line;
+
+				for (let i = comment.loc.start.line; i <= endLine; i++) {
+					lines.add(i);
+				}
+			});
+
+			return lines;
+		}
+
+		//--------------------------------------------------------------------------
+		// Public
+		//--------------------------------------------------------------------------
+
+		return {
+			Program: function checkTrailingSpaces(node) {
+				/*
+				 * Let's hack. Since Espree does not return whitespace nodes,
+				 * fetch the source code and do matching via regexps.
+				 */
+
+				const re = new RegExp(NONBLANK, "u"),
+					skipMatch = new RegExp(SKIP_BLANK, "u"),
+					lines = sourceCode.lines,
+					linebreaks = sourceCode
+						.getText()
+						.match(astUtils.createGlobalLinebreakMatcher()),
+					comments = sourceCode.getAllComments(),
+					commentLineNumbers = getCommentLineNumbers(comments);
+
+				let totalLength = 0;
+
+				for (let i = 0, ii = lines.length; i < ii; i++) {
+					const lineNumber = i + 1;
+
+					/*
+					 * Always add linebreak length to line length to accommodate for line break (\n or \r\n)
+					 * Because during the fix time they also reserve one spot in the array.
+					 * Usually linebreak length is 2 for \r\n (CRLF) and 1 for \n (LF)
+					 */
+					const linebreakLength =
+						linebreaks && linebreaks[i] ? linebreaks[i].length : 1;
+					const lineLength = lines[i].length + linebreakLength;
+
+					const matches = re.exec(lines[i]);
+
+					if (matches) {
+						const location = {
+							start: {
+								line: lineNumber,
+								column: matches.index,
+							},
+							end: {
+								line: lineNumber,
+								column: lineLength - linebreakLength,
+							},
+						};
+
+						const rangeStart = totalLength + location.start.column;
+						const rangeEnd = totalLength + location.end.column;
+						const containingNode =
+							sourceCode.getNodeByRangeIndex(rangeStart);
+
+						if (
+							containingNode &&
+							containingNode.type === "TemplateElement" &&
+							rangeStart > containingNode.parent.range[0] &&
+							rangeEnd < containingNode.parent.range[1]
+						) {
+							totalLength += lineLength;
+							continue;
+						}
+
+						/*
+						 * If the line has only whitespace, and skipBlankLines
+						 * is true, don't report it
+						 */
+						if (skipBlankLines && skipMatch.test(lines[i])) {
+							totalLength += lineLength;
+							continue;
+						}
+
+						const fixRange = [rangeStart, rangeEnd];
+
+						if (
+							!ignoreComments ||
+							!commentLineNumbers.has(lineNumber)
+						) {
+							report(node, location, fixRange);
+						}
+					}
+
+					totalLength += lineLength;
+				}
+			},
+		};
+	},
+};

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

@@ -0,0 +1,80 @@
+/**
+ * @fileoverview Rule to flag variables that are never assigned
+ * @author Jacob Bandes-Storch <https://github.com/jtbandes>
+ */
+"use strict";
+
+//------------------------------------------------------------------------------
+// Rule Definition
+//------------------------------------------------------------------------------
+
+/** @type {import('../types').Rule.RuleModule} */
+module.exports = {
+	meta: {
+		type: "problem",
+		dialects: ["typescript", "javascript"],
+		language: "javascript",
+
+		docs: {
+			description:
+				"Disallow `let` or `var` variables that are read but never assigned",
+			recommended: false,
+			url: "https://eslint.org/docs/latest/rules/no-unassigned-vars",
+		},
+
+		schema: [],
+		messages: {
+			unassigned:
+				"'{{name}}' is always 'undefined' because it's never assigned.",
+		},
+	},
+
+	create(context) {
+		const sourceCode = context.sourceCode;
+		let insideDeclareModule = false;
+
+		return {
+			"TSModuleDeclaration[declare=true]"() {
+				insideDeclareModule = true;
+			},
+			"TSModuleDeclaration[declare=true]:exit"() {
+				insideDeclareModule = false;
+			},
+			VariableDeclarator(node) {
+				/** @type {import('estree').VariableDeclaration} */
+				const declaration = node.parent;
+				const shouldSkip =
+					node.init ||
+					node.id.type !== "Identifier" ||
+					declaration.kind === "const" ||
+					declaration.declare ||
+					insideDeclareModule;
+				if (shouldSkip) {
+					return;
+				}
+				const [variable] = sourceCode.getDeclaredVariables(node);
+				if (!variable) {
+					return;
+				}
+				let hasRead = false;
+				for (const reference of variable.references) {
+					if (reference.isWrite()) {
+						return;
+					}
+					if (reference.isRead()) {
+						hasRead = true;
+					}
+				}
+				if (!hasRead) {
+					// Variables that are never read should be flagged by no-unused-vars instead
+					return;
+				}
+				context.report({
+					node,
+					messageId: "unassigned",
+					data: { name: node.id.name },
+				});
+			},
+		};
+	},
+};