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

package/rules/prefer-at.js

@@ -0,0 +1,374 @@
+'use strict';
+const {isOpeningBracketToken, isClosingBracketToken, getStaticValue} = require('@eslint-community/eslint-utils');
+const {
+	isParenthesized,
+	getParenthesizedRange,
+	getParenthesizedText,
+	isNodeMatchesNameOrPath,
+	needsSemicolon,
+	shouldAddParenthesesToMemberExpressionObject,
+	isLeftHandSide,
+} = require('./utils/index.js');
+const {
+	getNegativeIndexLengthNode,
+	removeLengthNode,
+} = require('./shared/negative-index.js');
+const {removeMemberExpressionProperty, removeMethodCall} = require('./fix/index.js');
+const {isLiteral, isCallExpression, isMethodCall} = require('./ast/index.js');
+
+const MESSAGE_ID_NEGATIVE_INDEX = 'negative-index';
+const MESSAGE_ID_INDEX = 'index';
+const MESSAGE_ID_STRING_CHAR_AT_NEGATIVE = 'string-char-at-negative';
+const MESSAGE_ID_STRING_CHAR_AT = 'string-char-at';
+const MESSAGE_ID_SLICE = 'slice';
+const MESSAGE_ID_GET_LAST_FUNCTION = 'get-last-function';
+const SUGGESTION_ID = 'use-at';
+const messages = {
+	[MESSAGE_ID_NEGATIVE_INDEX]: 'Prefer `.at(…)` over `[….length - index]`.',
+	[MESSAGE_ID_INDEX]: 'Prefer `.at(…)` over index access.',
+	[MESSAGE_ID_STRING_CHAR_AT_NEGATIVE]: 'Prefer `String#at(…)` over `String#charAt(….length - index)`.',
+	[MESSAGE_ID_STRING_CHAR_AT]: 'Prefer `String#at(…)` over `String#charAt(…)`.',
+	[MESSAGE_ID_SLICE]: 'Prefer `.at(…)` over the first element from `.slice(…)`.',
+	[MESSAGE_ID_GET_LAST_FUNCTION]: 'Prefer `.at(-1)` over `{{description}}(…)` to get the last element.',
+	[SUGGESTION_ID]: 'Use `.at(…)`.',
+};
+
+const isArguments = node => node.type === 'Identifier' && node.name === 'arguments';
+
+const isLiteralNegativeInteger = node =>
+	node.type === 'UnaryExpression'
+	&& node.prefix
+	&& node.operator === '-'
+	&& node.argument.type === 'Literal'
+	&& Number.isInteger(node.argument.value)
+	&& node.argument.value > 0;
+const isZeroIndexAccess = node => {
+	const {parent} = node;
+	return parent.type === 'MemberExpression'
+		&& !parent.optional
+		&& parent.computed
+		&& parent.object === node
+		&& isLiteral(parent.property, 0);
+};
+
+const isArrayPopOrShiftCall = (node, method) => {
+	const {parent} = node;
+	return parent.type === 'MemberExpression'
+		&& !parent.optional
+		&& !parent.computed
+		&& parent.object === node
+		&& parent.property.type === 'Identifier'
+		&& parent.property.name === method
+		&& parent.parent.type === 'CallExpression'
+		&& parent.parent.callee === parent
+		&& !parent.parent.optional
+		&& parent.parent.arguments.length === 0;
+};
+
+const isArrayPopCall = node => isArrayPopOrShiftCall(node, 'pop');
+const isArrayShiftCall = node => isArrayPopOrShiftCall(node, 'shift');
+
+function checkSliceCall(node) {
+	const sliceArgumentsLength = node.arguments.length;
+	const [startIndexNode, endIndexNode] = node.arguments;
+
+	if (!isLiteralNegativeInteger(startIndexNode)) {
+		return;
+	}
+
+	let firstElementGetMethod = '';
+	if (isZeroIndexAccess(node)) {
+		if (isLeftHandSide(node.parent)) {
+			return;
+		}
+
+		firstElementGetMethod = 'zero-index';
+	} else if (isArrayShiftCall(node)) {
+		firstElementGetMethod = 'shift';
+	} else if (isArrayPopCall(node)) {
+		firstElementGetMethod = 'pop';
+	}
+
+	if (!firstElementGetMethod) {
+		return;
+	}
+
+	const startIndex = -startIndexNode.argument.value;
+	if (sliceArgumentsLength === 1) {
+		if (
+			firstElementGetMethod === 'zero-index'
+			|| firstElementGetMethod === 'shift'
+			|| (startIndex === -1 && firstElementGetMethod === 'pop')
+		) {
+			return {safeToFix: true, firstElementGetMethod};
+		}
+
+		return;
+	}
+
+	if (
+		isLiteralNegativeInteger(endIndexNode)
+		&& -endIndexNode.argument.value === startIndex + 1
+	) {
+		return {safeToFix: true, firstElementGetMethod};
+	}
+
+	if (firstElementGetMethod === 'pop') {
+		return;
+	}
+
+	return {safeToFix: false, firstElementGetMethod};
+}
+
+const lodashLastFunctions = [
+	'_.last',
+	'lodash.last',
+	'underscore.last',
+];
+
+/** @param {import('eslint').Rule.RuleContext} context */
+function create(context) {
+	const {
+		getLastElementFunctions,
+		checkAllIndexAccess,
+	} = {
+		getLastElementFunctions: [],
+		checkAllIndexAccess: false,
+		...context.options[0],
+	};
+	const getLastFunctions = [...getLastElementFunctions, ...lodashLastFunctions];
+	const {sourceCode} = context;
+
+	// Index access
+	context.on('MemberExpression', node => {
+		if (
+			node.optional
+			|| !node.computed
+			|| isLeftHandSide(node)
+		) {
+			return;
+		}
+
+		const indexNode = node.property;
+		const lengthNode = getNegativeIndexLengthNode(indexNode, node.object);
+
+		if (!lengthNode) {
+			if (!checkAllIndexAccess) {
+				return;
+			}
+
+			// Only if we are sure it's an positive integer
+			const staticValue = getStaticValue(indexNode, sourceCode.getScope(indexNode));
+			if (!staticValue || !Number.isInteger(staticValue.value) || staticValue.value < 0) {
+				return;
+			}
+		}
+
+		const problem = {
+			node: indexNode,
+			messageId: lengthNode ? MESSAGE_ID_NEGATIVE_INDEX : MESSAGE_ID_INDEX,
+		};
+
+		if (isArguments(node.object)) {
+			return problem;
+		}
+
+		problem.fix = function * (fixer) {
+			if (lengthNode) {
+				yield removeLengthNode(lengthNode, fixer, sourceCode);
+			}
+
+			// Only remove space for `foo[foo.length - 1]`
+			if (
+				indexNode.type === 'BinaryExpression'
+				&& indexNode.operator === '-'
+				&& indexNode.left === lengthNode
+				&& indexNode.right.type === 'Literal'
+				&& /^\d+$/.test(indexNode.right.raw)
+			) {
+				const numberNode = indexNode.right;
+				const tokenBefore = sourceCode.getTokenBefore(numberNode);
+				if (
+					tokenBefore.type === 'Punctuator'
+					&& tokenBefore.value === '-'
+					&& /^\s+$/.test(sourceCode.text.slice(tokenBefore.range[1], numberNode.range[0]))
+				) {
+					yield fixer.removeRange([tokenBefore.range[1], numberNode.range[0]]);
+				}
+			}
+
+			const openingBracketToken = sourceCode.getTokenBefore(indexNode, isOpeningBracketToken);
+			yield fixer.replaceText(openingBracketToken, '.at(');
+
+			const closingBracketToken = sourceCode.getTokenAfter(indexNode, isClosingBracketToken);
+			yield fixer.replaceText(closingBracketToken, ')');
+		};
+
+		return problem;
+	});
+
+	// `string.charAt`
+	context.on('CallExpression', node => {
+		if (!isMethodCall(node, {
+			method: 'charAt',
+			argumentsLength: 1,
+			optionalCall: false,
+			optionalMember: false,
+		})) {
+			return;
+		}
+
+		const [indexNode] = node.arguments;
+		const lengthNode = getNegativeIndexLengthNode(indexNode, node.callee.object);
+
+		// `String#charAt` don't care about index value, we assume it's always number
+		if (!lengthNode && !checkAllIndexAccess) {
+			return;
+		}
+
+		return {
+			node: indexNode,
+			messageId: lengthNode ? MESSAGE_ID_STRING_CHAR_AT_NEGATIVE : MESSAGE_ID_STRING_CHAR_AT,
+			suggest: [{
+				messageId: SUGGESTION_ID,
+				* fix(fixer) {
+					if (lengthNode) {
+						yield removeLengthNode(lengthNode, fixer, sourceCode);
+					}
+
+					yield fixer.replaceText(node.callee.property, 'at');
+				},
+			}],
+		};
+	});
+
+	// `.slice()`
+	context.on('CallExpression', sliceCall => {
+		if (!isMethodCall(sliceCall, {
+			method: 'slice',
+			minimumArguments: 1,
+			maximumArguments: 2,
+			optionalCall: false,
+			optionalMember: false,
+		})) {
+			return;
+		}
+
+		const result = checkSliceCall(sliceCall);
+		if (!result) {
+			return;
+		}
+
+		const {safeToFix, firstElementGetMethod} = result;
+
+		/** @param {import('eslint').Rule.RuleFixer} fixer */
+		function * fix(fixer) {
+			// `.slice` to `.at`
+			yield fixer.replaceText(sliceCall.callee.property, 'at');
+
+			// Remove extra arguments
+			if (sliceCall.arguments.length !== 1) {
+				const [, start] = getParenthesizedRange(sliceCall.arguments[0], sourceCode);
+				const [end] = sourceCode.getLastToken(sliceCall).range;
+				yield fixer.removeRange([start, end]);
+			}
+
+			// Remove `[0]`, `.shift()`, or `.pop()`
+			if (firstElementGetMethod === 'zero-index') {
+				yield removeMemberExpressionProperty(fixer, sliceCall.parent, sourceCode);
+			} else {
+				yield * removeMethodCall(fixer, sliceCall.parent.parent, sourceCode);
+			}
+		}
+
+		const problem = {
+			node: sliceCall.callee.property,
+			messageId: MESSAGE_ID_SLICE,
+		};
+
+		if (safeToFix) {
+			problem.fix = fix;
+		} else {
+			problem.suggest = [{messageId: SUGGESTION_ID, fix}];
+		}
+
+		return problem;
+	});
+
+	context.on('CallExpression', node => {
+		if (!isCallExpression(node, {argumentsLength: 1, optional: false})) {
+			return;
+		}
+
+		const matchedFunction = getLastFunctions.find(nameOrPath => isNodeMatchesNameOrPath(node.callee, nameOrPath));
+		if (!matchedFunction) {
+			return;
+		}
+
+		const problem = {
+			node: node.callee,
+			messageId: MESSAGE_ID_GET_LAST_FUNCTION,
+			data: {description: matchedFunction.trim()},
+		};
+
+		const [array] = node.arguments;
+
+		if (isArguments(array)) {
+			return problem;
+		}
+
+		problem.fix = function (fixer) {
+			let fixed = getParenthesizedText(array, sourceCode);
+
+			if (
+				!isParenthesized(array, sourceCode)
+				&& shouldAddParenthesesToMemberExpressionObject(array, sourceCode)
+			) {
+				fixed = `(${fixed})`;
+			}
+
+			fixed = `${fixed}.at(-1)`;
+
+			const tokenBefore = sourceCode.getTokenBefore(node);
+			if (needsSemicolon(tokenBefore, sourceCode, fixed)) {
+				fixed = `;${fixed}`;
+			}
+
+			return fixer.replaceText(node, fixed);
+		};
+
+		return problem;
+	});
+}
+
+const schema = [
+	{
+		type: 'object',
+		additionalProperties: false,
+		properties: {
+			getLastElementFunctions: {
+				type: 'array',
+				uniqueItems: true,
+			},
+			checkAllIndexAccess: {
+				type: 'boolean',
+				default: false,
+			},
+		},
+	},
+];
+
+/** @type {import('eslint').Rule.RuleModule} */
+module.exports = {
+	create,
+	meta: {
+		type: 'suggestion',
+		docs: {
+			description: 'Prefer `.at()` method for index access and `String#charAt()`.',
+		},
+		fixable: 'code',
+		hasSuggestions: true,
+		schema,
+		messages,
+	},
+};

