@alexlit/lint-kit 166.0.1 → 167.0.0

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

@@ -1,249 +0,0 @@
-/**
- * @fileoverview Restrict usage of specified node modules.
- * @author Christian Schulz
- * @deprecated in ESLint v7.0.0
- */
-"use strict";
-
-//------------------------------------------------------------------------------
-// Requirements
-//------------------------------------------------------------------------------
-
-const astUtils = require("./utils/ast-utils");
-
-//------------------------------------------------------------------------------
-// Rule Definition
-//------------------------------------------------------------------------------
-
-const ignore = require("ignore");
-
-const arrayOfStrings = {
-	type: "array",
-	items: { type: "string" },
-	uniqueItems: true,
-};
-
-const arrayOfStringsOrObjects = {
-	type: "array",
-	items: {
-		anyOf: [
-			{ type: "string" },
-			{
-				type: "object",
-				properties: {
-					name: { type: "string" },
-					message: {
-						type: "string",
-						minLength: 1,
-					},
-				},
-				additionalProperties: false,
-				required: ["name"],
-			},
-		],
-	},
-	uniqueItems: true,
-};
-
-/** @type {import('../types').Rule.RuleModule} */
-module.exports = {
-	meta: {
-		deprecated: {
-			message: "Node.js rules were moved out of ESLint core.",
-			url: "https://eslint.org/docs/latest/use/migrating-to-7.0.0#deprecate-node-rules",
-			deprecatedSince: "7.0.0",
-			availableUntil: "11.0.0",
-			replacedBy: [
-				{
-					message:
-						"eslint-plugin-n now maintains deprecated Node.js-related rules.",
-					plugin: {
-						name: "eslint-plugin-n",
-						url: "https://github.com/eslint-community/eslint-plugin-n",
-					},
-					rule: {
-						name: "no-restricted-require",
-						url: "https://github.com/eslint-community/eslint-plugin-n/tree/master/docs/rules/no-restricted-require.md",
-					},
-				},
-			],
-		},
-
-		type: "suggestion",
-
-		docs: {
-			description: "Disallow specified modules when loaded by `require`",
-			recommended: false,
-			url: "https://eslint.org/docs/latest/rules/no-restricted-modules",
-		},
-
-		schema: {
-			anyOf: [
-				arrayOfStringsOrObjects,
-				{
-					type: "array",
-					items: {
-						type: "object",
-						properties: {
-							paths: arrayOfStringsOrObjects,
-							patterns: arrayOfStrings,
-						},
-						additionalProperties: false,
-					},
-					additionalItems: false,
-				},
-			],
-		},
-
-		messages: {
-			defaultMessage: "'{{name}}' module is restricted from being used.",
-			customMessage:
-				// eslint-disable-next-line eslint-plugin/report-message-format -- Custom message might not end in a period
-				"'{{name}}' module is restricted from being used. {{customMessage}}",
-			patternMessage:
-				"'{{name}}' module is restricted from being used by a pattern.",
-		},
-	},
-
-	create(context) {
-		const options = Array.isArray(context.options) ? context.options : [];
-		const isPathAndPatternsObject =
-			typeof options[0] === "object" &&
-			(Object.hasOwn(options[0], "paths") ||
-				Object.hasOwn(options[0], "patterns"));
-
-		const restrictedPaths =
-			(isPathAndPatternsObject ? options[0].paths : context.options) ||
-			[];
-		const restrictedPatterns =
-			(isPathAndPatternsObject ? options[0].patterns : []) || [];
-
-		const restrictedPathMessages = restrictedPaths.reduce(
-			(memo, importName) => {
-				if (typeof importName === "string") {
-					memo[importName] = null;
-				} else {
-					memo[importName.name] = importName.message;
-				}
-				return memo;
-			},
-			{},
-		);
-
-		// if no imports are restricted we don't need to check
-		if (
-			Object.keys(restrictedPaths).length === 0 &&
-			restrictedPatterns.length === 0
-		) {
-			return {};
-		}
-
-		// relative paths are supported for this rule
-		const ig = ignore({ allowRelativePaths: true }).add(restrictedPatterns);
-
-		/**
-		 * Function to check if a node is a string literal.
-		 * @param {ASTNode} node The node to check.
-		 * @returns {boolean} If the node is a string literal.
-		 */
-		function isStringLiteral(node) {
-			return (
-				node &&
-				node.type === "Literal" &&
-				typeof node.value === "string"
-			);
-		}
-
-		/**
-		 * Function to check if a node is a require call.
-		 * @param {ASTNode} node The node to check.
-		 * @returns {boolean} If the node is a require call.
-		 */
-		function isRequireCall(node) {
-			return (
-				node.callee.type === "Identifier" &&
-				node.callee.name === "require"
-			);
-		}
-
-		/**
-		 * Extract string from Literal or TemplateLiteral node
-		 * @param {ASTNode} node The node to extract from
-		 * @returns {string|null} Extracted string or null if node doesn't represent a string
-		 */
-		function getFirstArgumentString(node) {
-			if (isStringLiteral(node)) {
-				return node.value.trim();
-			}
-
-			if (astUtils.isStaticTemplateLiteral(node)) {
-				return node.quasis[0].value.cooked.trim();
-			}
-
-			return null;
-		}
-
-		/**
-		 * Report a restricted path.
-		 * @param {node} node representing the restricted path reference
-		 * @param {string} name restricted path
-		 * @returns {void}
-		 * @private
-		 */
-		function reportPath(node, name) {
-			const customMessage = restrictedPathMessages[name];
-			const messageId = customMessage
-				? "customMessage"
-				: "defaultMessage";
-
-			context.report({
-				node,
-				messageId,
-				data: {
-					name,
-					customMessage,
-				},
-			});
-		}
-
-		/**
-		 * Check if the given name is a restricted path name
-		 * @param {string} name name of a variable
-		 * @returns {boolean} whether the variable is a restricted path or not
-		 * @private
-		 */
-		function isRestrictedPath(name) {
-			return Object.hasOwn(restrictedPathMessages, name);
-		}
-
-		return {
-			CallExpression(node) {
-				if (isRequireCall(node)) {
-					// node has arguments
-					if (node.arguments.length) {
-						const name = getFirstArgumentString(node.arguments[0]);
-
-						// if first argument is a string literal or a static string template literal
-						if (name) {
-							// check if argument value is in restricted modules array
-							if (isRestrictedPath(name)) {
-								reportPath(node, name);
-							}
-
-							if (
-								restrictedPatterns.length > 0 &&
-								ig.ignores(name)
-							) {
-								context.report({
-									node,
-									messageId: "patternMessage",
-									data: { name },
-								});
-							}
-						}
-					}
-				}
-			},
-		};
-	},
-};

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

