@alexlit/lint-kit 176.0.1 → 177.0.0

package/packages/config-eslint/node_modules/eslint-plugin-unicorn/rules/no-zero-fractions.js

@@ -1,81 +0,0 @@
-import {isParenthesized} from '@eslint-community/eslint-utils';
-import needsSemicolon from './utils/needs-semicolon.js';
-import {isDecimalInteger} from './utils/numeric.js';
-import toLocation from './utils/to-location.js';
-import {fixSpaceAroundKeyword} from './fix/index.js';
-import {isNumericLiteral} from './ast/index.js';
-
-const MESSAGE_ZERO_FRACTION = 'zero-fraction';
-const MESSAGE_DANGLING_DOT = 'dangling-dot';
-const messages = {
-	[MESSAGE_ZERO_FRACTION]: 'Don\'t use a zero fraction in the number.',
-	[MESSAGE_DANGLING_DOT]: 'Don\'t use a dangling dot in the number.',
-};
-
-/** @param {import('eslint').Rule.RuleContext} context */
-const create = context => ({
-	Literal(node) {
-		if (!isNumericLiteral(node)) {
-			return;
-		}
-
-		// Legacy octal number `0777` and prefixed number `0o1234` cannot have a dot.
-		const {raw} = node;
-		const match = raw.match(/^(?<before>[\d_]*)(?<dotAndFractions>\.[\d_]*)(?<after>.*)$/);
-		if (!match) {
-			return;
-		}
-
-		const {before, dotAndFractions, after} = match.groups;
-		const fixedDotAndFractions = dotAndFractions.replaceAll(/[.0_]+$/g, '');
-		const formatted = ((before + fixedDotAndFractions) || '0') + after;
-
-		if (formatted === raw) {
-			return;
-		}
-
-		const isDanglingDot = dotAndFractions === '.';
-		const {sourceCode} = context;
-		// End of fractions
-		const end = sourceCode.getRange(node)[0] + before.length + dotAndFractions.length;
-		const start = end - (raw.length - formatted.length);
-		return {
-			loc: toLocation([start, end], context),
-			messageId: isDanglingDot ? MESSAGE_DANGLING_DOT : MESSAGE_ZERO_FRACTION,
-			* fix(fixer) {
-				let fixed = formatted;
-				if (
-					node.parent.type === 'MemberExpression'
-					&& node.parent.object === node
-					&& isDecimalInteger(formatted)
-					&& !isParenthesized(node, sourceCode)
-				) {
-					fixed = `(${fixed})`;
-
-					if (needsSemicolon(sourceCode.getTokenBefore(node), context, fixed)) {
-						fixed = `;${fixed}`;
-					}
-				}
-
-				yield fixer.replaceText(node, fixed);
-				yield fixSpaceAroundKeyword(fixer, node, context);
-			},
-		};
-	},
-});
-
-/** @type {import('eslint').Rule.RuleModule} */
-const config = {
-	create,
-	meta: {
-		type: 'suggestion',
-		docs: {
-			description: 'Disallow number literals with zero fractions or dangling dots.',
-			recommended: 'unopinionated',
-		},
-		fixable: 'code',
-		messages,
-	},
-};
-
-export default config;

package/packages/config-eslint/node_modules/eslint-plugin-unicorn/rules/number-literal-case.js

