@alexlit/lint-kit 176.0.1 → 177.0.0

package/packages/config-eslint/node_modules/eslint-plugin-unicorn/rules/utils/is-number.js

@@ -1,224 +0,0 @@
-import {getStaticValue} from '@eslint-community/eslint-utils';
-import {isNumericLiteral} from '../ast/index.js';
-
-const isStaticProperties = (node, object, properties) =>
-	node.type === 'MemberExpression'
-	&& !node.computed
-	&& !node.optional
-	&& node.object.type === 'Identifier'
-	&& node.object.name === object
-	&& node.property.type === 'Identifier'
-	&& properties.has(node.property.name);
-
-const isFunctionCall = (node, functionName) => node.type === 'CallExpression'
-	&& !node.optional
-	&& node.callee.type === 'Identifier'
-	&& node.callee.name === functionName;
-
-// https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Math#static_properties
-const mathProperties = new Set([
-	'E',
-	'LN2',
-	'LN10',
-	'LOG2E',
-	'LOG10E',
-	'PI',
-	'SQRT1_2',
-	'SQRT2',
-]);
-
-// `Math.{E,LN2,LN10,LOG2E,LOG10E,PI,SQRT1_2,SQRT2}`
-const isMathProperty = node => isStaticProperties(node, 'Math', mathProperties);
-
-// https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Math#static_methods
-const mathMethods = new Set([
-	'abs',
-	'acos',
-	'acosh',
-	'asin',
-	'asinh',
-	'atan',
-	'atanh',
-	'atan2',
-	'cbrt',
-	'ceil',
-	'clz32',
-	'cos',
-	'cosh',
-	'exp',
-	'expm1',
-	'floor',
-	'fround',
-	'hypot',
-	'imul',
-	'log',
-	'log1p',
-	'log10',
-	'log2',
-	'max',
-	'min',
-	'pow',
-	'random',
-	'round',
-	'sign',
-	'sin',
-	'sinh',
-	'sqrt',
-	'tan',
-	'tanh',
-	'trunc',
-]);
-// `Math.{abs, …, trunc}(…)`
-const isMathMethodCall = node =>
-	node.type === 'CallExpression'
-	&& !node.optional
-	&& isStaticProperties(node.callee, 'Math', mathMethods);
-
-// `Number(…)`
-const isNumberCall = node => isFunctionCall(node, 'Number');
-
-// https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Number#static_properties
-const numberProperties = new Set([
-	'EPSILON',
-	'MAX_SAFE_INTEGER',
-	'MAX_VALUE',
-	'MIN_SAFE_INTEGER',
-	'MIN_VALUE',
-	'NaN',
-	'NEGATIVE_INFINITY',
-	'POSITIVE_INFINITY',
-]);
-const isNumberProperty = node => isStaticProperties(node, 'Number', numberProperties);
-
-// https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Number#static_methods
-const numberMethods = new Set([
-	'parseFloat',
-	'parseInt',
-]);
-const isNumberMethodCall = node =>
-	node.type === 'CallExpression'
-	&& !node.optional
-	&& isStaticProperties(node.callee, 'Number', numberMethods);
-const isGlobalParseToNumberFunctionCall = node => isFunctionCall(node, 'parseInt') || isFunctionCall(node, 'parseFloat');
-
-const isStaticNumber = (node, scope) =>
-	typeof getStaticValue(node, scope)?.value === 'number';
-
-const isLengthProperty = node =>
-	node.type === 'MemberExpression'
-	&& !node.computed
-	&& !node.optional
-	&& node.property.type === 'Identifier'
-	&& node.property.name === 'length';
-
-// `+` and `>>>` operators are handled separately
-const mathOperators = new Set(['-', '*', '/', '%', '**', '<<', '>>', '|', '^', '&']);
-
-// eslint-disable-next-line complexity
-export default function isNumber(node, scope) {
-	if (
-		isNumericLiteral(node)
-		|| isMathProperty(node)
-		|| isMathMethodCall(node)
-		|| isNumberCall(node)
-		|| isNumberProperty(node)
-		|| isNumberMethodCall(node)
-		|| isGlobalParseToNumberFunctionCall(node)
-		|| isLengthProperty(node)
-	) {
-		return true;
-	}
-
-	switch (node.type) {
-		case 'AssignmentExpression': {
-			const {operator} = node;
-			if (operator === '=' && isNumber(node.right, scope)) {
-				return true;
-			}
-
-			// Fall through
-		}
-
-		case 'BinaryExpression': {
-			let {operator} = node;
-
-			if (node.type === 'AssignmentExpression') {
-				operator = operator.slice(0, -1);
-			}
-
-			if (operator === '+' && isNumber(node.left, scope) && isNumber(node.right, scope)) {
-				return true;
-			}
-
-			// `>>>` (zero-fill right shift) can't use on `BigInt`
-			// https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/BigInt#operators
-			if (operator === '>>>') {
-				return true;
-			}
-
-			// `a * b` can be `BigInt`, we need make sure at least one side is number
-			if (mathOperators.has(operator) && (isNumber(node.left, scope) || isNumber(node.right, scope))) {
-				return true;
-			}
-
-			break;
-		}
-
-		case 'UnaryExpression': {
-			const {operator} = node;
-
-			// `+` can't use on `BigInt`
-			// https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/BigInt#operators
-			if (operator === '+') {
-				return true;
-			}
-
-			if ((operator === '-' || operator === '~') && isNumber(node.argument, scope)) {
-				return true;
-			}
-
-			break;
-		}
-
-		case 'UpdateExpression': {
-			if (isNumber(node.argument, scope)) {
-				return true;
-			}
-
-			break;
-		}
-
-		case 'ConditionalExpression': {
-			const isConsequentNumber = isNumber(node.consequent, scope);
-			const isAlternateNumber = isNumber(node.alternate, scope);
-
-			if (isConsequentNumber && isAlternateNumber) {
-				return true;
-			}
-
-			const testStaticValueResult = getStaticValue(node.test, scope);
-			if (
-				testStaticValueResult !== null
-				&& (
-					(testStaticValueResult.value && isConsequentNumber)
-					|| (!testStaticValueResult.value && isAlternateNumber)
-				)
-			) {
-				return true;
-			}
-
-			break;
-		}
-
-		case 'SequenceExpression': {
-			if (isNumber(node.expressions.at(-1), scope)) {
-				return true;
-			}
-
-			break;
-		}
-		// No default
-	}
-
-	return isStaticNumber(node, scope);
-}