package/rules/prefer-blob-reading-methods.js

@@ -0,0 +1,45 @@
+'use strict';
+const {isMethodCall} = require('./ast/index.js');
+
+const MESSAGE_ID = 'error';
+const messages = {
+	[MESSAGE_ID]: 'Prefer `Blob#{{replacement}}()` over `FileReader#{{method}}(blob)`.',
+};
+
+/** @param {import('eslint').Rule.RuleContext} context */
+const create = () => ({
+	CallExpression(node) {
+		if (!isMethodCall(node, {
+			methods: ['readAsText', 'readAsArrayBuffer'],
+			argumentsLength: 1,
+			optionalCall: false,
+			optionalMember: false,
+		})) {
+			return;
+		}
+
+		const method = node.callee.property;
+		const methodName = method.name;
+
+		return {
+			node: method,
+			messageId: MESSAGE_ID,
+			data: {
+				method: methodName,
+				replacement: methodName === 'readAsArrayBuffer' ? 'arrayBuffer' : 'text',
+			},
+		};
+	},
+});
+
+/** @type {import('eslint').Rule.RuleModule} */
+module.exports = {
+	create,
+	meta: {
+		type: 'suggestion',
+		docs: {
+			description: 'Prefer `Blob#arrayBuffer()` over `FileReader#readAsArrayBuffer(…)` and `Blob#text()` over `FileReader#readAsText(…)`.',
+		},
+		messages,
+	},
+};

