@alexlit/lint-kit 175.0.0 → 176.0.1

package/packages/config-eslint/node_modules/eslint-plugin-unicorn/rules/shared/dom-events.js

@@ -0,0 +1,275 @@
+const getVendorPrefixedName = eventName => [
+	`webkit${eventName}`,
+	`o${eventName.toLowerCase()}`,
+	eventName.toLowerCase(),
+];
+
+// https://github.com/google/closure-library/blob/8782d8ba16ef2dd4a508d2081a6938f054fc60e8/closure/goog/events/eventtype.js#L44
+const domEvents = new Set([
+	// Mouse events
+	'click',
+	'rightclick',
+	'dblclick',
+	'auxclick',
+	'mousedown',
+	'mouseup',
+	'mouseover',
+	'mouseout',
+	'mousemove',
+	'mouseenter',
+	'mouseleave',
+
+	// Non-existent event; will never fire. This exists as a mouse counterpart to
+	// POINTERCANCEL.
+	'mousecancel',
+
+	// Selection events.
+	// https://www.w3.org/TR/selection-api/
+	'selectionchange',
+	'selectstart',	// IE, Safari, Chrome
+
+	// Wheel events
+	// http://www.w3.org/TR/DOM-Level-3-Events/#events-wheelevents
+	'wheel',
+
+	// Key events
+	'keypress',
+	'keydown',
+	'keyup',
+
+	// Focus
+	'blur',
+	'focus',
+	'deactivate',	// IE only
+	'focusin',
+	'focusout',
+
+	// Forms
+	'change',
+	'reset',
+	'select',
+	'submit',
+	'input',
+	'propertychange',	// IE only
+
+	// Drag and drop
+	'dragstart',
+	'drag',
+	'dragenter',
+	'dragover',
+	'dragleave',
+	'drop',
+	'dragend',
+
+	// Touch events
+	// Note that other touch events exist, but we should follow the W3C list here.
+	// http://www.w3.org/TR/touch-events/#list-of-touchevent-types
+	'touchstart',
+	'touchmove',
+	'touchend',
+	'touchcancel',
+
+	// Misc
+	'beforeunload',
+	'consolemessage',
+	'contextmenu',
+	'devicechange',
+	'devicemotion',
+	'deviceorientation',
+	'DOMContentLoaded',
+	'error',
+	'help',
+	'load',
+	'losecapture',
+	'orientationchange',
+	'readystatechange',
+	'resize',
+	'scroll',
+	'unload',
+
+	// Media events
+	'canplay',
+	'canplaythrough',
+	'durationchange',
+	'emptied',
+	'ended',
+	'loadeddata',
+	'loadedmetadata',
+	'pause',
+	'play',
+	'playing',
+	'progress',
+	'ratechange',
+	'seeked',
+	'seeking',
+	'stalled',
+	'suspend',
+	'timeupdate',
+	'volumechange',
+	'waiting',
+
+	// Media Source Extensions events
+	// https://www.w3.org/TR/media-source/#mediasource-events
+	'sourceopen',
+	'sourceended',
+	'sourceclosed',
+	// https://www.w3.org/TR/media-source/#sourcebuffer-events
+	'abort',
+	'update',
+	'updatestart',
+	'updateend',
+
+	// HTML 5 History events
+	// See http://www.w3.org/TR/html5/browsers.html#event-definitions-0
+	'hashchange',
+	'pagehide',
+	'pageshow',
+	'popstate',
+
+	// Copy and Paste
+	// Support is limited. Make sure it works on your favorite browser
+	// before using.
+	// http://www.quirksmode.org/dom/events/cutcopypaste.html
+	'copy',
+	'paste',
+	'cut',
+	'beforecopy',
+	'beforecut',
+	'beforepaste',
+
+	// HTML5 online/offline events.
+	// http://www.w3.org/TR/offline-webapps/#related
+	'online',
+	'offline',
+
+	// HTML 5 worker events
+	'message',
+	'connect',
+
+	// Service Worker Events - ServiceWorkerGlobalScope context
+	// See https://w3c.github.io/ServiceWorker/#execution-context-events
+	// message event defined in worker events section
+	'install',
+	'activate',
+	'fetch',
+	'foreignfetch',
+	'messageerror',
+
+	// Service Worker Events - Document context
+	// See https://w3c.github.io/ServiceWorker/#document-context-events
+	'statechange',
+	'updatefound',
+	'controllerchange',
+
+	// CSS animation events.
+	...getVendorPrefixedName('AnimationStart'),
+	...getVendorPrefixedName('AnimationEnd'),
+	...getVendorPrefixedName('AnimationIteration'),
+
+	// CSS transition events. Based on the browser support described at:
+	// https://developer.mozilla.org/en/css/css_transitions#Browser_compatibility
+	...getVendorPrefixedName('TransitionEnd'),
+
+	// W3C Pointer Events
+	// http://www.w3.org/TR/pointerevents/
+	'pointerdown',
+	'pointerup',
+	'pointercancel',
+	'pointermove',
+	'pointerover',
+	'pointerout',
+	'pointerenter',
+	'pointerleave',
+	'gotpointercapture',
+	'lostpointercapture',
+
+	// IE specific events.
+	// See http://msdn.microsoft.com/en-us/library/ie/hh772103(v=vs.85).aspx
+	// these events will be supplanted in IE11.
+	'MSGestureChange',
+	'MSGestureEnd',
+	'MSGestureHold',
+	'MSGestureStart',
+	'MSGestureTap',
+	'MSGotPointerCapture',
+	'MSInertiaStart',
+	'MSLostPointerCapture',
+	'MSPointerCancel',
+	'MSPointerDown',
+	'MSPointerEnter',
+	'MSPointerHover',
+	'MSPointerLeave',
+	'MSPointerMove',
+	'MSPointerOut',
+	'MSPointerOver',
+	'MSPointerUp',
+
+	// Native IMEs/input tools events.
+	'text',
+	// The textInput event is supported in IE9+, but only in lower case. All other
+	// browsers use the camel-case event name.
+	'textinput',
+	'textInput',
+	'compositionstart',
+	'compositionupdate',
+	'compositionend',
+
+	// The beforeinput event is initially only supported in Safari. See
+	// https://bugs.chromium.org/p/chromium/issues/detail?id=342670 for Chrome
+	// implementation tracking.
+	'beforeinput',
+
+	// Webview tag events
+	// See https://developer.chrome.com/apps/tags/webview
+	'exit',
+	'loadabort',
+	'loadcommit',
+	'loadredirect',
+	'loadstart',
+	'loadstop',
+	'responsive',
+	'sizechanged',
+	'unresponsive',
+
+	// HTML5 Page Visibility API.	See details at
+	// `goog.labs.dom.PageVisibilityMonitor`.
+	'visibilitychange',
+
+	// LocalStorage event.
+	'storage',
+
+	// DOM Level 2 mutation events (deprecated).
+	'DOMSubtreeModified',
+	'DOMNodeInserted',
+	'DOMNodeRemoved',
+	'DOMNodeRemovedFromDocument',
+	'DOMNodeInsertedIntoDocument',
+	'DOMAttrModified',
+	'DOMCharacterDataModified',
+
+	// Print events.
+	'beforeprint',
+	'afterprint',
+
+	// Web app manifest events.
+	'beforeinstallprompt',
+	'appinstalled',
+
+	// https://github.com/facebook/react/blob/cae635054e17a6f107a39d328649137b83f25972/packages/react-dom/src/events/DOMEventNames.js#L12
+	'afterblur',
+	'beforeblur',
+	'cancel',
+	'close',
+	'dragexit',
+	'encrypted',
+	'fullscreenchange',
+	'invalid',
+	'toggle',
+
+	// https://github.com/sindresorhus/eslint-plugin-unicorn/pull/147
+	'search',
+	'open',
+	'show',
+]);
+
+export default domEvents;

