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

package/rules/explicit-length-check.js

@@ -0,0 +1,229 @@
+'use strict';
+const {isParenthesized, getStaticValue} = require('@eslint-community/eslint-utils');
+const {checkVueTemplate} = require('./utils/rule.js');
+const isLogicalExpression = require('./utils/is-logical-expression.js');
+const {isBooleanNode, getBooleanAncestor} = require('./utils/boolean.js');
+const {fixSpaceAroundKeyword} = require('./fix/index.js');
+const {isLiteral, isMemberExpression, isNumberLiteral} = require('./ast/index.js');
+
+const TYPE_NON_ZERO = 'non-zero';
+const TYPE_ZERO = 'zero';
+const MESSAGE_ID_SUGGESTION = 'suggestion';
+const messages = {
+	[TYPE_NON_ZERO]: 'Use `.{{property}} {{code}}` when checking {{property}} is not zero.',
+	[TYPE_ZERO]: 'Use `.{{property}} {{code}}` when checking {{property}} is zero.',
+	[MESSAGE_ID_SUGGESTION]: 'Replace `.{{property}}` with `.{{property}} {{code}}`.',
+};
+
+const isCompareRight = (node, operator, value) =>
+	node.type === 'BinaryExpression'
+	&& node.operator === operator
+	&& isLiteral(node.right, value);
+const isCompareLeft = (node, operator, value) =>
+	node.type === 'BinaryExpression'
+	&& node.operator === operator
+	&& isLiteral(node.left, value);
+const nonZeroStyles = new Map([
+	[
+		'greater-than',
+		{
+			code: '> 0',
+			test: node => isCompareRight(node, '>', 0),
+		},
+	],
+	[
+		'not-equal',
+		{
+			code: '!== 0',
+			test: node => isCompareRight(node, '!==', 0),
+		},
+	],
+]);
+const zeroStyle = {
+	code: '=== 0',
+	test: node => isCompareRight(node, '===', 0),
+};
+
+function getLengthCheckNode(node) {
+	node = node.parent;
+
+	// Zero length check
+	if (
+		// `foo.length === 0`
+		isCompareRight(node, '===', 0)
+		// `foo.length == 0`
+		|| isCompareRight(node, '==', 0)
+		// `foo.length < 1`
+		|| isCompareRight(node, '<', 1)
+		// `0 === foo.length`
+		|| isCompareLeft(node, '===', 0)
+		// `0 == foo.length`
+		|| isCompareLeft(node, '==', 0)
+		// `1 > foo.length`
+		|| isCompareLeft(node, '>', 1)
+	) {
+		return {isZeroLengthCheck: true, node};
+	}
+
+	// Non-Zero length check
+	if (
+		// `foo.length !== 0`
+		isCompareRight(node, '!==', 0)
+		// `foo.length != 0`
+		|| isCompareRight(node, '!=', 0)
+		// `foo.length > 0`
+		|| isCompareRight(node, '>', 0)
+		// `foo.length >= 1`
+		|| isCompareRight(node, '>=', 1)
+		// `0 !== foo.length`
+		|| isCompareLeft(node, '!==', 0)
+		// `0 !== foo.length`
+		|| isCompareLeft(node, '!=', 0)
+		// `0 < foo.length`
+		|| isCompareLeft(node, '<', 0)
+		// `1 <= foo.length`
+		|| isCompareLeft(node, '<=', 1)
+	) {
+		return {isZeroLengthCheck: false, node};
+	}
+
+	return {};
+}
+
+function isNodeValueNumber(node, context) {
+	if (isNumberLiteral(node)) {
+		return true;
+	}
+
+	const staticValue = getStaticValue(node, context.sourceCode.getScope(node));
+	return staticValue && typeof staticValue.value === 'number';
+}
+
+function create(context) {
+	const options = {
+		'non-zero': 'greater-than',
+		...context.options[0],
+	};
+	const nonZeroStyle = nonZeroStyles.get(options['non-zero']);
+	const {sourceCode} = context;
+
+	function getProblem({node, isZeroLengthCheck, lengthNode, autoFix}) {
+		const {code, test} = isZeroLengthCheck ? zeroStyle : nonZeroStyle;
+		if (test(node)) {
+			return;
+		}
+
+		let fixed = `${sourceCode.getText(lengthNode)} ${code}`;
+		if (
+			!isParenthesized(node, sourceCode)
+			&& node.type === 'UnaryExpression'
+			&& (node.parent.type === 'UnaryExpression' || node.parent.type === 'AwaitExpression')
+		) {
+			fixed = `(${fixed})`;
+		}
+
+		const fix = function * (fixer) {
+			yield fixer.replaceText(node, fixed);
+			yield * fixSpaceAroundKeyword(fixer, node, sourceCode);
+		};
+
+		const problem = {
+			node,
+			messageId: isZeroLengthCheck ? TYPE_ZERO : TYPE_NON_ZERO,
+			data: {code, property: lengthNode.property.name},
+		};
+
+		if (autoFix) {
+			problem.fix = fix;
+		} else {
+			problem.suggest = [
+				{
+					messageId: MESSAGE_ID_SUGGESTION,
+					fix,
+				},
+			];
+		}
+
+		return problem;
+	}
+
+	return {
+		MemberExpression(memberExpression) {
+			if (
+				!isMemberExpression(memberExpression, {
+					properties: ['length', 'size'],
+					optional: false,
+				})
+				|| memberExpression.object.type === 'ThisExpression'
+			) {
+				return;
+			}
+
+			const lengthNode = memberExpression;
+			const staticValue = getStaticValue(lengthNode, sourceCode.getScope(lengthNode));
+			if (staticValue && (!Number.isInteger(staticValue.value) || staticValue.value < 0)) {
+				// Ignore known, non-positive-integer length properties.
+				return;
+			}
+
+			let node;
+			let autoFix = true;
+			let {isZeroLengthCheck, node: lengthCheckNode} = getLengthCheckNode(lengthNode);
+			if (lengthCheckNode) {
+				const {isNegative, node: ancestor} = getBooleanAncestor(lengthCheckNode);
+				node = ancestor;
+				if (isNegative) {
+					isZeroLengthCheck = !isZeroLengthCheck;
+				}
+			} else {
+				const {isNegative, node: ancestor} = getBooleanAncestor(lengthNode);
+				if (isBooleanNode(ancestor)) {
+					isZeroLengthCheck = isNegative;
+					node = ancestor;
+				} else if (
+					isLogicalExpression(lengthNode.parent)
+					&& !(
+						lengthNode.parent.operator === '||'
+						&& isNodeValueNumber(lengthNode.parent.right, context)
+					)
+				) {
+					isZeroLengthCheck = isNegative;
+					node = lengthNode;
+					autoFix = false;
+				}
+			}
+
+			if (node) {
+				return getProblem({node, isZeroLengthCheck, lengthNode, autoFix});
+			}
+		},
+	};
+}
+
+const schema = [
+	{
+		type: 'object',
+		additionalProperties: false,
+		properties: {
+			'non-zero': {
+				enum: [...nonZeroStyles.keys()],
+				default: 'greater-than',
+			},
+		},
+	},
+];
+
+/** @type {import('eslint').Rule.RuleModule} */
+module.exports = {
+	create: checkVueTemplate(create),
+	meta: {
+		type: 'problem',
+		docs: {
+			description: 'Enforce explicitly comparing the `length` or `size` property of a value.',
+		},
+		fixable: 'code',
+		schema,
+		messages,
+		hasSuggestions: true,
+	},
+};