package/rules/prefer-code-point.js

@@ -0,0 +1,67 @@
+'use strict';
+const {isMethodCall} = require('./ast/index.js');
+
+const messages = {
+	'error/charCodeAt': 'Prefer `String#codePointAt()` over `String#charCodeAt()`.',
+	'error/fromCharCode': 'Prefer `String.fromCodePoint()` over `String.fromCharCode()`.',
+	'suggestion/codePointAt': 'Use `String#codePointAt()`.',
+	'suggestion/fromCodePoint': 'Use `String.fromCodePoint()`.',
+};
+
+const getReplacement = node => {
+	if (isMethodCall(node, {
+		method: 'charCodeAt',
+		optionalCall: false,
+		optionalMember: false,
+	})) {
+		return 'codePointAt';
+	}
+
+	if (isMethodCall(node, {
+		object: 'String',
+		method: 'fromCharCode',
+		optionalCall: false,
+		optionalMember: false,
+	})) {
+		return 'fromCodePoint';
+	}
+};
+
+/** @param {import('eslint').Rule.RuleContext} context */
+const create = () => ({
+	CallExpression(node) {
+		const replacement = getReplacement(node);
+
+		if (!replacement) {
+			return;
+		}
+
+		const method = node.callee.property;
+		const methodName = method.name;
+		const fix = fixer => fixer.replaceText(method, replacement);
+
+		return {
+			node: method,
+			messageId: `error/${methodName}`,
+			suggest: [
+				{
+					messageId: `suggestion/${replacement}`,
+					fix,
+				},
+			],
+		};
+	},
+});
+
+/** @type {import('eslint').Rule.RuleModule} */
+module.exports = {
+	create,
+	meta: {
+		type: 'suggestion',
+		docs: {
+			description: 'Prefer `String#codePointAt(…)` over `String#charCodeAt(…)` and `String.fromCodePoint(…)` over `String.fromCharCode(…)`.',
+		},
+		hasSuggestions: true,
+		messages,
+	},
+};