package/packages/config-eslint/node_modules/eslint-plugin-unicorn/rules/shared/event-keys.js

@@ -0,0 +1,54 @@
+/* eslint sort-keys: ["error", "asc", {natural: true}] */
+
+// https://github.com/facebook/react/blob/b87aabd/packages/react-dom/src/events/getEventKey.js#L36
+// Only meta characters which can't be deciphered from `String.fromCharCode()`
+const eventKeys = {
+	8: 'Backspace',
+	9: 'Tab',
+	12: 'Clear',
+	13: 'Enter',
+	16: 'Shift',
+	17: 'Control',
+	18: 'Alt',
+	19: 'Pause',
+	20: 'CapsLock',
+	27: 'Escape',
+	32: ' ',
+	33: 'PageUp',
+	34: 'PageDown',
+	35: 'End',
+	36: 'Home',
+	37: 'ArrowLeft',
+	38: 'ArrowUp',
+	39: 'ArrowRight',
+	40: 'ArrowDown',
+	45: 'Insert',
+	46: 'Delete',
+	112: 'F1',
+	113: 'F2',
+	114: 'F3',
+	115: 'F4',
+	116: 'F5',
+	117: 'F6',
+	118: 'F7',
+	119: 'F8',
+	120: 'F9',
+	121: 'F10',
+	122: 'F11',
+	123: 'F12',
+	144: 'NumLock',
+	145: 'ScrollLock',
+	186: ';',
+	187: '=',
+	188: ',',
+	189: '-',
+	190: '.',
+	191: '/',
+	219: '[',
+	220: '\\',
+	221: ']',
+	222: '\'',
+	224: 'Meta',
+};
+
+export default eventKeys;