package/rules/filename-case.js

@@ -0,0 +1,258 @@
+'use strict';
+const path = require('node:path');
+const {camelCase, kebabCase, snakeCase, upperFirst} = require('./utils/lodash.js');
+const cartesianProductSamples = require('./utils/cartesian-product-samples.js');
+
+const MESSAGE_ID = 'filename-case';
+const MESSAGE_ID_EXTENSION = 'filename-extension';
+const messages = {
+	[MESSAGE_ID]: 'Filename is not in {{chosenCases}}. Rename it to {{renamedFilenames}}.',
+	[MESSAGE_ID_EXTENSION]: 'File extension `{{extension}}` is not in lowercase. Rename it to `{{filename}}`.',
+};
+
+const pascalCase = string => upperFirst(camelCase(string));
+const numberRegex = /\d+/;
+const PLACEHOLDER = '\uFFFF\uFFFF\uFFFF';
+const PLACEHOLDER_REGEX = new RegExp(PLACEHOLDER, 'i');
+const isIgnoredChar = char => !/^[a-z\d-_]$/i.test(char);
+const ignoredByDefault = new Set(['index.js', 'index.mjs', 'index.cjs', 'index.ts', 'index.tsx', 'index.vue']);
+const isLowerCase = string => string === string.toLowerCase();
+
+function ignoreNumbers(caseFunction) {
+	return string => {
+		const stack = [];
+		let execResult = numberRegex.exec(string);
+
+		while (execResult) {
+			stack.push(execResult[0]);
+			string = string.replace(execResult[0], PLACEHOLDER);
+			execResult = numberRegex.exec(string);
+		}
+
+		let withCase = caseFunction(string);
+
+		while (stack.length > 0) {
+			withCase = withCase.replace(PLACEHOLDER_REGEX, stack.shift());
+		}
+
+		return withCase;
+	};
+}
+
+const cases = {
+	camelCase: {
+		fn: camelCase,
+		name: 'camel case',
+	},
+	kebabCase: {
+		fn: kebabCase,
+		name: 'kebab case',
+	},
+	snakeCase: {
+		fn: snakeCase,
+		name: 'snake case',
+	},
+	pascalCase: {
+		fn: pascalCase,
+		name: 'pascal case',
+	},
+};
+
+/**
+Get the cases specified by the option.
+
+@param {object} options
+@returns {string[]} The chosen cases.
+*/
+function getChosenCases(options) {
+	if (options.case) {
+		return [options.case];
+	}
+
+	if (options.cases) {
+		const cases = Object.keys(options.cases)
+			.filter(cases => options.cases[cases]);
+
+		return cases.length > 0 ? cases : ['kebabCase'];
+	}
+
+	return ['kebabCase'];
+}
+
+function validateFilename(words, caseFunctions) {
+	return words
+		.filter(({ignored}) => !ignored)
+		.every(({word}) => caseFunctions.some(caseFunction => caseFunction(word) === word));
+}
+
+function fixFilename(words, caseFunctions, {leading, extension}) {
+	const replacements = words
+		.map(({word, ignored}) => ignored ? [word] : caseFunctions.map(caseFunction => caseFunction(word)));
+
+	const {
+		samples: combinations,
+	} = cartesianProductSamples(replacements);
+
+	return [...new Set(combinations.map(parts => `${leading}${parts.join('')}${extension.toLowerCase()}`))];
+}
+
+const leadingUnderscoresRegex = /^(?<leading>_+)(?<tailing>.*)$/;
+function splitFilename(filename) {
+	const result = leadingUnderscoresRegex.exec(filename) || {groups: {}};
+	const {leading = '', tailing = filename} = result.groups;
+
+	const words = [];
+
+	let lastWord;
+	for (const char of tailing) {
+		const isIgnored = isIgnoredChar(char);
+
+		if (lastWord?.ignored === isIgnored) {
+			lastWord.word += char;
+		} else {
+			lastWord = {
+				word: char,
+				ignored: isIgnored,
+			};
+			words.push(lastWord);
+		}
+	}
+
+	return {
+		leading,
+		words,
+	};
+}
+
+/**
+Turns `[a, b, c]` into `a, b, or c`.
+
+@param {string[]} words
+@returns {string}
+*/
+const englishishJoinWords = words => new Intl.ListFormat('en-US', {type: 'disjunction'}).format(words);
+
+/** @param {import('eslint').Rule.RuleContext} context */
+const create = context => {
+	const options = context.options[0] || {};
+	const chosenCases = getChosenCases(options);
+	const ignore = (options.ignore || []).map(item => {
+		if (item instanceof RegExp) {
+			return item;
+		}
+
+		return new RegExp(item, 'u');
+	});
+	const chosenCasesFunctions = chosenCases.map(case_ => ignoreNumbers(cases[case_].fn));
+	const filenameWithExtension = context.physicalFilename;
+
+	if (filenameWithExtension === '<input>' || filenameWithExtension === '<text>') {
+		return;
+	}
+
+	return {
+		Program() {
+			const extension = path.extname(filenameWithExtension);
+			const filename = path.basename(filenameWithExtension, extension);
+			const base = filename + extension;
+
+			if (ignoredByDefault.has(base) || ignore.some(regexp => regexp.test(base))) {
+				return;
+			}
+
+			const {leading, words} = splitFilename(filename);
+			const isValid = validateFilename(words, chosenCasesFunctions);
+
+			if (isValid) {
+				if (!isLowerCase(extension)) {
+					return {
+						loc: {column: 0, line: 1},
+						messageId: MESSAGE_ID_EXTENSION,
+						data: {filename: filename + extension.toLowerCase(), extension},
+					};
+				}
+
+				return;
+			}
+
+			const renamedFilenames = fixFilename(words, chosenCasesFunctions, {
+				leading,
+				extension,
+			});
+
+			return {
+				// Report on first character like `unicode-bom` rule
+				// https://github.com/eslint/eslint/blob/8a77b661bc921c3408bae01b3aa41579edfc6e58/lib/rules/unicode-bom.js#L46
+				loc: {column: 0, line: 1},
+				messageId: MESSAGE_ID,
+				data: {
+					chosenCases: englishishJoinWords(chosenCases.map(x => cases[x].name)),
+					renamedFilenames: englishishJoinWords(renamedFilenames.map(x => `\`${x}\``)),
+				},
+			};
+		},
+	};
+};
+
+const schema = [
+	{
+		oneOf: [
+			{
+				properties: {
+					case: {
+						enum: [
+							'camelCase',
+							'snakeCase',
+							'kebabCase',
+							'pascalCase',
+						],
+					},
+					ignore: {
+						type: 'array',
+						uniqueItems: true,
+					},
+				},
+				additionalProperties: false,
+			},
+			{
+				properties: {
+					cases: {
+						properties: {
+							camelCase: {
+								type: 'boolean',
+							},
+							snakeCase: {
+								type: 'boolean',
+							},
+							kebabCase: {
+								type: 'boolean',
+							},
+							pascalCase: {
+								type: 'boolean',
+							},
+						},
+						additionalProperties: false,
+					},
+					ignore: {
+						type: 'array',
+						uniqueItems: true,
+					},
+				},
+				additionalProperties: false,
+			},
+		],
+	},
+];
+
+/** @type {import('eslint').Rule.RuleModule} */
+module.exports = {
+	create,
+	meta: {
+		type: 'suggestion',
+		docs: {
+			description: 'Enforce a case style for filenames.',
+		},
+		schema,
+		messages,
+	},
+};

