@alexlit/lint-kit 175.0.0 → 176.0.0

package/packages/config-eslint/node_modules/eslint-plugin-unicorn/rules/text-encoding-identifier-case.js

@@ -0,0 +1,130 @@
+import {replaceStringRaw} from './fix/index.js';
+import {isMethodCall, isNewExpression} from './ast/index.js';
+
+const MESSAGE_ID_ERROR = 'text-encoding-identifier/error';
+const MESSAGE_ID_SUGGESTION = 'text-encoding-identifier/suggestion';
+const messages = {
+	[MESSAGE_ID_ERROR]: 'Prefer `{{replacement}}` over `{{value}}`.',
+	[MESSAGE_ID_SUGGESTION]: 'Replace `{{value}}` with `{{replacement}}`.',
+};
+
+const getReplacement = (encoding, withDash) => {
+	switch (encoding.toLowerCase()) {
+		// eslint-disable-next-line unicorn/text-encoding-identifier-case
+		case 'utf-8':
+		case 'utf8': {
+			// eslint-disable-next-line unicorn/text-encoding-identifier-case
+			return withDash ? 'utf-8' : 'utf8';
+		}
+
+		case 'ascii': {
+			return 'ascii';
+		}
+		// No default
+	}
+};
+
+// `fs.{readFile,readFileSync}()`
+const isFsReadFileEncoding = node =>
+	isMethodCall(node.parent, {
+		methods: ['readFile', 'readFileSync'],
+		optionalCall: false,
+		optionalMember: false,
+	})
+	&& node.parent.arguments[1] === node
+	&& node.parent.arguments[0].type !== 'SpreadElement';
+
+const isJsxElementAttributes = (node, {element, attributes}) =>
+	node.parent.type === 'JSXAttribute'
+	&& node.parent.value === node
+	&& node.parent.name.type === 'JSXIdentifier'
+	&& attributes.includes(node.parent.name.name.toLowerCase())
+	&& node.parent.parent.type === 'JSXOpeningElement'
+	&& node.parent.parent.attributes.includes(node.parent)
+	&& node.parent.parent.name.type === 'JSXIdentifier'
+	&& node.parent.parent.name.name.toLowerCase() === element;
+
+const shouldEnforceDash = node =>
+	isJsxElementAttributes(node, {element: 'meta', attributes: ['charset']})
+	|| isJsxElementAttributes(node, {element: 'form', attributes: ['acceptCharset', 'accept-charset'].map(attribute => attribute.toLowerCase())})
+	|| (isNewExpression(node.parent, {name: 'TextDecoder'}) && node.parent.arguments[0] === node);
+
+/** @param {import('eslint').Rule.RuleContext} context */
+const create = context => {
+	const options = context.options[0];
+
+	context.on('Literal', node => {
+		if (typeof node.value !== 'string') {
+			return;
+		}
+
+		const withDash = options.withDash || shouldEnforceDash(node);
+
+		const {raw} = node;
+		const value = raw.slice(1, -1);
+
+		const replacement = getReplacement(value, withDash);
+		if (!replacement || replacement === value) {
+			return;
+		}
+
+		/** @param {import('eslint').Rule.RuleFixer} fixer */
+		const fix = fixer => replaceStringRaw(node, replacement, context, fixer);
+
+		const problem = {
+			node,
+			messageId: MESSAGE_ID_ERROR,
+			data: {
+				value,
+				replacement,
+			},
+		};
+
+		if (isFsReadFileEncoding(node)) {
+			problem.fix = fix;
+			return problem;
+		}
+
+		problem.suggest = [
+			{
+				messageId: MESSAGE_ID_SUGGESTION,
+				fix: fixer => replaceStringRaw(node, replacement, context, fixer),
+			},
+		];
+
+		return problem;
+	});
+};
+
+const schema = [
+	{
+		type: 'object',
+		additionalProperties: false,
+		properties: {
+			withDash: {
+				type: 'boolean',
+			},
+		},
+	},
+];
+
+/** @type {import('eslint').Rule.RuleModule} */
+const config = {
+	create,
+	meta: {
+		type: 'suggestion',
+		docs: {
+			description: 'Enforce consistent case for text encoding identifiers.',
+			recommended: 'unopinionated',
+		},
+		fixable: 'code',
+		hasSuggestions: true,
+		schema,
+		defaultOptions: [{
+			withDash: false,
+		}],
+		messages,
+	},
+};
+
+export default config;

package/packages/config-eslint/node_modules/eslint-plugin-unicorn/rules/throw-new-error.js

