@invariant-ui/cli 0.0.0-stage → 0.2.0

package/dist/compiler-core/discovery/entries.js

@@ -0,0 +1,270 @@
+import ts from "typescript";
+import { listExports } from "./exports.js";
+import { isRecord } from "./packages.js";
+import { cmp, fileExists, posix, readBounded } from "./support.js";
+const CONDITION_ORDER = ["types", "import", "module", "default", "require", "node", "browser"];
+const CONVENTIONAL_ROOT_ENTRIES = [
+    "src/index.ts",
+    "src/index.tsx",
+    "src/public-api.ts",
+    "src/public_api.ts",
+    "public-api.ts",
+    "index.ts",
+    "index.tsx"
+];
+/** Package entry points from `exports` (or main/module/types), resolved to a readable file and enumerated. */
+export async function discoverEntryPoints(env, raw) {
+    const dir = raw.info.dir;
+    const tsconfig = await readOutRoot(env, dir);
+    const declared = declaredEntries(env, raw, tsconfig);
+    // ng-packagr libraries declare their entry in `ng-package.json` (or default to a `public-api` file),
+    // not in package.json: the source manifest has no entry fields at all.
+    if (declared.length === 0)
+        declared.push(...(await angularLibraryEntry(env, dir)));
+    declared.push(...(await angularSecondaryEntries(env, dir)));
+    // Resolve every entry first: an entry may re-export another one through the package's own name.
+    const resolvedEntries = [];
+    for (const d of declared)
+        resolvedEntries.push({
+            declared: d,
+            resolved: await resolveTarget(env, { dir, subpath: d.subpath, target: d.target, tsconfig })
+        });
+    const self = new Map();
+    const name = raw.info.name;
+    if (name)
+        for (const { declared: d, resolved } of resolvedEntries)
+            if (resolved && !self.has(selfSpecifier(name, d.subpath)))
+                self.set(selfSpecifier(name, d.subpath), resolved.file);
+    const entries = [];
+    for (const { declared: d, resolved } of resolvedEntries) {
+        const { subpath, condition, target } = d;
+        if (!resolved) {
+            env.diagnostics.warning("discovery.entry-unresolved", `Entry ${subpath} (${target}) in ${raw.info.id} could not be resolved to a file`, {
+                location: { path: raw.info.manifest.path }
+            });
+            entries.push({
+                subpath,
+                condition,
+                target,
+                resolution: "unresolved",
+                exports: [],
+                exportsComplete: false,
+                parsedFiles: []
+            });
+            continue;
+        }
+        const listing = await listExports(env, resolved.file, self);
+        entries.push({
+            subpath,
+            condition,
+            target,
+            resolution: resolved.resolution,
+            file: resolved.file,
+            exports: listing.exports,
+            exportsComplete: listing.complete,
+            parsedFiles: listing.parsedFiles
+        });
+    }
+    return entries.sort((a, b) => cmp(a.subpath, b.subpath));
+}
+/** `primevue` for the root entry, `primevue/accordion` for `./accordion`: how the package imports itself. */
+function selfSpecifier(name, subpath) {
+    return subpath === "." ? name : `${name}/${subpath.replace(/^\.\//, "")}`;
+}
+function declaredEntries(env, raw, tsconfig) {
+    const out = [];
+    const manifest = raw.manifest;
+    const add = (subpath, condition, target) => {
+        // `"./*": "./*"` maps every file of the package to itself: it is not a list of what the package offers, and expanding
+        // it makes each component appear once per build folder (dist/esm, dist/cjs, src) as separate, "ambiguous" copies.
+        if (subpath.includes("*") && posix.normalize(subpath) === posix.normalize(target)) {
+            env.diagnostics.info("discovery.entry-pattern-identity", `Entry pattern ${subpath} in ${raw.info.id} maps files to themselves and is not expanded`, { location: { path: raw.info.manifest.path } });
+            return;
+        }
+        if (subpath.includes("*") || target.includes("*")) {
+            const stars = (t) => t.split("*").length - 1;
+            if (stars(subpath) !== 1 || stars(target) !== 1) {
+                env.diagnostics.info("discovery.entry-pattern-unsupported", `Entry pattern ${subpath} in ${raw.info.id} is not expanded`, { location: { path: raw.info.manifest.path } });
+                return;
+            }
+            const matches = expandPattern(env, { dir: raw.info.dir, target, tsconfig });
+            if (matches.length === 0)
+                env.diagnostics.info("discovery.entry-pattern-unmatched", `Entry pattern ${subpath} (${target}) in ${raw.info.id} matches no file`, { location: { path: raw.info.manifest.path } });
+            for (const match of matches)
+                out.push({ subpath: subpath.replace("*", match), condition, target: target.replace("*", match) });
+            return;
+        }
+        out.push({ subpath, condition, target });
+    };
+    const walkConditions = (subpath, node, trail) => {
+        if (typeof node === "string")
+            add(subpath, trail || "default", node);
+        else if (Array.isArray(node))
+            for (const item of node)
+                walkConditions(subpath, item, trail);
+        else if (isRecord(node)) {
+            const keys = Object.keys(node).sort((a, b) => rank(a) - rank(b));
+            for (const key of keys)
+                walkConditions(subpath, node[key], trail ? `${trail}.${key}` : key);
+        }
+    };
+    const exportsField = manifest.exports;
+    if (typeof exportsField === "string" || Array.isArray(exportsField))
+        walkConditions(".", exportsField, "");
+    else if (isRecord(exportsField)) {
+        const subpathKeys = Object.keys(exportsField).filter((k) => k.startsWith("."));
+        if (subpathKeys.length > 0)
+            for (const key of subpathKeys)
+                walkConditions(key, exportsField[key], "");
+        else
+            walkConditions(".", exportsField, "");
+    }
+    else {
+        for (const field of ["types", "typings", "module", "main"]) {
+            const target = manifest[field];
+            if (typeof target === "string") {
+                add(".", field, target);
+                break;
+            }
+        }
+    }
+    // One entry per subpath: the highest-priority condition that resolves is chosen later; keep the
+    // first (best-ranked) declaration per subpath to stay deterministic and bounded.
+    const seen = new Set();
+    return out.filter((e) => {
+        if (seen.has(e.subpath))
+            return false;
+        seen.add(e.subpath);
+        return true;
+    });
+}
+/**
+ * What `*` stands for in a target pattern such as `./dist/*\/index.d.ts`, for every file that fits it. A target in
+ * build output is also matched against the sources it was built from (`src/*.ts`), as `resolveTarget` does.
+ */
+function expandPattern(env, input) {
+    const { dir, target, tsconfig } = input;
+    const declaredPath = posix.normalize(posix.join(dir, target));
+    const regexes = [globRegExp(declaredPath, "")];
+    if (tsconfig.outDir !== undefined) {
+        const out = posix.normalize(posix.join(dir, tsconfig.outDir));
+        if (declaredPath.startsWith(`${out}/`)) {
+            const rootDir = posix.normalize(posix.join(dir, tsconfig.rootDir ?? "src"));
+            const rel = declaredPath.slice(out.length + 1).replace(/\.d\.ts$|\.(?:[cm]?js|jsx)$/, "");
+            regexes.push(globRegExp(posix.join(rootDir, rel), String.raw `\.(?:[cm]?tsx?)`));
+        }
+    }
+    const found = new Set();
+    for (const file of env.files)
+        for (const [i, re] of regexes.entries()) {
+            // Declaration files are not the sources a build output was made from.
+            if (i > 0 && file.endsWith(".d.ts"))
+                continue;
+            const captured = re.exec(file)?.[1];
+            // `*` never stands for an empty string or for a dependency's files.
+            if (captured && !captured.split("/").includes("node_modules"))
+                found.add(captured);
+        }
+    return [...found].sort(cmp);
+}
+function globRegExp(pattern, suffix) {
+    const [head = "", tail = ""] = pattern.split("*");
+    const quote = (t) => t.replace(/[.+?^${}()|[\]\\]/g, "\\$&");
+    return new RegExp(`^${quote(head)}(.+)${quote(tail)}${suffix}$`);
+}
+function rank(condition) {
+    const i = CONDITION_ORDER.indexOf(condition);
+    return i < 0 ? CONDITION_ORDER.length : i;
+}
+async function resolveTarget(env, input) {
+    const { dir, subpath, target, tsconfig } = input;
+    const declaredPath = posix.normalize(posix.join(dir, target));
+    const isSource = /\.(?:tsx?|mts|cts)$/.test(declaredPath) && !declaredPath.endsWith(".d.ts");
+    if (isSource && (await fileExists(env, declaredPath)))
+        return { file: declaredPath, resolution: "declared" };
+    if (tsconfig.outDir !== undefined) {
+        const out = posix.normalize(posix.join(dir, tsconfig.outDir));
+        if (declaredPath.startsWith(`${out}/`)) {
+            const rootDir = posix.normalize(posix.join(dir, tsconfig.rootDir ?? "src"));
+            const rel = declaredPath.slice(out.length + 1).replace(/\.d\.ts$|\.(?:[cm]?js|jsx)$/, "");
+            for (const ext of [".ts", ".tsx", ".mts", ".cts"]) {
+                const candidate = posix.join(rootDir, rel + ext);
+                if (await fileExists(env, candidate))
+                    return { file: candidate, resolution: "mapped" };
+            }
+        }
+    }
+    if (await fileExists(env, declaredPath))
+        return { file: declaredPath, resolution: "declared" };
+    if (subpath === ".") {
+        for (const conventional of CONVENTIONAL_ROOT_ENTRIES) {
+            const candidate = posix.join(dir, conventional);
+            if (await fileExists(env, candidate))
+                return { file: candidate, resolution: "conventional" };
+        }
+    }
+    return undefined;
+}
+/** `outDir` / `rootDir` from the package's own tsconfig.json (no `extends` resolution). */
+async function readOutRoot(env, dir) {
+    const file = posix.join(dir, "tsconfig.json");
+    if (!env.fileSet.has(file))
+        return {};
+    const text = await readBounded(env, file);
+    if (text === undefined)
+        return {};
+    const parsed = ts.parseConfigFileTextToJson(file, text);
+    const options = isRecord(parsed.config) && isRecord(parsed.config.compilerOptions) ? parsed.config.compilerOptions : {};
+    return {
+        ...(typeof options.outDir === "string" ? { outDir: options.outDir } : {}),
+        ...(typeof options.rootDir === "string" ? { rootDir: options.rootDir } : {})
+    };
+}
+const PUBLIC_API_FILES = ["src/public-api.ts", "src/public_api.ts", "public-api.ts", "public_api.ts"];
+async function angularLibraryEntry(env, dir) {
+    const ngPackage = posix.join(dir, "ng-package.json");
+    if (env.fileSet.has(ngPackage)) {
+        const text = await readBounded(env, ngPackage);
+        if (text !== undefined) {
+            const parsed = ts.parseConfigFileTextToJson(ngPackage, text);
+            const lib = isRecord(parsed.config) && isRecord(parsed.config.lib) ? parsed.config.lib : undefined;
+            if (typeof lib?.entryFile === "string")
+                return [{ subpath: ".", condition: "ng-package", target: lib.entryFile }];
+        }
+    }
+    for (const candidate of PUBLIC_API_FILES) {
+        if (env.fileSet.has(posix.join(dir, candidate)))
+            return [{ subpath: ".", condition: "conventional", target: candidate }];
+    }
+    return [];
+}
+/**
+ * ng-packagr secondary entry points: subfolders with their own `ng-package.json`. Consumers import them
+ * as `<package>/<folder>`; the entry file defaults to a `public-api` file in the folder.
+ */
+async function angularSecondaryEntries(env, dir) {
+    if (!env.fileSet.has(posix.join(dir, "ng-package.json")))
+        return [];
+    const out = [];
+    for (const file of env.files) {
+        if (posix.basename(file) !== "ng-package.json" || !file.startsWith(dir === "." ? "" : `${dir}/`))
+            continue;
+        const folder = posix.dirname(file);
+        if (folder === dir)
+            continue;
+        const relative = posix.relative(dir, folder);
+        // A folder with its own package.json is a separate package, not a secondary entry point.
+        if (env.fileSet.has(posix.join(folder, "package.json")))
+            continue;
+        const text = await readBounded(env, file);
+        const parsed = text === undefined ? undefined : ts.parseConfigFileTextToJson(file, text);
+        const lib = parsed && isRecord(parsed.config) && isRecord(parsed.config.lib) ? parsed.config.lib : undefined;
+        const entry = typeof lib?.entryFile === "string"
+            ? lib.entryFile
+            : PUBLIC_API_FILES.map((f) => posix.basename(f)).find((f) => env.fileSet.has(posix.join(folder, f)));
+        if (entry)
+            out.push({ subpath: `./${relative}`, condition: "ng-package", target: posix.join(relative, entry) });
+    }
+    return out;
+}
+//# sourceMappingURL=entries.js.map