package/rules/fix/add-parenthesizes-to-return-or-throw-expression.js

@@ -0,0 +1,21 @@
+'use strict';
+const {isSemicolonToken} = require('@eslint-community/eslint-utils');
+
+function * addParenthesizesToReturnOrThrowExpression(fixer, node, sourceCode) {
+	if (node.type !== 'ReturnStatement' && node.type !== 'ThrowStatement') {
+		return;
+	}
+
+	const returnOrThrowToken = sourceCode.getFirstToken(node);
+	yield fixer.insertTextAfter(returnOrThrowToken, ' (');
+
+	const lastToken = sourceCode.getLastToken(node);
+	if (!isSemicolonToken(lastToken)) {
+		yield fixer.insertTextAfter(node, ')');
+		return;
+	}
+
+	yield fixer.insertTextBefore(lastToken, ')');
+}
+
+module.exports = addParenthesizesToReturnOrThrowExpression;

package/rules/fix/append-argument.js

@@ -0,0 +1,20 @@
+'use strict';
+const {isCommaToken} = require('@eslint-community/eslint-utils');
+
+function appendArgument(fixer, node, text, sourceCode) {
+	// This function should also work for `NewExpression`
+	// But parentheses of `NewExpression` could be omitted, add this check to prevent accident use on it
+	/* c8 ignore next 3 */
+	if (node.type !== 'CallExpression') {
+		throw new Error(`Unexpected node "${node.type}".`);
+	}
+
+	const [penultimateToken, lastToken] = sourceCode.getLastTokens(node, 2);
+	if (node.arguments.length > 0) {
+		text = isCommaToken(penultimateToken) ? ` ${text},` : `, ${text}`;
+	}
+
+	return fixer.insertTextBefore(lastToken, text);
+}
+
+module.exports = appendArgument;