package/packages/config-eslint/node_modules/eslint-plugin-unicorn/rules/utils/is-object-method.js

@@ -1,10 +0,0 @@
-export default function isObjectMethod(node, object, method) {
-	const {callee} = node;
-	return (
-		callee.type === 'MemberExpression'
-		&& callee.object.type === 'Identifier'
-		&& callee.object.name === object
-		&& callee.property.type === 'Identifier'
-		&& callee.property.name === method
-	);
-}

package/packages/config-eslint/node_modules/eslint-plugin-unicorn/rules/utils/is-on-same-line.js

@@ -1,7 +0,0 @@
-export default function isOnSameLine(nodeOrTokenA, nodeOrTokenB, context) {
-	const [
-		lineA,
-		lineB,
-	] = [nodeOrTokenA, nodeOrTokenB].map(nodeOrToken => context.sourceCode.getLoc(nodeOrToken).start.line);
-	return lineA === lineB;
-}

package/packages/config-eslint/node_modules/eslint-plugin-unicorn/rules/utils/is-same-identifier.js

@@ -1,5 +0,0 @@
-const isSameIdentifier = (nodeA, nodeB) => nodeA.type === 'Identifier'
-	&& nodeB.type === 'Identifier'
-	&& nodeA.name === nodeB.name;
-
-export default isSameIdentifier;

package/packages/config-eslint/node_modules/eslint-plugin-unicorn/rules/utils/is-same-reference.js

