bahlint 28.58.6934

package/lib/rules/no-restricted-modules.js

@@ -0,0 +1,249 @@
+/**
+ * @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/lib/rules/no-restricted-properties.js

@@ -0,0 +1,233 @@
+/**
+ * @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/lib/rules/no-restricted-syntax.js

@@ -0,0 +1,74 @@
+/**
+ * @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/lib/rules/no-return-assign.js

@@ -0,0 +1,87 @@
+/**
+ * @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",
+					});
+				}
+			},
+		};
+	},
+};