eslint-plugin-unicorn-ts 0.0.1-security → 50.0.1

package/rules/no-array-push-push.js

@@ -0,0 +1,144 @@
+'use strict';
+const {hasSideEffect, isCommaToken, isSemicolonToken} = require('@eslint-community/eslint-utils');
+const getCallExpressionArgumentsText = require('./utils/get-call-expression-arguments-text.js');
+const isSameReference = require('./utils/is-same-reference.js');
+const {isNodeMatches} = require('./utils/is-node-matches.js');
+const getPreviousNode = require('./utils/get-previous-node.js');
+const {isMethodCall} = require('./ast/index.js');
+
+const ERROR = 'error';
+const SUGGESTION = 'suggestion';
+const messages = {
+	[ERROR]: 'Do not call `Array#push()` multiple times.',
+	[SUGGESTION]: 'Merge with previous one.',
+};
+
+const isArrayPushCall = node =>
+	node
+	&& node.parent.type === 'ExpressionStatement'
+	&& node.parent.expression === node
+	&& isMethodCall(node, {
+		method: 'push',
+		optionalCall: false,
+		optionalMember: false,
+	});
+
+function getFirstArrayPushCall(secondCall, sourceCode) {
+	const firstCall = getPreviousNode(secondCall.parent, sourceCode)?.expression;
+	if (isArrayPushCall(firstCall)) {
+		return firstCall;
+	}
+}
+
+function create(context) {
+	const {ignore} = {
+		ignore: [],
+		...context.options[0],
+	};
+	const ignoredObjects = [
+		'stream',
+		'this',
+		'this.stream',
+		'process.stdin',
+		'process.stdout',
+		'process.stderr',
+		...ignore,
+	];
+	const {sourceCode} = context;
+
+	return {
+		CallExpression(secondCall) {
+			if (!isArrayPushCall(secondCall)) {
+				return;
+			}
+
+			const secondCallArray = secondCall.callee.object;
+
+			if (isNodeMatches(secondCallArray, ignoredObjects)) {
+				return;
+			}
+
+			const firstCall = getFirstArrayPushCall(secondCall, sourceCode);
+			if (!firstCall) {
+				return;
+			}
+
+			const firstCallArray = firstCall.callee.object;
+
+			// Not same array
+			if (!isSameReference(firstCallArray, secondCallArray)) {
+				return;
+			}
+
+			const secondCallArguments = secondCall.arguments;
+			const problem = {
+				node: secondCall.callee.property,
+				messageId: ERROR,
+			};
+
+			const fix = function * (fixer) {
+				if (secondCallArguments.length > 0) {
+					const text = getCallExpressionArgumentsText(secondCall, sourceCode);
+
+					const [penultimateToken, lastToken] = sourceCode.getLastTokens(firstCall, 2);
+					yield (
+						isCommaToken(penultimateToken)
+							? fixer.insertTextAfter(penultimateToken, ` ${text}`)
+							: fixer.insertTextBefore(lastToken, firstCall.arguments.length > 0 ? `, ${text}` : text)
+					);
+				}
+
+				const firstExpression = firstCall.parent;
+				const secondExpression = secondCall.parent;
+				const shouldKeepSemicolon = !isSemicolonToken(sourceCode.getLastToken(firstExpression))
+					&& isSemicolonToken(sourceCode.getLastToken(secondExpression));
+
+				yield fixer.replaceTextRange(
+					[firstExpression.range[1], secondExpression.range[1]],
+					shouldKeepSemicolon ? ';' : '',
+				);
+			};
+
+			if (secondCallArguments.some(element => hasSideEffect(element, sourceCode))) {
+				problem.suggest = [
+					{
+						messageId: SUGGESTION,
+						fix,
+					},
+				];
+			} else {
+				problem.fix = fix;
+			}
+
+			return problem;
+		},
+	};
+}
+
+const schema = [
+	{
+		type: 'object',
+		additionalProperties: false,
+		properties: {
+			ignore: {
+				type: 'array',
+				uniqueItems: true,
+			},
+		},
+	},
+];
+
+/** @type {import('eslint').Rule.RuleModule} */
+module.exports = {
+	create,
+	meta: {
+		type: 'suggestion',
+		docs: {
+			description: 'Enforce combining multiple `Array#push()` into one call.',
+		},
+		fixable: 'code',
+		hasSuggestions: true,
+		schema,
+		messages,
+	},
+};