@@ -1,170 +0,0 @@
-import {getStaticValue} from '@eslint-community/eslint-utils';
-
-// Copied from https://github.com/eslint/eslint/blob/94ba68d76a6940f68ff82eea7332c6505f93df76/lib/rules/utils/ast-utils.js#L392
-
-/**
-Gets the property name of a given node.
-The node can be a MemberExpression, a Property, or a MethodDefinition.
-
-If the name is dynamic, this returns `null`.
-
-For examples:
-
-	a.b		   // => "b"
-	a["b"]		// => "b"
-	a['b']		// => "b"
-	a[`b`]		// => "b"
-	a[100]		// => "100"
-	a[b]		  // => null
-	a["a" + "b"]  // => null
-	a[tag`b`]	 // => null
-	a[`${b}`]	 // => null
-
-	let a = {b: 1}			// => "b"
-	let a = {["b"]: 1}		// => "b"
-	let a = {['b']: 1}		// => "b"
-	let a = {[`b`]: 1}		// => "b"
-	let a = {[100]: 1}		// => "100"
-	let a = {[b]: 1}		  // => null
-	let a = {["a" + "b"]: 1}  // => null
-	let a = {[tag`b`]: 1}	 // => null
-	let a = {[`${b}`]: 1}	 // => null
-@param {ASTNode} node The node to get.
-@returns {string|undefined} The property name if static. Otherwise, undefined.
-*/
-function getStaticPropertyName(node) {
-	let property;
-
-	switch (node?.type) {
-		case 'MemberExpression': {
-			property = node.property;
-			break;
-		}
-
-		/* c8 ignore next 2 */
-		case 'ChainExpression': {
-			return getStaticPropertyName(node.expression);
-		}
-
-		// Only reachable when use this to get class/object member key
-		/* c8 ignore next */
-		case 'Property':
-		case 'MethodDefinition': {
-			/* c8 ignore next 2 */
-			property = node.key;
-			break;
-		}
-
-			// No default
-	}
-
-	if (property) {
-		if (property.type === 'Identifier' && !node.computed) {
-			return property.name;
-		}
-
-		const staticResult = getStaticValue(property);
-		if (!staticResult) {
-			return;
-		}
-
-		return String(staticResult.value);
-	}
-}
-
-/**
-Check if two literal nodes are the same value.
-@param {ASTNode} left The Literal node to compare.
-@param {ASTNode} right The other Literal node to compare.
-@returns {boolean} `true` if the two literal nodes are the same value.
-*/
-function equalLiteralValue(left, right) {
-	// RegExp literal.
-	if (left.regex || right.regex) {
-		return Boolean(
-			left.regex
-			&& right.regex
-			&& left.regex.pattern === right.regex.pattern
-			&& left.regex.flags === right.regex.flags,
-		);
-	}
-
-	// BigInt literal.
-	if (left.bigint || right.bigint) {
-		return left.bigint === right.bigint;
-	}
-
-	return left.value === right.value;
-}
-
-/**
-Check if two expressions reference the same value. For example:
-	a = a
-	a.b = a.b
-	a[0] = a[0]
-	a['b'] = a['b']
-@param {ASTNode} left The left side of the comparison.
-@param {ASTNode} right The right side of the comparison.
-@returns {boolean} `true` if both sides match and reference the same value.
-*/
-export default function isSameReference(left, right) {
-	if (left.type !== right.type) {
-		// Handle `a.b` and `a?.b` are samely.
-		if (left.type === 'ChainExpression') {
-			return isSameReference(left.expression, right);
-		}
-
-		if (right.type === 'ChainExpression') {
-			return isSameReference(left, right.expression);
-		}
-
-		return false;
-	}
-
-	switch (left.type) {
-		case 'Super':
-		case 'ThisExpression': {
-			return true;
-		}
-
-		case 'Identifier':
-		case 'PrivateIdentifier': {
-			return left.name === right.name;
-		}
-
-		case 'Literal': {
-			return equalLiteralValue(left, right);
-		}
-
-		case 'ChainExpression': {
-			return isSameReference(left.expression, right.expression);
-		}
-
-		case 'MemberExpression': {
-			const nameA = getStaticPropertyName(left);
-
-			// `x.y = x["y"]`
-			if (nameA !== undefined) {
-				return (
-					isSameReference(left.object, right.object)
-					&& nameA === getStaticPropertyName(right)
-				);
-			}
-
-			/*
-			`x[0] = x[0]`
-			`x[y] = x[y]`
-			`x.y = x.y`
-			*/
-			return (
-				left.computed === right.computed
-				&& isSameReference(left.object, right.object)
-				&& isSameReference(left.property, right.property)
-			);
-		}
-
-		default: {
-			return false;
-		}
-	}
-}

package/packages/config-eslint/node_modules/eslint-plugin-unicorn/rules/utils/is-shorthand-export-local.js

@@ -1,8 +0,0 @@
-import hasSameRange from './has-same-range.js';
-
-const isShorthandExportLocal = (node, context) => {
-	const {type, local, exported} = node.parent;
-	return type === 'ExportSpecifier' && hasSameRange(local, exported, context) && local === node;
-};
-
-export default isShorthandExportLocal;

package/packages/config-eslint/node_modules/eslint-plugin-unicorn/rules/utils/is-shorthand-import-local.js

