@alexlit/lint-kit 176.0.1 → 177.0.0

package/packages/config-eslint/node_modules/eslint-plugin-unicorn/rules/prefer-export-from.js

@@ -1,367 +0,0 @@
-import {isOpeningBraceToken} from '@eslint-community/eslint-utils';
-import {isStringLiteral} from './ast/index.js';
-import {removeSpecifier} from './fix/index.js';
-
-const MESSAGE_ID_ERROR = 'error';
-const MESSAGE_ID_SUGGESTION = 'suggestion';
-const messages = {
-	[MESSAGE_ID_ERROR]: 'Use `export…from` to re-export `{{exported}}`.',
-	[MESSAGE_ID_SUGGESTION]: 'Switch to `export…from`.',
-};
-
-// Default import/export can be `Identifier`, have to use `Symbol.for`
-const DEFAULT_SPECIFIER_NAME = Symbol.for('default');
-const NAMESPACE_SPECIFIER_NAME = Symbol('NAMESPACE_SPECIFIER_NAME');
-
-const getSpecifierName = node => {
-	switch (node.type) {
-		case 'Identifier': {
-			return Symbol.for(node.name);
-		}
-
-		case 'Literal': {
-			return node.value;
-		}
-		// No default
-	}
-};
-
-const isTypeExport = specifier => specifier.exportKind === 'type' || specifier.parent.exportKind === 'type';
-
-const isTypeImport = specifier => specifier.importKind === 'type' || specifier.parent.importKind === 'type';
-
-function * removeImportOrExport(node, fixer, context) {
-	switch (node.type) {
-		case 'ImportSpecifier':
-		case 'ExportSpecifier':
-		case 'ImportDefaultSpecifier':
-		case 'ImportNamespaceSpecifier': {
-			yield removeSpecifier(node, fixer, context);
-			return;
-		}
-
-		case 'ImportDeclaration':
-		case 'ExportDefaultDeclaration':
-		case 'ExportNamedDeclaration': {
-			yield fixer.remove(node);
-		}
-
-		// No default
-	}
-}
-
-function getSourceAndAssertionsText(declaration, context) {
-	const {sourceCode} = context;
-	const keywordFromToken = sourceCode.getTokenBefore(
-		declaration.source,
-		token => token.type === 'Identifier' && token.value === 'from',
-	);
-	const [start] = sourceCode.getRange(keywordFromToken);
-	const [, end] = sourceCode.getRange(declaration);
-	return sourceCode.text.slice(start, end);
-}
-
-function getFixFunction({
-	context,
-	imported,
-	exported,
-	exportDeclarations,
-	program,
-}) {
-	const importDeclaration = imported.declaration;
-	const sourceNode = importDeclaration.source;
-	const sourceValue = sourceNode.value;
-	const shouldExportAsType = imported.isTypeImport || exported.isTypeExport;
-
-	let exportDeclaration;
-	if (shouldExportAsType) {
-		// If a type export declaration already exists, reuse it, else use a value export declaration with an inline type specifier.
-		exportDeclaration = exportDeclarations.find(({source, exportKind}) => source.value === sourceValue && exportKind === 'type');
-	}
-
-	exportDeclaration ||= exportDeclarations.find(({source, exportKind}) => source.value === sourceValue && exportKind !== 'type');
-
-	/** @param {import('eslint').Rule.RuleFixer} fixer */
-	return function * (fixer) {
-		if (imported.name === NAMESPACE_SPECIFIER_NAME) {
-			yield fixer.insertTextAfter(
-				program,
-				`\nexport * as ${exported.text} ${getSourceAndAssertionsText(importDeclaration, context)}`,
-			);
-		} else {
-			let specifierText = exported.name === imported.name
-				? exported.text
-				: `${imported.text} as ${exported.text}`;
-
-			// Add an inline type specifier if the value is a type and the export deceleration is a value deceleration
-			if (shouldExportAsType && (!exportDeclaration || exportDeclaration.exportKind !== 'type')) {
-				specifierText = `type ${specifierText}`;
-			}
-
-			if (exportDeclaration) {
-				const lastSpecifier = exportDeclaration.specifiers.at(-1);
-
-				// `export {} from 'foo';`
-				if (lastSpecifier) {
-					yield fixer.insertTextAfter(lastSpecifier, `, ${specifierText}`);
-				} else {
-					const openingBraceToken = context.sourceCode.getFirstToken(exportDeclaration, isOpeningBraceToken);
-					yield fixer.insertTextAfter(openingBraceToken, specifierText);
-				}
-			} else {
-				yield fixer.insertTextAfter(
-					program,
-					`\nexport {${specifierText}} ${getSourceAndAssertionsText(importDeclaration, context)}`,
-				);
-			}
-		}
-
-		if (imported.variable.references.length === 1) {
-			yield removeImportOrExport(imported.node, fixer, context);
-		}
-
-		yield removeImportOrExport(exported.node, fixer, context);
-	};
-}
-
-function getExported(identifier, sourceCode) {
-	const {parent} = identifier;
-	switch (parent.type) {
-		case 'ExportDefaultDeclaration': {
-			return {
-				node: parent,
-				name: DEFAULT_SPECIFIER_NAME,
-				text: 'default',
-				isTypeExport: isTypeExport(parent),
-			};
-		}
-
-		case 'ExportSpecifier': {
-			return {
-				node: parent,
-				name: getSpecifierName(parent.exported),
-				text: sourceCode.getText(parent.exported),
-				isTypeExport: isTypeExport(parent),
-			};
-		}
-
-		case 'VariableDeclarator': {
-			if (
-				parent.init === identifier
-				&& parent.id.type === 'Identifier'
-				&& !parent.id.typeAnnotation
-				&& parent.parent.type === 'VariableDeclaration'
-				&& parent.parent.kind === 'const'
-				&& parent.parent.declarations.length === 1
-				&& parent.parent.declarations[0] === parent
-				&& parent.parent.parent.type === 'ExportNamedDeclaration'
-				&& isVariableUnused(parent, sourceCode)
-			) {
-				return {
-					node: parent.parent.parent,
-					name: Symbol.for(parent.id.name),
-					text: sourceCode.getText(parent.id),
-				};
-			}
-
-			break;
-		}
-
-		// No default
-	}
-}
-
-function isVariableUnused(node, sourceCode) {
-	const variables = sourceCode.getDeclaredVariables(node);
-
-	/* c8 ignore next 3 */
-	if (variables.length !== 1) {
-		return false;
-	}
-
-	const [{identifiers, references}] = variables;
-	return identifiers.length === 1
-		&& identifiers[0] === node.id
-		&& references.length === 1
-		&& references[0].identifier === node.id;
-}
-
-function getImported(variable, sourceCode) {
-	const specifier = variable.defs[0].node;
-	const result = {
-		node: specifier,
-		declaration: specifier.parent,
-		variable,
-		isTypeImport: isTypeImport(specifier),
-	};
-
-	switch (specifier.type) {
-		case 'ImportDefaultSpecifier': {
-			return {
-				name: DEFAULT_SPECIFIER_NAME,
-				text: 'default',
-				...result,
-			};
-		}
-
-		case 'ImportSpecifier': {
-			return {
-				name: getSpecifierName(specifier.imported),
-				text: sourceCode.getText(specifier.imported),
-				...result,
-			};
-		}
-
-		case 'ImportNamespaceSpecifier': {
-			return {
-				name: NAMESPACE_SPECIFIER_NAME,
-				text: '*',
-				...result,
-			};
-		}
-
-		// No default
-	}
-}
-
-function getExports(imported, sourceCode) {
-	const exports = [];
-	for (const {identifier} of imported.variable.references) {
-		const exported = getExported(identifier, sourceCode);
-
-		if (!exported) {
-			continue;
-		}
-
-		/*
-		There is no substitution for:
-
-		```js
-		import * as foo from 'foo';
-		export default foo;
-		```
-		*/
-		if (imported.name === NAMESPACE_SPECIFIER_NAME && exported.name === DEFAULT_SPECIFIER_NAME) {
-			continue;
-		}
-
-		exports.push(exported);
-	}
-
-	return exports;
-}
-
-const schema = [
-	{
-		type: 'object',
-		additionalProperties: false,
-		properties: {
-			ignoreUsedVariables: {
-				type: 'boolean',
-			},
-		},
-	},
-];
-
-/** @param {import('eslint').Rule.RuleContext} context */
-function create(context) {
-	const {sourceCode} = context;
-	const {ignoreUsedVariables} = {ignoreUsedVariables: false, ...context.options[0]};
-	const importDeclarations = new Set();
-	const exportDeclarations = [];
-
-	return {
-		ImportDeclaration(node) {
-			if (node.specifiers.length > 0) {
-				importDeclarations.add(node);
-			}
-		},
-		// `ExportAllDeclaration` and `ExportDefaultDeclaration` can't be reused
-		ExportNamedDeclaration(node) {
-			if (isStringLiteral(node.source)) {
-				exportDeclarations.push(node);
-			}
-		},
-		* 'Program:exit'(program) {
-			for (const importDeclaration of importDeclarations) {
-				let variables = sourceCode.getDeclaredVariables(importDeclaration);
-
-				if (variables.some(variable => variable.defs.length !== 1 || variable.defs[0].parent !== importDeclaration)) {
-					continue;
-				}
-
-				variables = variables.map(variable => {
-					const imported = getImported(variable, sourceCode);
-					const exports = getExports(imported, sourceCode);
-
-					return {
-						variable,
-						imported,
-						exports,
-					};
-				});
-
-				if (
-					ignoreUsedVariables
-					&& variables.some(({variable, exports}) => variable.references.length !== exports.length)
-				) {
-					continue;
-				}
-
-				const shouldUseSuggestion = ignoreUsedVariables
-					&& variables.some(({variable}) => variable.references.length === 0);
-
-				for (const {imported, exports} of variables) {
-					for (const exported of exports) {
-						const problem = {
-							node: exported.node,
-							messageId: MESSAGE_ID_ERROR,
-							data: {
-								exported: exported.text,
-							},
-						};
-						const fix = getFixFunction({
-							context,
-							imported,
-							exported,
-							exportDeclarations,
-							program,
-						});
-
-						if (shouldUseSuggestion) {
-							problem.suggest = [
-								{
-									messageId: MESSAGE_ID_SUGGESTION,
-									fix,
-								},
-							];
-						} else {
-							problem.fix = fix;
-						}
-
-						yield problem;
-					}
-				}
-			}
-		},
-	};
-}
-
-/** @type {import('eslint').Rule.RuleModule} */
-const config = {
-	create,
-	meta: {
-		type: 'suggestion',
-		docs: {
-			description: 'Prefer `export…from` when re-exporting.',
-			recommended: true,
-		},
-		fixable: 'code',
-		hasSuggestions: true,
-		schema,
-		defaultOptions: [{ignoreUsedVariables: false}],
-		messages,
-	},
-};
-
-export default config;

