@clearlydev/nx-archweave 0.0.0-stage → 0.1.1

package/dist/eslint/fsd-boundaries.d.ts

@@ -0,0 +1,119 @@
+/**
+ * `archweave/fsd-boundaries` — canonical FSD import rules inside one frontend app.
+ * Three findings:
+ *
+ * - upward:      a layer imports a layer above it (app > pages > widgets > features > entities > shared)
+ * - cross-slice: two slices on the same sliced layer import each other — unless through the
+ *                target slice's `@x/<importer-slice>` public API (FSD's cross-import notation)
+ * - sidestep:    a slice's (or a shared segment's) internal file is imported past its index
+ *
+ * Only relative specifiers and the configured aliases are judged; package specifiers
+ * (`react`, `firebase/app`) are never touched — string-matching layer names in them was the
+ * measured source of false positives. Locations are computed from path strings alone: the
+ * rule never reads the file system.
+ *
+ * Self-contained on purpose: no `eslint` import, so the plugin's only runtime dependency stays
+ * @nx/devkit. The handful of ESLint shapes it touches are typed structurally below.
+ */
+export type FsdEnforcementSeverity = 'error' | 'warn';
+export interface FsdBoundariesOptions {
+    /** The app's source root, relative to ESLint's cwd (Nx lints from the project root). */
+    root: string;
+    /** Import-prefix aliases → directories relative to cwd, e.g. `{ '@/': 'src' }`. */
+    aliases: Record<string, string>;
+}
+declare const LAYER_ORDER: readonly ["app", "pages", "widgets", "features", "entities", "shared"];
+type FsdLayer = (typeof LAYER_ORDER)[number];
+/** Where a file sits inside the FSD tree. `unit` is the slice on a sliced layer, the segment
+ * on `shared` (its segments carry a public API too), null on `app`. `rest` is the path below
+ * the unit, with a trailing `index[.ext]` dropped. */
+interface Location {
+    layer: FsdLayer;
+    unit: string | null;
+    rest: string[];
+}
+export declare function locate(rootRelativePath: string): Location | null;
+export type FsdViolation = {
+    kind: 'upward';
+    from: Location;
+    to: Location;
+} | {
+    kind: 'cross-slice';
+    from: Location;
+    to: Location;
+} | {
+    kind: 'sidestep';
+    from: Location;
+    to: Location;
+};
+/** Pure core: the violation (if any) of `from` importing `to`. */
+export declare function judge(from: Location, to: Location): FsdViolation | null;
+export declare function describeLocation(location: Location): string;
+/** Resolves an import specifier to a path relative to the source root, or null when it is
+ * a package specifier or lands outside the root. */
+export declare function resolveSpecifier(specifier: string, importerRootRelative: string, options: {
+    rootAbsolute: string;
+    cwd: string;
+    aliases: Record<string, string>;
+}): string | null;
+export interface SourceNode {
+    type: string;
+    value?: unknown;
+}
+export interface AstNode {
+    type: string;
+    source?: SourceNode | null;
+    arguments?: AstNode[];
+}
+export interface RuleContext {
+    filename: string;
+    cwd: string;
+    options: unknown[];
+    report(descriptor: {
+        node: AstNode;
+        messageId: string;
+        data?: Record<string, string>;
+    }): void;
+}
+export declare const fsdBoundariesRule: {
+    meta: {
+        type: "problem";
+        docs: {
+            description: string;
+            url: string;
+        };
+        schema: {
+            type: string;
+            properties: {
+                root: {
+                    type: string;
+                };
+                aliases: {
+                    type: string;
+                    additionalProperties: {
+                        type: string;
+                    };
+                };
+            };
+            additionalProperties: boolean;
+        }[];
+        messages: {
+            upward: string;
+            crossSlice: string;
+            sidestep: string;
+        };
+    };
+    create(context: RuleContext): {
+        ImportDeclaration?: undefined;
+        ExportNamedDeclaration?: undefined;
+        ExportAllDeclaration?: undefined;
+        ImportExpression?: undefined;
+    } | {
+        ImportDeclaration: (node: AstNode) => void;
+        ExportNamedDeclaration: (node: AstNode) => void;
+        ExportAllDeclaration: (node: AstNode) => void;
+        ImportExpression: (node: AstNode) => void;
+    };
+};
+export {};
+//# sourceMappingURL=fsd-boundaries.d.ts.map

package/dist/eslint/fsd-boundaries.js

