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

package/rules/utils/needs-semicolon.js

@@ -0,0 +1,114 @@
+'use strict';
+
+// https://github.com/eslint/espree/blob/6b7d0b8100537dcd5c84a7fb17bbe28edcabe05d/lib/token-translator.js#L20
+const tokenTypesNeedsSemicolon = new Set([
+	'String',
+	'Null',
+	'Boolean',
+	'Numeric',
+	'RegularExpression',
+]);
+
+const charactersMightNeedsSemicolon = new Set([
+	'[',
+	'(',
+	'/',
+	'`',
+	'+',
+	'-',
+	'*',
+	',',
+	'.',
+]);
+
+/**
+Determines if a semicolon needs to be inserted before `code`, in order to avoid a SyntaxError.
+
+@param {Token} tokenBefore Token before `code`.
+@param {SourceCode} sourceCode
+@param {String} [code] Code text to determine.
+@returns {boolean} `true` if a semicolon needs to be inserted before `code`.
+*/
+
+function needsSemicolon(tokenBefore, sourceCode, code) {
+	if (
+		code === ''
+		|| (code && !charactersMightNeedsSemicolon.has(code.charAt(0)))
+	) {
+		return false;
+	}
+
+	if (!tokenBefore) {
+		return false;
+	}
+
+	const {type, value, range} = tokenBefore;
+	const lastBlockNode = sourceCode.getNodeByRangeIndex(range[0]);
+	if (type === 'Punctuator') {
+		if (value === ';') {
+			return false;
+		}
+
+		if (value === ']') {
+			return true;
+		}
+
+		if (value === ')') {
+			switch (lastBlockNode.type) {
+				case 'IfStatement': {
+					if (sourceCode.getTokenBefore(lastBlockNode.consequent) === tokenBefore) {
+						return false;
+					}
+
+					break;
+				}
+
+				case 'ForStatement':
+				case 'ForInStatement':
+				case 'ForOfStatement':
+				case 'WhileStatement':
+				case 'DoWhileStatement':
+				case 'WithStatement': {
+					if (lastBlockNode.body && sourceCode.getTokenBefore(lastBlockNode.body) === tokenBefore) {
+						return false;
+					}
+
+					break;
+				}
+				// No default
+			}
+
+			return true;
+		}
+	}
+
+	if (tokenTypesNeedsSemicolon.has(type)) {
+		return true;
+	}
+
+	if (type === 'Template') {
+		return value.endsWith('`');
+	}
+
+	if (lastBlockNode.type === 'ObjectExpression') {
+		return true;
+	}
+
+	if (type === 'Identifier') {
+		// `for...of`
+		if (value === 'of' && lastBlockNode.type === 'ForOfStatement') {
+			return false;
+		}
+
+		// `await`
+		if (value === 'await' && lastBlockNode.type === 'AwaitExpression') {
+			return false;
+		}
+
+		return true;
+	}
+
+	return false;
+}
+
+module.exports = needsSemicolon;

package/rules/utils/numeric.js

@@ -0,0 +1,53 @@
+'use strict';
+
+const {isNumberLiteral, isBigIntLiteral} = require('../ast/index.js');
+
+// Determine whether this node is a decimal integer literal.
+// Copied from https://github.com/eslint/eslint/blob/cc4871369645c3409dc56ded7a555af8a9f63d51/lib/rules/utils/ast-utils.js#L1237
+const DECIMAL_INTEGER_PATTERN = /^(?:0|0[0-7]*[89]\d*|[1-9](?:_?\d)*)$/u;
+const isDecimalInteger = text => DECIMAL_INTEGER_PATTERN.test(text);
+const isDecimalIntegerNode = node => isNumberLiteral(node) && isDecimalInteger(node.raw);
+
+const isNumeric = node => isNumberLiteral(node) || isBigIntLiteral(node);
+const isLegacyOctal = node => isNumberLiteral(node) && /^0\d+$/.test(node.raw);
+
+function getPrefix(text) {
+	let prefix = '';
+	let data = text;
+
+	if (/^0[box]/i.test(text)) {
+		prefix = text.slice(0, 2);
+		data = text.slice(2);
+	}
+
+	return {prefix, data};
+}
+
+function parseNumber(text) {
+	const {
+		number,
+		mark = '',
+		sign = '',
+		power = '',
+	} = text.match(/^(?<number>[\d._]*?)(?:(?<mark>[Ee])(?<sign>[+-])?(?<power>[\d_]+))?$/).groups;
+
+	return {number, mark, sign, power};
+}
+
+function parseFloatNumber(text) {
+	const parts = text.split('.');
+	const [integer, fractional = ''] = parts;
+	const dot = parts.length === 2 ? '.' : '';
+
+	return {integer, dot, fractional};
+}
+
+module.exports = {
+	isDecimalIntegerNode,
+	isDecimalInteger,
+	isNumeric,
+	isLegacyOctal,
+	getPrefix,
+	parseNumber,
+	parseFloatNumber,
+};

