@alexlit/lint-kit 174.0.0 → 176.0.0

package/packages/config-eslint/node_modules/eslint-plugin-unicorn/rules/rule/to-eslint-create.js

@@ -0,0 +1,51 @@
+import createUnicornContext from './unicorn-context.js';
+import UnicornListeners from './unicorn-listeners.js';
+
+/**
+@import * as ESLint from 'eslint';
+@import {UnicornContext} from './unicorn-context.js';
+@import {EslintListers, ListenerType, EslintListener} from './to-eslint-listener.js'
+*/
+
+/**
+@typedef {ESLint.Rule.RuleModule['create']} EslintCreate
+@typedef {(context: UnicornContext) => (EslintListers | void)} UnicornCreate
+*/
+
+// `checkVueTemplate` function will wrap `create` function, there is no need to wrap twice
+const wrappedFunctions = new Set();
+const markFunctionWrapped = create => {
+	wrappedFunctions.add(create);
+	return create;
+};
+
+/**
+Convert Unicorn style of `create` to ESLint style
+
+@param {UnicornCreate} unicornCreate
+@returns {EslintCreate}
+*/
+function toEslintCreate(unicornCreate) {
+	if (wrappedFunctions.has(unicornCreate)) {
+		return unicornCreate;
+	}
+
+	return eslintContext => {
+		const unicornListeners = new UnicornListeners(eslintContext);
+		const unicornContext = createUnicornContext(eslintContext, unicornListeners);
+		const listeners = unicornCreate(unicornContext);
+
+		if (listeners) {
+			for (const [selector, listener] of Object.entries(listeners)) {
+				unicornListeners.on(selector, listener);
+			}
+		}
+
+		const eslintListeners = unicornListeners.toEslintListeners();
+
+		return eslintListeners;
+	};
+}
+
+export default toEslintCreate;
+export {markFunctionWrapped};

package/packages/config-eslint/node_modules/eslint-plugin-unicorn/rules/rule/to-eslint-listener.js

@@ -0,0 +1,40 @@
+import {iterateFixOrProblems} from './utilities.js';
+import toEslintProblem from './to-eslint-problem.js';
+
+/**
+@import * as ESLint from 'eslint';
+@import {UnicornContext} from './unicorn-context.js'
+@import {UnicornProblems} from './to-eslint-problem.js'
+*/
+
+/**
+@typedef {ESLint.Rule.RuleListener} EslintListers
+@typedef {keyof EslintListers} ListenerType
+@typedef {EslintListers[ListenerType]} EslintListener
+@typedef {(...listenerArguments: Parameters<EslintListener>) => UnicornProblems} UnicornRuleListen
+*/
+
+/**
+@param {UnicornContext} context
+@param {UnicornRuleListen} listener
+@returns {Listener}
+*/
+function toEslintListener(context, listener) {
+	// Listener arguments can be `codePath, node` or `node`
+
+	/**
+	@type {UnicornRuleListen}
+	*/
+	return (...listenerArguments) => {
+		const unicornProblems = listener(...listenerArguments);
+
+		for (const unicornProblem of iterateFixOrProblems(unicornProblems)) {
+			if (unicornProblem) {
+				const eslintProblem = toEslintProblem(unicornProblem);
+				context.report(eslintProblem);
+			}
+		}
+	};
+}
+
+export default toEslintListener;

package/packages/config-eslint/node_modules/eslint-plugin-unicorn/rules/rule/to-eslint-problem.js

@@ -0,0 +1,38 @@
+import toEslintFixer from './to-eslint-rule-fixer.js';
+
+/**
+@import * as ESLint from 'eslint';
+*/
+
+/**
+@typedef {Parameters<ESLint.Rule.RuleContext['report']>[0]} EslintProblem
+@typedef {EslintProblem} UnicornProblem
+@typedef {EslintProblem | undefined | EslintProblem[] | IterableIterator<EslintProblem>} UnicornProblems
+*/
+
+/**
+@param {UnicornProblem} unicornProblem
+@returns {EslintProblem}
+*/
+function toEslintProblem(unicornProblem) {
+	const eslintProblem = {...unicornProblem};
+
+	if (unicornProblem.fix) {
+		eslintProblem.fix = toEslintFixer(unicornProblem.fix);
+	}
+
+	if (Array.isArray(unicornProblem.suggest)) {
+		eslintProblem.suggest = unicornProblem.suggest.map(unicornSuggest => ({
+			...unicornSuggest,
+			fix: toEslintFixer(unicornSuggest.fix),
+			data: {
+				...unicornProblem.data,
+				...unicornSuggest.data,
+			},
+		}));
+	}
+
+	return eslintProblem;
+}
+
+export default toEslintProblem;