package/rules/fix/extend-fix-range.js

@@ -0,0 +1,15 @@
+'use strict';
+
+/**
+Extend fix range to prevent changes from other rules.
+https://github.com/eslint/eslint/pull/13748/files#diff-c692f3fde09eda7c89f1802c908511a3fb59f5d207fe95eb009cb52e46a99e84R348
+
+@param {ruleFixer} fixer - The fixer to fix.
+@param {int[]} range - The extended range node.
+*/
+function * extendFixRange(fixer, range) {
+	yield fixer.insertTextBeforeRange(range, '');
+	yield fixer.insertTextAfterRange(range, '');
+}
+
+module.exports = extendFixRange;

package/rules/fix/fix-space-around-keywords.js

@@ -0,0 +1,35 @@
+'use strict';
+const {getParenthesizedRange} = require('../utils/parentheses.js');
+
+const isProblematicToken = ({type, value}) => (
+	(type === 'Keyword' && /^[a-z]*$/.test(value))
+	// ForOfStatement
+	|| (type === 'Identifier' && value === 'of')
+	// AwaitExpression
+	|| (type === 'Identifier' && value === 'await')
+);
+
+function * fixSpaceAroundKeyword(fixer, node, sourceCode) {
+	const range = getParenthesizedRange(node, sourceCode);
+	const tokenBefore = sourceCode.getTokenBefore({range}, {includeComments: true});
+
+	if (
+		tokenBefore
+		&& range[0] === tokenBefore.range[1]
+		&& isProblematicToken(tokenBefore)
+	) {
+		yield fixer.insertTextAfter(tokenBefore, ' ');
+	}
+
+	const tokenAfter = sourceCode.getTokenAfter({range}, {includeComments: true});
+
+	if (
+		tokenAfter
+		&& range[1] === tokenAfter.range[0]
+		&& isProblematicToken(tokenAfter)
+	) {
+		yield fixer.insertTextBefore(tokenAfter, ' ');
+	}
+}
+
+module.exports = fixSpaceAroundKeyword;