package/dist/compiler-core/discovery/exports.js

@@ -0,0 +1,207 @@
+import ts from "typescript";
+import { cmp, fileExists, hashText, posix, readBounded } from "./support.js";
+const SOURCE_EXTS = [".ts", ".tsx", ".mts", ".cts", ".d.ts", ".js", ".jsx", ".mjs", ".cjs", ".vue"];
+const PARSEABLE = /\.(?:[cm]?[jt]sx?)$/;
+/**
+ * Enumerates the names a module exports, syntactically (no type checking, no execution). Follows
+ * relative `export *` and `export {…} from` chains. Whether an export is a component is NOT decided here.
+ */
+export async function listExports(env, entryFile, 
+/** The package's own entry points by import specifier (`primevue/accordion`) to file: followed like relative imports. */
+self = new Map()) {
+    const state = {
+        env,
+        self,
+        byName: new Map(),
+        parsed: new Map(),
+        complete: true,
+        visiting: new Set()
+    };
+    await visitModule(state, entryFile);
+    return {
+        exports: [...state.byName.values()].sort((a, b) => cmp(a.name, b.name)),
+        complete: state.complete,
+        parsedFiles: [...state.parsed]
+            .map(([path, contentHash]) => ({ path, contentHash }))
+            .sort((a, b) => cmp(a.path, b.path))
+    };
+}
+async function visitModule(state, file) {
+    if (state.visiting.has(file))
+        return;
+    if (state.parsed.size >= state.env.limits.maxParsedFilesPerEntry) {
+        state.complete = false;
+        state.env.diagnostics.warning("discovery.export-limit", `Stopped following re-exports after ${state.env.limits.maxParsedFilesPerEntry} files`, { location: { path: file } });
+        return;
+    }
+    state.visiting.add(file);
+    const text = await readBounded(state.env, file);
+    if (text === undefined) {
+        state.complete = false;
+        return;
+    }
+    state.parsed.set(file, hashText(text));
+    if (!PARSEABLE.test(file)) {
+        // Assets (css, json, .vue) have no enumerable JS exports; the caller must not read "none" as "complete".
+        if (state.visiting.size === 1)
+            state.complete = false;
+        return;
+    }
+    const sf = ts.createSourceFile(file, text, ts.ScriptTarget.ES2022, false, scriptKind(file));
+    const parseErrors = sf.parseDiagnostics ?? [];
+    if (parseErrors.length > 0) {
+        state.complete = false;
+        state.env.diagnostics.warning("discovery.parse-error", `Syntax errors in ${file}; exports may be incomplete`, { location: { path: file } });
+    }
+    const locals = localDeclarationKinds(sf);
+    const stars = [];
+    const record = (info, node) => {
+        // Explicit exports (collected first, in this file) win over star re-exports; first definition wins.
+        if (state.byName.has(info.name))
+            return;
+        state.byName.set(info.name, {
+            ...info,
+            file,
+            line: sf.getLineAndCharacterOfPosition(node.getStart(sf)).line + 1
+        });
+    };
+    for (const statement of sf.statements) {
+        if (ts.isExportDeclaration(statement)) {
+            const spec = statement.moduleSpecifier && ts.isStringLiteral(statement.moduleSpecifier)
+                ? statement.moduleSpecifier.text
+                : undefined;
+            const external = spec !== undefined && !spec.startsWith(".") && !state.self.has(spec);
+            const clause = statement.exportClause;
+            if (!clause) {
+                if (spec)
+                    stars.push(spec);
+            }
+            else if (ts.isNamespaceExport(clause)) {
+                record({
+                    name: clause.name.text,
+                    kind: "namespace",
+                    typeOnly: statement.isTypeOnly,
+                    ...(spec ? { reexportOf: { module: spec, external } } : {})
+                }, clause);
+            }
+            else {
+                for (const element of clause.elements) {
+                    const typeOnly = statement.isTypeOnly || element.isTypeOnly;
+                    const original = (element.propertyName ?? element.name).text;
+                    const kind = spec
+                        ? original === "default"
+                            ? "default"
+                            : external
+                                ? "unknown"
+                                : await reexportedKind(state, file, spec, original)
+                        : (locals.get(original) ?? "unknown");
+                    record({
+                        name: element.name.text,
+                        kind: typeOnly && kind === "unknown" ? "type" : kind,
+                        typeOnly,
+                        ...(spec ? { reexportOf: { module: spec, external } } : {})
+                    }, element);
+                }
+            }
+        }
+        else if (ts.isExportAssignment(statement)) {
+            if (statement.isExportEquals) {
+                state.complete = false;
+                state.env.diagnostics.info("discovery.unsupported-export-assignment", `'export =' in ${file} is not enumerated`, { location: { path: file } });
+            }
+            else
+                record({ name: "default", kind: "default", typeOnly: false }, statement);
+        }
+        else if (hasExportModifier(statement)) {
+            for (const [name, kind] of declaredNames(statement))
+                record({ name, kind, typeOnly: kind === "type" }, statement);
+        }
+    }
+    for (const spec of stars) {
+        if (!spec.startsWith(".") && !state.self.has(spec)) {
+            state.complete = false;
+            state.env.diagnostics.info("discovery.external-reexport", `'export * from "${spec}"' in ${file} is not followed`, { location: { path: file } });
+            continue;
+        }
+        const target = await resolveSpecifier(state, file, spec);
+        if (!target) {
+            state.complete = false;
+            state.env.diagnostics.warning("discovery.unresolved-module", `Could not resolve "${spec}" from ${file}`, { location: { path: file } });
+            continue;
+        }
+        await visitModule(state, target);
+    }
+}
+/** A relative path, or one of the package's own entry points imported by its name. */
+async function resolveSpecifier(state, from, spec) {
+    return spec.startsWith(".") ? resolveModule(state.env, from, spec) : state.self.get(spec);
+}
+async function resolveModule(env, from, spec) {
+    const base = posix.normalize(posix.join(posix.dirname(from), spec));
+    const stripped = base.replace(/\.(?:[cm]?jsx?)$/, "");
+    const candidates = [
+        ...(/\.[a-z]+$/i.test(base) && base === stripped ? [base] : []),
+        ...(stripped !== base ? [".ts", ".tsx", ".mts", ".cts", ".d.ts"].map((e) => stripped + e) : []),
+        ...(stripped !== base ? [base] : []),
+        ...SOURCE_EXTS.map((e) => base + e),
+        ...[".ts", ".tsx", ".d.ts", ".js", ".jsx"].map((e) => `${base}/index${e}`)
+    ];
+    for (const candidate of candidates) {
+        if (await fileExists(env, candidate))
+            return candidate;
+    }
+    return undefined;
+}
+/** Looks one level into a relative module to learn whether a re-exported name is a value, type or namespace. */
+async function reexportedKind(state, from, spec, name) {
+    const target = await resolveSpecifier(state, from, spec);
+    if (!target || !PARSEABLE.test(target))
+        return "unknown";
+    const text = await readBounded(state.env, target);
+    if (text === undefined)
+        return "unknown";
+    state.parsed.set(target, hashText(text));
+    const sf = ts.createSourceFile(target, text, ts.ScriptTarget.ES2022, false, scriptKind(target));
+    return localDeclarationKinds(sf).get(name) ?? "unknown";
+}
+function scriptKind(file) {
+    if (file.endsWith(".tsx"))
+        return ts.ScriptKind.TSX;
+    if (file.endsWith(".jsx"))
+        return ts.ScriptKind.JSX;
+    if (/\.[cm]?js$/.test(file))
+        return ts.ScriptKind.JS;
+    return ts.ScriptKind.TS;
+}
+function localDeclarationKinds(sf) {
+    const kinds = new Map();
+    for (const statement of sf.statements) {
+        for (const [name, kind] of declaredNames(statement))
+            kinds.set(name, kind);
+    }
+    return kinds;
+}
+function declaredNames(statement) {
+    const isDefault = ts.canHaveModifiers(statement) &&
+        !!ts.getModifiers(statement)?.some((m) => m.kind === ts.SyntaxKind.DefaultKeyword);
+    if (ts.isVariableStatement(statement)) {
+        return statement.declarationList.declarations.flatMap((d) => ts.isIdentifier(d.name) ? [[d.name.text, "value"]] : []);
+    }
+    if (ts.isFunctionDeclaration(statement) || ts.isClassDeclaration(statement)) {
+        if (isDefault)
+            return [["default", "default"]];
+        return statement.name ? [[statement.name.text, "value"]] : [];
+    }
+    if (ts.isInterfaceDeclaration(statement) || ts.isTypeAliasDeclaration(statement))
+        return [[statement.name.text, "type"]];
+    if (ts.isEnumDeclaration(statement))
+        return [[statement.name.text, "value"]];
+    if (ts.isModuleDeclaration(statement) && ts.isIdentifier(statement.name))
+        return [[statement.name.text, "namespace"]];
+    return [];
+}
+function hasExportModifier(statement) {
+    return (ts.canHaveModifiers(statement) &&
+        !!ts.getModifiers(statement)?.some((m) => m.kind === ts.SyntaxKind.ExportKeyword));
+}
+//# sourceMappingURL=exports.js.map