package/rules/no-array-reduce.js

@@ -0,0 +1,126 @@
+'use strict';
+const {isMethodCall} = require('./ast/index.js');
+const {isNodeValueNotFunction, isArrayPrototypeProperty} = require('./utils/index.js');
+
+const MESSAGE_ID = 'no-reduce';
+const messages = {
+	[MESSAGE_ID]: '`Array#{{method}}()` is not allowed',
+};
+
+const cases = [
+	// `array.{reduce,reduceRight}()`
+	{
+		test: callExpression =>
+			isMethodCall(callExpression, {
+				methods: ['reduce', 'reduceRight'],
+				minimumArguments: 1,
+				maximumArguments: 2,
+				optionalCall: false,
+				optionalMember: false,
+			})
+			&& !isNodeValueNotFunction(callExpression.arguments[0]),
+		getMethodNode: callExpression => callExpression.callee.property,
+		isSimpleOperation(callExpression) {
+			const [callback] = callExpression.arguments;
+
+			return (
+				callback
+				&& (
+					// `array.reduce((accumulator, element) => accumulator + element)`
+					(callback.type === 'ArrowFunctionExpression' && callback.body.type === 'BinaryExpression')
+					// `array.reduce((accumulator, element) => {return accumulator + element;})`
+					// `array.reduce(function (accumulator, element){return accumulator + element;})`
+					|| (
+						(callback.type === 'ArrowFunctionExpression' || callback.type === 'FunctionExpression')
+						&& callback.body.type === 'BlockStatement'
+						&& callback.body.body.length === 1
+						&& callback.body.body[0].type === 'ReturnStatement'
+						&& callback.body.body[0].argument.type === 'BinaryExpression'
+					)
+				)
+			);
+		},
+	},
+	// `[].{reduce,reduceRight}.call()` and `Array.{reduce,reduceRight}.call()`
+	{
+		test: callExpression =>
+			isMethodCall(callExpression, {
+				method: 'call',
+				optionalCall: false,
+				optionalMember: false,
+			})
+			&& isArrayPrototypeProperty(callExpression.callee.object, {
+				properties: ['reduce', 'reduceRight'],
+			})
+			&& (
+				!callExpression.arguments[1]
+				|| !isNodeValueNotFunction(callExpression.arguments[1])
+			),
+		getMethodNode: callExpression => callExpression.callee.object.property,
+	},
+	// `[].{reduce,reduceRight}.apply()` and `Array.{reduce,reduceRight}.apply()`
+	{
+		test: callExpression =>
+			isMethodCall(callExpression, {
+				method: 'apply',
+				optionalCall: false,
+				optionalMember: false,
+			})
+			&& isArrayPrototypeProperty(callExpression.callee.object, {
+				properties: ['reduce', 'reduceRight'],
+			}),
+		getMethodNode: callExpression => callExpression.callee.object.property,
+	},
+];
+
+const schema = [
+	{
+		type: 'object',
+		additionalProperties: false,
+		properties: {
+			allowSimpleOperations: {
+				type: 'boolean',
+				default: true,
+			},
+		},
+	},
+];
+
+/** @param {import('eslint').Rule.RuleContext} context */
+const create = context => {
+	const {allowSimpleOperations} = {allowSimpleOperations: true, ...context.options[0]};
+
+	return {
+		* CallExpression(callExpression) {
+			for (const {test, getMethodNode, isSimpleOperation} of cases) {
+				if (!test(callExpression)) {
+					continue;
+				}
+
+				if (allowSimpleOperations && isSimpleOperation?.(callExpression)) {
+					continue;
+				}
+
+				const methodNode = getMethodNode(callExpression);
+				yield {
+					node: methodNode,
+					messageId: MESSAGE_ID,
+					data: {method: methodNode.name},
+				};
+			}
+		},
+	};
+};
+
+/** @type {import('eslint').Rule.RuleModule} */
+module.exports = {
+	create,
+	meta: {
+		type: 'suggestion',
+		docs: {
+			description: 'Disallow `Array#reduce()` and `Array#reduceRight()`.',
+		},
+		schema,
+		messages,
+	},
+};