package/packages/config-eslint/node_modules/eslint-plugin-unicorn/rules/rule/to-eslint-rule-fixer.js

@@ -0,0 +1,49 @@
+import {iterateFixOrProblems} from './utilities.js';
+
+/**
+@import * as ESLint from 'eslint';
+*/
+
+class FixAbortError extends Error {
+	name = 'FixAbortError';
+}
+
+const fixOptions = {
+	abort() {
+		throw new FixAbortError('Fix aborted.');
+	},
+};
+
+/**
+@typedef {ESLint.Rule.ReportFixer | undefined} EslintReportFixer
+@typedef {EslintReportFixer | IterableIterator<EslintReportFixer>} UnicornReportFixer
+@typedef {(fixer: ESLint.Rule.RuleFixer, options: typeof fixOptions) => UnicornReportFixer} UnicornRuleFixer
+*/
+
+/**
+Convert Unicorn style fix function to ESLint style fix function
+
+@param {UnicornRuleFixer} fix
+@returns {ESLint.Rule.RuleFixer}
+*/
+function toEslintRuleFixer(fix) {
+	/** @param {UnicornReportFixer} fixer */
+	return fixer => {
+		const unicornReport = fix(fixer, fixOptions);
+
+		const eslintReport = iterateFixOrProblems(unicornReport);
+
+		try {
+			return [...eslintReport];
+		} catch (error) {
+			if (error instanceof FixAbortError) {
+				return;
+			}
+
+			/* c8 ignore next */
+			throw error;
+		}
+	};
+}
+
+export default toEslintRuleFixer;

package/packages/config-eslint/node_modules/eslint-plugin-unicorn/rules/rule/to-eslint-rule.js

@@ -0,0 +1,38 @@
+import toEslintCreate from './to-eslint-create.js';
+import getDocumentationUrl from '../utils/get-documentation-url.js';
+
+/**
+@import * as ESLint from 'eslint';
+@import {UnicornCreate} from './to-eslint-create.js';
+*/
+
+/**
+@typedef {ESLint.Rule.RuleModule & {
+	create: UnicornCreate
+}} UnicornRule
+*/
+
+/**
+Convert Unicorn rule to Eslint rule
+
+@param {string} ruleId
+@param {UnicornRule} unicornRule
+@returns {ESLint.Rule.RuleModule}
+*/
+function toEslintRule(ruleId, unicornRule) {
+	return {
+		meta: {
+			// If there is are, options add `[]` so ESLint can validate that no data is passed to the rule.
+			// https://github.com/not-an-aardvark/eslint-plugin-eslint-plugin/blob/master/docs/rules/require-meta-schema.md
+			schema: [],
+			...unicornRule.meta,
+			docs: {
+				...unicornRule.meta.docs,
+				url: getDocumentationUrl(ruleId),
+			},
+		},
+		create: toEslintCreate(unicornRule.create),
+	};
+}
+
+export default toEslintRule;

package/packages/config-eslint/node_modules/eslint-plugin-unicorn/rules/rule/to-eslint-rules.js

@@ -0,0 +1,13 @@
+import toEslintRule from './to-eslint-rule.js';
+
+function toEslintRules(rules) {
+	return Object.fromEntries(
+		Object.entries(rules).map(([ruleId, rule]) => [
+			ruleId,
+			toEslintRule(ruleId, rule),
+		]),
+	);
+}
+
+export default toEslintRules;
+

package/packages/config-eslint/node_modules/eslint-plugin-unicorn/rules/rule/unicorn-context.js

@@ -0,0 +1,36 @@
+/**
+@import * as ESLint from 'eslint';
+@import {UnicornListeners, ListenerType, Listener} from './to-eslint-create.js'
+*/
+
+/**
+@typedef {(type: ListenerType | ListenerType[], listener: Listener) => ReturnType<Listener>} UnicornRuleListen
+@typedef {ESLint.Rule.RuleContext & {
+	on: UnicornRuleListen
+	onExit: UnicornRuleListen
+}} UnicornContext
+*/
+
+/**
+Create a better `Context` object with `on` and `onExit` method to add listeners
+
+@param {ESLint.Rule.RuleContext} eslintContext
+@param {UnicornListeners} listeners
+@returns {UnicornContext}
+*/
+function createUnicornContext(eslintContext, listeners) {
+	/** @type {UnicornContext} */
+	const context = new Proxy(eslintContext, {
+		get(target, property, receiver) {
+			if (property === 'on' || property === 'onExit') {
+				return listeners[property].bind(listeners);
+			}
+
+			return Reflect.get(target, property, receiver);
+		},
+	});
+
+	return context;
+}
+
+export default createUnicornContext;