package/rules/utils/parentheses.js

@@ -0,0 +1,73 @@
+'use strict';
+const {isParenthesized, isOpeningParenToken, isClosingParenToken} = require('@eslint-community/eslint-utils');
+
+/*
+Get how many times the node is parenthesized.
+
+@param {Node} node - The node to be checked.
+@param {SourceCode} sourceCode - The source code object.
+@returns {number}
+*/
+function getParenthesizedTimes(node, sourceCode) {
+	let times = 0;
+
+	while (isParenthesized(times + 1, node, sourceCode)) {
+		times++;
+	}
+
+	return times;
+}
+
+/*
+Get all parentheses tokens around the node.
+
+@param {Node} node - The node to be checked.
+@param {SourceCode} sourceCode - The source code object.
+@returns {Token[]}
+*/
+function getParentheses(node, sourceCode) {
+	const count = getParenthesizedTimes(node, sourceCode);
+
+	if (count === 0) {
+		return [];
+	}
+
+	return [
+		...sourceCode.getTokensBefore(node, {count, filter: isOpeningParenToken}),
+		...sourceCode.getTokensAfter(node, {count, filter: isClosingParenToken}),
+	];
+}
+
+/*
+Get the parenthesized range of the node.
+
+@param {Node} node - The node to be checked.
+@param {SourceCode} sourceCode - The source code object.
+@returns {number[]}
+*/
+function getParenthesizedRange(node, sourceCode) {
+	const parentheses = getParentheses(node, sourceCode);
+	const [start] = (parentheses[0] || node).range;
+	const [, end] = (parentheses.at(-1) || node).range;
+	return [start, end];
+}
+
+/*
+Get the parenthesized text of the node.
+
+@param {Node} node - The node to be checked.
+@param {SourceCode} sourceCode - The source code object.
+@returns {string}
+*/
+function getParenthesizedText(node, sourceCode) {
+	const [start, end] = getParenthesizedRange(node, sourceCode);
+	return sourceCode.text.slice(start, end);
+}
+
+module.exports = {
+	isParenthesized,
+	getParenthesizedTimes,
+	getParentheses,
+	getParenthesizedRange,
+	getParenthesizedText,
+};

package/rules/utils/resolve-variable-name.js

@@ -0,0 +1,20 @@
+'use strict';
+
+/**
+Finds a variable named `name` in the scope `scope` (or it's parents).
+
+@param {string} name - The variable name to be resolve.
+@param {Scope} scope - The scope to look for the variable in.
+@returns {Variable?} - The found variable, if any.
+*/
+module.exports = (name, scope) => {
+	while (scope) {
+		const variable = scope.set.get(name);
+
+		if (variable) {
+			return variable;
+		}
+
+		scope = scope.upper;
+	}
+};

package/rules/utils/rule.js