@@ -1,8 +0,0 @@
-import hasSameRange from './has-same-range.js';
-
-const isShorthandImportLocal = (node, context) => {
-	const {type, local, imported} = node.parent;
-	return type === 'ImportSpecifier' && hasSameRange(local, imported, context) && local === node;
-};
-
-export default isShorthandImportLocal;

package/packages/config-eslint/node_modules/eslint-plugin-unicorn/rules/utils/is-shorthand-property-assignment-pattern-left.js

@@ -1,8 +0,0 @@
-import isShorthandPropertyValue from './is-shorthand-property-value.js';
-
-const isShorthandPropertyAssignmentPatternLeft = identifier =>
-	identifier.parent.type === 'AssignmentPattern'
-	&& identifier.parent.left === identifier
-	&& isShorthandPropertyValue(identifier.parent);
-
-export default isShorthandPropertyAssignmentPatternLeft;

package/packages/config-eslint/node_modules/eslint-plugin-unicorn/rules/utils/is-shorthand-property-value.js

@@ -1,6 +0,0 @@
-const isShorthandPropertyValue = identifier =>
-	identifier.parent.type === 'Property'
-	&& identifier.parent.shorthand
-	&& identifier === identifier.parent.value;
-
-export default isShorthandPropertyValue;

package/packages/config-eslint/node_modules/eslint-plugin-unicorn/rules/utils/is-unresolved-variable.js

@@ -1,14 +0,0 @@
-import {findVariable} from '@eslint-community/eslint-utils';
-
-/**
-Checks if the given identifier node is shadowed in the given scope.
-
-@param {string} node - The identifier node to check
-@param {import('eslint').Rule.RuleContext} context - The ESLint rule context.
-@returns {boolean} Whether or not the name is unresolved.
-*/
-export default function isUnresolvedVariable(node, context) {
-	const scope = context.sourceCode.getScope(node);
-	const variable = findVariable(scope, node);
-	return !variable;
-}

package/packages/config-eslint/node_modules/eslint-plugin-unicorn/rules/utils/is-value-not-usable.js

@@ -1,5 +0,0 @@
-import {isExpressionStatement} from '../ast/index.js';
-
-const isValueNotUsable = node => isExpressionStatement(node.parent);
-
-export default isValueNotUsable;

package/packages/config-eslint/node_modules/eslint-plugin-unicorn/rules/utils/needs-semicolon.js

@@ -1,118 +0,0 @@
-/* eslint-disable complexity */
-
-/**
-@import {TSESTree as ESTree} from '@typescript-eslint/types';
-@import * as ESLint from 'eslint';
-*/
-
-// 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 {ESTree.Token} tokenBefore Token before `code`.
-@param {ESLint.Rule.RuleContext} context - The ESLint rule context object.
-@param {String} [code] Code text to determine.
-@returns {boolean} `true` if a semicolon needs to be inserted before `code`.
-*/
-export default function needsSemicolon(tokenBefore, context, code) {
-	if (
-		code === ''
-		|| (code && !charactersMightNeedsSemicolon.has(code.charAt(0)))
-	) {
-		return false;
-	}
-
-	if (!tokenBefore) {
-		return false;
-	}
-
-	const {sourceCode} = context;
-	const {type, value} = tokenBefore;
-	const range = sourceCode.getRange(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;
-}

package/packages/config-eslint/node_modules/eslint-plugin-unicorn/rules/utils/numeric.js

@@ -1,49 +0,0 @@
-import {isNumericLiteral, isBigIntLiteral} from '../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;
-
-export const isDecimalInteger = text => DECIMAL_INTEGER_PATTERN.test(text);
-
-export const isDecimalIntegerNode = node => isNumericLiteral(node) && isDecimalInteger(node.raw);
-
-export const isNumeric = node => isNumericLiteral(node) || isBigIntLiteral(node);
-
-export const isLegacyOctal = node => isNumericLiteral(node) && /^0\d+$/.test(node.raw);
-
-export 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};
-}
-
-export function parseNumber(text) {
-	const {
-		number,
-		mark = '',
-		sign = '',
-		power = '',
-	} = text.match(/^(?<number>[\d._]*?)(?:(?<mark>[Ee])(?<sign>[+-])?(?<power>[\d_]+))?$/).groups;
-
-	return {
-		number,
-		mark,
-		sign,
-		power,
-	};
-}
-
-export function parseFloatNumber(text) {
-	const parts = text.split('.');
-	const [integer, fractional = ''] = parts;
-	const dot = parts.length === 2 ? '.' : '';
-
-	return {integer, dot, fractional};
-}