@useinsider/eslint-config 1.13.0 → 1.14.0

package/dist/main.js

@@ -1,12 +1,493 @@
 import { t as merge } from "./merge-DEya5rmo.js";
 import { t as mergeAll } from "./mergeAllConfig-BbXVeKTg.js";
-import { existsSync, readFileSync } from "node:fs";
+import { defineConfig } from "eslint/config";
+import globals from "globals";
+import { existsSync, readFileSync, realpathSync } from "node:fs";
 import { createRequire } from "node:module";
-import { resolve } from "node:path";
+import { dirname, resolve } from "node:path";
 import { fileURLToPath } from "node:url";
+import { AST_NODE_TYPES } from "@typescript-eslint/types";
 import { installPackage } from "@antfu/install-pkg";
 import semver from "semver";
 import { warn } from "node:console";
+//#region src/builders/configFiles.ts
+/**
+* Default globs treated as "configuration files" — root-level `*.config.*`
+* variants plus the canonical `eslint.config.*` flat-config filenames.
+*
+* These are intentionally conservative: only the top-level matches that the
+* v1 `config` preset was overwhelmingly applied to. Project-specific paths
+* (subdirectories, custom names) must be opted into by passing them via the
+* `configFiles: string[]` knob.
+*/
+var DEFAULT_CONFIG_FILE_GLOBS = [
+	"*.config.{ts,mts,cts,js,mjs,cjs}",
+	"*.config.*.{ts,mts,cts,js,mjs,cjs}",
+	"eslint.config.{mjs,js,cjs,ts}"
+];
+var configFileRules = {
+	"import-x/no-extraneous-dependencies": "off",
+	"import-x/prefer-default-export": "off"
+};
+function mergeGlobs(userGlobs) {
+	const seen = /* @__PURE__ */ new Set();
+	const merged = [];
+	DEFAULT_CONFIG_FILE_GLOBS.forEach((glob) => {
+		if (!seen.has(glob)) {
+			seen.add(glob);
+			merged.push(glob);
+		}
+	});
+	userGlobs.forEach((glob) => {
+		if (!seen.has(glob)) {
+			seen.add(glob);
+			merged.push(glob);
+		}
+	});
+	return merged;
+}
+function buildConfigFilesBlocks(value) {
+	if (value === false) return [];
+	return [{
+		files: value === void 0 ? [...DEFAULT_CONFIG_FILE_GLOBS] : mergeGlobs(value),
+		rules: { ...configFileRules }
+	}];
+}
+//#endregion
+//#region src/builders/jquery.ts
+function buildJqueryBlocks(entries) {
+	if (!entries || entries.length === 0) return [];
+	return entries.map((entry) => ({
+		files: entry.files,
+		languageOptions: { globals: { ...globals.jquery } }
+	}));
+}
+//#endregion
+//#region src/builders/typescript.ts
+function applyTypescriptOverrides(block, input) {
+	const languageOptions = block.languageOptions ?? {};
+	const parserOptions = languageOptions.parserOptions ?? {};
+	parserOptions.project = input.tsconfigPaths;
+	parserOptions.tsconfigRootDir = process.cwd();
+	languageOptions.parserOptions = parserOptions;
+	block.languageOptions = languageOptions;
+	return block;
+}
+//#endregion
+//#region src/builders/vue.ts
+function escapeRegex(input) {
+	return input.replace(/[\\^$.*+?()[\]{}|]/g, "\\$&");
+}
+function anchoredEscapeRegex(input) {
+	return `^${escapeRegex(input)}$`;
+}
+function applyVueOverrides(block, input) {
+	if (!input.globalComponents || input.globalComponents.length === 0) return block;
+	const rules = block.rules ?? {};
+	rules["vue/no-undef-components"] = ["error", { ignorePatterns: input.globalComponents.map(anchoredEscapeRegex) }];
+	block.rules = rules;
+	return block;
+}
+//#endregion
+//#region src/builders/scopeBlocks.ts
+var scopeMap = {
+	async config() {
+		return import("./config-Css2Pu_R.js");
+	},
+	async javascript() {
+		return import("./javascript-DBh1tdoj.js");
+	},
+	async javascriptDom() {
+		return import("./javascript-dom-vHj4V_jJ.js");
+	},
+	async javascriptNode() {
+		return import("./javascript-node-rbQ7OZX2.js");
+	},
+	async typescript() {
+		return import("./typescript-BkxC1Ebj.js");
+	},
+	async typescriptDom() {
+		return import("./typescript-dom-BMG-VaTV.js");
+	},
+	async typescriptNode() {
+		return import("./typescript-node-D_KHq9pf.js");
+	},
+	async vue2() {
+		return import("./vue2-npomS1zY.js");
+	},
+	async vue3() {
+		return import("./vue3-BnQYXB3K.js");
+	},
+	async vue2Typescript() {
+		return import("./vue2-typescript-DV30OSCU.js");
+	},
+	async vue3Typescript() {
+		return import("./vue3-typescript-C65tDgFp.js");
+	},
+	async vue2OptionsApi() {
+		return import("./vue2-options-api-BPw5U0yK.js");
+	},
+	async vue3OptionsApi() {
+		return import("./vue3-options-api-cejoqzVH.js");
+	},
+	async vue2TypescriptOptionsApi() {
+		return import("./vue2-typescript-options-api-Dxl4Cj_u.js");
+	},
+	async vue3TypescriptOptionsApi() {
+		return import("./vue3-typescript-options-api-DL7JFqMJ.js");
+	},
+	async jest() {
+		return import("./jest-B0jgh-Ns.js");
+	},
+	async vitest() {
+		return import("./vitest-BgPQ6GrC.js");
+	},
+	async jsdocBasedTs() {
+		return import("./jsdoc-based-ts-B40HFdNC.js");
+	}
+};
+var tsScopes = new Set([
+	"typescript",
+	"typescriptDom",
+	"typescriptNode",
+	"vue2Typescript",
+	"vue3Typescript",
+	"vue2TypescriptOptionsApi",
+	"vue3TypescriptOptionsApi",
+	"jsdocBasedTs"
+]);
+var vueScopes = new Set([
+	"vue2",
+	"vue3",
+	"vue2Typescript",
+	"vue3Typescript",
+	"vue2OptionsApi",
+	"vue3OptionsApi",
+	"vue2TypescriptOptionsApi",
+	"vue3TypescriptOptionsApi"
+]);
+function clonePreset(preset) {
+	return {
+		...preset,
+		languageOptions: preset.languageOptions ? {
+			...preset.languageOptions,
+			parserOptions: preset.languageOptions.parserOptions ? { ...preset.languageOptions.parserOptions } : void 0,
+			globals: preset.languageOptions.globals ? { ...preset.languageOptions.globals } : void 0
+		} : void 0,
+		rules: preset.rules ? { ...preset.rules } : void 0,
+		settings: preset.settings ? { ...preset.settings } : void 0
+	};
+}
+function isScopeName(key) {
+	return Object.keys(scopeMap).includes(key);
+}
+function applyCommonEntryFields(block, entry) {
+	if (entry.ignores && entry.ignores.length > 0) block.ignores = [...entry.ignores];
+	if (entry.globals) {
+		const languageOptions = block.languageOptions ?? {};
+		languageOptions.globals = {
+			...languageOptions.globals ?? {},
+			...entry.globals
+		};
+		block.languageOptions = languageOptions;
+	}
+}
+async function buildScopeBlocks(scope, entries) {
+	const preset = (await scopeMap[scope]()).default;
+	return entries.map((entry) => {
+		const block = clonePreset(preset);
+		block.files = entry.files;
+		if (tsScopes.has(scope)) {
+			const { tsconfigPaths } = entry;
+			if (tsconfigPaths) applyTypescriptOverrides(block, { tsconfigPaths });
+		}
+		if (vueScopes.has(scope)) {
+			const { globalComponents } = entry;
+			applyVueOverrides(block, { globalComponents });
+		}
+		applyCommonEntryFields(block, entry);
+		return block;
+	});
+}
+//#endregion
+//#region src/builders/spellChecker.ts
+function buildSpellCheckerBlocks(input) {
+	if (!input) return [];
+	const blocks = [];
+	if (input.customWordListFile) blocks.push({ rules: { "@cspell/spellchecker": ["error", { customWordListFile: input.customWordListFile }] } });
+	if (input.ignoredPaths && input.ignoredPaths.length > 0) blocks.push({
+		files: input.ignoredPaths,
+		rules: { "@cspell/spellchecker": "off" }
+	});
+	return blocks;
+}
+//#endregion
+//#region src/builders/strict.ts
+async function buildStrictBlocks(value) {
+	if (!value) return [];
+	const isFileScoped = Array.isArray(value);
+	if (isFileScoped && value.length === 0) return [];
+	const { default: strictConfig } = await import("./strict-BfeS2xp_.js");
+	const clone = { ...strictConfig };
+	if (clone.rules) clone.rules = { ...clone.rules };
+	if (isFileScoped) clone.files = value;
+	else delete clone.files;
+	return [clone];
+}
+//#endregion
+//#region src/utils/ensureConfigStructure.ts
+var CONFIG_FILE_REGEX = /eslint\.config\.[mc]?[jt]s(?:$|\?)/;
+var OPT_OUT_ENV = "INSIDER_SKIP_CONFIG_VALIDATION";
+var FILE_URL_PREFIX = "file://";
+var TARGET_CALLEE_NAME = "useInsider";
+var INSIDER_IMPORT_SOURCE = "@useinsider/eslint-config";
+var bypassWarnEmitted = false;
+function computeSelfModulePath() {
+	const raw = fileURLToPath(import.meta.url);
+	try {
+		return realpathSync(raw);
+	} catch {
+		return raw;
+	}
+}
+var SELF_MODULE_PATH = computeSelfModulePath();
+function isPathSpecifier(source) {
+	return source.startsWith(".") || source.startsWith("/");
+}
+function defaultIsInsiderImportSource(source, configPath) {
+	if (source === INSIDER_IMPORT_SOURCE) return true;
+	if (!configPath || !isPathSpecifier(source)) return false;
+	try {
+		return realpathSync(resolve(dirname(configPath), source)) === SELF_MODULE_PATH;
+	} catch {
+		return false;
+	}
+}
+function locOf(node) {
+	return {
+		line: node.loc.start.line,
+		column: node.loc.start.column
+	};
+}
+function validateCallExpression(callExpr) {
+	const { callee } = callExpr;
+	if (callee.type !== AST_NODE_TYPES.Identifier || callee.name !== TARGET_CALLEE_NAME) return [{
+		...locOf(callExpr),
+		reason: "Default export must call `useInsider(...)` directly."
+	}];
+	return [];
+}
+function validateExportedCall(callee, fallbackLoc) {
+	let target = callee;
+	if (target.type === AST_NODE_TYPES.AwaitExpression) target = target.argument;
+	if (target.type === AST_NODE_TYPES.CallExpression) return validateCallExpression(target);
+	if (target.type === AST_NODE_TYPES.ArrayExpression) return [{
+		...locOf(target),
+		reason: "Default export must not wrap `useInsider(...)` in an array. Use the typed options object instead."
+	}];
+	if (target.type === AST_NODE_TYPES.LogicalExpression || target.type === AST_NODE_TYPES.ConditionalExpression) {
+		const reason = ["Default export must not gate `useInsider(...)` behind a logical/conditional expression.", "Use the typed options object instead."].join(" ");
+		return [{
+			...locOf(target),
+			reason
+		}];
+	}
+	return [{
+		...fallbackLoc,
+		reason: "Default export must be a direct call to `useInsider(...)`."
+	}];
+}
+function collectInsiderBindings(node, bindings, isInsiderSource) {
+	if (!isInsiderSource(node.source.value)) return;
+	node.specifiers.forEach((specifier) => {
+		bindings.add(specifier.local.name);
+	});
+}
+function classifyExpressionStatement(node, insiderBindings) {
+	const { expression } = node;
+	if (expression.type === AST_NODE_TYPES.CallExpression && expression.callee.type === AST_NODE_TYPES.Identifier && insiderBindings.has(expression.callee.name)) return { type: "ignore" };
+	const reason = ["Disallowed top-level statement `ExpressionStatement`.", `Only call expressions whose callee was imported from \`${INSIDER_IMPORT_SOURCE}\` are allowed at top level.`].join(" ");
+	return {
+		type: "disallowed",
+		violation: {
+			...locOf(node),
+			reason
+		}
+	};
+}
+function classifyStatement(node, exportSeen, insiderBindings) {
+	if (node.type === AST_NODE_TYPES.ImportDeclaration || node.type === AST_NODE_TYPES.VariableDeclaration) return { type: "ignore" };
+	if (node.type === AST_NODE_TYPES.ExpressionStatement) return classifyExpressionStatement(node, insiderBindings);
+	if (node.type === AST_NODE_TYPES.ExportDefaultDeclaration) {
+		if (exportSeen) return {
+			type: "duplicateExport",
+			violation: {
+				...locOf(node),
+				reason: "Only one default export is allowed."
+			}
+		};
+		const declaration = node.declaration;
+		return {
+			type: "export",
+			violations: validateExportedCall(declaration, locOf(node))
+		};
+	}
+	const reason = [
+		`Disallowed top-level statement \`${node.type}\`.`,
+		"Only imports, variable declarations, helper calls from `@useinsider/eslint-config`,",
+		"and one `export default useInsider(...)` are allowed."
+	].join(" ");
+	return {
+		type: "disallowed",
+		violation: {
+			...locOf(node),
+			reason
+		}
+	};
+}
+function validateProgramStructure(program, configPath = "", options = {}) {
+	const violations = [];
+	const insiderBindings = /* @__PURE__ */ new Set();
+	const resolver = options.isInsiderImportSource ?? defaultIsInsiderImportSource;
+	const isInsiderSource = (source) => resolver(source, configPath);
+	let exportSeen = false;
+	program.body.forEach((node) => {
+		if (node.type === AST_NODE_TYPES.ImportDeclaration) collectInsiderBindings(node, insiderBindings, isInsiderSource);
+		const result = classifyStatement(node, exportSeen, insiderBindings);
+		if (result.type === "ignore") return;
+		if (result.type === "export") {
+			exportSeen = true;
+			violations.push(...result.violations);
+			return;
+		}
+		if (result.type === "duplicateExport") {
+			violations.push(result.violation);
+			return;
+		}
+		violations.push(result.violation);
+	});
+	if (!exportSeen) violations.push({
+		line: 1,
+		column: 0,
+		reason: "Missing `export default useInsider(...)`."
+	});
+	return violations;
+}
+function readStackFrames() {
+	const original = Error.prepareStackTrace;
+	Error.prepareStackTrace = (_, frames) => frames;
+	const holder = {};
+	Error.captureStackTrace(holder, readStackFrames);
+	const { stack } = holder;
+	Error.prepareStackTrace = original;
+	if (!Array.isArray(stack)) return [];
+	return stack;
+}
+function normalizeFrameFilename(raw) {
+	if (!raw) return null;
+	const withoutPrefix = raw.startsWith(FILE_URL_PREFIX) ? raw.slice(7) : raw;
+	const queryIndex = withoutPrefix.indexOf("?");
+	return queryIndex === -1 ? withoutPrefix : withoutPrefix.slice(0, queryIndex);
+}
+function extractMatchesFromStack(frames) {
+	const matches = /* @__PURE__ */ new Set();
+	frames.forEach((frame) => {
+		const name = normalizeFrameFilename(frame.getFileName());
+		if (name && CONFIG_FILE_REGEX.test(name)) matches.add(name);
+	});
+	return Array.from(matches);
+}
+function argvCandidateAt(argv, index) {
+	const arg = argv[index];
+	if (arg === "--config" || arg === "-c") return argv[index + 1] ?? null;
+	if (arg.startsWith("--config=")) return arg.slice(9);
+	return null;
+}
+function extractConfigFromArgv(argv) {
+	for (let i = 0; i < argv.length; i += 1) {
+		const candidate = argvCandidateAt(argv, i);
+		if (candidate && CONFIG_FILE_REGEX.test(candidate)) return candidate;
+	}
+	return null;
+}
+function getConsumerConfigPath(frames = readStackFrames(), argv = process.argv) {
+	const stackMatches = extractMatchesFromStack(frames);
+	if (stackMatches.length === 1) return stackMatches[0];
+	const fromArgv = extractConfigFromArgv(argv);
+	if (fromArgv) return fromArgv;
+	return null;
+}
+function formatReport(configPath, violations) {
+	const header = ["@useinsider/eslint-config: protected configuration structure violated in:", `  ${configPath}`].join("\n");
+	const lines = violations.map((violation) => `  - [${violation.line}:${violation.column}] ${violation.reason}`);
+	const footer = [
+		"",
+		"Allowed structure:",
+		"  - import statements",
+		"  - const/let/var declarations",
+		"  - exactly one `export default useInsider({ ... })`",
+		"",
+		"Emergency bypass: set INSIDER_SKIP_CONFIG_VALIDATION=true (do not commit)."
+	].join("\n");
+	return `${header}\n${lines.join("\n")}\n${footer}`;
+}
+function emitBypassWarning() {
+	if (bypassWarnEmitted) return;
+	bypassWarnEmitted = true;
+	const message = ["@useinsider/eslint-config: structure validation BYPASSED", "via INSIDER_SKIP_CONFIG_VALIDATION — emergency use only."].join(" ");
+	console.warn(message);
+}
+var ConfigStructureExit = class extends Error {};
+function fail(message) {
+	console.error(message);
+	process.exit.bind(process)(1);
+	throw new ConfigStructureExit(message);
+}
+function readConsumerSource(configPath) {
+	try {
+		return readFileSync(configPath, "utf8");
+	} catch (readError) {
+		const { message } = readError;
+		return fail(`@useinsider/eslint-config: failed to read consumer config at ${configPath}: ${message}`);
+	}
+}
+var lazyRequire = createRequire(import.meta.url);
+function loadParser() {
+	return lazyRequire("@typescript-eslint/parser").parse;
+}
+function parseConsumerSource(configPath, source) {
+	const parse = loadParser();
+	try {
+		return parse(source, {
+			sourceType: "module",
+			range: true,
+			loc: true
+		});
+	} catch (parseError) {
+		const { message } = parseError;
+		return fail(`@useinsider/eslint-config: failed to parse consumer config at ${configPath}: ${message}`);
+	}
+}
+function runValidation(overridePath) {
+	const configPath = overridePath === void 0 ? getConsumerConfigPath() : overridePath;
+	if (!configPath) fail(["@useinsider/eslint-config: unable to locate consumer `eslint.config.*` file for structure validation.", "If this is an unexpected environment, set INSIDER_SKIP_CONFIG_VALIDATION=true (do not commit)."].join("\n"));
+	const violations = validateProgramStructure(parseConsumerSource(configPath, readConsumerSource(configPath)), configPath);
+	if (violations.length === 0) return;
+	fail(formatReport(configPath, violations));
+}
+function ensureConfigStructure(overridePath) {
+	if (process.env[OPT_OUT_ENV] === "true") {
+		emitBypassWarning();
+		return;
+	}
+	try {
+		runValidation(overridePath);
+	} catch (error) {
+		if (error instanceof ConfigStructureExit) return;
+		throw error;
+	}
+}
+//#endregion
 //#region src/utils/ensureDependencies.ts
 var turnOff = false;
 var scanned = false;