@@ -1,82 +0,0 @@
-import {checkVueTemplate} from './utils/rule.js';
-import {isNumericLiteral, isBigIntLiteral} from './ast/index.js';
-
-const MESSAGE_ID = 'number-literal-case';
-const messages = {
-	[MESSAGE_ID]: 'Invalid number literal casing.',
-};
-
-/**
-@param {string} raw
-@param {Options} options
-*/
-const fix = (raw, {hexadecimalValue}) => {
-	let fixed = raw.toLowerCase();
-	if (fixed.startsWith('0x')) {
-		fixed = '0x' + fixed.slice(2)[hexadecimalValue === 'lowercase' ? 'toLowerCase' : 'toUpperCase']();
-	}
-
-	return fixed;
-};
-
-/** @param {import('eslint').Rule.RuleContext} context */
-const create = context => ({
-	Literal(node) {
-		const {raw} = node;
-
-		/** @type {Options} */
-		const options = context.options[0] ?? {};
-		options.hexadecimalValue ??= 'uppercase';
-
-		let fixed = raw;
-		if (isNumericLiteral(node)) {
-			fixed = fix(raw, options);
-		} else if (isBigIntLiteral(node)) {
-			fixed = fix(raw.slice(0, -1), options) + 'n';
-		}
-
-		if (raw !== fixed) {
-			return {
-				node,
-				messageId: MESSAGE_ID,
-				fix: fixer => fixer.replaceText(node, fixed),
-			};
-		}
-	},
-});
-
-/** @typedef {Record<keyof typeof schema[0]["properties"], typeof caseEnum["enum"][number]>} Options */
-
-const caseEnum = /** @type {const} */ ({
-	enum: ['uppercase', 'lowercase'],
-});
-
-const schema = [
-	{
-		type: 'object',
-		additionalProperties: false,
-		properties: {
-			hexadecimalValue: caseEnum,
-		},
-	},
-];
-
-/** @type {import('eslint').Rule.RuleModule} */
-const config = {
-	create: checkVueTemplate(create),
-	meta: {
-		type: 'suggestion',
-		docs: {
-			description: 'Enforce proper case for numeric literals.',
-			recommended: 'unopinionated',
-		},
-		fixable: 'code',
-		schema,
-		defaultOptions: [{
-			hexadecimalValue: 'uppercase',
-		}],
-		messages,
-	},
-};
-
-export default config;

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

@@ -1,189 +0,0 @@
-import * as numeric from './utils/numeric.js';
-import {isBigIntLiteral} from './ast/index.js';
-
-const MESSAGE_ID = 'numeric-separators-style';
-const messages = {
-	[MESSAGE_ID]: 'Invalid group length in numeric value.',
-};
-
-function addSeparator(value, {minimumDigits, groupLength}, fromLeft) {
-	const {length} = value;
-
-	if (length < minimumDigits) {
-		return value;
-	}
-
-	const parts = [];
-	if (fromLeft) {
-		for (let start = 0; start < length; start += groupLength) {
-			const end = Math.min(start + groupLength, length);
-			parts.push(value.slice(start, end));
-		}
-	} else {
-		for (let end = length; end > 0; end -= groupLength) {
-			const start = Math.max(end - groupLength, 0);
-			parts.unshift(value.slice(start, end));
-		}
-	}
-
-	return parts.join('_');
-}
-
-function addSeparatorFromLeft(value, options) {
-	return addSeparator(value, options, true);
-}
-
-function formatNumber(value, options) {
-	const {integer, dot, fractional} = numeric.parseFloatNumber(value);
-	return addSeparator(integer, options) + dot + addSeparatorFromLeft(fractional, options);
-}
-
-function format(value, {prefix, data}, options) {
-	const formatOption = options[prefix.toLowerCase()];
-
-	if (prefix) {
-		return prefix + addSeparator(data, formatOption);
-	}
-
-	const {
-		number,
-		mark,
-		sign,
-		power,
-	} = numeric.parseNumber(value);
-
-	return formatNumber(number, formatOption) + mark + sign + addSeparator(power, options['']);
-}
-
-const defaultOptions = {
-	binary: {minimumDigits: 0, groupLength: 4},
-	octal: {minimumDigits: 0, groupLength: 4},
-	hexadecimal: {minimumDigits: 0, groupLength: 2},
-	number: {minimumDigits: 5, groupLength: 3},
-};
-const create = context => {
-	const {
-		onlyIfContainsSeparator,
-		binary,
-		octal,
-		hexadecimal,
-		number,
-	} = {
-		onlyIfContainsSeparator: false,
-		...context.options[0],
-	};
-
-	const options = {
-		'0b': {
-			onlyIfContainsSeparator,
-			...defaultOptions.binary,
-			...binary,
-		},
-		'0o': {
-			onlyIfContainsSeparator,
-			...defaultOptions.octal,
-			...octal,
-		},
-		'0x': {
-			onlyIfContainsSeparator,
-			...defaultOptions.hexadecimal,
-			...hexadecimal,
-		},
-		'': {
-			onlyIfContainsSeparator,
-			...defaultOptions.number,
-			...number,
-		},
-	};
-
-	return {
-		Literal(node) {
-			if (!numeric.isNumeric(node) || numeric.isLegacyOctal(node)) {
-				return;
-			}
-
-			const {raw} = node;
-			let number = raw;
-			let suffix = '';
-			if (isBigIntLiteral(node)) {
-				number = raw.slice(0, -1);
-				suffix = 'n';
-			}
-
-			const strippedNumber = number.replaceAll('_', '');
-			const {prefix, data} = numeric.getPrefix(strippedNumber);
-
-			const {onlyIfContainsSeparator} = options[prefix.toLowerCase()];
-			if (onlyIfContainsSeparator && !raw.includes('_')) {
-				return;
-			}
-
-			const formatted = format(strippedNumber, {prefix, data}, options) + suffix;
-
-			if (raw !== formatted) {
-				return {
-					node,
-					messageId: MESSAGE_ID,
-					fix: fixer => fixer.replaceText(node, formatted),
-				};
-			}
-		},
-	};
-};
-
-const formatOptionsSchema = () => ({
-	type: 'object',
-	additionalProperties: false,
-	properties: {
-		onlyIfContainsSeparator: {
-			type: 'boolean',
-		},
-		minimumDigits: {
-			type: 'integer',
-			minimum: 0,
-		},
-		groupLength: {
-			type: 'integer',
-			minimum: 1,
-		},
-	},
-});
-
-const schema = [{
-	type: 'object',
-	additionalProperties: false,
-	properties: {
-		...Object.fromEntries(
-			Object.entries(defaultOptions).map(([type]) => [type, formatOptionsSchema()]),
-		),
-		onlyIfContainsSeparator: {
-			type: 'boolean',
-		},
-	},
-}];
-
-/** @type {import('eslint').Rule.RuleModule} */
-const config = {
-	create,
-	meta: {
-		type: 'suggestion',
-		docs: {
-			description: 'Enforce the style of numeric separators by correctly grouping digits.',
-			recommended: 'unopinionated',
-		},
-		fixable: 'code',
-		schema,
-		defaultOptions: [
-			{
-				onlyIfContainsSeparator: false,
-				binary: defaultOptions.binary,
-				octal: defaultOptions.octal,
-				hexadecimal: defaultOptions.hexadecimal,
-				number: defaultOptions.number,
-			},
-		],
-		messages,
-	},
-};
-
-export default config;

