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

package/rules/utils/avoid-capture.js

@@ -0,0 +1,146 @@
+'use strict';
+const {
+	isIdentifierName,
+	isStrictReservedWord,
+	isKeyword,
+} = require('@babel/helper-validator-identifier');
+const resolveVariableName = require('./resolve-variable-name.js');
+const getReferences = require('./get-references.js');
+
+// https://github.com/microsoft/TypeScript/issues/2536#issuecomment-87194347
+const typescriptReservedWords = new Set([
+	'break',
+	'case',
+	'catch',
+	'class',
+	'const',
+	'continue',
+	'debugger',
+	'default',
+	'delete',
+	'do',
+	'else',
+	'enum',
+	'export',
+	'extends',
+	'false',
+	'finally',
+	'for',
+	'function',
+	'if',
+	'import',
+	'in',
+	'instanceof',
+	'new',
+	'null',
+	'return',
+	'super',
+	'switch',
+	'this',
+	'throw',
+	'true',
+	'try',
+	'typeof',
+	'var',
+	'void',
+	'while',
+	'with',
+	'as',
+	'implements',
+	'interface',
+	'let',
+	'package',
+	'private',
+	'protected',
+	'public',
+	'static',
+	'yield',
+	'any',
+	'boolean',
+	'constructor',
+	'declare',
+	'get',
+	'module',
+	'require',
+	'number',
+	'set',
+	'string',
+	'symbol',
+	'type',
+	'from',
+	'of',
+]);
+
+// Copied from https://github.com/babel/babel/blob/fce35af69101c6b316557e28abf60bdbf77d6a36/packages/babel-types/src/validators/isValidIdentifier.ts#L7
+// Use this function instead of `require('@babel/types').isIdentifier`, since `@babel/helper-validator-identifier` package is much smaller
+const isValidIdentifier = name =>
+	typeof name === 'string'
+	&& !isKeyword(name)
+	&& !isStrictReservedWord(name, true)
+	&& isIdentifierName(name)
+	&& name !== 'arguments'
+	&& !typescriptReservedWords.has(name);
+
+/*
+Unresolved reference is probably from the global scope. We should avoid using that name.
+
+For example, like `foo` and `bar` below.
+
+```
+function unicorn() {
+	return foo;
+}
+
+function unicorn() {
+	return function() {
+		return bar;
+	};
+}
+```
+*/
+const isUnresolvedName = (name, scope) =>
+	getReferences(scope).some(({identifier, resolved}) => identifier?.name === name && !resolved);
+
+const isSafeName = (name, scopes) =>
+	!scopes.some(scope => resolveVariableName(name, scope) || isUnresolvedName(name, scope));
+
+const alwaysTrue = () => true;
+
+/**
+Rule-specific name check function.
+
+@callback isSafe
+@param {string} name - The generated candidate name.
+@param {Scope[]} scopes - The same list of scopes you pass to `avoidCapture`.
+@returns {boolean} - `true` if the `name` is ok.
+*/
+
+/**
+Generates a unique name prefixed with `name` such that:
+- it is not defined in any of the `scopes`,
+- it is not a reserved word,
+- it is not `arguments` in strict scopes (where `arguments` is not allowed),
+- it does not collide with the actual `arguments` (which is always defined in function scopes).
+
+Useful when you want to rename a variable (or create a new variable) while being sure not to shadow any other variables in the code.
+
+@param {string} name - The desired name for a new variable.
+@param {Scope[]} scopes - The list of scopes the new variable will be referenced in.
+@param {isSafe} [isSafe] - Rule-specific name check function.
+@returns {string} - Either `name` as is, or a string like `${name}_` suffixed with underscores to make the name unique.
+*/
+module.exports = (name, scopes, isSafe = alwaysTrue) => {
+	if (!isValidIdentifier(name)) {
+		name += '_';
+
+		if (!isValidIdentifier(name)) {
+			return;
+		}
+	}
+
+	while (!isSafeName(name, scopes) || !isSafe(name, scopes)) {
+		name += '_';
+	}
+
+	return name;
+};

package/rules/utils/boolean.js