@@ -0,0 +1,60 @@
+import {isMemberExpression} from './ast/index.js';
+import {switchCallExpressionToNewExpression} from './fix/index.js';
+
+const messageId = 'throw-new-error';
+const messages = {
+	[messageId]: 'Use `new` when creating an error.',
+};
+
+const customError = /^(?:[A-Z][\da-z]*)*Error$/;
+
+/** @param {import('eslint').Rule.RuleContext} context */
+const create = context => ({
+	CallExpression(node) {
+		const {callee} = node;
+		if (!(
+			(callee.type === 'Identifier' && customError.test(callee.name))
+			|| (
+				callee.type === 'MemberExpression'
+				&& !callee.computed
+				&& callee.property.type === 'Identifier'
+				&& customError.test(callee.property.name)
+			)
+		)) {
+			return;
+		}
+
+		// https://github.com/sindresorhus/eslint-plugin-unicorn/issues/2654 (Effect library)
+		if (
+			isMemberExpression(callee, {
+				object: 'Data',
+				property: 'TaggedError',
+				computed: false,
+			})
+		) {
+			return;
+		}
+
+		return {
+			node,
+			messageId,
+			fix: fixer => switchCallExpressionToNewExpression(node, context, fixer),
+		};
+	},
+});
+
+/** @type {import('eslint').Rule.RuleModule} */
+const config = {
+	create,
+	meta: {
+		type: 'suggestion',
+		docs: {
+			description: 'Require `new` when creating an error.',
+			recommended: 'unopinionated',
+		},
+		fixable: 'code',
+		messages,
+	},
+};
+
+export default config;

package/packages/config-eslint/node_modules/eslint-plugin-unicorn/rules/utils/array-or-object-prototype-property.js

@@ -0,0 +1,57 @@
+import {isMemberExpression} from '../ast/index.js';
+
+/**
+@param {
+	{
+		object?: string,
+		method?: string,
+		methods?: string[],
+	}
+} [options]
+@returns {string}
+*/
+function isPrototypeProperty(node, options) {
+	const {
+		object,
+		property,
+		properties,
+	} = {
+		property: '',
+		properties: [],
+		...options,
+	};
+
+	if (!isMemberExpression(node, {
+		property,
+		properties,
+		optional: false,
+	})) {
+		return;
+	}
+
+	const objectNode = node.object;
+
+	return (
+		// `Object.prototype.method` or `Array.prototype.method`
+		isMemberExpression(objectNode, {
+			object,
+			property: 'prototype',
+			optional: false,
+		})
+		// `[].method`
+		|| (
+			object === 'Array'
+			&& objectNode.type === 'ArrayExpression'
+			&& objectNode.elements.length === 0
+		)
+		// `{}.method`
+		|| (
+			object === 'Object'
+			&& objectNode.type === 'ObjectExpression'
+			&& objectNode.properties.length === 0
+		)
+	);
+}
+
+export const isArrayPrototypeProperty = (node, options) => isPrototypeProperty(node, {...options, object: 'Array'});
+export const isObjectPrototypeProperty = (node, options) => isPrototypeProperty(node, {...options, object: 'Object'});

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

@@ -0,0 +1,29 @@
+const ISSUE_LINK_PREFIX = 'https://github.com/sindresorhus/eslint-plugin-unicorn/issues/new?';
+
+export default function assertToken(token, {test, expected, ruleId}) {
+	if (test?.(token)) {
+		return;
+	}
+
+	expected = Array.isArray(expected) ? expected : [expected];
+	expected = expected.map(expectedToken => typeof expectedToken === 'string' ? {value: expectedToken} : expectedToken);
+
+	if (
+		!test
+		&& expected.some(
+			expectedToken =>
+				Object.entries(expectedToken)
+					.every(([key, value]) => token[key] === value),
+		)
+	) {
+		return;
+	}
+
+	const actual = `'${JSON.stringify({value: token.value, type: token.type})}'`;
+	expected = expected.map(expectedToken => `'${JSON.stringify(expectedToken)}'`).join(' or ');
+	const title = `\`${ruleId}\`: Unexpected token ${actual}`;
+	const issueLink = `${ISSUE_LINK_PREFIX}title=${encodeURIComponent(title)}`;
+	const message = `Expected token ${expected}, got ${actual}.\nPlease open an issue at ${issueLink}.`;
+
+	throw new Error(message);
+}

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

@@ -0,0 +1,88 @@
+import isLogicalExpression from './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}
+*/
+export 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}
+*/
+export function getBooleanAncestor(node) {
+	let isNegative = false;
+
+	while (true) {
+		if (isLogicNotArgument(node)) {
+			isNegative = !isNegative;
+			node = node.parent;
+		} else if (isBooleanCallArgument(node)) {
+			node = node.parent;
+		} else {
+			break;
+		}
+	}
+
+	return {node, isNegative};
+}

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

