@useinsider/eslint-config 1.13.0-beta.6 → 1.13.0-beta.7

package/README.md

@@ -244,6 +244,7 @@ Every scope entry shape also accepts two common fields:
 | `strict`         | `boolean \| string[]`                                                                                    | Applies the strict preset globally (`true`) or scoped to globs. |
 | `spellChecker`   | `{ ignoredPaths?: string[]; customWordListFile?: string }`                                               | Cross-cutting cspell overrides. |
 | `silenceRules`   | `string[]`                                                                                               | Rule IDs to demote to `'warn'` across every block. |
+| `configFiles`    | `false \| string[]`                                                                                      | Emits a dedicated block for root-level configuration files (`*.config.*`, `eslint.config.*`) that disables `import-x/no-extraneous-dependencies` and `import-x/prefer-default-export`. **Defaults are applied automatically** — omit the key (or pass `[]`) to use the built-in defaults only, pass a `string[]` to layer your own globs on top, or pass `false` to opt out entirely. |
 
 A scope entry with per-entry globals — declare project-specific bindings
 without spreading the `useInsider` return into your own array:

package/dist/builders/configFiles.d.ts

@@ -0,0 +1,12 @@
+import type { Linter } from 'eslint';
+/**
+ * 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.
+ */
+export declare const DEFAULT_CONFIG_FILE_GLOBS: readonly string[];
+export declare function buildConfigFilesBlocks(value: false | string[] | undefined): Linter.Config[];

package/dist/cli.cjs