@@ -0,0 +1,144 @@
+import { posix, relative, resolve, sep } from 'node:path';
+const LAYER_ORDER = ['app', 'pages', 'widgets', 'features', 'entities', 'shared'];
+/** Directory name → layer. `_app`/`_pages` are FSD's own Next.js naming (its routers own
+ * `app/` and `pages/`). */
+const LAYER_BY_DIR = {
+    app: 'app',
+    _app: 'app',
+    pages: 'pages',
+    _pages: 'pages',
+    widgets: 'widgets',
+    features: 'features',
+    entities: 'entities',
+    shared: 'shared',
+};
+const SLICED_LAYERS = new Set(['pages', 'widgets', 'features', 'entities']);
+const INDEX_FILE = /^index(\.[cm]?[jt]sx?)?$/;
+export function locate(rootRelativePath) {
+    const segments = rootRelativePath.split('/').filter((s) => s.length > 0 && s !== '.');
+    if (segments.length === 0)
+        return null;
+    const layer = LAYER_BY_DIR[segments[0]];
+    if (layer === undefined)
+        return null;
+    const hasUnit = layer !== 'app';
+    const unit = hasUnit ? (segments[1] ?? null) : null;
+    const rest = segments.slice(hasUnit ? 2 : 1);
+    if (rest.length > 0 && INDEX_FILE.test(rest[rest.length - 1]))
+        rest.pop();
+    return { layer, unit, rest };
+}
+/** Pure core: the violation (if any) of `from` importing `to`. */
+export function judge(from, to) {
+    if (LAYER_ORDER.indexOf(to.layer) < LAYER_ORDER.indexOf(from.layer))
+        return { kind: 'upward', from, to };
+    if (to.unit === null)
+        return null; // the app layer, or a bare layer directory — nothing finer to guard
+    const sameUnit = from.layer === to.layer && from.unit === to.unit;
+    if (sameUnit)
+        return null; // inside one slice/segment anything goes
+    const viaCrossImportApi = to.rest[0] === '@x' && to.rest[1] === from.unit && from.layer === to.layer;
+    if (viaCrossImportApi)
+        return null;
+    if (from.layer === to.layer && SLICED_LAYERS.has(to.layer))
+        return { kind: 'cross-slice', from, to };
+    if (to.rest.length > 0)
+        return { kind: 'sidestep', from, to };
+    return null;
+}
+export function describeLocation(location) {
+    return location.unit === null ? location.layer : `${location.layer}/${location.unit}`;
+}
+/** Resolves an import specifier to a path relative to the source root, or null when it is
+ * a package specifier or lands outside the root. */
+export function resolveSpecifier(specifier, importerRootRelative, options) {
+    let rootRelative = null;
+    if (specifier.startsWith('./') || specifier.startsWith('../') || specifier === '.' || specifier === '..') {
+        rootRelative = posix.normalize(posix.join(posix.dirname(importerRootRelative), specifier));
+    }
+    else {
+        for (const [prefix, target] of Object.entries(options.aliases)) {
+            if (!specifier.startsWith(prefix))
+                continue;
+            const targetAbsolute = resolve(options.cwd, target);
+            const targetRootRelative = toPosix(relative(options.rootAbsolute, targetAbsolute));
+            rootRelative = posix.normalize(posix.join(targetRootRelative === '' ? '.' : targetRootRelative, specifier.slice(prefix.length)));
+            break;
+        }
+    }
+    if (rootRelative === null)
+        return null;
+    if (rootRelative === '..' || rootRelative.startsWith('../'))
+        return null;
+    return rootRelative;
+}
+function toPosix(path) {
+    return sep === '/' ? path : path.split(sep).join('/');
+}
+export const fsdBoundariesRule = {
+    meta: {
+        type: 'problem',
+        docs: {
+            description: 'Enforce canonical Feature-Sliced Design import rules inside a frontend app',
+            url: 'https://github.com/clearlydev/nx-archweave#fsd-lite',
+        },
+        schema: [
+            {
+                type: 'object',
+                properties: {
+                    root: { type: 'string' },
+                    aliases: { type: 'object', additionalProperties: { type: 'string' } },
+                },
+                additionalProperties: false,
+            },
+        ],
+        messages: {
+            upward: 'FSD: "{{from}}" may not import from "{{to}}" (a higher layer).',
+            crossSlice: 'FSD: "{{from}}" may not import a sibling slice "{{to}}" — move the shared part down a layer, or expose it through "{{to}}/@x/{{fromUnit}}".',
+            sidestep: 'FSD: import "{{to}}" through its public API (index.ts), not its internal file "{{path}}".',
+        },
+    },
+    create(context) {
+        const options = (context.options[0] ?? {});
+        const root = options.root ?? 'src';
+        const aliases = options.aliases ?? { '@/': root };
+        const cwd = context.cwd;
+        const rootAbsolute = resolve(cwd, root);
+        const importerRootRelative = toPosix(relative(rootAbsolute, context.filename));
+        if (importerRootRelative === '' || importerRootRelative.startsWith('..'))
+            return {};
+        const from = locate(importerRootRelative);
+        if (from === null)
+            return {};
+        const check = (node, specifier) => {
+            if (typeof specifier !== 'string')
+                return;
+            const target = resolveSpecifier(specifier, importerRootRelative, { rootAbsolute, cwd, aliases });
+            if (target === null)
+                return;
+            const to = locate(target);
+            if (to === null)
+                return;
+            const violation = judge(from, to);
+            if (violation === null)
+                return;
+            const data = { from: describeLocation(from), to: describeLocation(to), fromUnit: from.unit ?? '', path: target };
+            context.report({
+                node,
+                messageId: violation.kind === 'upward' ? 'upward' : violation.kind === 'cross-slice' ? 'crossSlice' : 'sidestep',
+                data,
+            });
+        };
+        const fromSource = (node) => check(node, node.source?.value);
+        return {
+            ImportDeclaration: fromSource,
+            ExportNamedDeclaration: fromSource,
+            ExportAllDeclaration: fromSource,
+            ImportExpression: (node) => {
+                const argument = node.source;
+                if (argument && argument.type === 'Literal')
+                    check(node, argument.value);
+            },
+        };
+    },
+};