@@ -1,233 +0,0 @@
-/**
- * @fileoverview Rule to disallow certain object properties
- * @author Will Klein & Eli White
- */
-
-"use strict";
-
-const astUtils = require("./utils/ast-utils");
-
-//------------------------------------------------------------------------------
-// Rule Definition
-//------------------------------------------------------------------------------
-
-/** @type {import('../types').Rule.RuleModule} */
-module.exports = {
-	meta: {
-		type: "suggestion",
-
-		docs: {
-			description: "Disallow certain properties on certain objects",
-			recommended: false,
-			url: "https://eslint.org/docs/latest/rules/no-restricted-properties",
-		},
-
-		schema: {
-			type: "array",
-			items: {
-				type: "object",
-				properties: {
-					object: {
-						type: "string",
-					},
-					property: {
-						type: "string",
-					},
-					allowObjects: {
-						type: "array",
-						items: {
-							type: "string",
-						},
-						uniqueItems: true,
-					},
-					allowProperties: {
-						type: "array",
-						items: {
-							type: "string",
-						},
-						uniqueItems: true,
-					},
-					message: {
-						type: "string",
-					},
-				},
-				anyOf: [
-					{
-						required: ["object"],
-					},
-					{
-						required: ["property"],
-					},
-				],
-				not: {
-					anyOf: [
-						{ required: ["allowObjects", "object"] },
-						{ required: ["allowProperties", "property"] },
-					],
-				},
-				additionalProperties: false,
-			},
-			uniqueItems: true,
-		},
-
-		messages: {
-			restrictedObjectProperty:
-				// eslint-disable-next-line eslint-plugin/report-message-format -- Custom message might not end in a period
-				"'{{objectName}}.{{propertyName}}' is restricted from being used.{{allowedPropertiesMessage}}{{message}}",
-			restrictedProperty:
-				// eslint-disable-next-line eslint-plugin/report-message-format -- Custom message might not end in a period
-				"'{{propertyName}}' is restricted from being used.{{allowedObjectsMessage}}{{message}}",
-		},
-	},
-
-	create(context) {
-		const restrictedCalls = context.options;
-
-		if (restrictedCalls.length === 0) {
-			return {};
-		}
-
-		const restrictedProperties = new Map();
-		const globallyRestrictedObjects = new Map();
-		const globallyRestrictedProperties = new Map();
-
-		restrictedCalls.forEach(option => {
-			const objectName = option.object;
-			const propertyName = option.property;
-
-			if (typeof objectName === "undefined") {
-				globallyRestrictedProperties.set(propertyName, {
-					allowObjects: option.allowObjects,
-					message: option.message,
-				});
-			} else if (typeof propertyName === "undefined") {
-				globallyRestrictedObjects.set(objectName, {
-					allowProperties: option.allowProperties,
-					message: option.message,
-				});
-			} else {
-				if (!restrictedProperties.has(objectName)) {
-					restrictedProperties.set(objectName, new Map());
-				}
-
-				restrictedProperties.get(objectName).set(propertyName, {
-					message: option.message,
-				});
-			}
-		});
-
-		/**
-		 * Checks if a name is in the allowed list.
-		 * @param {string} name The name to check
-		 * @param {string[]} [allowedList] The list of allowed names
-		 * @returns {boolean} True if the name is allowed, false otherwise
-		 */
-		function isAllowed(name, allowedList) {
-			if (!allowedList) {
-				return false;
-			}
-
-			return allowedList.includes(name);
-		}
-
-		/**
-		 * Checks to see whether a property access is restricted, and reports it if so.
-		 * @param {ASTNode} node The node to report
-		 * @param {string} objectName The name of the object
-		 * @param {string} propertyName The name of the property
-		 * @returns {undefined}
-		 */
-		function checkPropertyAccess(node, objectName, propertyName) {
-			if (propertyName === null) {
-				return;
-			}
-			const matchedObject = restrictedProperties.get(objectName);
-			const matchedObjectProperty = matchedObject
-				? matchedObject.get(propertyName)
-				: globallyRestrictedObjects.get(objectName);
-			const globalMatchedProperty =
-				globallyRestrictedProperties.get(propertyName);
-
-			if (
-				matchedObjectProperty &&
-				!isAllowed(propertyName, matchedObjectProperty.allowProperties)
-			) {
-				const message = matchedObjectProperty.message
-					? ` ${matchedObjectProperty.message}`
-					: "";
-				const allowedPropertiesMessage =
-					matchedObjectProperty.allowProperties
-						? ` Only these properties are allowed: ${matchedObjectProperty.allowProperties.join(", ")}.`
-						: "";
-
-				context.report({
-					node,
-					messageId: "restrictedObjectProperty",
-					data: {
-						objectName,
-						propertyName,
-						message,
-						allowedPropertiesMessage,
-					},
-				});
-			} else if (
-				globalMatchedProperty &&
-				!isAllowed(objectName, globalMatchedProperty.allowObjects)
-			) {
-				const message = globalMatchedProperty.message
-					? ` ${globalMatchedProperty.message}`
-					: "";
-				const allowedObjectsMessage = globalMatchedProperty.allowObjects
-					? ` Property '${propertyName}' is only allowed on these objects: ${globalMatchedProperty.allowObjects.join(", ")}.`
-					: "";
-
-				context.report({
-					node,
-					messageId: "restrictedProperty",
-					data: {
-						propertyName,
-						message,
-						allowedObjectsMessage,
-					},
-				});
-			}
-		}
-
-		return {
-			MemberExpression(node) {
-				checkPropertyAccess(
-					node,
-					node.object && node.object.name,
-					astUtils.getStaticPropertyName(node),
-				);
-			},
-			ObjectPattern(node) {
-				let objectName = null;
-
-				if (node.parent.type === "VariableDeclarator") {
-					if (
-						node.parent.init &&
-						node.parent.init.type === "Identifier"
-					) {
-						objectName = node.parent.init.name;
-					}
-				} else if (
-					node.parent.type === "AssignmentExpression" ||
-					node.parent.type === "AssignmentPattern"
-				) {
-					if (node.parent.right.type === "Identifier") {
-						objectName = node.parent.right.name;
-					}
-				}
-
-				node.properties.forEach(property => {
-					checkPropertyAccess(
-						node,
-						objectName,
-						astUtils.getStaticPropertyName(property),
-					);
-				});
-			},
-		};
-	},
-};

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