@@ -96,62 +577,57 @@ function filterSilencedRules(rules, silencedRules) {
 }
 //#endregion
 //#region src/main.ts
-var configMap = {
-	async config() {
-		return import("./config-Css2Pu_R.js");
-	},
-	async javascript() {
-		return import("./javascript-BXgxOHrE.js");
-	},
-	async "javascript-node"() {
-		return import("./javascript-node-DDpIBysN.js");
-	},
-	async "javascript-dom"() {
-		return import("./javascript-dom-DQiJS6LF.js");
-	},
-	async typescript() {
-		return import("./typescript-Z0gBgZeY.js");
-	},
-	async "typescript-node"() {
-		return import("./typescript-node-B3akGwfD.js");
-	},
-	async "typescript-dom"() {
-		return import("./typescript-dom-BFinGO4G.js");
-	},
-	async vue3() {
-		return import("./vue3-CKwnKeS6.js");
-	},
-	async "vue3-typescript"() {
-		return import("./vue3-typescript-CbM4dYzN.js");
-	},
-	async vue2() {
-		return import("./vue2-DDKBhsLm.js");
-	},
-	async "vue2-typescript"() {
-		return import("./vue2-typescript-CUqjxRHT.js");
-	},
-	async jest() {
-		return import("./jest-B0jgh-Ns.js");
-	},
-	async "jsdoc-based-ts"() {
-		return import("./jsdoc-based-ts-B40HFdNC.js");
-	},
-	async strict() {
-		return import("./strict-BfeS2xp_.js");
-	}
-};
+var reservedKeys = new Set([
+	"ignores",
+	"jquery",
+	"strict",
+	"spellChecker",
+	"silenceRules",
+	"configFiles"
+]);
+function isProcessableScopeKey(key) {
+	return !reservedKeys.has(key) && isScopeName(key);
+}
+async function collectScopeBlocks(config) {
+	return Object.keys(config).filter(isProcessableScopeKey).reduce(async (accumulator, key) => {
+		const blocks = await accumulator;
+		const entries = config[key];
+		if (!entries || entries.length === 0) return blocks;
+		const scopeBlocks = await buildScopeBlocks(key, entries);
+		return [...blocks, ...scopeBlocks];
+	}, Promise.resolve([]));
+}
+function applySilenceRules(blocks, perCallSilence) {
+	blocks.forEach((block) => {
+		if (!block.rules) return;
+		block.rules = perCallSilence ? filterSilencedRules(block.rules, perCallSilence) : filterSilencedRules(block.rules);
+	});
+}
+function buildIgnoresBlocks(ignores) {
+	if (!ignores || ignores.length === 0) return [];
+	return [{ ignores: [...ignores] }];
+}
 async function useInsider(config) {
+	ensureConfigStructure();
 	await ensureDependencies();
-	const configs = config.preset.map(async (scope) => typeof configMap[scope] === "function" && (await configMap[scope]()).default).filter(Boolean);
-	const resolvedConfigAll = (await Promise.all(configs)).reduce((acc, scope) => merge(acc, scope), {});
-	delete resolvedConfigAll.files;
-	const mergedConfig = merge(resolvedConfigAll, config.config);
-	if (!mergedConfig) return Promise.reject(/* @__PURE__ */ new Error("No config found"));
-	if (config.silenceRules) mergedConfig.rules = filterSilencedRules(mergedConfig.rules, config.silenceRules);
-	else mergedConfig.rules = filterSilencedRules(mergedConfig.rules);
-	return mergedConfig;
+	const ignoresBlocks = buildIgnoresBlocks(config.ignores);
+	const scopeBlocks = await collectScopeBlocks(config);
+	const jqueryBlocks = buildJqueryBlocks(config.jquery);
+	const configFilesBlocks = buildConfigFilesBlocks(config.configFiles);
+	const strictBlocks = await buildStrictBlocks(config.strict);
+	const spellCheckerBlocks = buildSpellCheckerBlocks(config.spellChecker);
+	const blocks = [
+		...ignoresBlocks,
+		...scopeBlocks,
+		...jqueryBlocks,
+		...configFilesBlocks,
+		...strictBlocks,
+		...spellCheckerBlocks
+	];
+	applySilenceRules(blocks, config.silenceRules);
+	return defineConfig(blocks);
 }
 //#endregion
-export { merge, mergeAll, silenceDependencyWarning, silenceRules, useInsider };
+export { ensureConfigStructure, merge, mergeAll, silenceDependencyWarning, silenceRules, useInsider };
 
 //# sourceMappingURL=main.js.map