package/dist/eslint/index.d.ts

@@ -0,0 +1,78 @@
+import { type FsdEnforcementSeverity } from './fsd-boundaries.ts';
+export { fsdBoundariesRule, type FsdBoundariesOptions, type FsdEnforcementSeverity } from './fsd-boundaries.ts';
+export { aliasesFromTsconfig } from './tsconfig-aliases.ts';
+/** The ESLint plugin object — `plugins: { archweave: archweavePlugin }`. */
+export declare const archweavePlugin: {
+    meta: {
+        name: string;
+        version: string;
+    };
+    rules: {
+        'fsd-boundaries': {
+            meta: {
+                type: "problem";
+                docs: {
+                    description: string;
+                    url: string;
+                };
+                schema: {
+                    type: string;
+                    properties: {
+                        root: {
+                            type: string;
+                        };
+                        aliases: {
+                            type: string;
+                            additionalProperties: {
+                                type: string;
+                            };
+                        };
+                    };
+                    additionalProperties: boolean;
+                }[];
+                messages: {
+                    upward: string;
+                    crossSlice: string;
+                    sidestep: string;
+                };
+            };
+            create(context: import("./fsd-boundaries.ts").RuleContext): {
+                ImportDeclaration?: undefined;
+                ExportNamedDeclaration?: undefined;
+                ExportAllDeclaration?: undefined;
+                ImportExpression?: undefined;
+            } | {
+                ImportDeclaration: (node: import("./fsd-boundaries.ts").AstNode) => void;
+                ExportNamedDeclaration: (node: import("./fsd-boundaries.ts").AstNode) => void;
+                ExportAllDeclaration: (node: import("./fsd-boundaries.ts").AstNode) => void;
+                ImportExpression: (node: import("./fsd-boundaries.ts").AstNode) => void;
+            };
+        };
+    };
+};
+export interface FsdBoundariesConfigOptions {
+    /** `error` (Team preset) or `warn` (Solo / Quick Start). Default `error`. */
+    severity?: FsdEnforcementSeverity;
+    /** The app's source root, relative to the config file's directory. Default `src`. */
+    root?: string;
+    /** Import-prefix aliases → directories relative to the config file's directory. Default:
+     * `{ '@/': <root> }` (the alias Nx's Next.js template ships) plus whatever the app's
+     * tsconfig `paths` declare (see `tsconfig`). Passing this replaces both. */
+    aliases?: Record<string, string>;
+    /** The tsconfig whose `compilerOptions.paths` (and its `extends` chain) add to the default
+     * aliases, relative to `cwd`. Default `tsconfig.json`; `false` turns the lookup off. */
+    tsconfig?: string | false;
+    /** The directory the config is evaluated from — Nx lints from the project root. Default
+     * `process.cwd()`. */
+    cwd?: string;
+    /** Override the files the rule applies to. Default: everything under `root`. */
+    files?: string[];
+}
+/**
+ * The one flat-config entry add-fsd-lite adds to a frontend app's eslint.config.mjs:
+ *
+ *   import { fsdBoundaries } from '@clearlydev/nx-archweave/eslint';
+ *   export default [...baseConfig, ...fsdBoundaries({ severity: 'error' })];
+ */
+export declare function fsdBoundaries(options?: FsdBoundariesConfigOptions): object[];
+//# sourceMappingURL=index.d.ts.map