package/packages/config-eslint/node_modules/eslint-plugin-unicorn/rules/shared/negative-index.js

@@ -0,0 +1,52 @@
+import isSameReference from '../utils/is-same-reference.js';
+import {getParenthesizedRange} from '../utils/parentheses.js';
+import {isNumericLiteral} from '../ast/index.js';
+
+/**
+@import {TSESTree as ESTree} from '@typescript-eslint/types';
+@import * as ESLint from 'eslint';
+*/
+
+const isLengthMemberExpression = node =>
+	node.type === 'MemberExpression'
+	&& !node.computed
+	&& !node.optional
+	&& node.property.type === 'Identifier'
+	&& node.property.name === 'length';
+
+const isLiteralPositiveNumber = node =>
+	isNumericLiteral(node)
+	&& node.value > 0;
+
+export function getNegativeIndexLengthNode(node, objectNode) {
+	if (!node) {
+		return;
+	}
+
+	const {type, operator, left, right} = node;
+
+	if (type !== 'BinaryExpression' || operator !== '-' || !isLiteralPositiveNumber(right)) {
+		return;
+	}
+
+	if (isLengthMemberExpression(left) && isSameReference(left.object, objectNode)) {
+		return left;
+	}
+
+	// Nested BinaryExpression
+	return getNegativeIndexLengthNode(left, objectNode);
+}
+
+/**
+@param {ESTree.Node} node
+@param {ESLint.Rule.RuleContext} context - The ESLint rule context object.
+@returns {ESLint.Rule.ReportFixer}
+*/
+export function removeLengthNode(node, fixer, context) {
+	const [start, end] = getParenthesizedRange(node, context);
+	return fixer.removeRange([
+		start,
+		end + context.sourceCode.text.slice(end).match(/\S|$/).index,
+	]);
+}
+

package/packages/config-eslint/node_modules/eslint-plugin-unicorn/rules/shared/no-array-mutate-rule.js