package/packages/config-eslint/node_modules/eslint-plugin-unicorn/rules/prefer-global-this.js

@@ -1,222 +0,0 @@
-const MESSAGE_ID_ERROR = 'prefer-global-this/error';
-const messages = {
-	[MESSAGE_ID_ERROR]: 'Prefer `{{replacement}}` over `{{value}}`.',
-};
-
-const globalIdentifier = new Set([
-	'window',
-	'self',
-	'global',
-]);
-
-const windowSpecificEvents = new Set([
-	'resize',
-	'blur',
-	'focus',
-	'load',
-	'scroll',
-	'scrollend',
-	'wheel',
-	'beforeunload', // Browsers might have specific behaviors on exactly `window.onbeforeunload =`
-	'message',
-	'messageerror',
-	'pagehide',
-	'pagereveal',
-	'pageshow',
-	'pageswap',
-	'unload',
-]);
-
-/**
-Note: What kind of API should be a windows-specific interface?
-
-1. It's directly related to window (✅ window.close())
-2. It does NOT work well as globalThis.x or x (✅ window.frames, window.top)
-
-Some constructors are occasionally related to window (like Element !== iframe.contentWindow.Element), but they don't need to mention window anyway.
-
-Please use these criteria to decide whether an API should be added here. Context: https://github.com/sindresorhus/eslint-plugin-unicorn/pull/2410#discussion_r1695312427
-*/
-const windowSpecificAPIs = new Set([
-	// Properties and methods
-	// https://html.spec.whatwg.org/multipage/nav-history-apis.html#the-window-object
-	'name',
-	'locationbar',
-	'menubar',
-	'personalbar',
-	'scrollbars',
-	'statusbar',
-	'toolbar',
-	'status',
-	'close',
-	'closed',
-	'stop',
-	'focus',
-	'blur',
-	'frames',
-	'length',
-	'top',
-	'opener',
-	'parent',
-	'frameElement',
-	'open',
-	'originAgentCluster',
-	'postMessage',
-	'navigation',
-
-	// Events commonly associated with "window"
-	...[...windowSpecificEvents].map(event => `on${event}`),
-
-	// To add/remove/dispatch events that are commonly associated with "window"
-	// https://www.w3.org/TR/DOM-Level-2-Events/events.html#Events-flow
-	'addEventListener',
-	'removeEventListener',
-	'dispatchEvent',
-
-	// https://dom.spec.whatwg.org/#idl-index
-	'event', // Deprecated and quirky, best left untouched
-
-	// https://drafts.csswg.org/cssom-view/#idl-index
-	'screen',
-	'visualViewport',
-	'moveTo',
-	'moveBy',
-	'resizeTo',
-	'resizeBy',
-	'innerWidth',
-	'innerHeight',
-	'outerWidth',
-	'outerHeight',
-	'scrollX',
-	'pageXOffset',
-	'scrollY',
-	'pageYOffset',
-	'scroll',
-	'scrollTo',
-	'scrollBy',
-	'screenX',
-	'screenLeft',
-	'screenY',
-	'screenTop',
-	'screenWidth',
-	'screenHeight',
-	'devicePixelRatio',
-]);
-
-const webWorkerSpecificAPIs = new Set([
-	// https://html.spec.whatwg.org/multipage/workers.html#the-workerglobalscope-common-interface
-	'addEventListener',
-	'removeEventListener',
-	'dispatchEvent',
-
-	'self',
-	'location',
-	'navigator',
-	'onerror',
-	'onlanguagechange',
-	'onoffline',
-	'ononline',
-	'onrejectionhandled',
-	'onunhandledrejection',
-
-	// https://html.spec.whatwg.org/multipage/workers.html#dedicated-workers-and-the-dedicatedworkerglobalscope-interface
-	'name',
-	'postMessage',
-	'onconnect',
-]);
-
-/**
-Check if the node is a window-specific API.
-
-@param {import('estree').MemberExpression} node
-@returns {boolean}
-*/
-const isWindowSpecificAPI = node => {
-	if (node.type !== 'MemberExpression') {
-		return false;
-	}
-
-	if (node.object.name !== 'window' || node.property.type !== 'Identifier') {
-		return false;
-	}
-
-	if (windowSpecificAPIs.has(node.property.name)) {
-		if (['addEventListener', 'removeEventListener', 'dispatchEvent'].includes(node.property.name) && node.parent.type === 'CallExpression' && node.parent.callee === node) {
-			const argument = node.parent.arguments[0];
-			return argument && argument.type === 'Literal' && windowSpecificEvents.has(argument.value);
-		}
-
-		return true;
-	}
-
-	return false;
-};
-
-/**
-@param {import('estree').Identifier} identifier
-@returns {boolean}
-*/
-function isComputedMemberExpressionObject(identifier) {
-	return identifier.parent.type === 'MemberExpression' && identifier.parent.computed && identifier.parent.object === identifier;
-}
-
-/**
-Check if the node is a web worker specific API.
-
-@param {import('estree').MemberExpression} node
-@returns {boolean}
-*/
-const isWebWorkerSpecificAPI = node => node.type === 'MemberExpression' && node.object.name === 'self' && node.property.type === 'Identifier' && webWorkerSpecificAPIs.has(node.property.name);
-
-/** @param {import('eslint').Rule.RuleContext} context */
-const create = context => ({
-	* Program(program) {
-		const scope = context.sourceCode.getScope(program);
-
-		const references = [
-			// Variables declared at globals options
-			...scope.variables.flatMap(variable => globalIdentifier.has(variable.name) ? variable.references : []),
-			// Variables not declared at globals options
-			...scope.through.filter(reference => globalIdentifier.has(reference.identifier.name)),
-		];
-
-		for (const {identifier} of references) {
-			if (
-				isComputedMemberExpressionObject(identifier)
-				|| isWindowSpecificAPI(identifier.parent)
-				|| isWebWorkerSpecificAPI(identifier.parent)
-			) {
-				continue;
-			}
-
-			// Skip the fix for `typeof window` and `typeof self`
-			const isTypeofLegacyGlobal = identifier.parent.type === 'UnaryExpression' && identifier.parent.operator === 'typeof' && identifier.parent.argument === identifier;
-
-			const replacement = isTypeofLegacyGlobal ? 'globalThis.' + identifier.name : 'globalThis';
-
-			yield {
-				node: identifier,
-				messageId: MESSAGE_ID_ERROR,
-				data: {replacement, value: identifier.name},
-				fix: fixer => fixer.replaceText(identifier, replacement),
-			};
-		}
-	},
-});
-
-/** @type {import('eslint').Rule.RuleModule} */
-const config = {
-	create,
-	meta: {
-		type: 'suggestion',
-		docs: {
-			description: 'Prefer `globalThis` over `window`, `self`, and `global`.',
-			recommended: 'unopinionated',
-		},
-		fixable: 'code',
-		hasSuggestions: false,
-		messages,
-	},
-};
-
-export default config;