package/dist/eslint/index.js

@@ -0,0 +1,256 @@
+// src/eslint/index.ts
+import { existsSync as existsSync2, readFileSync as readFileSync2 } from "node:fs";
+import { dirname as dirname2, join } from "node:path";
+import { fileURLToPath } from "node:url";
+
+// src/eslint/fsd-boundaries.ts
+import { posix, relative, resolve, sep } from "node:path";
+var LAYER_ORDER = ["app", "pages", "widgets", "features", "entities", "shared"];
+var LAYER_BY_DIR = {
+  app: "app",
+  _app: "app",
+  pages: "pages",
+  _pages: "pages",
+  widgets: "widgets",
+  features: "features",
+  entities: "entities",
+  shared: "shared"
+};
+var SLICED_LAYERS = /* @__PURE__ */ new Set(["pages", "widgets", "features", "entities"]);
+var INDEX_FILE = /^index(\.[cm]?[jt]sx?)?$/;
+function locate(rootRelativePath) {
+  const segments = rootRelativePath.split("/").filter((s) => s.length > 0 && s !== ".");
+  if (segments.length === 0) return null;
+  const layer = LAYER_BY_DIR[segments[0]];
+  if (layer === void 0) return null;
+  const hasUnit = layer !== "app";
+  const unit = hasUnit ? segments[1] ?? null : null;
+  const rest = segments.slice(hasUnit ? 2 : 1);
+  if (rest.length > 0 && INDEX_FILE.test(rest[rest.length - 1])) rest.pop();
+  return { layer, unit, rest };
+}
+function judge(from, to) {
+  if (LAYER_ORDER.indexOf(to.layer) < LAYER_ORDER.indexOf(from.layer)) return { kind: "upward", from, to };
+  if (to.unit === null) return null;
+  const sameUnit = from.layer === to.layer && from.unit === to.unit;
+  if (sameUnit) return null;
+  const viaCrossImportApi = to.rest[0] === "@x" && to.rest[1] === from.unit && from.layer === to.layer;
+  if (viaCrossImportApi) return null;
+  if (from.layer === to.layer && SLICED_LAYERS.has(to.layer)) return { kind: "cross-slice", from, to };
+  if (to.rest.length > 0) return { kind: "sidestep", from, to };
+  return null;
+}
+function describeLocation(location) {
+  return location.unit === null ? location.layer : `${location.layer}/${location.unit}`;
+}
+function resolveSpecifier(specifier, importerRootRelative, options) {
+  let rootRelative = null;
+  if (specifier.startsWith("./") || specifier.startsWith("../") || specifier === "." || specifier === "..") {
+    rootRelative = posix.normalize(posix.join(posix.dirname(importerRootRelative), specifier));
+  } else {
+    for (const [prefix, target] of Object.entries(options.aliases)) {
+      if (!specifier.startsWith(prefix)) continue;
+      const targetAbsolute = resolve(options.cwd, target);
+      const targetRootRelative = toPosix(relative(options.rootAbsolute, targetAbsolute));
+      rootRelative = posix.normalize(posix.join(targetRootRelative === "" ? "." : targetRootRelative, specifier.slice(prefix.length)));
+      break;
+    }
+  }
+  if (rootRelative === null) return null;
+  if (rootRelative === ".." || rootRelative.startsWith("../")) return null;
+  return rootRelative;
+}
+function toPosix(path) {
+  return sep === "/" ? path : path.split(sep).join("/");
+}
+var fsdBoundariesRule = {
+  meta: {
+    type: "problem",
+    docs: {
+      description: "Enforce canonical Feature-Sliced Design import rules inside a frontend app",
+      url: "https://github.com/clearlydev/nx-archweave#fsd-lite"
+    },
+    schema: [
+      {
+        type: "object",
+        properties: {
+          root: { type: "string" },
+          aliases: { type: "object", additionalProperties: { type: "string" } }
+        },
+        additionalProperties: false
+      }
+    ],
+    messages: {
+      upward: 'FSD: "{{from}}" may not import from "{{to}}" (a higher layer).',
+      crossSlice: 'FSD: "{{from}}" may not import a sibling slice "{{to}}" \u2014 move the shared part down a layer, or expose it through "{{to}}/@x/{{fromUnit}}".',
+      sidestep: 'FSD: import "{{to}}" through its public API (index.ts), not its internal file "{{path}}".'
+    }
+  },
+  create(context) {
+    const options = context.options[0] ?? {};
+    const root = options.root ?? "src";
+    const aliases = options.aliases ?? { "@/": root };
+    const cwd = context.cwd;
+    const rootAbsolute = resolve(cwd, root);
+    const importerRootRelative = toPosix(relative(rootAbsolute, context.filename));
+    if (importerRootRelative === "" || importerRootRelative.startsWith("..")) return {};
+    const from = locate(importerRootRelative);
+    if (from === null) return {};
+    const check = (node, specifier) => {
+      if (typeof specifier !== "string") return;
+      const target = resolveSpecifier(specifier, importerRootRelative, { rootAbsolute, cwd, aliases });
+      if (target === null) return;
+      const to = locate(target);
+      if (to === null) return;
+      const violation = judge(from, to);
+      if (violation === null) return;
+      const data = { from: describeLocation(from), to: describeLocation(to), fromUnit: from.unit ?? "", path: target };
+      context.report({
+        node,
+        messageId: violation.kind === "upward" ? "upward" : violation.kind === "cross-slice" ? "crossSlice" : "sidestep",
+        data
+      });
+    };
+    const fromSource = (node) => check(node, node.source?.value);
+    return {
+      ImportDeclaration: fromSource,
+      ExportNamedDeclaration: fromSource,
+      ExportAllDeclaration: fromSource,
+      ImportExpression: (node) => {
+        const argument = node.source;
+        if (argument && argument.type === "Literal") check(node, argument.value);
+      }
+    };
+  }
+};
+
+// src/eslint/tsconfig-aliases.ts
+import { existsSync, readFileSync } from "node:fs";
+import { dirname, isAbsolute, relative as relative2, resolve as resolve2, sep as sep2 } from "node:path";
+function aliasesFromTsconfig({ cwd, tsconfig = "tsconfig.json", maxDepth = 8 }) {
+  const aliases = {};
+  let current = resolve2(cwd, tsconfig);
+  const seen = /* @__PURE__ */ new Set();
+  for (let depth = 0; current !== null && depth < maxDepth && !seen.has(current); depth++) {
+    seen.add(current);
+    const config = readJsonc(current);
+    if (config === null) break;
+    const compilerOptions = asRecord(config["compilerOptions"]);
+    const paths = asRecord(compilerOptions?.["paths"]);
+    if (paths) {
+      const baseUrl = typeof compilerOptions?.["baseUrl"] === "string" ? resolve2(dirname(current), compilerOptions["baseUrl"]) : dirname(current);
+      for (const [pattern, targets] of Object.entries(paths)) {
+        if (!pattern.endsWith("*")) continue;
+        const prefix = pattern.slice(0, -1);
+        if (prefix in aliases) continue;
+        const target = Array.isArray(targets) ? targets.find((t) => typeof t === "string") : void 0;
+        if (target === void 0 || !target.endsWith("/*")) continue;
+        const dir = toPosix2(relative2(cwd, resolve2(baseUrl, target.slice(0, -"/*".length))));
+        aliases[prefix] = dir === "" ? "." : dir;
+      }
+    }
+    const parent = config["extends"];
+    const parentPath = typeof parent === "string" ? parent : Array.isArray(parent) ? parent.find((p) => typeof p === "string") : void 0;
+    current = parentPath !== void 0 && (parentPath.startsWith(".") || isAbsolute(parentPath)) ? resolveExtends(dirname(current), parentPath) : null;
+  }
+  return aliases;
+}
+function resolveExtends(fromDir, target) {
+  const candidates = [resolve2(fromDir, target), resolve2(fromDir, `${target}.json`)];
+  return candidates.find((candidate) => existsSync(candidate)) ?? null;
+}
+function asRecord(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value) ? value : null;
+}
+function toPosix2(path) {
+  return sep2 === "/" ? path : path.split(sep2).join("/");
+}
+function readJsonc(path) {
+  let text;
+  try {
+    text = readFileSync(path, "utf-8");
+  } catch {
+    return null;
+  }
+  let out = "";
+  let mode = "code";
+  for (let i = 0; i < text.length; i++) {
+    const c = text[i];
+    const d = text[i + 1];
+    if (mode === "code") {
+      if (c === '"') {
+        mode = "string";
+        out += c;
+      } else if (c === "/" && d === "/") {
+        mode = "line";
+        i++;
+      } else if (c === "/" && d === "*") {
+        mode = "block";
+        i++;
+      } else {
+        out += c;
+      }
+    } else if (mode === "string") {
+      out += c;
+      if (c === "\\") {
+        out += d ?? "";
+        i++;
+      } else if (c === '"') {
+        mode = "code";
+      }
+    } else if (mode === "line") {
+      if (c === "\n") {
+        mode = "code";
+        out += c;
+      }
+    } else if (c === "*" && d === "/") {
+      mode = "code";
+      i++;
+    }
+  }
+  try {
+    const parsed = JSON.parse(out.replace(/,(\s*[}\]])/g, "$1"));
+    return asRecord(parsed);
+  } catch {
+    return null;
+  }
+}
+
+// src/eslint/index.ts
+function ownVersion() {
+  let dir = dirname2(fileURLToPath(import.meta.url));
+  for (; ; ) {
+    const manifest = join(dir, "package.json");
+    if (existsSync2(manifest)) {
+      const pkg = JSON.parse(readFileSync2(manifest, "utf-8"));
+      if (pkg.name === "@clearlydev/nx-archweave" && pkg.version) return pkg.version;
+    }
+    const parent = dirname2(dir);
+    if (parent === dir) throw new Error("@clearlydev/nx-archweave: its own package.json was not found");
+    dir = parent;
+  }
+}
+var archweavePlugin = {
+  meta: { name: "@clearlydev/nx-archweave", version: ownVersion() },
+  rules: { "fsd-boundaries": fsdBoundariesRule }
+};
+function fsdBoundaries(options = {}) {
+  const root = options.root ?? "src";
+  const cwd = options.cwd ?? process.cwd();
+  const fromTsconfig = options.aliases === void 0 && options.tsconfig !== false ? aliasesFromTsconfig({ cwd, tsconfig: options.tsconfig }) : {};
+  const ruleOptions = { root, aliases: options.aliases ?? { "@/": root, ...fromTsconfig } };
+  return [
+    {
+      name: "nx-archweave/fsd-boundaries",
+      files: options.files ?? [`${root}/**/*.{ts,tsx,js,jsx,mts,cts,mjs,cjs}`],
+      plugins: { archweave: archweavePlugin },
+      rules: { "archweave/fsd-boundaries": [options.severity ?? "error", ruleOptions] }
+    }
+  ];
+}
+export {
+  aliasesFromTsconfig,
+  archweavePlugin,
+  fsdBoundaries,
+  fsdBoundariesRule
+};

package/dist/eslint/tsconfig-aliases.d.ts

@@ -0,0 +1,18 @@
+/**
+ * Import aliases from a tsconfig's `compilerOptions.paths`: every
+ * `"<prefix>*": ["<dir>/*"]` entry becomes `{ "<prefix>": "<dir>" }`, the directory relative
+ * to `cwd` (what the rule's `aliases` option takes). The `extends` chain is followed
+ * (relative paths only — a package preset is skipped), the nearest config winning per key;
+ * `baseUrl` of the config that declares the paths resolves the targets. Comments and
+ * trailing commas are tolerated, like tsc. Anything unreadable yields nothing: the rule
+ * then falls back to its default alias — a wrong alias map costs a missed report, never a
+ * false one, so this stays best-effort.
+ */
+export declare function aliasesFromTsconfig({ cwd, tsconfig, maxDepth }: {
+    cwd: string;
+    tsconfig?: string;
+    maxDepth?: number;
+}): Record<string, string>;
+/** tsconfig is JSON with comments and trailing commas; strip both outside strings. */
+export declare function readJsonc(path: string): Record<string, unknown> | null;
+//# sourceMappingURL=tsconfig-aliases.d.ts.map