package/packages/config-eslint/node_modules/eslint-plugin-unicorn/rules/rule/unicorn-listeners.js

@@ -0,0 +1,65 @@
+import toEslintListener from './to-eslint-listener.js';
+
+/**
+@import {EslintListers, ListenerType, Listener} from './to-eslint-create.js'
+*/
+
+class UnicornListeners {
+	#context;
+	#listeners = new Map();
+
+	constructor(context) {
+		this.#context = context;
+	}
+
+	#addEventListener(selectors, listener) {
+		const listeners = this.#listeners;
+		for (const selector of selectors) {
+			if (listeners.has(selector)) {
+				listeners.get(selector).push(listener);
+			} else {
+				listeners.set(selector, [listener]);
+			}
+		}
+	}
+
+	/**
+	@param {ListenerType | ListenerType[]} selectorOrSelectors
+	@param {Listener} listener
+	*/
+	on(selectorOrSelectors, listener) {
+		const selectors = Array.isArray(selectorOrSelectors) ? selectorOrSelectors : [selectorOrSelectors];
+		this.#addEventListener(selectors, listener);
+	}
+
+	/**
+	@param {ListenerType | ListenerType[]} selectorOrSelectors
+	@param {Listener} listener
+	*/
+	onExit(selectorOrSelectors, listener) {
+		const selectors = Array.isArray(selectorOrSelectors) ? selectorOrSelectors : [selectorOrSelectors];
+		this.#addEventListener(selectors.map(selector => `${selector}:exit`), listener);
+	}
+
+	/**
+	@returns {EslintListers}
+	*/
+	toEslintListeners() {
+		const eslintListeners = {};
+
+		for (const [selector, listeners] of this.#listeners) {
+			eslintListeners[selector] = toEslintListener(
+				this.#context,
+				function * (...listenerArguments) {
+					for (const listener of listeners) {
+						yield listener(...listenerArguments);
+					}
+				},
+			);
+		}
+
+		return eslintListeners;
+	}
+}
+
+export default UnicornListeners;

package/packages/config-eslint/node_modules/eslint-plugin-unicorn/rules/rule/utilities.js

@@ -0,0 +1,27 @@
+const isIterable = object => typeof object?.[Symbol.iterator] === 'function';
+
+/**
+@import * as ESLint from 'eslint';
+@import {UnicornReportFixer} from './to-eslint-rule-fixer.js';
+@import {UnicornProblems, UnicornProblem} from './to-eslint-problem.js';
+*/
+
+/**
+Iterate ESLint fix or ESLint problem
+
+@template {UnicornReportFixer | UnicornProblems} ValueType
+
+@param {ValueType} value
+@returns {IterableIterator<ValueType extends UnicornReportFixer ? ESLint.Rule.Fix : UnicornProblem>}
+*/
+export function * iterateFixOrProblems(value) {
+	if (!isIterable(value)) {
+		yield value;
+		return;
+	}
+
+	for (const element of value) {
+		yield * iterateFixOrProblems(element);
+	}
+}
+

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

