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

package/rules/no-useless-undefined.js

@@ -0,0 +1,301 @@
+'use strict';
+const {isCommaToken} = require('@eslint-community/eslint-utils');
+const {replaceNodeOrTokenAndSpacesBefore} = require('./fix/index.js');
+const {isUndefined, isFunction} = require('./ast/index.js');
+
+const messageId = 'no-useless-undefined';
+const messages = {
+	[messageId]: 'Do not use useless `undefined`.',
+};
+
+const compareFunctionNames = new Set([
+	'is',
+	'equal',
+	'notEqual',
+	'strictEqual',
+	'notStrictEqual',
+	'propertyVal',
+	'notPropertyVal',
+	'not',
+	'include',
+	'property',
+	'toBe',
+	'toHaveBeenCalledWith',
+	'toContain',
+	'toContainEqual',
+	'toEqual',
+	'same',
+	'notSame',
+	'strictSame',
+	'strictNotSame',
+]);
+const shouldIgnore = node => {
+	let name;
+
+	if (node.type === 'Identifier') {
+		name = node.name;
+	} else if (
+		node.type === 'MemberExpression'
+		&& node.computed === false
+		&& node.property.type === 'Identifier'
+	) {
+		name = node.property.name;
+	}
+
+	return compareFunctionNames.has(name)
+		// `array.push(undefined)`
+		|| name === 'push'
+		// `array.unshift(undefined)`
+		|| name === 'unshift'
+		// `array.includes(undefined)`
+		|| name === 'includes'
+
+		// `set.add(undefined)`
+		|| name === 'add'
+		// `set.has(undefined)`
+		|| name === 'has'
+
+		// `map.set(foo, undefined)`
+		|| name === 'set'
+
+		// `React.createContext(undefined)`
+		|| name === 'createContext'
+		// `setState(undefined)`
+		|| /^set[A-Z]/.test(name)
+
+		// https://vuejs.org/api/reactivity-core.html#ref
+		|| name === 'ref';
+};
+
+const getFunction = scope => {
+	for (; scope; scope = scope.upper) {
+		if (scope.type === 'function') {
+			return scope.block;
+		}
+	}
+};
+
+const isFunctionBindCall = node =>
+	!node.optional
+	&& node.callee.type === 'MemberExpression'
+	&& !node.callee.computed
+	&& node.callee.property.type === 'Identifier'
+	&& node.callee.property.name === 'bind';
+
+const isTypeScriptFile = context =>
+	/\.(?:ts|mts|cts|tsx)$/i.test(context.physicalFilename);
+
+/** @param {import('eslint').Rule.RuleContext} context */
+const create = context => {
+	const {sourceCode} = context;
+
+	const getProblem = (node, fix, checkFunctionReturnType) => {
+		if (checkFunctionReturnType) {
+			const functionNode = getFunction(sourceCode.getScope(node));
+			if (functionNode?.returnType) {
+				return;
+			}
+		}
+
+		return {
+			node,
+			messageId,
+			fix,
+		};
+	};
+
+	const options = {
+		checkArguments: true,
+		checkArrowFunctionBody: true,
+		...context.options[0],
+	};
+
+	const removeNodeAndLeadingSpace = (node, fixer) =>
+		replaceNodeOrTokenAndSpacesBefore(node, '', fixer, sourceCode);
+
+	// `return undefined`
+	context.on('Identifier', node => {
+		if (
+			isUndefined(node)
+			&& node.parent.type === 'ReturnStatement'
+			&& node.parent.argument === node
+		) {
+			return getProblem(
+				node,
+				fixer => removeNodeAndLeadingSpace(node, fixer),
+				/* CheckFunctionReturnType */ true,
+			);
+		}
+	});
+
+	// `yield undefined`
+	context.on('Identifier', node => {
+		if (
+			isUndefined(node)
+			&& node.parent.type === 'YieldExpression'
+			&& !node.parent.delegate
+			&& node.parent.argument === node
+		) {
+			return getProblem(
+				node,
+				fixer => removeNodeAndLeadingSpace(node, fixer),
+			);
+		}
+	});
+
+	// `() => undefined`
+	if (options.checkArrowFunctionBody) {
+		context.on('Identifier', node => {
+			if (
+				isUndefined(node)
+				&& node.parent.type === 'ArrowFunctionExpression'
+				&& node.parent.body === node
+			) {
+				return getProblem(
+					node,
+					fixer => replaceNodeOrTokenAndSpacesBefore(node, ' {}', fixer, sourceCode),
+					/* CheckFunctionReturnType */ true,
+				);
+			}
+		});
+	}
+
+	// `let foo = undefined` / `var foo = undefined`
+	context.on('Identifier', node => {
+		if (
+			isUndefined(node)
+			&& node.parent.type === 'VariableDeclarator'
+			&& node.parent.init === node
+			&& node.parent.parent.type === 'VariableDeclaration'
+			&& node.parent.parent.kind !== 'const'
+			&& node.parent.parent.declarations.includes(node.parent)
+		) {
+			return getProblem(
+				node,
+				fixer => fixer.removeRange([node.parent.id.range[1], node.range[1]]),
+				/* CheckFunctionReturnType */ true,
+			);
+		}
+	});
+
+	// `const {foo = undefined} = {}`
+	context.on('Identifier', node => {
+		if (
+			isUndefined(node)
+			&& node.parent.type === 'AssignmentPattern'
+			&& node.parent.right === node
+		) {
+			return getProblem(
+				node,
+				function * (fixer) {
+					const assignmentPattern = node.parent;
+					const {left} = assignmentPattern;
+
+					yield fixer.removeRange([left.range[1], node.range[1]]);
+					if (
+						(left.typeAnnotation || isTypeScriptFile(context))
+						&& !left.optional
+						&& isFunction(assignmentPattern.parent)
+						&& assignmentPattern.parent.params.includes(assignmentPattern)
+					) {
+						yield (
+							left.typeAnnotation
+								? fixer.insertTextBefore(left.typeAnnotation, '?')
+								: fixer.insertTextAfter(left, '?')
+						);
+					}
+				},
+				/* CheckFunctionReturnType */ true,
+			);
+		}
+	});
+
+	if (!options.checkArguments) {
+		return;
+	}
+
+	context.on('CallExpression', node => {
+		if (shouldIgnore(node.callee)) {
+			return;
+		}
+
+		const argumentNodes = node.arguments;
+
+		// Ignore arguments in `Function#bind()`, but not `this` argument
+		if (isFunctionBindCall(node) && argumentNodes.length !== 1) {
+			return;
+		}
+
+		const undefinedArguments = [];
+		for (let index = argumentNodes.length - 1; index >= 0; index--) {
+			const node = argumentNodes[index];
+			if (isUndefined(node)) {
+				undefinedArguments.unshift(node);
+			} else {
+				break;
+			}
+		}
+
+		if (undefinedArguments.length === 0) {
+			return;
+		}
+
+		const firstUndefined = undefinedArguments[0];
+		const lastUndefined = undefinedArguments.at(-1);
+
+		return {
+			messageId,
+			loc: {
+				start: firstUndefined.loc.start,
+				end: lastUndefined.loc.end,
+			},
+			fix(fixer) {
+				let start = firstUndefined.range[0];
+				let end = lastUndefined.range[1];
+
+				const previousArgument = argumentNodes[argumentNodes.length - undefinedArguments.length - 1];
+
+				if (previousArgument) {
+					start = previousArgument.range[1];
+				} else {
+					// If all arguments removed, and there is trailing comma, we need remove it.
+					const tokenAfter = sourceCode.getTokenAfter(lastUndefined);
+					if (isCommaToken(tokenAfter)) {
+						end = tokenAfter.range[1];
+					}
+				}
+
+				return fixer.removeRange([start, end]);
+			},
+		};
+	});
+};
+
+const schema = [
+	{
+		type: 'object',
+		additionalProperties: false,
+		properties: {
+			checkArguments: {
+				type: 'boolean',
+			},
+			checkArrowFunctionBody: {
+				type: 'boolean',
+			},
+		},
+	},
+];
+
+/** @type {import('eslint').Rule.RuleModule} */
+module.exports = {
+	create,
+	meta: {
+		type: 'suggestion',
+		docs: {
+			description: 'Disallow useless `undefined`.',
+		},
+		fixable: 'code',
+		schema,
+		messages,
+	},
+};