@@ -722,7 +722,8 @@ function freshConfig$1() {
 		scopes: /* @__PURE__ */ new Map(),
 		strictGlobs: [],
 		strictWholeFile: false,
-		spellChecker: { ignoredPaths: [] }
+		spellChecker: { ignoredPaths: [] },
+		configFiles: []
 	};
 }
 function appendScope$1(config, scope, entry) {
@@ -762,6 +763,11 @@ function mapInsiderPreset(preset) {
 	if (preset === "config") return "config";
 	return presetToScope$1[preset] ?? null;
 }
+function captureConfigPresetFiles$1(input, context) {
+	input.files.forEach((file) => {
+		if (!context.config.configFiles.includes(file)) context.config.configFiles.push(file);
+	});
+}
 function emitInsiderScopes(presets, input, context) {
 	let emitted = false;
 	presets.forEach((preset) => {
@@ -774,7 +780,10 @@ function emitInsiderScopes(presets, input, context) {
 			});
 			return;
 		}
-		if (mapped === "config") return;
+		if (mapped === "config") {
+			captureConfigPresetFiles$1(input, context);
+			return;
+		}
 		const entry = buildEntry$1({
 			files: input.files,
 			scope: mapped,
@@ -1307,17 +1316,34 @@ function parseV1Config(source, filePath) {
 //#endregion
 //#region src/cli/migrate/render.ts
 var indent$1 = "    ";
+var MAX_LINE_LENGTH = 120;
 function quote$1(value) {
 	return `'${value.replace(/'/g, "\\'")}'`;
 }
-function formatStringArray$1(values) {
+function formatStringArrayInline(values) {
 	return `[${values.map(quote$1).join(", ")}]`;
 }
+function formatStringArrayMultiline(values, baseIndent) {
+	const childIndent = `${baseIndent}${indent$1}`;
+	return [
+		"[",
+		...values.map((value) => `${childIndent}${quote$1(value)},`),
+		`${baseIndent}]`
+	].join("\n");
+}
+function renderStringArrayField(label, values, baseIndent) {
+	const inline = `${baseIndent}${label}: ${formatStringArrayInline(values)},`;
+	if (inline.length <= MAX_LINE_LENGTH) return inline;
+	return `${baseIndent}${label}: ${formatStringArrayMultiline(values, baseIndent)},`;
+}
 function formatGlobalValue(value) {
 	if (typeof value === "string") return quote$1(value);
 	return String(value);
 }
-function formatGlobalsObject(globals, baseIndent) {
+function formatGlobalsInline(globals) {
+	return `{ ${Object.entries(globals).map(([key, value]) => `${key}: ${formatGlobalValue(value)}`).join(", ")} }`;
+}
+function formatGlobalsMultiline(globals, baseIndent) {
 	const childIndent = `${baseIndent}${indent$1}`;
 	return [
 		"{",
@@ -1325,19 +1351,19 @@ function formatGlobalsObject(globals, baseIndent) {
 		`${baseIndent}}`
 	].join("\n");
 }
-function formatEntryField(label, value, baseIndent) {
-	return `${baseIndent}${indent$1}${label}: ${value},`;
+function renderGlobalsField(globals, baseIndent) {
+	const inline = `${baseIndent}globals: ${formatGlobalsInline(globals)},`;
+	if (inline.length <= MAX_LINE_LENGTH) return inline;
+	return `${baseIndent}globals: ${formatGlobalsMultiline(globals, baseIndent)},`;
 }
 function formatEntry$1(entry, baseIndent) {
+	const fieldIndent = `${baseIndent}${indent$1}`;
 	const lines = [`${baseIndent}{`];
-	lines.push(formatEntryField("files", formatStringArray$1(entry.files), baseIndent));
-	if (entry.tsconfigPaths && entry.tsconfigPaths.length > 0) lines.push(formatEntryField("tsconfigPaths", formatStringArray$1(entry.tsconfigPaths), baseIndent));
-	if (entry.globalComponents && entry.globalComponents.length > 0) lines.push(formatEntryField("globalComponents", formatStringArray$1(entry.globalComponents), baseIndent));
-	if (entry.ignores && entry.ignores.length > 0) lines.push(formatEntryField("ignores", formatStringArray$1(entry.ignores), baseIndent));
-	if (entry.globals && Object.keys(entry.globals).length > 0) {
-		const globalsBlock = formatGlobalsObject(entry.globals, `${baseIndent}${indent$1}`);
-		lines.push(`${baseIndent}${indent$1}globals: ${globalsBlock},`);
-	}
+	lines.push(renderStringArrayField("files", entry.files, fieldIndent));
+	if (entry.tsconfigPaths && entry.tsconfigPaths.length > 0) lines.push(renderStringArrayField("tsconfigPaths", entry.tsconfigPaths, fieldIndent));
+	if (entry.globalComponents && entry.globalComponents.length > 0) lines.push(renderStringArrayField("globalComponents", entry.globalComponents, fieldIndent));
+	if (entry.ignores && entry.ignores.length > 0) lines.push(renderStringArrayField("ignores", entry.ignores, fieldIndent));
+	if (entry.globals && Object.keys(entry.globals).length > 0) lines.push(renderGlobalsField(entry.globals, fieldIndent));
 	lines.push(`${baseIndent}},`);
 	return lines.join("\n");
 }
@@ -1354,6 +1380,8 @@ function renderImports(plan) {
 	return `import { ${(plan.needsSilenceRulesImport ? ["silenceRules", "useInsider"] : ["useInsider"]).slice().sort((left, right) => left.localeCompare(right)).join(", ")} } from '@useinsider/eslint-config';`;
 }
 function renderSilenceRulesCall(rules) {
+	const inline = `silenceRules(${formatStringArrayInline(rules)});`;
+	if (inline.length <= MAX_LINE_LENGTH) return inline;
 	return [
 		"silenceRules([",
 		rules.map((rule) => `${indent$1}${quote$1(rule)},`).join("\n"),
@@ -1366,28 +1394,35 @@ function renderSilenceRulesCalls(plan) {
 }
 function hasAnyContent(plan) {
 	const { config } = plan;
-	return config.scopes.size > 0 || config.ignores.length > 0 || config.strictGlobs.length > 0 || config.strictWholeFile || config.spellChecker.ignoredPaths.length > 0;
+	return config.scopes.size > 0 || config.ignores.length > 0 || config.strictGlobs.length > 0 || config.strictWholeFile || config.spellChecker.ignoredPaths.length > 0 || config.configFiles.length > 0;
 }
 function renderStrict(plan) {
 	if (plan.config.strictWholeFile) return `${indent$1}strict: true,`;
-	if (plan.config.strictGlobs.length > 0) return `${indent$1}strict: ${formatStringArray$1(plan.config.strictGlobs)},`;
+	if (plan.config.strictGlobs.length > 0) return renderStringArrayField("strict", plan.config.strictGlobs, indent$1);
 	return null;
 }
 function renderSpellChecker(plan) {
 	if (plan.config.spellChecker.ignoredPaths.length === 0) return null;
+	const innerIndent = `${indent$1}${indent$1}`;
 	return [
 		`${indent$1}spellChecker: {`,
-		`${indent$1}${indent$1}ignoredPaths: ${formatStringArray$1(plan.config.spellChecker.ignoredPaths)},`,
+		renderStringArrayField("ignoredPaths", plan.config.spellChecker.ignoredPaths, innerIndent),
 		`${indent$1}},`
 	].join("\n");
 }
 function renderScopes(plan) {
 	return [...plan.config.scopes.entries()].map(([scope, entries]) => formatScope$1(scope, entries, indent$1));
 }
+function renderConfigFiles(plan) {
+	if (plan.config.configFiles.length === 0) return null;
+	return renderStringArrayField("configFiles", plan.config.configFiles, indent$1);
+}
 function renderConfigBody(plan) {
 	const lines = [];
-	if (plan.config.ignores.length > 0) lines.push(`${indent$1}ignores: ${formatStringArray$1(plan.config.ignores)},`);
+	if (plan.config.ignores.length > 0) lines.push(renderStringArrayField("ignores", plan.config.ignores, indent$1));
 	lines.push(...renderScopes(plan));
+	const configFilesLine = renderConfigFiles(plan);
+	if (configFilesLine) lines.push(configFilesLine);
 	const strictLine = renderStrict(plan);
 	if (strictLine) lines.push(strictLine);
 	const spellCheckerSection = renderSpellChecker(plan);
@@ -1450,7 +1485,8 @@ function freshConfig() {
 		scopes: /* @__PURE__ */ new Map(),
 		strictGlobs: [],
 		strictWholeFile: false,
-		spellChecker: { ignoredPaths: [] }
+		spellChecker: { ignoredPaths: [] },
+		configFiles: []
 	};
 }
 function appendScope(config, scope, entry) {
@@ -1515,7 +1551,14 @@ function handlePreset(preset, call, config, warnings) {
 	const entry = buildEntry(call, scope, warnings);
 	if (entry) appendScope(config, scope, entry);
 }
+function captureConfigPresetFiles(call, config) {
+	if (!call.presets.includes("config") || !call.files) return;
+	call.files.forEach((file) => {
+		if (!config.configFiles.includes(file)) config.configFiles.push(file);
+	});
+}
 function processUseInsiderCall(call, config, warnings) {
+	captureConfigPresetFiles(call, config);
 	const filteredPresets = call.presets.filter((preset) => preset !== "config");
 	const droppedRules = call.extraRuleCount > 0 ? call.extraRuleCount : 0;
 	const droppedRuleBlocks = call.extraRuleCount > 0 ? 1 : 0;