@@ -0,0 +1,92 @@
+'use strict';
+
+const isLogicalExpression = require('./is-logical-expression.js');
+
+const isLogicNot = node => node?.type === 'UnaryExpression' && node.operator === '!';
+const isLogicNotArgument = node => isLogicNot(node.parent) && node.parent.argument === node;
+const isBooleanCallArgument = node => isBooleanCall(node.parent) && node.parent.arguments[0] === node;
+const isBooleanCall = node =>
+	node?.type === 'CallExpression'
+	&& node.callee.type === 'Identifier'
+	&& node.callee.name === 'Boolean'
+	&& node.arguments.length === 1;
+const isVueBooleanAttributeValue = node =>
+	node?.type === 'VExpressionContainer'
+	&& node.parent.type === 'VAttribute'
+	&& node.parent.directive
+	&& node.parent.value === node
+	&& node.parent.key.type === 'VDirectiveKey'
+	&& node.parent.key.name.type === 'VIdentifier'
+	&& (
+		node.parent.key.name.rawName === 'if'
+		|| node.parent.key.name.rawName === 'else-if'
+		|| node.parent.key.name.rawName === 'show'
+	);
+
+/**
+Check if the value of node is a `boolean`.
+
+@param {Node} node
+@returns {boolean}
+*/
+function isBooleanNode(node) {
+	if (
+		isLogicNot(node)
+		|| isLogicNotArgument(node)
+		|| isBooleanCall(node)
+		|| isBooleanCallArgument(node)
+	) {
+		return true;
+	}
+
+	const {parent} = node;
+	if (isVueBooleanAttributeValue(parent)) {
+		return true;
+	}
+
+	if (
+		(
+			parent.type === 'IfStatement'
+			|| parent.type === 'ConditionalExpression'
+			|| parent.type === 'WhileStatement'
+			|| parent.type === 'DoWhileStatement'
+			|| parent.type === 'ForStatement'
+		)
+		&& parent.test === node
+	) {
+		return true;
+	}
+
+	if (isLogicalExpression(parent)) {
+		return isBooleanNode(parent);
+	}
+
+	return false;
+}
+
+/**
+Get the boolean type-casting ancestor.
+
+@typedef {{ node: Node, isNegative: boolean }} Result
+
+@param {Node} node
+@returns {Result}
+*/
+function getBooleanAncestor(node) {
+	let isNegative = false;
+	// eslint-disable-next-line no-constant-condition
+	while (true) {
+		if (isLogicNotArgument(node)) {
+			isNegative = !isNegative;
+			node = node.parent;
+		} else if (isBooleanCallArgument(node)) {
+			node = node.parent;
+		} else {
+			break;
+		}
+	}
+
+	return {node, isNegative};
+}
+
+module.exports = {isBooleanNode, getBooleanAncestor};

package/rules/utils/builtins.js

@@ -0,0 +1,36 @@
+'use strict';
+const typedArray = require('../shared/typed-array.js');
+
+const enforceNew = [
+	'Object',
+	'Array',
+	'ArrayBuffer',
+	'DataView',
+	'Date',
+	'Error',
+	'Function',
+	'Map',
+	'WeakMap',
+	'Set',
+	'WeakSet',
+	'Promise',
+	'RegExp',
+	'SharedArrayBuffer',
+	'Proxy',
+	'WeakRef',
+	'FinalizationRegistry',
+	...typedArray,
+];
+
+const disallowNew = [
+	'BigInt',
+	'Boolean',
+	'Number',
+	'String',
+	'Symbol',
+];
+
+module.exports = {
+	enforceNew,
+	disallowNew,
+};

package/rules/utils/cartesian-product-samples.js

@@ -0,0 +1,24 @@
+'use strict';
+
+module.exports = (combinations, length = Number.POSITIVE_INFINITY) => {
+	const total = combinations.reduce((total, {length}) => total * length, 1);
+
+	const samples = Array.from({length: Math.min(total, length)}, (_, sampleIndex) => {
+		let indexRemaining = sampleIndex;
+		const combination = [];
+		for (let combinationIndex = combinations.length - 1; combinationIndex >= 0; combinationIndex--) {
+			const items = combinations[combinationIndex];
+			const {length} = items;
+			const index = indexRemaining % length;
+			indexRemaining = (indexRemaining - index) / length;
+			combination.unshift(items[index]);
+		}
+
+		return combination;
+	});
+
+	return {
+		total,
+		samples,
+	};
+};

package/rules/utils/create-deprecated-rules.js

@@ -0,0 +1,25 @@
+'use strict';
+const packageJson = require('../../package.json');
+
+const repoUrl = 'https://github.com/sindresorhus/eslint-plugin-unicorn';
+
+/** @returns {{ [ruleName: string]: import('eslint').Rule.RuleModule }} */
+function createDeprecatedRules(data) {
+	return Object.fromEntries(
+		Object.entries(data).map(([ruleId, replacedBy = []]) => [
+			ruleId,
+			{
+				create: () => ({}),
+				meta: {
+					docs: {
+						url: `${repoUrl}/blob/v${packageJson.version}/docs/deprecated-rules.md#${ruleId}`,
+					},
+					deprecated: true,
+					replacedBy: Array.isArray(replacedBy) ? replacedBy : [replacedBy],
+				},
+			},
+		]),
+	);
+}
+
+module.exports = createDeprecatedRules;

package/rules/utils/escape-string.js