package/rules/no-zero-fractions.js

@@ -0,0 +1,79 @@
+'use strict';
+const {isParenthesized} = require('@eslint-community/eslint-utils');
+const needsSemicolon = require('./utils/needs-semicolon.js');
+const {isDecimalInteger} = require('./utils/numeric.js');
+const toLocation = require('./utils/to-location.js');
+const {fixSpaceAroundKeyword} = require('./fix/index.js');
+const {isNumberLiteral} = require('./ast/index.js');
+
+const MESSAGE_ZERO_FRACTION = 'zero-fraction';
+const MESSAGE_DANGLING_DOT = 'dangling-dot';
+const messages = {
+	[MESSAGE_ZERO_FRACTION]: 'Don\'t use a zero fraction in the number.',
+	[MESSAGE_DANGLING_DOT]: 'Don\'t use a dangling dot in the number.',
+};
+
+/** @param {import('eslint').Rule.RuleContext} context */
+const create = context => ({
+	Literal(node) {
+		if (!isNumberLiteral(node)) {
+			return;
+		}
+
+		// Legacy octal number `0777` and prefixed number `0o1234` cannot have a dot.
+		const {raw} = node;
+		const match = raw.match(/^(?<before>[\d_]*)(?<dotAndFractions>\.[\d_]*)(?<after>.*)$/);
+		if (!match) {
+			return;
+		}
+
+		const {before, dotAndFractions, after} = match.groups;
+		const fixedDotAndFractions = dotAndFractions.replaceAll(/[.0_]+$/g, '');
+		const formatted = ((before + fixedDotAndFractions) || '0') + after;
+
+		if (formatted === raw) {
+			return;
+		}
+
+		const isDanglingDot = dotAndFractions === '.';
+		// End of fractions
+		const end = node.range[0] + before.length + dotAndFractions.length;
+		const start = end - (raw.length - formatted.length);
+		const {sourceCode} = context;
+		return {
+			loc: toLocation([start, end], sourceCode),
+			messageId: isDanglingDot ? MESSAGE_DANGLING_DOT : MESSAGE_ZERO_FRACTION,
+			* fix(fixer) {
+				let fixed = formatted;
+				if (
+					node.parent.type === 'MemberExpression'
+					&& node.parent.object === node
+					&& isDecimalInteger(formatted)
+					&& !isParenthesized(node, sourceCode)
+				) {
+					fixed = `(${fixed})`;
+
+					if (needsSemicolon(sourceCode.getTokenBefore(node), sourceCode, fixed)) {
+						fixed = `;${fixed}`;
+					}
+				}
+
+				yield fixer.replaceText(node, fixed);
+				yield * fixSpaceAroundKeyword(fixer, node, sourceCode);
+			},
+		};
+	},
+});
+
+/** @type {import('eslint').Rule.RuleModule} */
+module.exports = {
+	create,
+	meta: {
+		type: 'suggestion',
+		docs: {
+			description: 'Disallow number literals with zero fractions or dangling dots.',
+		},
+		fixable: 'code',
+		messages,
+	},
+};

