@isentinel/eslint-config 6.0.0-beta.2 → 6.0.0-beta.21

package/dist/lint-ignored.d.mts

@@ -0,0 +1 @@
+export {}

package/dist/lint-ignored.mjs

@@ -0,0 +1,280 @@
+import { createRequire } from "node:module";
+import fs from "node:fs";
+import path from "node:path";
+import process from "node:process";
+import { pathToFileURL } from "node:url";
+//#region src/guards.ts
+/**
+* Internal runtime type guards. Prefer these over `as` assertions so values
+* crossing untyped boundaries (`JSON.parse`, dynamic `import`, plugin objects)
+* are validated at runtime rather than asserted away.
+*/
+/**
+* Whether a value is a non-null, non-array object usable as a string-keyed
+* record. Narrows `unknown` without an assertion.
+*
+* @param value - The value to test.
+* @returns Whether the value is a plain object.
+*/
+function isRecord(value) {
+	return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+/**
+* Whether a value is an array whose every element is a string.
+*
+* @param value - The value to test.
+* @returns Whether the value is a `string` array.
+*/
+function isStringArray(value) {
+	return Array.isArray(value) && value.every((item) => typeof item === "string");
+}
+//#endregion
+//#region src/lint-cli/lib/exec/eslint-install.ts
+/**
+* Locating the ESLint installation a run's config is resolved against.
+*
+* The runner and its ignore helper both need it and must agree: the helper
+* serializes the config's match patterns out of one ESLint's config loader, and
+* the runner evaluates them with that same ESLint's matcher. Resolving them
+* separately would let the two drift onto different installations, and a
+* matcher that disagrees with the one that produced the patterns is exactly the
+* failure this feature cannot have.
+*/
+/**
+* A synthetic basename for `createRequire`, which resolves relative to a file
+* rather than a directory. Spelled so it can never collide with a real consumer
+* module.
+*/
+const RESOLVE_ANCHOR = "__isentinel-lint__.js";
+/**
+* Resolve the ESLint the consumer's config will be linted with: their own,
+* resolved from `cwd`, falling back to the one resolvable from this file (the
+* hoisted peer dependency) when `cwd` has no `node_modules` of its own — the
+* case in the fixture-based tests.
+*
+* @param cwd - The consumer project root.
+* @returns The package root and a require anchored in it.
+* @throws {Error} When ESLint cannot be resolved from either location.
+*/
+function resolveEslintInstall(cwd) {
+	let packageJson;
+	try {
+		packageJson = createRequire(path.join(cwd, RESOLVE_ANCHOR)).resolve("eslint/package.json");
+	} catch {
+		packageJson = createRequire(import.meta.url).resolve("eslint/package.json");
+	}
+	return {
+		requireFrom: createRequire(packageJson),
+		root: path.dirname(packageJson)
+	};
+}
+//#endregion
+//#region src/lint-cli/ignored-child.ts
+/**
+* Internal helper process for {@link file://./ignored.ts}. Loads the consumer's
+* resolved ESLint config once and writes back what the runner needs to classify
+* lint targets: the config's match patterns when they are serializable, and
+* otherwise the ignored subset of a target list.
+*
+* Run as a child rather than in-process for two reasons: the config-loading
+* API is async while `plan` is synchronous end to end, and loading a
+* consumer's flat config pulls their whole plugin tree (and jiti) into memory
+* — 6-10s and several hundred MB in a large project, neither of which should
+* outlive the one query the runner needs.
+*
+* Invoked as `node <this file> <cwd> <outFile>` with the JSON target array on
+* stdin.
+*/
+/**
+* Whether a required module exposes the `ESLint` constructor this helper uses.
+*
+* @param value - The imported module's namespace.
+* @returns Whether the namespace carries an `ESLint` constructor.
+*/
+function isEslintModule(value) {
+	return isRecord(value) && typeof value["ESLint"] === "function";
+}
+/**
+* Whether a required module exposes the `ConfigLoader` constructor this helper
+* uses.
+*
+* @param value - The required module's exports.
+* @returns Whether the exports carry a `ConfigLoader` constructor.
+*/
+function isConfigLoaderModule(value) {
+	return isRecord(value) && typeof value["ConfigLoader"] === "function";
+}
+/**
+* The config keys that leave a `files`-less config able to say something about
+* a path, mirroring `META_FIELDS` in `@eslint/config-array`: a config carrying
+* `ignores` and nothing else outside this set is a global ignore, and one with
+* any further key only excludes files from itself.
+*/
+const META_KEYS = /* @__PURE__ */ new Set(["basePath", "name"]);
+/**
+* Load the consumer's resolved config array.
+*
+* Reaching it means reaching past the `eslint` package's exports map: no public
+* API returns it, and `calculateConfigForFile` strips exactly the
+* `files`/`ignores` keys this needs. Only that coupling is caught here — a
+* config that throws on load is a broken project, not a missing capability, and
+* is left to fail the helper outright rather than be retried through a second,
+* equally doomed config load.
+*
+* @param cwd - The consumer project root.
+* @returns The config array, or `undefined` when the loader is unreachable.
+* @rejects {Error} When the consumer's config fails to load.
+*/
+async function loadConfigArray(cwd) {
+	let loader;
+	try {
+		const { requireFrom, root } = resolveEslintInstall(cwd);
+		const configLoaderModule = requireFrom(path.join(root, "lib", "config", "config-loader.js"));
+		if (!isConfigLoaderModule(configLoaderModule)) throw new Error("eslint config-loader did not export a ConfigLoader constructor");
+		const { ConfigLoader } = configLoaderModule;
+		loader = new ConfigLoader({
+			configFile: void 0,
+			cwd,
+			ignoreEnabled: true
+		});
+	} catch {
+		return;
+	}
+	return loader.loadConfigArrayForDirectory(path.join(cwd, "__placeholder__"));
+}
+/**
+* Whether a config ignores paths for the whole run rather than just for itself.
+*
+* @param config - One entry of the resolved config array.
+* @returns True when `ignores` is the config's only substantive key.
+*/
+function isGlobalIgnore(config) {
+	return config["ignores"] !== void 0 && Object.keys(config).filter((key) => !META_KEYS.has(key)).length === 1;
+}
+/**
+* Whether a `files`/`ignores` value is made purely of glob strings. Flat config
+* also permits function matchers, and `files` may nest one level for AND
+* matching; a function anywhere leaves the config with no form as data.
+*
+* @param value - The `files` or `ignores` value to test.
+* @returns True when every matcher is a string.
+*/
+function isGlobList(value) {
+	return Array.isArray(value) && value.flat(1).every((matcher) => typeof matcher === "string");
+}
+/**
+* Reduce one config to its match keys.
+*
+* @param config - One entry of the resolved config array.
+* @returns The entry, or `undefined` when a matcher is a function.
+*/
+function serializeEntry({ basePath, files, ignores }) {
+	const entry = {};
+	if (files !== void 0) {
+		if (!isGlobList(files)) return;
+		entry.files = files;
+	}
+	if (ignores !== void 0) {
+		if (!isGlobList(ignores)) return;
+		entry.ignores = ignores;
+	}
+	if (typeof basePath === "string") entry.basePath = basePath;
+	return entry;
+}
+/**
+* Reduce the resolved config array to the entries that decide whether ESLint
+* lints a path at all, or `undefined` when a matcher is a function rather than
+* a glob and so cannot cross a process boundary.
+*
+* Only two kinds of entry can make that decision: one with `files`, which can
+* match a path, and a bare global ignore, which can veto it. A `files`-less
+* config with other keys alongside its `ignores` merely narrows which configs
+* merge into the one ESLint lints with, which nothing here reads — so it is
+* dropped rather than carried, and with it the risk of a stripped `rules` key
+* silently promoting it into a global ignore.
+*
+* @param configArray - The resolved config array.
+* @returns The serializable entries, or `undefined` when one is a function.
+*/
+function serializeEntries(configArray) {
+	const entries = [];
+	for (const config of configArray) {
+		if (config["files"] === void 0 && !isGlobalIgnore(config)) continue;
+		const entry = serializeEntry(config);
+		if (entry === void 0) return;
+		entries.push(entry);
+	}
+	return entries;
+}
+/**
+* The last-resort classification: load ESLint itself and ask it per target.
+* Only reached when no config array could be built, so nothing cheaper is
+* already in hand.
+*
+* @param cwd - The consumer project root.
+* @param targets - The target files to classify.
+* @returns The ignored subset of `targets`.
+* @rejects {Error} When ESLint cannot be resolved or its config fails to load.
+*/
+async function queryEslint(cwd, targets) {
+	const { requireFrom } = resolveEslintInstall(cwd);
+	const eslintModule = await import(pathToFileURL(requireFrom.resolve("eslint")).href);
+	if (!isEslintModule(eslintModule)) throw new Error("eslint did not export an ESLint constructor");
+	const { ESLint } = eslintModule;
+	const eslint = new ESLint({ cwd });
+	const ignored = [];
+	for (const target of targets) if (await eslint.isPathIgnored(target)) ignored.push(target);
+	return ignored;
+}
+/**
+* The target list, read only by the paths that classify it — the predicate
+* never looks at it, and it is the larger of the two inputs.
+*
+* @returns The target files, absolute.
+*/
+function readTargets() {
+	const parsed = JSON.parse(fs.readFileSync(0, "utf8"));
+	if (!isStringArray(parsed)) throw new Error("expected a JSON array of target paths on stdin");
+	return parsed;
+}
+/**
+* The best answer this helper can give: the config's patterns when they are
+* data, the ignored subset of the target list when they are not.
+*
+* Both fallbacks reuse whatever the step before them already paid for. A config
+* that holds a function matcher still classifies targets here, off the array
+* already loaded, rather than loading the config a second time through `ESLint`
+* — which only the case of no reachable config loader at all has to fall back
+* to.
+*
+* @param cwd - The consumer project root.
+* @returns The payload to write back.
+* @rejects {Error} When the consumer's config fails to load.
+*/
+async function resolvePayload(cwd) {
+	const configArray = await loadConfigArray(cwd);
+	if (configArray === void 0) return {
+		ignored: await queryEslint(cwd, readTargets()),
+		mode: "answers"
+	};
+	const entries = serializeEntries(configArray);
+	if (entries === void 0) return {
+		ignored: readTargets().filter((target) => configArray.getConfigStatus(target) !== "matched"),
+		mode: "answers"
+	};
+	return {
+		basePath: configArray.basePath,
+		entries,
+		mode: "predicate"
+	};
+}
+async function main() {
+	const [cwd, outFile] = process.argv.slice(2);
+	if (cwd === void 0 || outFile === void 0) throw new Error("usage: node ignored-child <cwd> <outFile> (targets on stdin)");
+	fs.writeFileSync(outFile, JSON.stringify(await resolvePayload(cwd)));
+}
+main().catch(() => {
+	process.exitCode = 1;
+});
+//#endregion
+export {};