@@ -0,0 +1,139 @@
+import {isMethodCall} from '../ast/index.js';
+import {getParenthesizedText} from '../utils/index.js';
+
+const MESSAGE_ID_ERROR = 'error';
+const MESSAGE_ID_SUGGESTION_APPLY_REPLACEMENT = 'suggestion-apply-replacement';
+const MESSAGE_ID_SUGGESTION_SPREADING_ARRAY = 'suggestion-spreading-array';
+const MESSAGE_ID_SUGGESTION_NOT_SPREADING_ARRAY = 'suggestion-not-spreading-array';
+
+const methods = new Map([
+	[
+		'reverse',
+		{
+			replacement: 'toReversed',
+			predicate: callExpression => isMethodCall(callExpression, {
+				method: 'reverse',
+				argumentsLength: 0,
+				optionalCall: false,
+			}),
+		},
+	],
+	[
+		'sort',
+		{
+			replacement: 'toSorted',
+			predicate: callExpression => isMethodCall(callExpression, {
+				method: 'sort',
+				maximumArguments: 1,
+				optionalCall: false,
+			}),
+		},
+	],
+]);
+
+const schema = [
+	{
+		type: 'object',
+		additionalProperties: false,
+		properties: {
+			allowExpressionStatement: {
+				type: 'boolean',
+			},
+		},
+	},
+];
+
+function noArrayMutateRule(methodName) {
+	const {
+		replacement,
+		predicate,
+	} = methods.get(methodName);
+
+	const messages = {
+		[MESSAGE_ID_ERROR]: `Use \`Array#${replacement}()\` instead of \`Array#${methodName}()\`.`,
+		[MESSAGE_ID_SUGGESTION_APPLY_REPLACEMENT]: `Switch to \`.${replacement}()\`.`,
+		[MESSAGE_ID_SUGGESTION_SPREADING_ARRAY]: 'The spreading object is an array.',
+		[MESSAGE_ID_SUGGESTION_NOT_SPREADING_ARRAY]: 'The spreading object is NOT an array.',
+	};
+
+	/** @param {import('eslint').Rule.RuleContext} context */
+	const create = context => {
+		const {allowExpressionStatement} = context.options[0];
+
+		return {
+			CallExpression(callExpression) {
+				if (!predicate(callExpression)) {
+					return;
+				}
+
+				const array = callExpression.callee.object;
+
+				// `[...array].reverse()`
+				const isSpreadAndMutate = array.type === 'ArrayExpression'
+					&& array.elements.length === 1
+					&& array.elements[0].type === 'SpreadElement';
+
+				if (allowExpressionStatement && !isSpreadAndMutate) {
+					const maybeExpressionStatement = callExpression.parent.type === 'ChainExpression'
+						? callExpression.parent.parent
+						: callExpression.parent;
+					if (maybeExpressionStatement.type === 'ExpressionStatement') {
+						return;
+					}
+				}
+
+				const methodProperty = callExpression.callee.property;
+				const suggestions = [];
+				const fixMethodName = fixer => fixer.replaceText(methodProperty, replacement);
+
+				/*
+				For `[...array].reverse()`, provide two suggestions, let user choose if the object can be unwrapped,
+				otherwise only change `.reverse()` to `.toReversed()`
+				*/
+				if (isSpreadAndMutate) {
+					suggestions.push({
+						messageId: MESSAGE_ID_SUGGESTION_SPREADING_ARRAY,
+						* fix(fixer) {
+							const text = getParenthesizedText(array.elements[0].argument, context);
+							yield fixer.replaceText(array, text);
+							yield fixMethodName(fixer);
+						},
+					});
+				}
+
+				suggestions.push({
+					messageId: isSpreadAndMutate
+						? MESSAGE_ID_SUGGESTION_NOT_SPREADING_ARRAY
+						: MESSAGE_ID_SUGGESTION_APPLY_REPLACEMENT,
+					fix: fixMethodName,
+				});
+
+				return {
+					node: methodProperty,
+					messageId: MESSAGE_ID_ERROR,
+					suggest: suggestions,
+				};
+			},
+		};
+	};
+
+	/** @type {import('eslint').Rule.RuleModule} */
+	const config = {
+		create,
+		meta: {
+			type: 'suggestion',
+			docs: {
+				description: `Prefer \`Array#${replacement}()\` over \`Array#${methodName}()\`.`,
+				recommended: 'unopinionated',
+			},
+			hasSuggestions: true,
+			schema,
+			defaultOptions: [{allowExpressionStatement: true}],
+			messages,
+		},
+	};
+
+	return config;
+}
+
+export default noArrayMutateRule;