package/rules/prefer-date-now.js

@@ -0,0 +1,135 @@
+'use strict';
+const {
+	isMethodCall,
+	isCallExpression,
+	isNewExpression,
+} = require('./ast/index.js');
+const {fixSpaceAroundKeyword} = require('./fix/index.js');
+
+const MESSAGE_ID_DEFAULT = 'prefer-date';
+const MESSAGE_ID_METHOD = 'prefer-date-now-over-methods';
+const MESSAGE_ID_NUMBER = 'prefer-date-now-over-number-data-object';
+const messages = {
+	[MESSAGE_ID_DEFAULT]: 'Prefer `Date.now()` over `new Date()`.',
+	[MESSAGE_ID_METHOD]: 'Prefer `Date.now()` over `Date#{{method}}()`.',
+	[MESSAGE_ID_NUMBER]: 'Prefer `Date.now()` over `Number(new Date())`.',
+};
+
+const isNewDate = node => isNewExpression(node, {name: 'Date', argumentsLength: 0});
+
+const getProblem = (node, problem, sourceCode) => ({
+	node,
+	messageId: MESSAGE_ID_DEFAULT,
+	* fix(fixer) {
+		yield fixer.replaceText(node, 'Date.now()');
+
+		if (node.type === 'UnaryExpression') {
+			yield * fixSpaceAroundKeyword(fixer, node, sourceCode);
+		}
+	},
+	...problem,
+});
+
+/** @param {import('eslint').Rule.RuleContext} context */
+const create = context => ({
+	CallExpression(callExpression) {
+		// `new Date().{getTime,valueOf}()`
+		if (
+			isMethodCall(callExpression, {
+				methods: ['getTime', 'valueOf'],
+				argumentsLength: 0,
+				optionalCall: false,
+				optionalMember: false,
+			})
+			&& isNewDate(callExpression.callee.object)
+		) {
+			const method = callExpression.callee.property;
+			return getProblem(callExpression, {
+				node: method,
+				messageId: MESSAGE_ID_METHOD,
+				data: {method: method.name},
+			});
+		}
+
+		// `{Number,BigInt}(new Date())`
+		if (
+			isCallExpression(callExpression, {
+				names: ['Number', 'BigInt'],
+				argumentsLength: 1,
+				optional: false,
+			})
+			&& isNewDate(callExpression.arguments[0])
+		) {
+			const {name} = callExpression.callee;
+			if (name === 'Number') {
+				return getProblem(callExpression, {
+					messageId: MESSAGE_ID_NUMBER,
+				});
+			}
+
+			return getProblem(callExpression.arguments[0]);
+		}
+	},
+	UnaryExpression(unaryExpression) {
+		// https://github.com/estree/estree/blob/master/es5.md#unaryoperator
+		if (
+			unaryExpression.operator !== '+'
+			&& unaryExpression.operator !== '-'
+		) {
+			return;
+		}
+
+		if (isNewDate(unaryExpression.argument)) {
+			return getProblem(
+				unaryExpression.operator === '-' ? unaryExpression.argument : unaryExpression,
+				{},
+				context.sourceCode,
+			);
+		}
+	},
+	AssignmentExpression(assignmentExpression) {
+		if (
+			assignmentExpression.operator !== '-='
+			&& assignmentExpression.operator !== '*='
+			&& assignmentExpression.operator !== '/='
+			&& assignmentExpression.operator !== '%='
+			&& assignmentExpression.operator !== '**='
+		) {
+			return;
+		}
+
+		if (isNewDate(assignmentExpression.right)) {
+			return getProblem(assignmentExpression.right);
+		}
+	},
+	* BinaryExpression(binaryExpression) {
+		if (
+			binaryExpression.operator !== '-'
+			&& binaryExpression.operator !== '*'
+			&& binaryExpression.operator !== '/'
+			&& binaryExpression.operator !== '%'
+			&& binaryExpression.operator !== '**'
+		) {
+			return;
+		}
+
+		for (const node of [binaryExpression.left, binaryExpression.right]) {
+			if (isNewDate(node)) {
+				yield getProblem(node);
+			}
+		}
+	},
+});
+
+/** @type {import('eslint').Rule.RuleModule} */
+module.exports = {
+	create,
+	meta: {
+		type: 'suggestion',
+		docs: {
+			description: 'Prefer `Date.now()` to get the number of milliseconds since the Unix Epoch.',
+		},
+		fixable: 'code',
+		messages,
+	},
+};