package/rules/no-await-expression-member.js

@@ -0,0 +1,90 @@
+'use strict';
+const {
+	removeParentheses,
+	removeMemberExpressionProperty,
+} = require('./fix/index.js');
+const {isLiteral} = require('./ast/index.js');
+
+const MESSAGE_ID = 'no-await-expression-member';
+const messages = {
+	[MESSAGE_ID]: 'Do not access a member directly from an await expression.',
+};
+
+/** @param {import('eslint').Rule.RuleContext} context */
+const create = context => {
+	const {sourceCode} = context;
+
+	return {
+		MemberExpression(memberExpression) {
+			if (memberExpression.object.type !== 'AwaitExpression') {
+				return;
+			}
+
+			const {property} = memberExpression;
+			const problem = {
+				node: property,
+				messageId: MESSAGE_ID,
+			};
+
+			// `const foo = (await bar)[0]`
+			if (
+				memberExpression.computed
+				&& !memberExpression.optional
+				&& (isLiteral(property, 0) || isLiteral(property, 1))
+				&& memberExpression.parent.type === 'VariableDeclarator'
+				&& memberExpression.parent.init === memberExpression
+				&& memberExpression.parent.id.type === 'Identifier'
+				&& !memberExpression.parent.id.typeAnnotation
+			) {
+				problem.fix = function * (fixer) {
+					const variable = memberExpression.parent.id;
+					yield fixer.insertTextBefore(variable, property.value === 0 ? '[' : '[, ');
+					yield fixer.insertTextAfter(variable, ']');
+
+					yield removeMemberExpressionProperty(fixer, memberExpression, sourceCode);
+					yield * removeParentheses(memberExpression.object, fixer, sourceCode);
+				};
+
+				return problem;
+			}
+
+			// `const foo = (await bar).foo`
+			if (
+				!memberExpression.computed
+				&& !memberExpression.optional
+				&& property.type === 'Identifier'
+				&& memberExpression.parent.type === 'VariableDeclarator'
+				&& memberExpression.parent.init === memberExpression
+				&& memberExpression.parent.id.type === 'Identifier'
+				&& memberExpression.parent.id.name === property.name
+				&& !memberExpression.parent.id.typeAnnotation
+			) {
+				problem.fix = function * (fixer) {
+					const variable = memberExpression.parent.id;
+					yield fixer.insertTextBefore(variable, '{');
+					yield fixer.insertTextAfter(variable, '}');
+
+					yield removeMemberExpressionProperty(fixer, memberExpression, sourceCode);
+					yield * removeParentheses(memberExpression.object, fixer, sourceCode);
+				};
+
+				return problem;
+			}
+
+			return problem;
+		},
+	};
+};
+
+/** @type {import('eslint').Rule.RuleModule} */
+module.exports = {
+	create,
+	meta: {
+		type: 'suggestion',
+		docs: {
+			description: 'Disallow member access from await expression.',
+		},
+		fixable: 'code',
+		messages,
+	},
+};

package/rules/no-console-spaces.js

