@pumpn/eslint-config 17.2.3 → 18.0.0

package/_common/_exports.js

@@ -0,0 +1,5 @@
+export { default as allExtensions } from "./all-extensions.js";
+export { default as convertExtensionsToGlob } from "./convert-extensions-to-glob.js";
+export { default as jsJsxExtensions } from "./js-jsx-extensions.js";
+export { default as tsExtensions } from "./ts-extensions.js";
+export { default as tsJsxExtensions } from "./ts-jsx-extensions.js";

package/_common/all-extensions/_exports.js

@@ -0,0 +1 @@
+export { default as jsExtensions } from "./js-extensions.js";

package/_common/all-extensions/js-extensions.js

@@ -0,0 +1,10 @@
+import jsJsxExtensions from "../js-jsx-extensions.js";
+
+const jsExtensions = /** @type {const} */ ([
+	...jsJsxExtensions,
+	".js",
+	".cjs",
+	".mjs"
+]);
+
+export default jsExtensions;

package/_common/all-extensions.js

@@ -0,0 +1,6 @@
+import { jsExtensions } from "./all-extensions/_exports.js";
+import tsExtensions from "./ts-extensions.js";
+
+const allExtensions = /** @type {const} */ ([...jsExtensions, ...tsExtensions]);
+
+export default allExtensions;

package/_common/convert-extensions-to-glob.js

@@ -0,0 +1,12 @@
+/**
+ * @param {readonly `.${string}`[]} extensions
+ */
+const convertExtensionsToGlob = (extensions) => {
+	const suffix = extensions.length > 1
+		? `.{${extensions.map((extension) => extension.replace(/^\./v, "")).join(",")}}`
+		: extensions[0];
+
+	return `**/*${suffix}`;
+};
+
+export default convertExtensionsToGlob;

package/_common/js-jsx-extensions.js

@@ -0,0 +1,3 @@
+const jsJsxExtensions = /** @type {const} */ ([".jsx", ".mjsx"]);
+
+export default jsJsxExtensions;

package/_common/ts-extensions.js

@@ -0,0 +1,10 @@
+import tsJsxExtensions from "./ts-jsx-extensions.js";
+
+const tsExtensions = /** @type {const} */ ([
+	...tsJsxExtensions,
+	".ts",
+	".cts",
+	".mts"
+]);
+
+export default tsExtensions;

package/_common/ts-jsx-extensions.js

@@ -0,0 +1,3 @@
+const tsJsxExtensions = /** @type {const} */ ([".tsx", ".mtsx"]);
+
+export default tsJsxExtensions;

package/config/_common/_exports.js

@@ -0,0 +1,5 @@
+export { default as addPrefixToRules } from "./add-prefix-to-rules.js";
+export { default as coreJsonRules } from "./core-json-rules.js";
+export { default as jsonPlugins } from "./json-plugins.js";
+export { default as pickUnicornRulesForLanguage } from "./pick-unicorn-rules-for-language.js";
+export { default as tabWidth } from "./tab-width.js";

package/config/_common/add-prefix-to-rules.js

@@ -0,0 +1,13 @@
+import { mapKeys } from "radashi";
+
+/**
+ * @import { Linter } from "eslint";
+ */
+
+/**
+ * @param {string} prefix
+ * @param {Linter.RulesRecord} rules
+ */
+const addPrefixToRules = (prefix, rules) => mapKeys(rules, (key) => `${prefix}/${key}`);
+
+export default addPrefixToRules;

package/config/_common/core-json-rules.js

@@ -0,0 +1,24 @@
+import addPrefixToRules from "./add-prefix-to-rules.js";
+
+const coreJsonRules = addPrefixToRules(
+	"json",
+	{
+		"no-duplicate-keys": "error",
+		"no-empty-keys": "error",
+		"no-unnormalized-keys": ["error", { form: "NFC" }],
+		"no-unsafe-values": "error",
+		"sort-keys": [
+			"error",
+			"asc",
+			{
+				minKeys: 2,
+				allowLineSeparatedGroups: true,
+				caseSensitive: false,
+				natural: true
+			}
+		],
+		"top-level-interop": "error"
+	}
+);
+
+export default coreJsonRules;

package/config/_common/json-plugins.js

@@ -0,0 +1,9 @@
+import json from "@eslint/json";
+import unicorn from "eslint-plugin-unicorn";
+
+const jsonPlugins = {
+	json,
+	unicorn
+};
+
+export default jsonPlugins;