@@ -1,74 +0,0 @@
-/**
- * @fileoverview Rule to flag use of certain node types
- * @author Burak Yigit Kaya
- */
-"use strict";
-
-//------------------------------------------------------------------------------
-// Rule Definition
-//------------------------------------------------------------------------------
-
-/** @type {import('../types').Rule.RuleModule} */
-module.exports = {
-	meta: {
-		type: "suggestion",
-
-		docs: {
-			description: "Disallow specified syntax",
-			recommended: false,
-			url: "https://eslint.org/docs/latest/rules/no-restricted-syntax",
-		},
-
-		schema: {
-			type: "array",
-			items: {
-				oneOf: [
-					{
-						type: "string",
-					},
-					{
-						type: "object",
-						properties: {
-							selector: { type: "string" },
-							message: { type: "string" },
-						},
-						required: ["selector"],
-						additionalProperties: false,
-					},
-				],
-			},
-			uniqueItems: true,
-			minItems: 0,
-		},
-
-		messages: {
-			// eslint-disable-next-line eslint-plugin/report-message-format -- Custom message might not end in a period
-			restrictedSyntax: "{{message}}",
-		},
-	},
-
-	create(context) {
-		return context.options.reduce((result, selectorOrObject) => {
-			const isStringFormat = typeof selectorOrObject === "string";
-			const hasCustomMessage =
-				!isStringFormat && Boolean(selectorOrObject.message);
-
-			const selector = isStringFormat
-				? selectorOrObject
-				: selectorOrObject.selector;
-			const message = hasCustomMessage
-				? selectorOrObject.message
-				: `Using '${selector}' is not allowed.`;
-
-			return Object.assign(result, {
-				[selector](node) {
-					context.report({
-						node,
-						messageId: "restrictedSyntax",
-						data: { message },
-					});
-				},
-			});
-		}, {});
-	},
-};

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