@@ -0,0 +1,270 @@
+/* eslint sort-keys: ["error", "asc", {"caseSensitive": false}] */
+
+export const defaultReplacements = {
+	acc: {
+		accumulator: true,
+	},
+	arg: {
+		argument: true,
+	},
+	args: {
+		arguments: true,
+	},
+	arr: {
+		array: true,
+	},
+	attr: {
+		attribute: true,
+	},
+	attrs: {
+		attributes: true,
+	},
+	btn: {
+		button: true,
+	},
+	cb: {
+		callback: true,
+	},
+	conf: {
+		config: true,
+	},
+	ctx: {
+		context: true,
+	},
+	cur: {
+		current: true,
+	},
+	curr: {
+		current: true,
+	},
+	db: {
+		database: true,
+	},
+	def: {
+		defer: true,
+		deferred: true,
+		define: true,
+		definition: true,
+	},
+	dest: {
+		destination: true,
+	},
+	dev: {
+		development: true,
+	},
+	dir: {
+		direction: true,
+		directory: true,
+	},
+	dirs: {
+		directories: true,
+	},
+	dist: {
+		distribution: true,
+	},
+	doc: {
+		document: true,
+	},
+	docs: {
+		documentation: true,
+		documents: true,
+	},
+	dst: {
+		daylightSavingTime: true,
+		destination: true,
+		distribution: true,
+	},
+	e: {
+		error: true,
+		event: true,
+	},
+	el: {
+		element: true,
+	},
+	elem: {
+		element: true,
+	},
+	elems: {
+		elements: true,
+	},
+	env: {
+		environment: true,
+	},
+	envs: {
+		environments: true,
+	},
+	err: {
+		error: true,
+	},
+	ev: {
+		event: true,
+	},
+	evt: {
+		event: true,
+	},
+	ext: {
+		extension: true,
+	},
+	exts: {
+		extensions: true,
+	},
+	fn: {
+		function: true,
+	},
+	func: {
+		function: true,
+	},
+	i: {
+		index: true,
+	},
+	idx: {
+		index: true,
+	},
+	j: {
+		index: true,
+	},
+	len: {
+		length: true,
+	},
+	lib: {
+		library: true,
+	},
+	mod: {
+		module: true,
+	},
+	msg: {
+		message: true,
+	},
+	num: {
+		number: true,
+	},
+	obj: {
+		object: true,
+	},
+	opts: {
+		options: true,
+	},
+	param: {
+		parameter: true,
+	},
+	params: {
+		parameters: true,
+	},
+	pkg: {
+		package: true,
+	},
+	prev: {
+		previous: true,
+	},
+	prod: {
+		production: true,
+	},
+	prop: {
+		property: true,
+	},
+	props: {
+		properties: true,
+	},
+	ref: {
+		reference: true,
+	},
+	refs: {
+		references: true,
+	},
+	rel: {
+		related: true,
+		relationship: true,
+		relative: true,
+	},
+	req: {
+		request: true,
+	},
+	res: {
+		resource: true,
+		response: true,
+		result: true,
+	},
+	ret: {
+		returnValue: true,
+	},
+	retval: {
+		returnValue: true,
+	},
+	sep: {
+		separator: true,
+	},
+	src: {
+		source: true,
+	},
+	stdDev: {
+		standardDeviation: true,
+	},
+	str: {
+		string: true,
+	},
+	tbl: {
+		table: true,
+	},
+	temp: {
+		temporary: true,
+	},
+	tit: {
+		title: true,
+	},
+	tmp: {
+		temporary: true,
+	},
+	util: {
+		utility: true,
+	},
+	utils: {
+		utilities: true,
+	},
+	val: {
+		value: true,
+	},
+	var: {
+		variable: true,
+	},
+	vars: {
+		variables: true,
+	},
+	ver: {
+		version: true,
+	},
+};
+
+export const defaultAllowList = {
+	// React.Component Class property
+	// https://reactjs.org/docs/react-component.html#defaultprops
+	defaultProps: true,
+	// `package.json` field
+	// https://docs.npmjs.com/specifying-dependencies-and-devdependencies-in-a-package-json-file
+	devDependencies: true,
+	// Ember class name
+	// https://api.emberjs.com/ember/3.10/classes/Ember.EmberENV/properties
+	EmberENV: true,
+	// React.Component static method
+	// https://reactjs.org/docs/react-component.html#static-getderivedstatefromprops
+	getDerivedStateFromProps: true,
+	// Next.js function
+	// https://nextjs.org/learn/basics/fetching-data-for-pages
+	getInitialProps: true,
+	getServerSideProps: true,
+	getStaticProps: true,
+	// The name iOS is a standard name for an OS
+	iOS: true,
+	// React PropTypes
+	// https://reactjs.org/docs/typechecking-with-proptypes.html
+	propTypes: true,
+	// Jest configuration
+	// https://jestjs.io/docs/en/configuration#setupfilesafterenv-array
+	setupFilesAfterEnv: true,
+};
+
+export const defaultIgnore = [
+	// Internationalization and localization
+	// https://github.com/sindresorhus/eslint-plugin-unicorn/issues/1188
+	'i18n',
+	'l10n',
+];

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

@@ -0,0 +1,14 @@
+const builtinErrors = [
+	// https://developer.mozilla.org/en-US/docs/Web/JavaScript/Reference/Global_Objects/Error
+	'Error',
+	'EvalError',
+	'RangeError',
+	'ReferenceError',
+	'SyntaxError',
+	'TypeError',
+	'URIError',
+	'AggregateError',
+	'SuppressedError',
+];
+
+export default builtinErrors;