package/config/_common/pick-unicorn-rules-for-language/_exports.js

@@ -0,0 +1,2 @@
+export { default as pickRulesForLanguage } from "./pick-rules-for-language.js";
+export { default as unicornRules } from "./unicorn.js";

package/config/_common/pick-unicorn-rules-for-language/pick-rules-for-language.js

@@ -0,0 +1,52 @@
+import { pick } from "radashi";
+
+/**
+ * @import { Linter } from "eslint";
+ */
+
+/**
+ *
+ * @param {Linter.RulesRecord} rules
+ * @param {string} language
+ * @param {Exclude<Linter.Config["plugins"], undefined>[string]} plugin
+ */
+const pickRulesForLanguage = (
+	rules,
+	language,
+	plugin
+) => pick(
+	rules,
+	(rule, prefixedRuleKey) => {
+		const ruleId = String(prefixedRuleKey);
+
+		// same split as ESLint, so scoped prefixes like `@scope/plugin` work
+		const prefix = /^(?<prefix>@.+|[^\/]+)\//v.exec(ruleId)?.groups?.prefix ?? "";
+
+		const pluginRule = plugin.rules?.[ruleId.slice(prefix.length + 1)];
+
+		if (pluginRule === undefined) {
+			throw new Error(`Rule "${ruleId}" does not exist`);
+		}
+
+		const {
+			meta: {
+				deprecated,
+				languages
+			} = {}
+		} = pluginRule;
+
+		const isDeprecated = deprecated !== undefined && Boolean(deprecated);
+
+		const isLanguage = (
+			languages !== undefined &&
+			(languages.includes(language) || languages.includes("*"))
+		);
+
+		return (
+			!isDeprecated &&
+			isLanguage
+		);
+	}
+);
+
+export default pickRulesForLanguage;

package/config/_common/pick-unicorn-rules-for-language/unicorn/_exports.js

@@ -0,0 +1,9 @@
+export { default as binaryGroupLength } from "./binary-group-length.js";
+export { default as hexadecimalGroupLength } from "./hexadecimal-group-length.js";
+export { default as maximumNestedCalls } from "./maximum-nested-calls.js";
+export { default as numberGroupLength } from "./number-group-length.js";
+export { default as octalGroupLength } from "./octal-group-length.js";
+export { default as patterns } from "./patterns.js";
+export { default as unicornConsistencyRules } from "./unicorn-consistency-rules.js";
+export { default as unicornPreferenceRules } from "./unicorn-preference-rules.js";
+export { default as unicornRedundancyRules } from "./unicorn-redundancy-rules.js";

package/config/_common/pick-unicorn-rules-for-language/unicorn/binary-group-length.js

@@ -0,0 +1,3 @@
+const binaryGroupLength = 4;
+
+export default binaryGroupLength;

package/config/_common/pick-unicorn-rules-for-language/unicorn/hexadecimal-group-length.js

@@ -0,0 +1,3 @@
+const hexadecimalGroupLength = 2;
+
+export default hexadecimalGroupLength;

package/config/_common/pick-unicorn-rules-for-language/unicorn/maximum-nested-calls.js

@@ -0,0 +1,3 @@
+const maximumNestedCalls = 3;
+
+export default maximumNestedCalls;

package/config/_common/pick-unicorn-rules-for-language/unicorn/number-group-length.js

@@ -0,0 +1,3 @@
+const numberGroupLength = 3;
+
+export default numberGroupLength;

package/config/_common/pick-unicorn-rules-for-language/unicorn/octal-group-length.js

@@ -0,0 +1,3 @@
+const octalGroupLength = 4;
+
+export default octalGroupLength;

package/config/_common/pick-unicorn-rules-for-language/unicorn/patterns.js

