@exadev/eslint-config 1.4.1 → 2.1.0

package/dist/index.cjs

@@ -1,2 +1,506 @@
-const require_plugin = require("./plugin-BscQLyGY.cjs");
-module.exports = require_plugin.plugin;
+Object.defineProperties(exports, {
+	__esModule: { value: true },
+	[Symbol.toStringTag]: { value: "Module" }
+});
+//#region \0rolldown/runtime.js
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __copyProps = (to, from, except, desc) => {
+	if (from && typeof from === "object" || typeof from === "function") for (var keys = __getOwnPropNames(from), i = 0, n = keys.length, key; i < n; i++) {
+		key = keys[i];
+		if (!__hasOwnProp.call(to, key) && key !== except) __defProp(to, key, {
+			get: ((k) => from[k]).bind(null, key),
+			enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
+		});
+	}
+	return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(isNodeMode || !mod || !mod.__esModule || !__hasOwnProp.call(mod, "default") ? __defProp(target, "default", {
+	value: mod,
+	enumerable: true
+}) : target, mod));
+//#endregion
+let typescript_eslint = require("typescript-eslint");
+typescript_eslint = __toESM(typescript_eslint, 1);
+let node_path = require("node:path");
+//#region package.json
+var version = "2.1.0";
+//#endregion
+//#region src/rules/barrel-helpers.ts
+const INDEX_BASENAME$1 = /^index\.[cm]?[tj]sx?$/;
+function basenameOf(filename) {
+	const slash = filename.lastIndexOf("/");
+	return slash === -1 ? filename : filename.slice(slash + 1);
+}
+function isIndexFile(filename) {
+	return INDEX_BASENAME$1.test(basenameOf(filename));
+}
+function isMainBarrel(filename) {
+	return filename.endsWith("/src/index.ts");
+}
+function isPureReexport(statement) {
+	if (statement.type === "ExportAllDeclaration") return true;
+	return statement.type === "ExportNamedDeclaration" && statement.source !== null && statement.source !== void 0;
+}
+function isDirectSibling(specifier) {
+	if (!specifier.startsWith("./")) return false;
+	let rest = node_path.posix.normalize(specifier.slice(2));
+	if (rest.endsWith("/")) rest = rest.slice(0, -1);
+	return rest !== "." && rest !== ".." && rest !== "" && !rest.includes("/");
+}
+function isBarrelMode(value) {
+	return value === "banned" || value === "single" || value === "siblings";
+}
+function isPermittedBarrel(filename, mode) {
+	if (mode === "banned") return false;
+	if (mode === "single") return isMainBarrel(filename);
+	return isIndexFile(filename);
+}
+function createSplitReexportDetector() {
+	const importsByName = /* @__PURE__ */ new Map();
+	const bareExportSpecifiers = [];
+	const defaultExportDeclarations = [];
+	return {
+		visitImport(node) {
+			for (const specifier of node.specifiers) importsByName.set(specifier.local.name, {
+				declaration: node,
+				specifier
+			});
+		},
+		visitExportNamed(node) {
+			if (node.source !== null && node.source !== void 0) return;
+			for (const specifier of node.specifiers) bareExportSpecifiers.push({
+				declaration: node,
+				specifier
+			});
+		},
+		visitExportDefault(node) {
+			defaultExportDeclarations.push(node);
+		},
+		violations() {
+			const out = [];
+			for (const { declaration, specifier } of bareExportSpecifiers) {
+				const name = specifier.local.type === "Identifier" ? specifier.local.name : void 0;
+				if (name === void 0) continue;
+				const trackedImport = importsByName.get(name);
+				if (trackedImport === void 0) continue;
+				out.push({
+					kind: "named",
+					specifier,
+					declaration,
+					name,
+					trackedImport
+				});
+			}
+			for (const declarationNode of defaultExportDeclarations) {
+				const name = declarationNode.declaration.type === "Identifier" ? declarationNode.declaration.name : void 0;
+				if (name === void 0) continue;
+				const trackedImport = importsByName.get(name);
+				if (trackedImport === void 0) continue;
+				out.push({
+					kind: "default",
+					declaration: declarationNode,
+					name,
+					trackedImport
+				});
+			}
+			return out;
+		}
+	};
+}
+//#endregion
+//#region src/rules/barrel-direct-siblings-only.ts
+const barrelDirectSiblingsOnly = {
+	meta: {
+		type: "problem",
+		schema: [],
+		messages: { notADirectSibling: "A barrel may re-export only from a direct sibling file or folder ('./module' or './module.ts') -- found '{{ source }}'. Move the source closer, or import it directly at the call site rather than re-exporting it through this barrel." }
+	},
+	create(context) {
+		if (!isIndexFile(context.filename)) return {};
+		return {
+			ExportNamedDeclaration(node) {
+				if (node.source === null || node.source === void 0) return;
+				const source = node.source.value;
+				if (typeof source !== "string") return;
+				if (!isDirectSibling(source)) context.report({
+					node,
+					messageId: "notADirectSibling",
+					data: { source }
+				});
+			},
+			ExportAllDeclaration(node) {
+				const source = node.source.value;
+				if (typeof source !== "string") return;
+				if (!isDirectSibling(source)) context.report({
+					node,
+					messageId: "notADirectSibling",
+					data: { source }
+				});
+			}
+		};
+	}
+};
+//#endregion
+//#region src/rules/barrel-policy.ts
+function readMode(options) {
+	if (options === void 0 || typeof options !== "object" || options === null || !("mode" in options) || !isBarrelMode(options.mode)) throw new Error("exadev/barrel-policy requires options: { mode: 'banned' | 'single' | 'siblings' }.");
+	return options.mode;
+}
+const barrelPolicy = {
+	meta: {
+		type: "problem",
+		schema: [{
+			type: "object",
+			properties: { mode: {
+				type: "string",
+				enum: [
+					"banned",
+					"single",
+					"siblings"
+				]
+			} },
+			required: ["mode"],
+			additionalProperties: false
+		}],
+		messages: {
+			indexFileBanned: "Index (barrel) files are banned in this project -- import directly from the module that owns the export instead. Rename this file to something descriptive.",
+			nonMainIndexFile: "Only src/index.ts may be a barrel in this project -- this index file is not it. Move its contents into the module that owns them or give the file a descriptive name.",
+			sideEffectInBarrel: "A barrel may contain only re-export statements ('export * from ...' / 'export { x } from ...' / 'export type { x } from ...') -- nothing else, so it can never have a side effect at import time by construction. Found: {{ description }}.",
+			reexportOutsideBarrel: "Re-exports belong only in a barrel (index) file -- import this value directly in the file that uses it instead of re-exporting it through this one.",
+			notADirectSibling: "A barrel may re-export only from a direct sibling file or folder ('./module' or './module.ts') -- found '{{ source }}'. Move the source closer, or import it directly at the call site rather than re-exporting it through this barrel."
+		}
+	},
+	create(context) {
+		const mode = readMode(context.options[0]);
+		const filename = context.filename;
+		const detector = createSplitReexportDetector();
+		function hasSource(node) {
+			return node.source !== null && node.source !== void 0;
+		}
+		return {
+			Program(node) {
+				if (mode === "banned") {
+					if (isIndexFile(filename)) context.report({
+						node,
+						messageId: "indexFileBanned"
+					});
+					return;
+				}
+				if (mode === "single") {
+					if (isIndexFile(filename) && !isMainBarrel(filename)) {
+						context.report({
+							node,
+							messageId: "nonMainIndexFile"
+						});
+						return;
+					}
+					if (isMainBarrel(filename)) {
+						for (const statement of node.body) if (!isPureReexport(statement)) context.report({
+							node: statement,
+							messageId: "sideEffectInBarrel",
+							data: { description: statement.type }
+						});
+					}
+					return;
+				}
+				if (isIndexFile(filename)) {
+					for (const statement of node.body) if (!isPureReexport(statement)) context.report({
+						node: statement,
+						messageId: "sideEffectInBarrel",
+						data: { description: statement.type }
+					});
+				}
+			},
+			ImportDeclaration: (node) => detector.visitImport(node),
+			ExportNamedDeclaration(node) {
+				detector.visitExportNamed(node);
+				if (hasSource(node)) {
+					const source = node.source === null || node.source === void 0 ? void 0 : node.source.value;
+					if (!isPermittedBarrel(filename, mode)) context.report({
+						node,
+						messageId: "reexportOutsideBarrel"
+					});
+					else if (mode === "siblings" && typeof source === "string" && !isDirectSibling(source)) context.report({
+						node,
+						messageId: "notADirectSibling",
+						data: { source }
+					});
+				}
+			},
+			ExportAllDeclaration(node) {
+				const source = node.source.value;
+				if (!isPermittedBarrel(filename, mode)) context.report({
+					node,
+					messageId: "reexportOutsideBarrel"
+				});
+				else if (mode === "siblings" && typeof source === "string" && !isDirectSibling(source)) context.report({
+					node,
+					messageId: "notADirectSibling",
+					data: { source }
+				});
+			},
+			ExportDefaultDeclaration: (node) => detector.visitExportDefault(node),
+			"Program:exit"() {
+				for (const violation of detector.violations()) if (isPermittedBarrel(filename, mode)) {
+					if (mode === "siblings") {
+						const importSource = violation.trackedImport.declaration.source.value;
+						if (typeof importSource === "string" && !isDirectSibling(importSource)) context.report({
+							node: violation.kind === "named" ? violation.specifier : violation.declaration,
+							messageId: "notADirectSibling",
+							data: { source: importSource }
+						});
+					}
+				} else context.report({
+					node: violation.kind === "named" ? violation.specifier : violation.declaration,
+					messageId: "reexportOutsideBarrel"
+				});
+			}
+		};
+	}
+};
+//#endregion
+//#region src/rules/no-index-files.ts
+const noIndexFiles = {
+	meta: {
+		type: "problem",
+		schema: [],
+		messages: { indexFileBanned: "Index (barrel) files are banned -- import directly from the module that owns the export instead. Rename this file to something descriptive." }
+	},
+	create(context) {
+		if (!isIndexFile(context.filename)) return {};
+		return { Program(node) {
+			context.report({
+				node,
+				messageId: "indexFileBanned"
+			});
+		} };
+	}
+};
+//#endregion
+//#region src/rules/no-non-barrel-index.ts
+const INDEX_BASENAME = /^index\.[cm]?[tj]s$/;
+const noNonBarrelIndex = {
+	meta: {
+		type: "problem",
+		schema: [],
+		messages: { barrel: "Only src/index.ts may be named index.* (the public convenience barrel); give any other module a descriptive filename." }
+	},
+	create(context) {
+		const filename = context.filename;
+		const slash = filename.lastIndexOf("/");
+		const basename = slash === -1 ? filename : filename.slice(slash + 1);
+		if (!INDEX_BASENAME.test(basename)) return {};
+		if (filename.endsWith("/src/index.ts")) return {};
+		return { Program(node) {
+			context.report({
+				node,
+				messageId: "barrel"
+			});
+		} };
+	}
+};
+//#endregion
+//#region src/rules/no-non-barrel-reexport.ts
+function removeListMember(fixer, sourceCode, declaration, members, target) {
+	if (members.length === 1) return fixer.remove(declaration);
+	const targetIndex = members.indexOf(target);
+	const isLast = targetIndex === members.length - 1;
+	const neighbor = members[isLast ? targetIndex - 1 : targetIndex + 1];
+	if (neighbor === void 0) throw new Error("Unreachable: a list with more than one member always has a neighbor either side of any member within it.");
+	return isLast ? fixer.removeRange([sourceCode.getRange(neighbor)[1], sourceCode.getRange(target)[1]]) : fixer.removeRange([sourceCode.getRange(target)[0], sourceCode.getRange(neighbor)[0]]);
+}
+function importIsOnlyUsedByThisExport(sourceCode, trackedImport, usageIdentifier) {
+	const variable = sourceCode.getDeclaredVariables(trackedImport.declaration).find((candidate) => candidate.defs.some((def) => def.node === trackedImport.specifier));
+	if (variable === void 0) return false;
+	if (variable.references.length !== 1) return false;
+	const [onlyReference] = variable.references;
+	if (onlyReference === void 0) throw new Error("Unreachable: the length check above guarantees exactly one element.");
+	return onlyReference.identifier === usageIdentifier;
+}
+const noNonBarrelReexport = {
+	meta: {
+		type: "problem",
+		fixable: "code",
+		schema: [],
+		messages: {
+			splitStatementReexport: "'{{ name }}' is imported here and handed straight back out via a bare export -- the identical re-export 'export { {{ name }} } from ...' would be, just split across two statements. Re-exports belong only in the public barrel.",
+			splitStatementDefaultReexport: "'{{ name }}' is imported here and handed straight back out via `export default` -- the identical re-export 'export { {{ name }} as default } from ...' would be, just split across two statements. Re-exports belong only in the public barrel."
+		}
+	},
+	create(context) {
+		if (isIndexFile(context.filename)) return {};
+		const detector = createSplitReexportDetector();
+		return {
+			ImportDeclaration: (node) => detector.visitImport(node),
+			ExportNamedDeclaration: (node) => detector.visitExportNamed(node),
+			ExportDefaultDeclaration: (node) => detector.visitExportDefault(node),
+			"Program:exit"() {
+				const { sourceCode } = context;
+				for (const violation of detector.violations()) if (violation.kind === "named") {
+					const { specifier, declaration, name, trackedImport } = violation;
+					context.report({
+						node: specifier,
+						messageId: "splitStatementReexport",
+						data: { name },
+						fix(fixer) {
+							const fixes = [removeListMember(fixer, sourceCode, declaration, declaration.specifiers, specifier)];
+							if (specifier.local.type === "Identifier" && importIsOnlyUsedByThisExport(sourceCode, trackedImport, specifier.local)) fixes.push(removeListMember(fixer, sourceCode, trackedImport.declaration, trackedImport.declaration.specifiers, trackedImport.specifier));
+							return fixes;
+						}
+					});
+				} else {
+					const { declaration, name, trackedImport } = violation;
+					context.report({
+						node: declaration,
+						messageId: "splitStatementDefaultReexport",
+						data: { name },
+						fix(fixer) {
+							const fixes = [fixer.remove(declaration)];
+							if (declaration.declaration.type === "Identifier" && importIsOnlyUsedByThisExport(sourceCode, trackedImport, declaration.declaration)) fixes.push(removeListMember(fixer, sourceCode, trackedImport.declaration, trackedImport.declaration.specifiers, trackedImport.specifier));
+							return fixes;
+						}
+					});
+				}
+			}
+		};
+	}
+};
+//#endregion
+//#region src/rules/no-pointless-reassignment.ts
+function isIdentifierReference(reference) {
+	return reference.identifier.type === "Identifier";
+}
+//#endregion
+//#region src/plugin.ts
+const plugin = {
+	meta: {
+		name: "@exadev/eslint-config",
+		version,
+		namespace: "exadev"
+	},
+	rules: {
+		"barrel-direct-siblings-only": barrelDirectSiblingsOnly,
+		"barrel-policy": barrelPolicy,
+		"no-index-files": noIndexFiles,
+		"no-non-barrel-index": noNonBarrelIndex,
+		"no-non-barrel-reexport": noNonBarrelReexport,
+		"no-pointless-reassignment": {
+			meta: {
+				type: "problem",
+				fixable: "code",
+				schema: [],
+				messages: { pointlessReassignment: "Pointless reassignment: '{{ name }}' is just an alias for '{{ value }}'. Use the original directly." }
+			},
+			create(context) {
+				return { VariableDeclarator(node) {
+					if (node.id.type !== "Identifier" || node.init?.type !== "Identifier" || node.id.name.startsWith("_")) return;
+					if (node.parent.type !== "VariableDeclaration" || node.parent.kind !== "const") return;
+					const scope = context.sourceCode.getScope(node);
+					const sourceVariable = scope.references.find((reference) => reference.identifier === node.init)?.resolved;
+					if (!sourceVariable || sourceVariable.references.some((reference) => reference.isWrite() && !reference.init)) return;
+					const aliasName = node.id.name;
+					const originalName = node.init.name;
+					context.report({
+						node,
+						messageId: "pointlessReassignment",
+						data: {
+							name: aliasName,
+							value: originalName
+						},
+						fix(fixer) {
+							const variable = scope.set.get(aliasName);
+							if (!variable) return null;
+							if (variable.references.filter((reference) => reference.isWrite() && reference.identifier !== node.id).length > 0) return null;
+							const readRefs = variable.references.filter((reference) => reference.isRead() && isIdentifierReference(reference));
+							if (readRefs.some((reference) => {
+								const afterToken = context.sourceCode.getTokenAfter(reference.identifier);
+								if (afterToken?.value === ":") return false;
+								if (afterToken?.value !== "}" && afterToken?.value !== ",") return false;
+								let token = context.sourceCode.getTokenBefore(reference.identifier);
+								while (token) {
+									if (token.value === "{") return true;
+									if (token.value === "[" || token.value === "(") return false;
+									if (token.value === ":") return false;
+									token = context.sourceCode.getTokenBefore(token);
+								}
+								return false;
+							})) return null;
+							const fixes = readRefs.map((reference) => fixer.replaceText(reference.identifier, originalName));
+							const declaration = node.parent;
+							if (declaration.type !== "VariableDeclaration" || declaration.declarations.length !== 1) return null;
+							fixes.push(fixer.remove(declaration));
+							return fixes;
+						}
+					});
+				} };
+			}
+		},
+		"no-side-effects-in-index": {
+			meta: {
+				type: "problem",
+				schema: [],
+				messages: { notAPureReexport: "A barrel (index) file may contain only re-export statements ('export * from ...' / 'export { x } from ...' / 'export type { x } from ...') -- nothing else, so it can never have a side effect at import time by construction. Found: {{ description }}." }
+			},
+			create(context) {
+				if (!isIndexFile(context.filename)) return {};
+				return { Program(node) {
+					for (const statement of node.body) if (!isPureReexport(statement)) context.report({
+						node: statement,
+						messageId: "notAPureReexport",
+						data: { description: statement.type }
+					});
+				} };
+			}
+		}
+	},
+	configs: {
+		get recommended() {
+			return {
+				plugins: { exadev: plugin },
+				linterOptions: { noInlineConfig: true },
+				rules: {
+					"exadev/barrel-policy": ["error", { mode: "banned" }],
+					"exadev/no-pointless-reassignment": "error"
+				}
+			};
+		},
+		get barrel() {
+			return {
+				plugins: { exadev: plugin },
+				rules: { "exadev/barrel-policy": ["error", { mode: "single" }] }
+			};
+		}
+	}
+};
+//#endregion
+//#region src/recommended-type-checked.ts
+const TEST_FILE_PATTERNS = "**/*.{test,spec}.{ts,tsx,mts,cts,js,jsx,mjs,cjs}";
+const recommendedTypeChecked = [
+	...typescript_eslint.default.configs.recommendedTypeChecked,
+	...typescript_eslint.default.configs.stylisticTypeChecked,
+	{
+		plugins: { exadev: plugin },
+		linterOptions: { noInlineConfig: true },
+		rules: {
+			"exadev/barrel-policy": ["error", { mode: "banned" }],
+			"exadev/no-pointless-reassignment": "error",
+			"@typescript-eslint/consistent-type-assertions": ["error", { assertionStyle: "never" }],
+			"@typescript-eslint/ban-ts-comment": ["error", { "ts-expect-error": true }]
+		}
+	},
+	{
+		files: [TEST_FILE_PATTERNS],
+		rules: {
+			"@typescript-eslint/ban-ts-comment": ["error", { "ts-expect-error": "allow-with-description" }],
+			"@typescript-eslint/consistent-type-assertions": ["error", { assertionStyle: "as" }]
+		}
+	}
+];
+//#endregion
+exports.default = recommendedTypeChecked;
+exports.plugin = plugin;

package/dist/index.d.cts

@@ -1,2 +1,10 @@
-import plugin from "./plugin.cjs";
-export = plugin;
+import { ESLint } from "eslint";
+//#region src/recommended-type-checked.d.ts
+type ConfigValue = NonNullable<ESLint.Plugin['configs']>[string];
+type ConfigArrayValue = Extract<ConfigValue, unknown[]>;
+declare const recommendedTypeChecked: ConfigArrayValue;
+//#endregion
+//#region src/plugin.d.ts
+declare const plugin: ESLint.Plugin;
+//#endregion
+export { recommendedTypeChecked as default, plugin };

package/dist/index.d.ts

@@ -1,2 +1,10 @@
-import plugin from "./plugin.js";
-export { plugin as default };
+import { ESLint } from "eslint";
+//#region src/recommended-type-checked.d.ts
+type ConfigValue = NonNullable<ESLint.Plugin['configs']>[string];
+type ConfigArrayValue = Extract<ConfigValue, unknown[]>;
+declare const recommendedTypeChecked: ConfigArrayValue;
+//#endregion
+//#region src/plugin.d.ts
+declare const plugin: ESLint.Plugin;
+//#endregion
+export { recommendedTypeChecked as default, plugin };