package/dist/compiler-core/discovery/graph.js

@@ -0,0 +1,59 @@
+import { cmp, owningPackage } from "./support.js";
+/** Source relationship graph: sorted nodes and edges, derived only from discovered facts. */
+export function buildGraph(input) {
+    const nodes = new Map();
+    const edges = new Map();
+    const node = (id, type, label) => {
+        nodes.set(id, { id, type, label });
+    };
+    const edge = (from, to, type, weight) => {
+        edges.set(`${from}\u0000${type}\u0000${to}`, { from, to, type, ...(weight ? { weight } : {}) });
+    };
+    const byName = new Map(input.packages.flatMap((p) => (p.name ? [[p.name, p]] : [])));
+    for (const pkg of input.packages) {
+        node(pkg.id, "package", pkg.name ?? pkg.dir);
+        for (const dep of pkg.dependencies) {
+            const target = byName.get(dep.name);
+            if (target && target.id !== pkg.id)
+                edge(pkg.id, target.id, "depends-on");
+        }
+        for (const fw of pkg.frameworks) {
+            node(`framework:${fw.name}`, "framework", fw.name);
+            edge(pkg.id, `framework:${fw.name}`, "uses-framework");
+        }
+        for (const tool of pkg.buildTools) {
+            node(`tool:${tool.name}`, "build-tool", tool.name);
+            edge(pkg.id, `tool:${tool.name}`, "built-with");
+        }
+    }
+    for (const storybook of input.storybooks) {
+        node(storybook.id, "storybook-config", storybook.configPath);
+        if (storybook.package)
+            edge(storybook.package, storybook.id, "configured-by");
+        const counts = new Map();
+        for (const file of storybook.storyFiles) {
+            const owner = owningPackage(input.packages, file);
+            if (owner)
+                counts.set(owner.id, (counts.get(owner.id) ?? 0) + 1);
+        }
+        for (const [pkgId, count] of counts)
+            edge(storybook.id, pkgId, "documents", count);
+    }
+    for (const file of input.tokenFiles) {
+        node(`tokens:${file.path}`, "token-file", file.path);
+        const owner = owningPackage(input.packages, file.path);
+        if (owner)
+            edge(owner.id, `tokens:${file.path}`, "contains");
+    }
+    for (const file of input.docFiles) {
+        node(`doc:${file.path}`, "doc-file", file.path);
+        const owner = owningPackage(input.packages, file.path);
+        if (owner)
+            edge(owner.id, `doc:${file.path}`, "contains");
+    }
+    return {
+        nodes: [...nodes.values()].sort((a, b) => cmp(a.id, b.id)),
+        edges: [...edges.values()].sort((a, b) => cmp(a.from, b.from) || cmp(a.type, b.type) || cmp(a.to, b.to))
+    };
+}
+//# sourceMappingURL=graph.js.map