@@ -0,0 +1,28 @@
+const patterns = {
+	"'": "’",
+	"(?<=“[^“]*?\\s)['‘]([^'‘]+?)['’](?=\\s[^“]*?”)": "‘$1’",
+	"(?<=[!?])”\\.(?=(?:(?:\\s+[\\p{Letter}\\p{Number}])|$))": "”",
+	"(?<=[!?])\\.": "",
+	"(?<=[\\p{Letter}\\p{Number}] )-+(?= [\\p{Letter}\\p{Number}])": "—",
+	"(?<=\\p{Punctuation})\\p{Zs}{2,}(?=[\\p{Letter}\\p{Number}])": " ",
+	"([\"'])((?:\\\\.|[^\\\\])*?)\\1": "“$2”",
+	"-->": "⟶",
+	"->": "→",
+	"\\.”\\.(?=(?:(?:\\s+[\\p{Letter}\\p{Number}])|$))": ".”",
+	"<-": "←",
+	"<--": "⟵",
+	"<-->": "⟷",
+	"<->": "↔",
+	"<=": "≤",
+	"<==": "⇐",
+	"<===": "⟸",
+	"<==>": "⟺",
+	"<=>": "⇔",
+	"===>": "⟹",
+	"==>": "⇒",
+	">=": "≥",
+	"\\.\\.(?=(?:(?:\\s+[\\p{Letter}\\p{Number}])|$))": ".",
+	"\\.\\.\\.": "…"
+};
+
+export default patterns;

package/config/_common/pick-unicorn-rules-for-language/unicorn/unicorn-consistency-rules/_exports.js

@@ -0,0 +1 @@
+export { default as consistentFunctionStyle } from "./consistent-function-style.js";

package/config/_common/pick-unicorn-rules-for-language/unicorn/unicorn-consistency-rules/consistent-function-style.js

@@ -0,0 +1,3 @@
+const consistentFunctionStyle = "arrow-function";
+
+export default consistentFunctionStyle;

package/config/_common/pick-unicorn-rules-for-language/unicorn/unicorn-consistency-rules.js

@@ -0,0 +1,66 @@
+import { consistentFunctionStyle } from "./unicorn-consistency-rules/_exports.js";
+
+/**
+ * @import { Linter } from "eslint";
+ */
+
+/**
+ * @satisfies {Linter.RulesRecord}
+ */
+const unicornConsistencyRules = {
+	"consistent-arrow-return-style": "off",
+	"consistent-assert": "error",
+	"consistent-boolean-name": [
+		"error",
+		{
+			checkArguments: "always",
+			checkFields: "never",
+			checkFunctions: "always",
+			checkMethods: "never",
+			checkVariables: "always",
+			ignore: [],
+			prefixes: {
+				are: true,
+				can: true,
+				did: true,
+				has: true,
+				have: true,
+				is: true,
+				requires: true,
+				should: true,
+				was: true,
+				were: true,
+				will: true
+			},
+			wrappers: {}
+		}
+	],
+	"consistent-class-member-order": "off",
+	"consistent-compound-words": "error",
+	"consistent-conditional-object-spread": ["error", "ternary"],
+	"consistent-date-clone": "error",
+	"consistent-destructuring": "error",
+	"consistent-empty-array-spread": "error",
+	"consistent-existence-index-check": "error",
+	"consistent-export-decorator-position": ["error", "above"],
+	"consistent-function-scoping": "error",
+	"consistent-function-style": [
+		"error",
+		{
+			callbacks: consistentFunctionStyle,
+			default: consistentFunctionStyle,
+			defaultExport: consistentFunctionStyle,
+			namedExports: consistentFunctionStyle,
+			namedFunctions: consistentFunctionStyle,
+			objectProperties: consistentFunctionStyle,
+			reassignedVariables: consistentFunctionStyle,
+			typedVariables: consistentFunctionStyle
+		}
+	],
+	"consistent-json-file-read": ["error", "string"],
+	"consistent-optional-chaining": "error",
+	"consistent-template-literal-escape": "error",
+	"consistent-tuple-labels": "error"
+};
+
+export default unicornConsistencyRules;

package/config/_common/pick-unicorn-rules-for-language/unicorn/unicorn-preference-rules.js