package/rules/number-literal-case.js

@@ -0,0 +1,52 @@
+'use strict';
+const {checkVueTemplate} = require('./utils/rule.js');
+const {isNumberLiteral, isBigIntLiteral} = require('./ast/index.js');
+
+const MESSAGE_ID = 'number-literal-case';
+const messages = {
+	[MESSAGE_ID]: 'Invalid number literal casing.',
+};
+
+const fix = raw => {
+	let fixed = raw.toLowerCase();
+	if (fixed.startsWith('0x')) {
+		fixed = '0x' + fixed.slice(2).toUpperCase();
+	}
+
+	return fixed;
+};
+
+/** @param {import('eslint').Rule.RuleContext} context */
+const create = () => ({
+	Literal(node) {
+		const {raw} = node;
+
+		let fixed = raw;
+		if (isNumberLiteral(node)) {
+			fixed = fix(raw);
+		} else if (isBigIntLiteral(node)) {
+			fixed = fix(raw.slice(0, -1)) + 'n';
+		}
+
+		if (raw !== fixed) {
+			return {
+				node,
+				messageId: MESSAGE_ID,
+				fix: fixer => fixer.replaceText(node, fixed),
+			};
+		}
+	},
+});
+
+/** @type {import('eslint').Rule.RuleModule} */
+module.exports = {
+	create: checkVueTemplate(create),
+	meta: {
+		type: 'suggestion',
+		docs: {
+			description: 'Enforce proper case for numeric literals.',
+		},
+		fixable: 'code',
+		messages,
+	},
+};

package/rules/numeric-separators-style.js

