@alexlit/lint-kit 175.0.0 → 176.0.1

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

@@ -1,365 +0,0 @@
-/**
- * @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

@@ -1,46 +0,0 @@
-/**
- * @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

@@ -1,227 +0,0 @@
-/**
- * @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

@@ -1,80 +0,0 @@
-/**
- * @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: true,
-			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 },
-				});
-			},
-		};
-	},
-};