@@ -0,0 +1,199 @@
+/**
+ * @import { Linter } from "eslint";
+ */
+
+/**
+ * @satisfies {Linter.RulesRecord}
+ */
+const unicornPreferenceRules = {
+	"prefer-abort-signal-any": "error",
+	"prefer-abort-signal-timeout": "error",
+	"prefer-add-event-listener": "error",
+	"prefer-add-event-listener-options": "error",
+	"prefer-aggregate-error": "error",
+	"prefer-array-find": "error",
+	"prefer-array-flat": "error",
+	"prefer-array-flat-map": "error",
+	"prefer-array-from-async": "error",
+	"prefer-array-from-map": "error",
+	"prefer-array-from-range": "error",
+	"prefer-array-index-of": "error",
+	"prefer-array-iterable-methods": "error",
+	"prefer-array-last-methods": "error",
+	"prefer-array-slice": "error",
+	"prefer-array-some": "error",
+	"prefer-at": "error",
+	"prefer-await": "error",
+	"prefer-bigint-literals": "error",
+	"prefer-blob-reading-methods": "error",
+	"prefer-block-statement-over-iife": "error",
+	"prefer-boolean-return": "error",
+	"prefer-class-fields": "error",
+	"prefer-classlist-toggle": "error",
+	"prefer-code-point": "error",
+	"prefer-combined-guards": [
+		"error",
+		{
+			checkCompoundConditions: true,
+			checkMultiStatementBodies: true
+		}
+	],
+	"prefer-continue": [
+		"error",
+		{
+			maximumStatements: 1,
+			checkShortBodies: false
+		}
+	],
+	"prefer-date-now": "error",
+	"prefer-default-parameters": ["error", { checkFallbackExpressions: true }],
+	"prefer-direct-iteration": "error",
+	"prefer-dispose": "error",
+	"prefer-dom-node-append": "error",
+	"prefer-dom-node-html-methods": [
+		"error",
+		{
+			checkGetHTML: true,
+			checkSetHTML: true
+		}
+	],
+	"prefer-dom-node-remove": "error",
+	"prefer-dom-node-replace-children": "error",
+	"prefer-dom-node-text-content": "error",
+	"prefer-early-return": [
+		"error",
+		{
+			maximumStatements: 1,
+			checkShortBodies: false
+		}
+	],
+	"prefer-else-if": "error",
+	"prefer-error-is-error": "error",
+	"prefer-escaped-irregular-whitespace": "error",
+	"prefer-event-target": "error",
+	"prefer-export-from": "error",
+	"prefer-flat-math-min-max": "error",
+	"prefer-get-or-insert-computed": "error",
+	"prefer-global-number-constants": "off",
+	"prefer-global-this": "error",
+	"prefer-group-by": "error",
+	"prefer-has-check": "error",
+	"prefer-hoisting-branch-code": "error",
+	"prefer-https": "error",
+	"prefer-identifier-import-export-specifiers": "error",
+	"prefer-import-meta-properties": "error",
+	"prefer-includes": "error",
+	"prefer-includes-over-repeated-comparisons": "error",
+	"prefer-iterable-in-constructor": "error",
+	"prefer-iterator-concat": "off",
+	"prefer-iterator-helpers": "error",
+	"prefer-iterator-to-array": "error",
+	"prefer-iterator-to-array-at-end": "error",
+	"prefer-iterator-zip": "error",
+	"prefer-json-import": "error",
+	"prefer-keyboard-event-key": "error",
+	"prefer-literal-ascii": "error",
+	"prefer-location-assign": "error",
+	"prefer-logical-operator-over-ternary": "error",
+	"prefer-map-from-entries": "error",
+	"prefer-math-abs": "error",
+	"prefer-math-constants": "error",
+	"prefer-math-min-max": "error",
+	"prefer-math-trunc": "error",
+	"prefer-minimal-ternary": [
+		"error",
+		{
+			checkComputedMemberAccess: true,
+			checkVaryingBase: false
+		}
+	],
+	"prefer-modern-dom-apis": "error",
+	"prefer-modern-math-apis": "error",
+	"prefer-module": "error",
+	"prefer-native-coercion-functions": "error",
+	"prefer-negative-index": "error",
+	"prefer-node-protocol": "error",
+	"prefer-number-coercion": "error",
+	"prefer-number-is-safe-integer": "error",
+	"prefer-number-properties": [
+		"error",
+		{
+			checkInfinity: false
+		}
+	],
+	"prefer-object-define-properties": "error",
+	"prefer-object-destructuring-defaults": "error",
+	"prefer-object-from-entries": "error",
+	"prefer-object-iterable-methods": "error",
+	"prefer-observer-apis": "error",
+	"prefer-optional-catch-binding": "error",
+	"prefer-path2d": "error",
+	"prefer-private-class-fields": "error",
+	"prefer-promise-static-methods": "error",
+	"prefer-promise-try": "error",
+	"prefer-promise-with-resolvers": "error",
+	"prefer-prototype-methods": "error",
+	"prefer-query-selector": "error",
+	"prefer-queue-microtask": [
+		"error",
+		{
+			checkSetImmediate: true,
+			checkSetTimeout: true
+		}
+	],
+	"prefer-reflect-apply": "error",
+	"prefer-regexp-escape": "error",
+	"prefer-regexp-test": "error",
+	"prefer-response-static-json": "error",
+	"prefer-scoped-selector": "error",
+	"prefer-set-has": "error",
+	"prefer-set-methods": "error",
+	"prefer-set-size": "error",
+	"prefer-short-arrow-method": ["error", "always"],
+	"prefer-short-escape-sequences": "error",
+	"prefer-simple-condition-first": "error",
+	"prefer-simple-sort-comparator": "error",
+	"prefer-simplified-conditions": ["error", { negatedConditions: "simplify" }],
+	"prefer-single-array-predicate": "error",
+	"prefer-single-call": "error",
+	"prefer-single-object-destructuring": "error",
+	"prefer-single-replace": "error",
+	"prefer-smaller-scope": "error",
+	"prefer-split-limit": "error",
+	"prefer-spread": "error",
+	"prefer-string-match-all": "error",
+	"prefer-string-pad-start-end": "error",
+	"prefer-string-raw": "error",
+	"prefer-string-repeat": "error",
+	"prefer-string-replace-all": "error",
+	"prefer-string-slice": "error",
+	"prefer-string-starts-ends-with": "error",
+	"prefer-string-trim-start-end": "error",
+	"prefer-structured-clone": "error",
+	"prefer-switch": "error",
+	"prefer-temporal": [
+		"error",
+		{
+			checkDateNow: true,
+			checkMethods: true,
+			checkReferences: false
+		}
+	],
+	"prefer-temporal-conversion": "error",
+	"prefer-ternary": ["error", "only-single-line"],
+	"prefer-then-catch": "error",
+	"prefer-toggle-attribute": "error",
+	"prefer-top-level-await": "error",
+	"prefer-type-error": "error",
+	"prefer-type-literal-last": "error",
+	"prefer-uint8array-base64": "error",
+	"prefer-uint8array-hex": "error",
+	"prefer-unary-minus": "error",
+	"prefer-unicode-code-point-escapes": "error",
+	"prefer-url-can-parse": "error",
+	"prefer-url-href": "error",
+	"prefer-url-search-parameters": "error",
+	"prefer-while-loop-condition": "error"
+};
+
+export default unicornPreferenceRules;