package/packages/config-eslint/node_modules/eslint-plugin-unicorn/rules/shared/no-unnecessary-length-or-infinity-rule.js

@@ -0,0 +1,80 @@
+import {isMethodCall, isMemberExpression} from '../ast/index.js';
+import {isSameReference} from '../utils/index.js';
+import {removeArgument} from '../fix/index.js';
+
+function getObjectLengthOrInfinityDescription(node, object) {
+	// `Infinity`
+	if (node.type === 'Identifier' && node.name === 'Infinity') {
+		return 'Infinity';
+	}
+
+	// `Number.POSITIVE_INFINITY`
+	if (isMemberExpression(node, {
+		object: 'Number',
+		property: 'POSITIVE_INFINITY',
+		computed: false,
+		optional: false,
+	})) {
+		return 'Number.POSITIVE_INFINITY';
+	}
+
+	// `object?.length`
+	const isOptional = node.type === 'ChainExpression';
+	if (isOptional) {
+		node = node.expression;
+	}
+
+	// `object.length`
+	if (!(
+		isMemberExpression(node, {property: 'length', computed: false})
+		&& isSameReference(object, node.object)
+	)) {
+		return;
+	}
+
+	return `${object.type === 'Identifier' ? object.name : '…'}${isOptional ? '?.' : '.'}length`;
+}
+
+/** @param {import('eslint').Rule.RuleContext} context */
+function listen(context, {methods, messageId}) {
+	context.on('CallExpression', callExpression => {
+		if (!isMethodCall(callExpression, {
+			methods,
+			argumentsLength: 2,
+			optionalCall: false,
+		})) {
+			return;
+		}
+
+		const secondArgument = callExpression.arguments[1];
+		const description = getObjectLengthOrInfinityDescription(
+			secondArgument,
+			callExpression.callee.object,
+		);
+
+		if (!description) {
+			return;
+		}
+
+		const methodName = callExpression.callee.property.name;
+		const messageData = {
+			description,
+		};
+
+		if (methodName === 'splice') {
+			messageData.argumentName = 'deleteCount';
+		} else if (methodName === 'toSpliced') {
+			messageData.argumentName = 'skipCount';
+		}
+
+		return {
+			node: secondArgument,
+			messageId,
+			data: messageData,
+			/** @param {import('eslint').Rule.RuleFixer} fixer */
+			fix: fixer => removeArgument(fixer, secondArgument, context),
+		};
+	});
+}
+
+export {listen};

package/packages/config-eslint/node_modules/eslint-plugin-unicorn/rules/shared/package-json.js

@@ -0,0 +1,42 @@
+import fs from 'node:fs';
+import {findUpSync} from 'find-up-simple';
+
+const directoryCache = new Map();
+const dataCache = new Map();
+
+/**
+Finds the closest package.json file to the given directory and returns its path and contents.
+
+Caches the result for future lookups.
+
+@param dirname {string}
+@return {{ path: string, packageJson: Record<string, unknown> } | undefined}
+*/
+export function readPackageJson(dirname) {
+	let packageJsonPath;
+	if (directoryCache.has(dirname)) {
+		packageJsonPath = directoryCache.get(dirname);
+	} else {
+		packageJsonPath = findUpSync('package.json', {cwd: dirname, type: 'file'});
+		directoryCache.set(dirname, packageJsonPath);
+	}
+
+	if (!packageJsonPath) {
+		return;
+	}
+
+	let packageJson;
+	if (dataCache.has(packageJsonPath)) {
+		packageJson = dataCache.get(packageJsonPath);
+	} else {
+		try {
+			packageJson = JSON.parse(fs.readFileSync(packageJsonPath));
+			dataCache.set(packageJsonPath, packageJson);
+		} catch {
+			// This can happen if package.json files have comments in them etc.
+			return;
+		}
+	}
+
+	return {path: packageJsonPath, packageJson};
+}