@@ -0,0 +1,86 @@
+'use strict';
+const toLocation = require('./utils/to-location.js');
+const {isStringLiteral, isMethodCall} = require('./ast/index.js');
+
+const MESSAGE_ID = 'no-console-spaces';
+const messages = {
+	[MESSAGE_ID]: 'Do not use {{position}} space between `console.{{method}}` parameters.',
+};
+
+// Find exactly one leading space, allow exactly one space
+const hasLeadingSpace = value => value.length > 1 && value.charAt(0) === ' ' && value.charAt(1) !== ' ';
+
+// Find exactly one trailing space, allow exactly one space
+const hasTrailingSpace = value => value.length > 1 && value.at(-1) === ' ' && value.at(-2) !== ' ';
+
+/** @param {import('eslint').Rule.RuleContext} context */
+const create = context => {
+	const {sourceCode} = context;
+	const getProblem = (node, method, position) => {
+		const index = position === 'leading'
+			? node.range[0] + 1
+			: node.range[1] - 2;
+		const range = [index, index + 1];
+
+		return {
+			loc: toLocation(range, sourceCode),
+			messageId: MESSAGE_ID,
+			data: {method, position},
+			fix: fixer => fixer.removeRange(range),
+		};
+	};
+
+	return {
+		* CallExpression(node) {
+			if (
+				!isMethodCall(node, {
+					object: 'console',
+					methods: [
+						'log',
+						'debug',
+						'info',
+						'warn',
+						'error',
+					],
+					minimumArguments: 1,
+					optionalCall: false,
+					optionalMember: false,
+				})
+			) {
+				return;
+			}
+
+			const method = node.callee.property.name;
+			const {arguments: messages} = node;
+			const {length} = messages;
+			for (const [index, node] of messages.entries()) {
+				if (!isStringLiteral(node) && node.type !== 'TemplateLiteral') {
+					continue;
+				}
+
+				const raw = sourceCode.getText(node).slice(1, -1);
+
+				if (index !== 0 && hasLeadingSpace(raw)) {
+					yield getProblem(node, method, 'leading');
+				}
+
+				if (index !== length - 1 && hasTrailingSpace(raw)) {
+					yield getProblem(node, method, 'trailing');
+				}
+			}
+		},
+	};
+};
+
+/** @type {import('eslint').Rule.RuleModule} */
+module.exports = {
+	create,
+	meta: {
+		type: 'suggestion',
+		docs: {
+			description: 'Do not use leading/trailing space between `console.log` parameters.',
+		},
+		fixable: 'code',
+		messages,
+	},
+};

package/rules/no-document-cookie.js

@@ -0,0 +1,25 @@
+'use strict';
+const {GlobalReferenceTracker} = require('./utils/global-reference-tracker.js');
+
+const MESSAGE_ID = 'no-document-cookie';
+const messages = {
+	[MESSAGE_ID]: 'Do not use `document.cookie` directly.',
+};
+
+const tracker = new GlobalReferenceTracker({
+	object: 'document.cookie',
+	filter: ({node}) => node.parent.type === 'AssignmentExpression' && node.parent.left === node,
+	handle: ({node}) => ({node, messageId: MESSAGE_ID}),
+});
+
+/** @type {import('eslint').Rule.RuleModule} */
+module.exports = {
+	create: context => tracker.createListeners(context),
+	meta: {
+		type: 'problem',
+		docs: {
+			description: 'Do not use `document.cookie` directly.',
+		},
+		messages,
+	},
+};

package/rules/no-empty-file.js

@@ -0,0 +1,57 @@
+'use strict';
+const {isEmptyNode} = require('./ast/index.js');
+
+const MESSAGE_ID = 'no-empty-file';
+const messages = {
+	[MESSAGE_ID]: 'Empty files are not allowed.',
+};
+
+const isDirective = node => node.type === 'ExpressionStatement' && typeof node.directive === 'string';
+const isEmpty = node => isEmptyNode(node, isDirective);
+
+const isTripleSlashDirective = node =>
+	node.type === 'Line' && node.value.startsWith('/');
+
+const hasTripeSlashDirectives = comments =>
+	comments.some(currentNode => isTripleSlashDirective(currentNode));
+
+/** @param {import('eslint').Rule.RuleContext} context */
+const create = context => {
+	const filename = context.physicalFilename;
+
+	if (!/\.(?:js|mjs|cjs|jsx|ts|mts|cts|tsx)$/i.test(filename)) {
+		return;
+	}
+
+	return {
+		Program(node) {
+			if (node.body.some(node => !isEmpty(node))) {
+				return;
+			}
+
+			const {sourceCode} = context;
+			const comments = sourceCode.getAllComments();
+
+			if (hasTripeSlashDirectives(comments)) {
+				return;
+			}
+
+			return {
+				node,
+				messageId: MESSAGE_ID,
+			};
+		},
+	};
+};
+
+/** @type {import('eslint').Rule.RuleModule} */
+module.exports = {
+	create,
+	meta: {
+		type: 'suggestion',
+		docs: {
+			description: 'Disallow empty files.',
+		},
+		messages,
+	},
+};