package/config/_common/pick-unicorn-rules-for-language/unicorn/unicorn-redundancy-rules.js

@@ -0,0 +1,47 @@
+/**
+ * @import { Linter } from "eslint";
+ */
+
+/**
+ * @satisfies {Linter.RulesRecord}
+ */
+const unicornRedundancyRules = {
+	"no-unnecessary-array-flat-depth": "error",
+	"no-unnecessary-array-flat-map": "error",
+	"no-unnecessary-array-splice-count": "error",
+	"no-unnecessary-await": "error",
+	"no-unnecessary-boolean-comparison": "error",
+	"no-unnecessary-default-arguments": "error",
+	"no-unnecessary-fetch-options": "error",
+	"no-unnecessary-global-this": "error",
+	"no-unnecessary-nested-ternary": "error",
+	"no-unnecessary-parameters": ["error", { minimumCallCount: 2 }],
+	"no-unnecessary-polyfills": "error",
+	"no-unnecessary-slice-end": "error",
+	"no-unnecessary-splice": "error",
+	"no-unnecessary-string-trim": "error",
+	"no-useless-boolean-cast": "error",
+	"no-useless-coercion": "error",
+	"no-useless-collection-argument": "error",
+	"no-useless-compound-assignment": "error",
+	"no-useless-concat": "error",
+	"no-useless-continue": "error",
+	"no-useless-delete-check": "error",
+	"no-useless-else": "error",
+	"no-useless-error-capture-stack-trace": "error",
+	"no-useless-fallback-in-spread": "error",
+	"no-useless-iterator-to-array": "error",
+	"no-useless-length-check": "error",
+	"no-useless-logical-operand": "error",
+	"no-useless-override": "error",
+	"no-useless-promise-resolve-reject": "error",
+	"no-useless-re-export": "error",
+	"no-useless-recursion": "error",
+	"no-useless-set-construction": "error",
+	"no-useless-spread": "error",
+	"no-useless-switch-case": "error",
+	"no-useless-template-literals": "error",
+	"no-useless-undefined": "off"
+};
+
+export default unicornRedundancyRules;