@alexlit/lint-kit 176.0.1 → 177.0.0

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

@@ -1,130 +0,0 @@
-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

@@ -1,60 +0,0 @@
-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

@@ -1,57 +0,0 @@
-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

@@ -1,29 +0,0 @@
-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

@@ -1,88 +0,0 @@
-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

@@ -1,30 +0,0 @@
-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

@@ -1,22 +0,0 @@
-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

@@ -1,29 +0,0 @@
-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

@@ -1,24 +0,0 @@
-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

@@ -1,6 +0,0 @@
-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

@@ -1,15 +0,0 @@
-// 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

@@ -1,147 +0,0 @@
-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

@@ -1,5 +0,0 @@
-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

@@ -1,36 +0,0 @@
-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);
-}