@@ -1,87 +0,0 @@
-/**
- * @fileoverview Rule to flag when return statement contains assignment
- * @author Ilya Volodin
- */
-"use strict";
-
-//------------------------------------------------------------------------------
-// Requirements
-//------------------------------------------------------------------------------
-
-const astUtils = require("./utils/ast-utils");
-
-//------------------------------------------------------------------------------
-// Helpers
-//------------------------------------------------------------------------------
-
-const SENTINEL_TYPE =
-	/^(?:[a-zA-Z]+?Statement|ArrowFunctionExpression|FunctionExpression|ClassExpression)$/u;
-
-//------------------------------------------------------------------------------
-// Rule Definition
-//------------------------------------------------------------------------------
-
-/** @type {import('../types').Rule.RuleModule} */
-module.exports = {
-	meta: {
-		type: "suggestion",
-
-		defaultOptions: ["except-parens"],
-
-		docs: {
-			description: "Disallow assignment operators in `return` statements",
-			recommended: false,
-			url: "https://eslint.org/docs/latest/rules/no-return-assign",
-		},
-
-		schema: [
-			{
-				enum: ["except-parens", "always"],
-			},
-		],
-
-		messages: {
-			returnAssignment: "Return statement should not contain assignment.",
-			arrowAssignment: "Arrow function should not return assignment.",
-		},
-	},
-
-	create(context) {
-		const always = context.options[0] !== "except-parens";
-		const sourceCode = context.sourceCode;
-
-		return {
-			AssignmentExpression(node) {
-				if (!always && astUtils.isParenthesised(sourceCode, node)) {
-					return;
-				}
-
-				let currentChild = node;
-				let parent = currentChild.parent;
-
-				// Find ReturnStatement or ArrowFunctionExpression in ancestors.
-				while (parent && !SENTINEL_TYPE.test(parent.type)) {
-					currentChild = parent;
-					parent = parent.parent;
-				}
-
-				// Reports.
-				if (parent && parent.type === "ReturnStatement") {
-					context.report({
-						node: parent,
-						messageId: "returnAssignment",
-					});
-				} else if (
-					parent &&
-					parent.type === "ArrowFunctionExpression" &&
-					parent.body === currentChild
-				) {
-					context.report({
-						node: parent,
-						messageId: "arrowAssignment",
-					});
-				}
-			},
-		};
-	},
-};