@@ -0,0 +1,190 @@
+'use strict';
+const path = require('node:path');
+const fs = require('node:fs');
+const getDocumentationUrl = require('./get-documentation-url.js');
+
+const isIterable = object => typeof object?.[Symbol.iterator] === 'function';
+
+class FixAbortError extends Error {}
+const fixOptions = {
+	abort() {
+		throw new FixAbortError('Fix aborted.');
+	},
+};
+
+function wrapFixFunction(fix) {
+	return fixer => {
+		const result = fix(fixer, fixOptions);
+
+		if (isIterable(result)) {
+			try {
+				return [...result];
+			} catch (error) {
+				if (error instanceof FixAbortError) {
+					return;
+				}
+
+				/* c8 ignore next */
+				throw error;
+			}
+		}
+
+		return result;
+	};
+}
+
+function reportListenerProblems(problems, context) {
+	if (!problems) {
+		return;
+	}
+
+	if (!isIterable(problems)) {
+		problems = [problems];
+	}
+
+	for (const problem of problems) {
+		if (problem.fix) {
+			problem.fix = wrapFixFunction(problem.fix);
+		}
+
+		if (Array.isArray(problem.suggest)) {
+			for (const suggest of problem.suggest) {
+				if (suggest.fix) {
+					suggest.fix = wrapFixFunction(suggest.fix);
+				}
+
+				suggest.data = {
+					...problem.data,
+					...suggest.data,
+				};
+			}
+		}
+
+		context.report(problem);
+	}
+}
+
+// `checkVueTemplate` function will wrap `create` function, there is no need to wrap twice
+const wrappedFunctions = new Set();
+function reportProblems(create) {
+	if (wrappedFunctions.has(create)) {
+		return create;
+	}
+
+	const wrapped = context => {
+		const listeners = {};
+		const addListener = (selector, listener) => {
+			listeners[selector] ??= [];
+			listeners[selector].push(listener);
+		};
+
+		const contextProxy = new Proxy(context, {
+			get(target, property, receiver) {
+				if (property === 'on') {
+					return (selectorOrSelectors, listener) => {
+						const selectors = Array.isArray(selectorOrSelectors) ? selectorOrSelectors : [selectorOrSelectors];
+						for (const selector of selectors) {
+							addListener(selector, listener);
+						}
+					};
+				}
+
+				if (property === 'onExit') {
+					return (selectorOrSelectors, listener) => {
+						const selectors = Array.isArray(selectorOrSelectors) ? selectorOrSelectors : [selectorOrSelectors];
+						for (const selector of selectors) {
+							addListener(`${selector}:exit`, listener);
+						}
+					};
+				}
+
+				return Reflect.get(target, property, receiver);
+			},
+		});
+
+		for (const [selector, listener] of Object.entries(create(contextProxy) ?? {})) {
+			addListener(selector, listener);
+		}
+
+		return Object.fromEntries(
+			Object.entries(listeners)
+				.map(([selector, listeners]) => [
+					selector,
+					// Listener arguments can be `codePath, node` or `node`
+					(...listenerArguments) => {
+						for (const listener of listeners) {
+							reportListenerProblems(listener(...listenerArguments), context);
+						}
+					},
+				]),
+		);
+	};
+
+	wrappedFunctions.add(wrapped);
+
+	return wrapped;
+}
+
+function checkVueTemplate(create, options) {
+	const {
+		visitScriptBlock,
+	} = {
+		visitScriptBlock: true,
+		...options,
+	};
+
+	create = reportProblems(create);
+
+	const wrapped = context => {
+		const listeners = create(context);
+		const {parserServices} = context.sourceCode;
+
+		// `vue-eslint-parser`
+		if (parserServices?.defineTemplateBodyVisitor) {
+			return visitScriptBlock
+				? parserServices.defineTemplateBodyVisitor(listeners, listeners)
+				: parserServices.defineTemplateBodyVisitor(listeners);
+		}
+
+		return listeners;
+	};
+
+	wrappedFunctions.add(wrapped);
+	return wrapped;
+}
+
+/** @returns {import('eslint').Rule.RuleModule} */
+function loadRule(ruleId) {
+	const rule = require(`../${ruleId}`);
+
+	return {
+		meta: {
+			// If there is are, options add `[]` so ESLint can validate that no data is passed to the rule.
+			// https://github.com/not-an-aardvark/eslint-plugin-eslint-plugin/blob/master/docs/rules/require-meta-schema.md
+			schema: [],
+			...rule.meta,
+			docs: {
+				...rule.meta.docs,
+				url: getDocumentationUrl(ruleId),
+			},
+		},
+		create: reportProblems(rule.create),
+	};
+}
+
+function loadRules() {
+	return Object.fromEntries(
+		fs.readdirSync(path.join(__dirname, '..'), {withFileTypes: true})
+			.filter(file => file.isFile())
+			.map(file => {
+				const ruleId = path.basename(file.name, '.js');
+				return [ruleId, loadRule(ruleId)];
+			}),
+	);
+}
+
+module.exports = {
+	loadRule,
+	loadRules,
+	checkVueTemplate,
+};