package/rules/fix/index.js

@@ -0,0 +1,23 @@
+'use strict';
+
+module.exports = {
+	// Utilities
+	extendFixRange: require('./extend-fix-range.js'),
+	removeParentheses: require('./remove-parentheses.js'),
+
+	appendArgument: require('./append-argument.js'),
+	removeArgument: require('./remove-argument.js'),
+	replaceArgument: require('./replace-argument.js'),
+	switchNewExpressionToCallExpression: require('./switch-new-expression-to-call-expression.js'),
+	switchCallExpressionToNewExpression: require('./switch-call-expression-to-new-expression.js'),
+	removeMemberExpressionProperty: require('./remove-member-expression-property.js'),
+	removeMethodCall: require('./remove-method-call.js'),
+	replaceTemplateElement: require('./replace-template-element.js'),
+	replaceReferenceIdentifier: require('./replace-reference-identifier.js'),
+	renameVariable: require('./rename-variable.js'),
+	replaceNodeOrTokenAndSpacesBefore: require('./replace-node-or-token-and-spaces-before.js'),
+	removeSpacesAfter: require('./remove-spaces-after.js'),
+	fixSpaceAroundKeyword: require('./fix-space-around-keywords.js'),
+	replaceStringLiteral: require('./replace-string-literal.js'),
+	addParenthesizesToReturnOrThrowExpression: require('./add-parenthesizes-to-return-or-throw-expression.js'),
+};