@@ -0,0 +1,30 @@
+import typedArray from '../shared/typed-array.js';
+
+export const enforceNew = [
+	'Object',
+	'Array',
+	'ArrayBuffer',
+	'DataView',
+	'Date',
+	'Error',
+	'Function',
+	'Map',
+	'WeakMap',
+	'Set',
+	'WeakSet',
+	'Promise',
+	'RegExp',
+	'SharedArrayBuffer',
+	'Proxy',
+	'WeakRef',
+	'FinalizationRegistry',
+	...typedArray,
+];
+
+export const disallowNew = [
+	'BigInt',
+	'Boolean',
+	'Number',
+	'String',
+	'Symbol',
+];

package/packages/config-eslint/node_modules/eslint-plugin-unicorn/rules/utils/cartesian-product-samples.js

@@ -0,0 +1,22 @@
+export default function cartesianProductSamples(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/packages/config-eslint/node_modules/eslint-plugin-unicorn/rules/utils/create-deprecated-rules.js

@@ -0,0 +1,29 @@
+import packageJson from '../../package.json' with {type: 'json'};
+
+const repoUrl = 'https://github.com/sindresorhus/eslint-plugin-unicorn';
+
+/** @returns {{ [ruleName: string]: import('eslint').Rule.RuleModule }} */
+export default function createDeprecatedRules(rules) {
+	return Object.fromEntries(
+		Object.entries(rules).map(([ruleId, deprecatedInfo]) => {
+			const url = `${repoUrl}/blob/v${packageJson.version}/docs/deprecated-rules.md#${ruleId}`;
+			return [
+				ruleId,
+				{
+					create: () => ({}),
+					meta: {
+						docs: {
+							description: deprecatedInfo.message,
+							url,
+						},
+						deprecated: {
+							message: deprecatedInfo.message,
+							url,
+							replacedBy: deprecatedInfo.replacedBy,
+						},
+					},
+				},
+			];
+		}),
+	);
+}

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

@@ -0,0 +1,24 @@
+import jsesc from '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.
+*/
+export default function escapeString(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/packages/config-eslint/node_modules/eslint-plugin-unicorn/rules/utils/escape-template-element-raw.js

@@ -0,0 +1,6 @@
+const escapeTemplateElementRaw = string => string.replaceAll(
+	/(?<=(?:^|[^\\])(?:\\\\)*)(?<symbol>(?:`|\$(?={)))/g,
+	String.raw`\$<symbol>`,
+);
+
+export default escapeTemplateElementRaw;

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

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

package/packages/config-eslint/node_modules/eslint-plugin-unicorn/rules/utils/get-available-variable-name.js

@@ -0,0 +1,147 @@
+import helperValidatorIdentifier from '@babel/helper-validator-identifier';
+import resolveVariableName from './resolve-variable-name.js';
+import getReferences from './get-references.js';
+
+const {
+	isIdentifierName,
+	isStrictReservedWord,
+	isKeyword,
+} = helperValidatorIdentifier;
+
+// 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 `getAvailableVariableName`.
+@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.
+*/
+export default function getAvailableVariableName(name, scopes, isSafe = alwaysTrue) {
+	if (!isValidIdentifier(name)) {
+		name += '_';
+
+		if (!isValidIdentifier(name)) {
+			return;
+		}
+	}
+
+	while (!isSafeName(name, scopes) || !isSafe(name, scopes)) {
+		name += '_';
+	}
+
+	return name;
+}

package/packages/config-eslint/node_modules/eslint-plugin-unicorn/rules/utils/get-builtin-rule.js

@@ -0,0 +1,5 @@
+import {builtinRules} from 'eslint/use-at-your-own-risk';
+
+export default function getBuiltinRule(id) {
+	return builtinRules.get(id);
+}

package/packages/config-eslint/node_modules/eslint-plugin-unicorn/rules/utils/get-call-expression-arguments-text.js

@@ -0,0 +1,36 @@
+import {getCallExpressionTokens} from './get-call-or-new-expression-tokens.js';
+
+/**
+@import {TSESTree as ESTree} from '@typescript-eslint/types';
+@import * as ESLint from 'eslint';
+*/
+
+/**
+Get the text of the arguments list of `CallExpression`.
+
+@param {ESTree.CallExpression} callExpression - The `CallExpression` node.
+@param {ESLint.Rule.RuleContext} context - The ESLint rule context object.
+@param {boolean} [includeTrailingComma = true] - Whether the trailing comma should be included.
+@returns {string}
+*/
+export default function getCallExpressionArgumentsText(
+	context,
+	callExpression,
+	includeTrailingComma = true,
+) {
+	const {sourceCode} = context;
+	const {
+		openingParenthesisToken,
+		closingParenthesisToken,
+		trailingCommaToken,
+	} = getCallExpressionTokens(callExpression, context);
+
+	const [, start] = sourceCode.getRange(openingParenthesisToken);
+	const [end] = sourceCode.getRange(
+		includeTrailingComma
+			? closingParenthesisToken
+			: (trailingCommaToken ?? closingParenthesisToken),
+	);
+
+	return sourceCode.text.slice(start, end);
+}