package/rules/utils/should-add-parentheses-to-conditional-expression-child.js

@@ -0,0 +1,17 @@
+'use strict';
+
+/**
+Check if parentheses should be added to a `node` when it's used as child of `ConditionalExpression`.
+
+@param {Node} node - The AST node to check.
+@returns {boolean}
+*/
+function shouldAddParenthesesToConditionalExpressionChild(node) {
+	return node.type === 'AwaitExpression'
+		// Lower precedence, see https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Operators/Operator_Precedence#Table
+		|| node.type === 'AssignmentExpression'
+		|| node.type === 'YieldExpression'
+		|| node.type === 'SequenceExpression';
+}
+
+module.exports = shouldAddParenthesesToConditionalExpressionChild;

package/rules/utils/should-add-parentheses-to-expression-statement-expression.js

@@ -0,0 +1,26 @@
+'use strict';
+
+/**
+Check if parentheses should to be added to a `node` when it's used as an `expression` of `ExpressionStatement`.
+
+@param {Node} node - The AST node to check.
+@param {SourceCode} sourceCode - The source code object.
+@returns {boolean}
+*/
+function shouldAddParenthesesToExpressionStatementExpression(node) {
+	switch (node.type) {
+		case 'ObjectExpression': {
+			return true;
+		}
+
+		case 'AssignmentExpression': {
+			return node.left.type === 'ObjectPattern' || node.left.type === 'ArrayPattern';
+		}
+
+		default: {
+			return false;
+		}
+	}
+}
+
+module.exports = shouldAddParenthesesToExpressionStatementExpression;

package/rules/utils/should-add-parentheses-to-logical-expression-child.js

@@ -0,0 +1,47 @@
+'use strict';
+
+/**
+Check if parentheses should be added to a `node` when it's used as child of `LogicalExpression`.
+@param {Node} node - The AST node to check.
+@param {{operator: string, property: string}} options - Options
+@returns {boolean}
+*/
+function shouldAddParenthesesToLogicalExpressionChild(node, {operator, property}) {
+	// We are not using this, but we can improve this function with it
+	/* c8 ignore next 3 */
+	if (!property) {
+		throw new Error('`property` is required.');
+	}
+
+	if (
+		node.type === 'LogicalExpression'
+		&& node.operator === operator
+	) {
+		return false;
+	}
+
+	// Not really needed, but more readable
+	if (
+		node.type === 'AwaitExpression'
+		|| node.type === 'BinaryExpression'
+	) {
+		return true;
+	}
+
+	// Lower precedence than `LogicalExpression`
+	// see https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Operators/Operator_Precedence#Table
+	if (
+		node.type === 'LogicalExpression'
+		|| node.type === 'ConditionalExpression'
+		|| node.type === 'AssignmentExpression'
+		|| node.type === 'ArrowFunctionExpression'
+		|| node.type === 'YieldExpression'
+		|| node.type === 'SequenceExpression'
+	) {
+		return true;
+	}
+
+	return false;
+}
+
+module.exports = shouldAddParenthesesToLogicalExpressionChild;

package/rules/utils/should-add-parentheses-to-member-expression-object.js

@@ -0,0 +1,47 @@
+'use strict';
+
+const isNewExpressionWithParentheses = require('./is-new-expression-with-parentheses.js');
+const {isDecimalIntegerNode} = require('./numeric.js');
+
+/**
+Check if parentheses should to be added to a `node` when it's used as an `object` of `MemberExpression`.
+
+@param {Node} node - The AST node to check.
+@param {SourceCode} sourceCode - The source code object.
+@returns {boolean}
+*/
+function shouldAddParenthesesToMemberExpressionObject(node, sourceCode) {
+	switch (node.type) {
+		// This is not a full list. Some other nodes like `FunctionDeclaration` don't need parentheses,
+		// but it's not possible to be in the place we are checking at this point.
+		case 'Identifier':
+		case 'MemberExpression':
+		case 'CallExpression':
+		case 'ChainExpression':
+		case 'TemplateLiteral':
+		case 'ThisExpression':
+		case 'ArrayExpression':
+		case 'FunctionExpression': {
+			return false;
+		}
+
+		case 'NewExpression': {
+			return !isNewExpressionWithParentheses(node, sourceCode);
+		}
+
+		case 'Literal': {
+			/* c8 ignore next */
+			if (isDecimalIntegerNode(node)) {
+				return true;
+			}
+
+			return false;
+		}
+
+		default: {
+			return true;
+		}
+	}
+}
+
+module.exports = shouldAddParenthesesToMemberExpressionObject;