package/dist/compiler-core/discovery/index.js

@@ -0,0 +1,103 @@
+import { DiagnosticCollector } from "../../shared/index.js";
+import { DEFAULT_IGNORED_DIRS, walk } from "../walk.js";
+import { discoverDocFiles } from "./docs.js";
+import { discoverEntryPoints } from "./entries.js";
+import { buildGraph } from "./graph.js";
+import { discoverPackages } from "./packages.js";
+import { DISCOVERY_VERSION, projectDiscoverySchema } from "./schema.js";
+import { discoverStorybooks } from "./storybook.js";
+import { DEFAULT_LIMITS, owningPackage } from "./support.js";
+import { discoverTokenFiles } from "./tokens.js";
+import { detectBuildTools, detectFrameworks, detectPackageManager } from "./tooling.js";
+/** Build output folders: ignored in a project, but the content of a published package. */
+const FRAMEWORK_PACKAGE_NAME = { react: "react", vue: "vue", angular: "@angular/core" };
+const BUILD_OUTPUT_DIRS = ["dist", "build", "out"];
+/**
+ * Framework-neutral project discovery: packages, workspaces, package manager, frameworks and
+ * versions, build tools, entry points and exports, Storybook configs, token files and CSS
+ * variables, documentation files, and the relationship graph. Read-only and deterministic.
+ */
+export async function discoverProject(options) {
+    const limits = { ...DEFAULT_LIMITS, ...options.limits };
+    const diagnostics = new DiagnosticCollector();
+    const ignore = new Set([...DEFAULT_IGNORED_DIRS, ...(options.ignoreDirs ?? [])]);
+    const walked = await walk(options.fs, { ignoreDirs: ignore, maxFiles: limits.maxFiles });
+    if (walked.truncated) {
+        diagnostics.warning("discovery.walk-truncated", `Stopped after ${limits.maxFiles} files; discovery is incomplete`);
+    }
+    const roots = new Set((options.declarationRoots ?? []).map((r) => r.replace(/^\.\//, "").replace(/\/+$/, "")));
+    const files = new Set(walked.files);
+    const packageIgnore = new Set([...ignore].filter((d) => !BUILD_OUTPUT_DIRS.includes(d)));
+    for (const root of [...roots].sort()) {
+        try {
+            await options.fs.readDir(root);
+        }
+        catch {
+            diagnostics.warning("discovery.declaration-root-missing", `${root} was not found; is the package installed?`);
+            continue;
+        }
+        const inside = await walk(options.fs, {
+            ignoreDirs: packageIgnore,
+            maxFiles: limits.maxFiles,
+            start: root
+        });
+        if (inside.truncated)
+            diagnostics.warning("discovery.walk-truncated", `Stopped reading ${root} after ${limits.maxFiles} files`);
+        for (const file of inside.files)
+            files.add(file);
+    }
+    const allFiles = [...files].sort();
+    const env = {
+        fs: options.fs,
+        files: allFiles,
+        fileSet: files,
+        declarationRoots: roots,
+        ignoreDirs: ignore,
+        diagnostics,
+        limits
+    };
+    const { packages: raws, workspaces } = await discoverPackages(env);
+    const root = raws.find((p) => p.info.dir === ".");
+    const packageManager = await detectPackageManager(env, root);
+    for (const raw of raws) {
+        raw.info.frameworks = await detectFrameworks(env, raw);
+        const configured = options.declaredFrameworks?.[raw.info.dir];
+        // shortcut: a configured framework is recorded as a `*` peer dependency; upgrade if discovery needs to tell them apart.
+        if (configured && raw.info.frameworks.length === 0)
+            raw.info.frameworks = [
+                {
+                    name: configured,
+                    package: FRAMEWORK_PACKAGE_NAME[configured],
+                    dependencyKind: "peerDependencies",
+                    declaredRange: "*"
+                }
+            ];
+        raw.info.buildTools = detectBuildTools(env, raw);
+        raw.info.entryPoints = await discoverEntryPoints(env, raw);
+    }
+    const packages = raws.map((r) => r.info);
+    const storybooks = await discoverStorybooks(env, raws);
+    const tokenFiles = (await discoverTokenFiles(env)).map((file) => withOwner(file, packages));
+    const docFiles = (await discoverDocFiles(env)).map((file) => withOwner(file, packages));
+    const result = {
+        discoveryVersion: DISCOVERY_VERSION,
+        packageManager,
+        workspaces,
+        packages,
+        storybooks,
+        tokenFiles,
+        docFiles,
+        graph: buildGraph({ packages, storybooks, tokenFiles, docFiles }),
+        stats: { filesScanned: allFiles.length, truncated: walked.truncated },
+        diagnostics: diagnostics.toArray()
+    };
+    return projectDiscoverySchema.parse(result);
+}
+function withOwner(file, packages) {
+    const owner = owningPackage(packages, file.path);
+    return owner ? { ...file, package: owner.id } : file;
+}
+export { parsePnpmWorkspacePackages } from "./packages.js";
+export { DISCOVERY_VERSION, projectDiscoverySchema } from "./schema.js";
+export { parseCssCustomProperties, scanCssCustomProperties } from "./tokens.js";
+//# sourceMappingURL=index.js.map