@@ -0,0 +1,26 @@
+'use strict';
+
+const jsesc = require('jsesc');
+
+/**
+Escape string and wrap the result in quotes.
+
+@param {string} string - The string to be quoted.
+@param {string} [quote] - The quote character.
+@returns {string} - The quoted and escaped string.
+*/
+module.exports = (string, quote = '\'') => {
+	/* c8 ignore start */
+	if (typeof string !== 'string') {
+		throw new TypeError('Unexpected string.');
+	}
+	/* c8 ignore end */
+
+	return jsesc(string, {
+		quotes: quote === '"' ? 'double' : 'single',
+		wrap: true,
+		es6: true,
+		minimal: true,
+		lowercaseHex: false,
+	});
+};

package/rules/utils/escape-template-element-raw.js

@@ -0,0 +1,6 @@
+'use strict';
+
+module.exports = string => string.replaceAll(
+	/(?<=(?:^|[^\\])(?:\\\\)*)(?<symbol>(?:`|\$(?={)))/g,
+	'\\$<symbol>',
+);

package/rules/utils/get-ancestor.js

@@ -0,0 +1,20 @@
+'use strict';
+
+// TODO: Support more types
+function getPredicate(options) {
+	if (typeof options === 'string') {
+		return node => node.type === options;
+	}
+}
+
+function getAncestor(node, options) {
+	const predicate = getPredicate(options);
+
+	for (;node.parent; node = node.parent) {
+		if (predicate(node)) {
+			return node;
+		}
+	}
+}
+
+module.exports = getAncestor;

package/rules/utils/get-builtin-rule.js

@@ -0,0 +1,7 @@
+'use strict';
+
+function getBuiltinRule(id) {
+	return require('eslint/use-at-your-own-risk').builtinRules.get(id);
+}
+
+module.exports = getBuiltinRule;

package/rules/utils/get-call-expression-arguments-text.js

@@ -0,0 +1,21 @@
+'use strict';
+const {isOpeningParenToken} = require('@eslint-community/eslint-utils');
+
+/**
+Get the text of the arguments list of `CallExpression`.
+
+@param {Node} node - The `CallExpression` node.
+@param {SourceCode} sourceCode - The source code object.
+@returns {string}
+*/
+const getCallExpressionArgumentsText = (node, sourceCode) => {
+	const openingParenthesisToken = sourceCode.getTokenAfter(node.callee, isOpeningParenToken);
+	const closingParenthesisToken = sourceCode.getLastToken(node);
+
+	return sourceCode.text.slice(
+		openingParenthesisToken.range[1],
+		closingParenthesisToken.range[0],
+	);
+};
+
+module.exports = getCallExpressionArgumentsText;

package/rules/utils/get-class-head-location.js

@@ -0,0 +1,22 @@
+'use strict';
+
+/**
+@typedef {line: number, column: number} Position
+
+Get the location of the given class node for reporting.
+
+@param {Node} node - The class node to get.
+@param {SourceCode} sourceCode - The source code object to get tokens.
+@returns {{start: Position, end: Position}} The location of the class node for reporting.
+*/
+function getClassHeadLocation(node, sourceCode) {
+	const {loc, body} = node;
+	const tokenBeforeBody = sourceCode.getTokenBefore(body);
+
+	const {start} = loc;
+	const {end} = tokenBeforeBody.loc;
+
+	return {start, end};
+}
+
+module.exports = getClassHeadLocation;

package/rules/utils/get-documentation-url.js

@@ -0,0 +1,10 @@
+'use strict';
+const path = require('node:path');
+const packageJson = require('../../package.json');
+
+const repoUrl = 'https://github.com/sindresorhus/eslint-plugin-unicorn';
+
+module.exports = filename => {
+	const ruleName = path.basename(filename, '.js');
+	return `${repoUrl}/blob/v${packageJson.version}/docs/rules/${ruleName}.md`;
+};

package/rules/utils/get-indent-string.js

@@ -0,0 +1,11 @@
+'use strict';
+
+function getIndentString(node, sourceCode) {
+	const {line, column} = sourceCode.getLocFromIndex(node.range[0]);
+	const lines = sourceCode.getLines();
+	const before = lines[line - 1].slice(0, column);
+
+	return before.match(/\s*$/)[0];
+}
+
+module.exports = getIndentString;

package/rules/utils/get-previous-node.js

@@ -0,0 +1,24 @@
+'use strict';
+
+function getPreviousNode(node, sourceCode) {
+	const {parent} = node;
+	const visitorKeys = sourceCode.visitorKeys[parent.type] || Object.keys(parent);
+
+	for (const property of visitorKeys) {
+		const value = parent[property];
+
+		if (value === node) {
+			return;
+		}
+
+		if (Array.isArray(value)) {
+			const index = value.indexOf(node);
+
+			if (index !== -1) {
+				return value[index - 1];
+			}
+		}
+	}
+}
+
+module.exports = getPreviousNode;

package/rules/utils/get-references.js

@@ -0,0 +1,9 @@
+'use strict';
+
+const getScopes = require('./get-scopes.js');
+
+const getReferences = scope => [...new Set(
+	getScopes(scope).flatMap(({references}) => references),
+)];
+
+module.exports = getReferences;

package/rules/utils/get-scopes.js

@@ -0,0 +1,14 @@
+'use strict';
+
+/**
+Gather a list of all Scopes starting recursively from the input Scope.
+
+@param {Scope} scope - The Scope to start checking from.
+@returns {Scope[]} - The resulting Scopes.
+*/
+const getScopes = scope => [
+	scope,
+	...scope.childScopes.flatMap(scope => getScopes(scope)),
+];
+
+module.exports = getScopes;

package/rules/utils/get-switch-case-head-location.js

@@ -0,0 +1,21 @@
+'use strict';
+
+const {isColonToken} = require('@eslint-community/eslint-utils');
+
+/**
+@typedef {line: number, column: number} Position
+
+Get the location of the given `SwitchCase` node for reporting.
+
+@param {Node} node - The `SwitchCase` node to get.
+@param {SourceCode} sourceCode - The source code object to get tokens from.
+@returns {{start: Position, end: Position}} The location of the class node for reporting.
+*/
+function getSwitchCaseHeadLocation(node, sourceCode) {
+	const startToken = node.test || sourceCode.getFirstToken(node);
+	const colonToken = sourceCode.getTokenAfter(startToken, isColonToken);
+
+	return {start: node.loc.start, end: colonToken.loc.end};
+}
+
+module.exports = getSwitchCaseHeadLocation;

package/rules/utils/get-variable-identifiers.js

@@ -0,0 +1,7 @@
+'use strict';
+
+// Get identifiers of given variable
+module.exports = ({identifiers, references}) => [...new Set([
+	...identifiers,
+	...references.map(({identifier}) => identifier),
+])];

package/rules/utils/global-reference-tracker.js

@@ -0,0 +1,72 @@
+'use strict';
+const {ReferenceTracker} = require('@eslint-community/eslint-utils');
+
+const createTraceMap = (object, type) => {
+	let map = {[type]: true};
+
+	const path = object.split('.').reverse();
+	for (const name of path) {
+		map = {[name]: map};
+	}
+
+	return map;
+};
+
+class GlobalReferenceTracker {
+	#traceMap = {};
+	#filter;
+	#handle;
+
+	constructor({
+		object,
+		objects = [object],
+		filter,
+		handle,
+		type = ReferenceTracker.READ,
+	}) {
+		for (const object of objects) {
+			Object.assign(this.#traceMap, createTraceMap(object, type));
+		}
+
+		this.#filter = filter;
+		this.#handle = handle;
+	}
+
+	* track(globalScope) {
+		const tracker = new ReferenceTracker(globalScope);
+
+		for (const reference of tracker.iterateGlobalReferences(this.#traceMap)) {
+			if (this.#filter && !this.#filter(reference)) {
+				continue;
+			}
+
+			const problems = this.#handle(reference);
+
+			if (!problems) {
+				continue;
+			}
+
+			if (problems[Symbol.iterator]) {
+				yield * problems;
+			} else {
+				yield problems;
+			}
+		}
+	}
+
+	createListeners(context) {
+		return {
+			'Program:exit': program => this.track(context.sourceCode.getScope(program)),
+		};
+	}
+}
+
+Object.assign(GlobalReferenceTracker, {
+	READ: ReferenceTracker.READ,
+	CALL: ReferenceTracker.CALL,
+	CONSTRUCT: ReferenceTracker.CONSTRUCT,
+});
+
+module.exports = {
+	GlobalReferenceTracker,
+};

package/rules/utils/has-optional-chain-element.js

@@ -0,0 +1,21 @@
+'use strict';
+
+const isChainElement = node => node.type === 'MemberExpression' || node.type === 'CallExpression';
+
+function hasOptionalChainElement(node) {
+	if (!isChainElement(node)) {
+		return false;
+	}
+
+	if (node.optional) {
+		return true;
+	}
+
+	if (node.type === 'MemberExpression') {
+		return hasOptionalChainElement(node.object);
+	}
+
+	return false;
+}
+
+module.exports = hasOptionalChainElement;

package/rules/utils/has-same-range.js

@@ -0,0 +1,7 @@
+'use strict';
+
+module.exports = (node1, node2) =>
+	node1
+	&& node2
+	&& node1.range[0] === node2.range[0]
+	&& node1.range[1] === node2.range[1];