package/rules/fix/remove-argument.js

@@ -0,0 +1,32 @@
+'use strict';
+const {isCommaToken} = require('@eslint-community/eslint-utils');
+const {getParentheses} = require('../utils/parentheses.js');
+
+function removeArgument(fixer, node, sourceCode) {
+	const callExpression = node.parent;
+	const index = callExpression.arguments.indexOf(node);
+	const parentheses = getParentheses(node, sourceCode);
+	const firstToken = parentheses[0] || node;
+	const lastToken = parentheses.at(-1) || node;
+
+	let [start] = firstToken.range;
+	let [, end] = lastToken.range;
+
+	if (index !== 0) {
+		start = sourceCode.getTokenBefore(firstToken).range[0];
+	}
+
+	// If the removed argument is the only argument, the trailing comma must be removed too
+	/* c8 ignore start */
+	if (callExpression.arguments.length === 1) {
+		const tokenAfter = sourceCode.getTokenBefore(lastToken);
+		if (isCommaToken(tokenAfter)) {
+			end = tokenAfter[1];
+		}
+	}
+	/* c8 ignore end */
+
+	return fixer.replaceTextRange([start, end], '');
+}
+
+module.exports = removeArgument;

package/rules/fix/remove-member-expression-property.js

@@ -0,0 +1,11 @@
+'use strict';
+const {getParenthesizedRange} = require('../utils/parentheses.js');
+
+function removeMemberExpressionProperty(fixer, memberExpression, sourceCode) {
+	const [, start] = getParenthesizedRange(memberExpression.object, sourceCode);
+	const [, end] = memberExpression.range;
+
+	return fixer.removeRange([start, end]);
+}
+
+module.exports = removeMemberExpressionProperty;

package/rules/fix/remove-method-call.js

@@ -0,0 +1,20 @@
+'use strict';
+const {getParenthesizedRange} = require('../utils/parentheses.js');
+const removeMemberExpressionProperty = require('./remove-member-expression-property.js');
+
+function * removeMethodCall(fixer, callExpression, sourceCode) {
+	const memberExpression = callExpression.callee;
+
+	// `(( (( foo )).bar ))()`
+	//              ^^^^
+	yield removeMemberExpressionProperty(fixer, memberExpression, sourceCode);
+
+	// `(( (( foo )).bar ))()`
+	//                     ^^
+	const [, start] = getParenthesizedRange(memberExpression, sourceCode);
+	const [, end] = callExpression.range;
+
+	yield fixer.removeRange([start, end]);
+}
+
+module.exports = removeMethodCall;

package/rules/fix/remove-parentheses.js

@@ -0,0 +1,11 @@
+'use strict';
+const {getParentheses} = require('../utils/parentheses.js');
+
+function * removeParentheses(node, fixer, sourceCode) {
+	const parentheses = getParentheses(node, sourceCode);
+	for (const token of parentheses) {
+		yield fixer.remove(token);
+	}
+}
+
+module.exports = removeParentheses;

package/rules/fix/remove-spaces-after.js

@@ -0,0 +1,14 @@
+'use strict';
+
+function removeSpacesAfter(indexOrNodeOrToken, sourceCode, fixer) {
+	let index = indexOrNodeOrToken;
+	if (typeof indexOrNodeOrToken === 'object' && Array.isArray(indexOrNodeOrToken.range)) {
+		index = indexOrNodeOrToken.range[1];
+	}
+
+	const textAfter = sourceCode.text.slice(index);
+	const [leadingSpaces] = textAfter.match(/^\s*/);
+	return fixer.removeRange([index, index + leadingSpaces.length]);
+}
+
+module.exports = removeSpacesAfter;