package/rules/utils/should-add-parentheses-to-new-expression-callee.js

@@ -0,0 +1,32 @@
+'use strict';
+
+// Copied from https://github.com/eslint/eslint/blob/aa87329d919f569404ca573b439934552006572f/lib/rules/no-extra-parens.js#L448
+/**
+Check if a member expression contains a call expression.
+
+@param {ASTNode} node - The `MemberExpression` node to evaluate.
+@returns {boolean} true if found, false if not.
+*/
+function doesMemberExpressionContainCallExpression(node) {
+	let currentNode = node.object;
+	let currentNodeType = node.object.type;
+
+	while (currentNodeType === 'MemberExpression') {
+		currentNode = currentNode.object;
+		currentNodeType = currentNode.type;
+	}
+
+	return currentNodeType === 'CallExpression';
+}
+
+/**
+Check if parentheses should be added to a `node` when it's used as `callee` of `NewExpression`.
+
+@param {Node} node - The AST node to check.
+@returns {boolean}
+*/
+function shouldAddParenthesesToNewExpressionCallee(node) {
+	return node.type === 'MemberExpression' && doesMemberExpressionContainCallExpression(node);
+}
+
+module.exports = shouldAddParenthesesToNewExpressionCallee;

package/rules/utils/should-add-parentheses-to-spread-element-argument.js

@@ -0,0 +1,22 @@
+'use strict';
+
+const nodeTypesDoNotNeedParentheses = new Set([
+	'CallExpression',
+	'Identifier',
+	'Literal',
+	'MemberExpression',
+	'NewExpression',
+	'TemplateLiteral',
+	'ThisExpression',
+]);
+
+/**
+Check if parentheses should be added to a `node` when it's used as `argument` of `SpreadElement`.
+
+@param {Node} node - The AST node to check.
+@returns {boolean}
+*/
+const shouldAddParenthesesToSpreadElementArgument = node =>
+	!nodeTypesDoNotNeedParentheses.has(node.type);
+
+module.exports = shouldAddParenthesesToSpreadElementArgument;

package/rules/utils/singular.js

@@ -0,0 +1,18 @@
+'use strict';
+
+const {singular: pluralizeSingular} = require('pluralize');
+
+/**
+Singularizes a word/name, i.e. `items` to `item`.
+
+@param {string} original - The word/name to singularize.
+@returns {string|undefined} - The singularized result, or `undefined` if attempting singularization resulted in no change.
+*/
+const singular = original => {
+	const singularized = pluralizeSingular(original);
+	if (singularized !== original) {
+		return singularized;
+	}
+};
+
+module.exports = singular;

package/rules/utils/to-location.js

@@ -0,0 +1,21 @@
+'use strict';
+
+/**
+Get location info for the given node or range.
+
+@param {import('estree').Node | number[]} nodeOrRange - The AST node or range to get the location for.
+@param {import('eslint').SourceCode} sourceCode - The source code object.
+@param {int} [startOffset] - Start position offset.
+@param {int} [endOffset] - End position offset.
+@returns {import('estree').SourceLocation}
+*/
+function toLocation(nodeOrRange, sourceCode, startOffset = 0, endOffset = 0) {
+	const [start, end] = Array.isArray(nodeOrRange) ? nodeOrRange : nodeOrRange.range;
+
+	return {
+		start: sourceCode.getLocFromIndex(start + startOffset),
+		end: sourceCode.getLocFromIndex(end + endOffset),
+	};
+}
+
+module.exports = toLocation;

package/README.md

@@ -1,5 +0,0 @@
-# Security holding package
-
-This package contained malicious code and was removed from the registry by the npm security team. A placeholder was published to ensure users are not affected in the future.
-
-Please refer to www.npmjs.com/advisories?search=eslint-plugin-unicorn-ts for more information.