package/packages/config-eslint/node_modules/eslint-plugin-unicorn/rules/prefer-add-event-listener.js

@@ -1,191 +0,0 @@
-import {isParenthesized} from '@eslint-community/eslint-utils';
-import eventTypes from './shared/dom-events.js';
-import {isUndefined, isNullLiteral, isStaticRequire} from './ast/index.js';
-
-const MESSAGE_ID = 'prefer-add-event-listener';
-const messages = {
-	[MESSAGE_ID]: 'Prefer `{{replacement}}` over `{{method}}`.{{extra}}',
-};
-const extraMessages = {
-	beforeunload: 'Use `event.preventDefault(); event.returnValue = \'foo\'` to trigger the prompt.',
-	message: 'Note that there is difference between `SharedWorker#onmessage` and `SharedWorker#addEventListener(\'message\')`.',
-	error: 'Note that there is difference between `{window,element}.onerror` and `{window,element}.addEventListener(\'error\')`.',
-};
-
-const getEventMethodName = memberExpression => memberExpression.property.name;
-const getEventTypeName = eventMethodName => eventMethodName.slice('on'.length);
-
-const fixCode = (fixer, sourceCode, assignmentNode, memberExpression) => {
-	const eventTypeName = getEventTypeName(getEventMethodName(memberExpression));
-	let eventObjectCode = sourceCode.getText(memberExpression.object);
-	if (isParenthesized(memberExpression.object, sourceCode)) {
-		eventObjectCode = `(${eventObjectCode})`;
-	}
-
-	let fncCode = sourceCode.getText(assignmentNode.right);
-	if (isParenthesized(assignmentNode.right, sourceCode)) {
-		fncCode = `(${fncCode})`;
-	}
-
-	const fixedCodeStatement = `${eventObjectCode}.addEventListener('${eventTypeName}', ${fncCode})`;
-	return fixer.replaceText(assignmentNode, fixedCodeStatement);
-};
-
-const shouldFixBeforeUnload = (assignedExpression, nodeReturnsSomething) => {
-	if (
-		assignedExpression.type !== 'ArrowFunctionExpression'
-		&& assignedExpression.type !== 'FunctionExpression'
-	) {
-		return false;
-	}
-
-	if (assignedExpression.body.type !== 'BlockStatement') {
-		return false;
-	}
-
-	return !nodeReturnsSomething.get(assignedExpression);
-};
-
-const isClearing = node => isUndefined(node) || isNullLiteral(node);
-
-/** @param {import('eslint').Rule.RuleContext} context */
-const create = context => {
-	const options = context.options[0] || {};
-	const excludedPackages = new Set(options.excludedPackages || ['koa', 'sax']);
-	let isDisabled;
-
-	const nodeReturnsSomething = new WeakMap();
-	let codePathInfo;
-
-	return {
-		onCodePathStart(codePath, node) {
-			codePathInfo = {
-				node,
-				upper: codePathInfo,
-				returnsSomething: false,
-			};
-		},
-
-		onCodePathEnd() {
-			nodeReturnsSomething.set(codePathInfo.node, codePathInfo.returnsSomething);
-			codePathInfo = codePathInfo.upper;
-		},
-
-		CallExpression(node) {
-			if (!isStaticRequire(node)) {
-				return;
-			}
-
-			if (!isDisabled && excludedPackages.has(node.arguments[0].value)) {
-				isDisabled = true;
-			}
-		},
-
-		Literal(node) {
-			if (node.parent.type === 'ImportDeclaration' && !isDisabled && excludedPackages.has(node.value)) {
-				isDisabled = true;
-			}
-		},
-
-		ReturnStatement(node) {
-			codePathInfo.returnsSomething ||= Boolean(node.argument);
-		},
-
-		'AssignmentExpression:exit'(node) {
-			if (isDisabled) {
-				return;
-			}
-
-			const {left: memberExpression, right: assignedExpression, operator} = node;
-
-			if (
-				memberExpression.type !== 'MemberExpression'
-				|| memberExpression.computed
-			) {
-				return;
-			}
-
-			const eventMethodName = getEventMethodName(memberExpression);
-
-			if (!eventMethodName || !eventMethodName.startsWith('on')) {
-				return;
-			}
-
-			const eventTypeName = getEventTypeName(eventMethodName);
-
-			if (!eventTypes.has(eventTypeName)) {
-				return;
-			}
-
-			let replacement = 'addEventListener';
-			let extra = '';
-			let fix;
-
-			if (isClearing(assignedExpression)) {
-				replacement = 'removeEventListener';
-			} else if (
-				eventTypeName === 'beforeunload'
-				&& !shouldFixBeforeUnload(assignedExpression, nodeReturnsSomething)
-			) {
-				extra = extraMessages.beforeunload;
-			} else if (eventTypeName === 'message') {
-				// Disable `onmessage` fix, see #537
-				extra = extraMessages.message;
-			} else if (eventTypeName === 'error') {
-				// Disable `onerror` fix, see #1493
-				extra = extraMessages.error;
-			} else if (
-				operator === '='
-				&& node.parent.type === 'ExpressionStatement'
-				&& node.parent.expression === node
-			) {
-				fix = fixer => fixCode(fixer, context.sourceCode, node, memberExpression);
-			}
-
-			return {
-				node: memberExpression.property,
-				messageId: MESSAGE_ID,
-				data: {
-					replacement,
-					method: eventMethodName,
-					extra: extra ? ` ${extra}` : '',
-				},
-				fix,
-			};
-		},
-	};
-};
-
-const schema = [
-	{
-		type: 'object',
-		additionalProperties: false,
-		properties: {
-			excludedPackages: {
-				type: 'array',
-				items: {
-					type: 'string',
-				},
-				uniqueItems: true,
-			},
-		},
-	},
-];
-
-/** @type {import('eslint').Rule.RuleModule} */
-const config = {
-	create,
-	meta: {
-		type: 'suggestion',
-		docs: {
-			description: 'Prefer `.addEventListener()` and `.removeEventListener()` over `on`-functions.',
-			recommended: 'unopinionated',
-		},
-		fixable: 'code',
-		schema,
-		defaultOptions: [{}],
-		messages,
-	},
-};
-
-export default config;