@@ -0,0 +1,181 @@
+'use strict';
+const numeric = require('./utils/numeric.js');
+const {isBigIntLiteral} = require('./ast/index.js');
+
+const MESSAGE_ID = 'numeric-separators-style';
+const messages = {
+	[MESSAGE_ID]: 'Invalid group length in numeric value.',
+};
+
+function addSeparator(value, {minimumDigits, groupLength}, fromLeft) {
+	const {length} = value;
+
+	if (length < minimumDigits) {
+		return value;
+	}
+
+	const parts = [];
+	if (fromLeft) {
+		for (let start = 0; start < length; start += groupLength) {
+			const end = Math.min(start + groupLength, length);
+			parts.push(value.slice(start, end));
+		}
+	} else {
+		for (let end = length; end > 0; end -= groupLength) {
+			const start = Math.max(end - groupLength, 0);
+			parts.unshift(value.slice(start, end));
+		}
+	}
+
+	return parts.join('_');
+}
+
+function addSeparatorFromLeft(value, options) {
+	return addSeparator(value, options, true);
+}
+
+function formatNumber(value, options) {
+	const {integer, dot, fractional} = numeric.parseFloatNumber(value);
+	return addSeparator(integer, options) + dot + addSeparatorFromLeft(fractional, options);
+}
+
+function format(value, {prefix, data}, options) {
+	const formatOption = options[prefix.toLowerCase()];
+
+	if (prefix) {
+		return prefix + addSeparator(data, formatOption);
+	}
+
+	const {
+		number,
+		mark,
+		sign,
+		power,
+	} = numeric.parseNumber(value);
+
+	return formatNumber(number, formatOption) + mark + sign + addSeparator(power, options['']);
+}
+
+const defaultOptions = {
+	binary: {minimumDigits: 0, groupLength: 4},
+	octal: {minimumDigits: 0, groupLength: 4},
+	hexadecimal: {minimumDigits: 0, groupLength: 2},
+	number: {minimumDigits: 5, groupLength: 3},
+};
+const create = context => {
+	const {
+		onlyIfContainsSeparator,
+		binary,
+		octal,
+		hexadecimal,
+		number,
+	} = {
+		onlyIfContainsSeparator: false,
+		...context.options[0],
+	};
+
+	const options = {
+		'0b': {
+			onlyIfContainsSeparator,
+			...defaultOptions.binary,
+			...binary,
+		},
+		'0o': {
+			onlyIfContainsSeparator,
+			...defaultOptions.octal,
+			...octal,
+		},
+		'0x': {
+			onlyIfContainsSeparator,
+			...defaultOptions.hexadecimal,
+			...hexadecimal,
+		},
+		'': {
+			onlyIfContainsSeparator,
+			...defaultOptions.number,
+			...number,
+		},
+	};
+
+	return {
+		Literal(node) {
+			if (!numeric.isNumeric(node) || numeric.isLegacyOctal(node)) {
+				return;
+			}
+
+			const {raw} = node;
+			let number = raw;
+			let suffix = '';
+			if (isBigIntLiteral(node)) {
+				number = raw.slice(0, -1);
+				suffix = 'n';
+			}
+
+			const strippedNumber = number.replaceAll('_', '');
+			const {prefix, data} = numeric.getPrefix(strippedNumber);
+
+			const {onlyIfContainsSeparator} = options[prefix.toLowerCase()];
+			if (onlyIfContainsSeparator && !raw.includes('_')) {
+				return;
+			}
+
+			const formatted = format(strippedNumber, {prefix, data}, options) + suffix;
+
+			if (raw !== formatted) {
+				return {
+					node,
+					messageId: MESSAGE_ID,
+					fix: fixer => fixer.replaceText(node, formatted),
+				};
+			}
+		},
+	};
+};
+
+const formatOptionsSchema = ({minimumDigits, groupLength}) => ({
+	type: 'object',
+	additionalProperties: false,
+	properties: {
+		onlyIfContainsSeparator: {
+			type: 'boolean',
+		},
+		minimumDigits: {
+			type: 'integer',
+			minimum: 0,
+			default: minimumDigits,
+		},
+		groupLength: {
+			type: 'integer',
+			minimum: 1,
+			default: groupLength,
+		},
+	},
+});
+
+const schema = [{
+	type: 'object',
+	additionalProperties: false,
+	properties: {
+		...Object.fromEntries(
+			Object.entries(defaultOptions).map(([type, options]) => [type, formatOptionsSchema(options)]),
+		),
+		onlyIfContainsSeparator: {
+			type: 'boolean',
+			default: false,
+		},
+	},
+}];
+
+/** @type {import('eslint').Rule.RuleModule} */
+module.exports = {
+	create,
+	meta: {
+		type: 'suggestion',
+		docs: {
+			description: 'Enforce the style of numeric separators by correctly grouping digits.',
+		},
+		fixable: 'code',
+		schema,
+		messages,
+	},
+};