@invariant-ui/cli 0.0.0-stage → 0.2.0

package/dist/compiler-core/adapters/inventory.js

@@ -0,0 +1,312 @@
+import { hashJson } from "../../shared/index.js";
+import { cmp } from "../discovery/support.js";
+import { IrBuilder } from "../ir-builder.js";
+export const npmPackageAdapter = {
+    id: "inventory-npm",
+    version: "0.1.0",
+    type: "npm",
+    async discover({ project }) {
+        const ids = new SourceIds("npm");
+        return {
+            sources: project.packages.map((pkg) => ({
+                id: ids.next(pkg.name ?? pkg.dir),
+                type: "npm",
+                location: pkg.dir,
+                config: { packageId: pkg.id },
+                ...(pkg.version
+                    ? { version: { kind: "package-version", value: pkg.version } }
+                    : {}),
+                inputHash: hashJson({
+                    manifest: pkg.manifest.contentHash,
+                    parsed: pkg.entryPoints.flatMap((e) => e.parsedFiles.map((f) => [f.path, f.contentHash]))
+                })
+            })),
+            diagnostics: []
+        };
+    },
+    async extract({ project, source, clock }, config) {
+        const pkg = requirePackage(project, config.packageId);
+        const builder = new IrBuilder({
+            source: irSource(source, npmPackageAdapter),
+            extractor: { name: "inventory-npm", version: npmPackageAdapter.version },
+            capabilities: ["package.*", "frameworks", "buildTools", "entryPoints", "export.*"],
+            clock
+        });
+        const manifest = (line) => builder.evidence({
+            sourceRef: pkg.manifest.path,
+            location: { type: "file", path: pkg.manifest.path, ...(line ? { line } : {}) },
+            method: "structured-parse"
+        });
+        const subject = builder.entity(pkg.id, "package", pkg.name ?? pkg.dir);
+        const base = manifest();
+        if (pkg.name)
+            builder.fact(subject, "package.name", pkg.name, base);
+        if (pkg.version)
+            builder.fact(subject, "package.version", pkg.version, base);
+        builder.fact(subject, "package.private", pkg.private, base);
+        builder.fact(subject, "package.directory", pkg.dir, base);
+        if (pkg.dir === ".")
+            builder.fact(subject, "package.manager", project.packageManager, base);
+        builder.fact(subject, "frameworks", pkg.frameworks, manifest(pkg.frameworks[0]?.line));
+        builder.fact(subject, "buildTools", pkg.buildTools, base);
+        builder.fact(subject, "entryPoints", pkg.entryPoints.map(({ subpath, condition, target, resolution, file, exportsComplete }) => ({
+            subpath,
+            condition,
+            target,
+            resolution,
+            ...(file ? { file } : {}),
+            exportsComplete
+        })), base);
+        for (const entry of pkg.entryPoints) {
+            for (const exported of entry.exports) {
+                const ref = `${pkg.id}#${entry.subpath}:${exported.name}`;
+                builder.entity(ref, "export", exported.name);
+                const evidence = builder.evidence({
+                    sourceRef: `${exported.file}#${exported.name}`,
+                    location: { type: "file", path: exported.file, line: exported.line },
+                    method: "ast"
+                });
+                const completeness = entry.exportsComplete ? "complete" : "partial";
+                builder.fact(ref, "export.name", exported.name, evidence, { completeness });
+                builder.fact(ref, "export.kind", exported.kind, evidence, { completeness });
+                builder.fact(ref, "export.typeOnly", exported.typeOnly, evidence, { completeness });
+                builder.fact(ref, "export.entry", entry.subpath, evidence, { completeness });
+                if (exported.reexportOf)
+                    builder.fact(ref, "export.reexportOf", exported.reexportOf, evidence, { completeness });
+            }
+        }
+        for (const d of diagnosticsAbout(project, [
+            pkg.manifest.path,
+            ...pkg.entryPoints.flatMap((e) => e.parsedFiles.map((f) => f.path))
+        ]))
+            builder.diagnostic(d);
+        const partial = pkg.entryPoints.some((e) => !e.exportsComplete);
+        return { ir: builder.build(partial ? "partial" : "complete") };
+    },
+    async validate() {
+        return [];
+    }
+};
+export const storybookConfigAdapter = {
+    id: "inventory-storybook",
+    version: "0.1.0",
+    type: "storybook",
+    async discover({ project }) {
+        const ids = new SourceIds("storybook");
+        return {
+            sources: project.storybooks.map((sb) => ({
+                id: ids.next(sb.directory === "." ? "root" : sb.directory),
+                type: "storybook",
+                location: sb.directory,
+                config: { storybookId: sb.id },
+                ...(sb.version?.installedVersion
+                    ? { version: { kind: "tool-version", value: sb.version.installedVersion } }
+                    : {}),
+                inputHash: hashJson({ config: sb.configHash, stories: sb.storyFiles })
+            })),
+            diagnostics: []
+        };
+    },
+    async extract({ project, source, clock }, config) {
+        const sb = project.storybooks.find((s) => s.id === config.storybookId);
+        if (!sb)
+            throw new Error(`Storybook ${config.storybookId} is not in the project discovery`);
+        const builder = new IrBuilder({
+            source: irSource(source, storybookConfigAdapter),
+            extractor: { name: "inventory-storybook", version: storybookConfigAdapter.version },
+            capabilities: ["config.*"],
+            clock
+        });
+        const subject = builder.entity(sb.id, "config", `Storybook (${sb.directory})`);
+        const evidence = builder.evidence({
+            sourceRef: sb.configPath,
+            location: { type: "file", path: sb.configPath },
+            method: "ast"
+        });
+        const complete = sb.dynamicProperties.length === 0 ? "complete" : "partial";
+        const put = (path, value, completeness = complete) => {
+            if (value !== undefined)
+                builder.fact(subject, path, value, evidence, { completeness });
+        };
+        put("config.path", sb.configPath);
+        put("config.framework", sb.framework);
+        put("config.addons", sb.addons);
+        put("config.stories", sb.stories);
+        put("config.staticDirs", sb.staticDirs);
+        put("config.dynamicProperties", sb.dynamicProperties);
+        put("config.version", sb.version);
+        put("config.builtOutput", sb.builtOutput);
+        put("config.storyFileCount", sb.storyFileCount);
+        put("config.storyFiles", sb.storyFiles, sb.storyFilesTruncated ? "partial" : "complete");
+        for (const d of diagnosticsAbout(project, [sb.configPath]))
+            builder.diagnostic(d);
+        return {
+            ir: builder.build(sb.dynamicProperties.length > 0 || sb.storyFilesTruncated ? "partial" : "complete")
+        };
+    },
+    async validate() {
+        return [];
+    }
+};
+export const tokenFilesAdapter = {
+    id: "inventory-tokens",
+    version: "0.1.0",
+    type: "tokens",
+    async discover({ project }) {
+        const ids = new SourceIds("tokens");
+        return {
+            sources: groupByPackage(project, project.tokenFiles).map(({ pkg, files }) => ({
+                id: ids.next(pkg?.name ?? pkg?.dir ?? "root"),
+                type: "tokens",
+                location: pkg?.dir ?? ".",
+                config: { packageId: pkg?.id ?? "", files: files.map((f) => f.path) },
+                inputHash: hashJson(files.map((f) => [f.path, f.contentHash]))
+            })),
+            diagnostics: []
+        };
+    },
+    async extract({ project, source, clock }, config) {
+        const builder = new IrBuilder({
+            source: irSource(source, tokenFilesAdapter),
+            extractor: { name: "inventory-tokens", version: tokenFilesAdapter.version },
+            capabilities: ["file.*", "name", "extensions.css.*"],
+            clock
+        });
+        let partial = false;
+        for (const file of project.tokenFiles.filter((f) => config.files.includes(f.path))) {
+            const fileRef = builder.entity(`token-file:${file.path}`, "token-file", file.path);
+            const fileEvidence = builder.evidence({
+                sourceRef: file.path,
+                location: { type: "file", path: file.path },
+                method: "structured-parse"
+            });
+            builder.fact(fileRef, "file.kind", file.kind, fileEvidence);
+            if (file.format)
+                builder.fact(fileRef, "file.format", file.format, fileEvidence);
+            if (file.tokenCount !== undefined)
+                builder.fact(fileRef, "file.tokenCount", file.tokenCount, fileEvidence);
+            if (file.cssVariablesTruncated)
+                partial = true;
+            for (const variable of file.cssVariables ?? []) {
+                const ref = `css:${file.path}#${variable.name}@${variable.scope}`;
+                builder.entity(ref, "token", variable.name);
+                const evidence = builder.evidence({
+                    sourceRef: `${file.path}#${variable.name}`,
+                    location: { type: "file", path: file.path, line: variable.line },
+                    method: "structured-parse",
+                    original: `${variable.name}: ${variable.value};`
+                });
+                builder.fact(ref, "name", variable.name, evidence);
+                builder.fact(ref, "extensions.css.scope", variable.scope, evidence);
+                builder.fact(ref, "extensions.css.rawValue", variable.value, evidence);
+                if (variable.aliasOf)
+                    builder.fact(ref, "extensions.css.aliasOf", variable.aliasOf, evidence);
+            }
+            for (const d of diagnosticsAbout(project, [file.path]))
+                builder.diagnostic(d);
+        }
+        return { ir: builder.build(partial ? "partial" : "complete") };
+    },
+    async validate() {
+        return [];
+    }
+};
+export const markdownDocsAdapter = {
+    id: "inventory-markdown",
+    version: "0.1.0",
+    type: "markdown",
+    async discover({ project }) {
+        const ids = new SourceIds("docs");
+        return {
+            sources: groupByPackage(project, project.docFiles).map(({ pkg, files }) => ({
+                id: ids.next(pkg?.name ?? pkg?.dir ?? "root"),
+                type: "markdown",
+                location: pkg?.dir ?? ".",
+                config: { packageId: pkg?.id ?? "", files: files.map((f) => f.path) },
+                inputHash: hashJson(files.map((f) => [f.path, f.contentHash]))
+            })),
+            diagnostics: []
+        };
+    },
+    async extract({ project, source, clock }, config) {
+        const builder = new IrBuilder({
+            source: irSource(source, markdownDocsAdapter),
+            extractor: { name: "inventory-markdown", version: markdownDocsAdapter.version },
+            capabilities: ["doc.*"],
+            clock
+        });
+        for (const file of project.docFiles.filter((f) => config.files.includes(f.path))) {
+            const ref = builder.entity(`doc:${file.path}`, "doc-page", file.title ?? file.path);
+            const evidence = builder.evidence({
+                sourceRef: file.path,
+                location: { type: "file", path: file.path, line: 1 },
+                method: "document-parse"
+            });
+            builder.fact(ref, "doc.kind", file.kind, evidence, { origin: "authored" });
+            if (file.title)
+                builder.fact(ref, "doc.title", file.title, evidence, { origin: "authored" });
+            builder.fact(ref, "doc.headings", file.headings, evidence, {
+                origin: "authored"
+            });
+            builder.fact(ref, "doc.lineCount", file.lineCount, evidence, { origin: "authored" });
+        }
+        return { ir: builder.build("complete") };
+    },
+    async validate() {
+        return [];
+    }
+};
+export const INVENTORY_ADAPTERS = [
+    npmPackageAdapter,
+    storybookConfigAdapter,
+    tokenFilesAdapter,
+    markdownDocsAdapter
+];
+function irSource(source, adapter) {
+    return {
+        id: source.id,
+        type: source.type,
+        location: source.location,
+        ...(source.version ? { version: source.version } : {}),
+        inputHash: source.inputHash,
+        adapter: { name: adapter.id, version: adapter.version }
+    };
+}
+function requirePackage(project, id) {
+    const pkg = project.packages.find((p) => p.id === id);
+    if (!pkg)
+        throw new Error(`Package ${id} is not in the project discovery`);
+    return pkg;
+}
+function diagnosticsAbout(project, paths) {
+    const set = new Set(paths);
+    return project.diagnostics.filter((d) => d.location !== undefined && set.has(d.location.path));
+}
+function groupByPackage(project, files) {
+    const groups = new Map();
+    for (const file of files)
+        groups.set(file.package ?? "", [...(groups.get(file.package ?? "") ?? []), file]);
+    return [...groups]
+        .map(([id, group]) => ({ pkg: project.packages.find((p) => p.id === id), files: group }))
+        .sort((a, b) => cmp(a.pkg?.dir ?? "", b.pkg?.dir ?? ""));
+}
+/** Slug generator that stays unique within one adapter run. */
+class SourceIds {
+    prefix;
+    used = new Set();
+    constructor(prefix) {
+        this.prefix = prefix;
+    }
+    next(label) {
+        const slug = label
+            .toLowerCase()
+            .replace(/[^a-z0-9._-]+/g, "-")
+            .replace(/^[^a-z0-9]+|[-.]+$/g, "") || "root";
+        let id = `${this.prefix}-${slug}`;
+        for (let n = 2; this.used.has(id); n++)
+            id = `${this.prefix}-${slug}-${n}`;
+        this.used.add(id);
+        return id;
+    }
+}
+//# sourceMappingURL=inventory.js.map

package/dist/compiler-core/compile.js

@@ -0,0 +1,148 @@
+import { canonicalizeIrDocument, computeIrContentHash, IR_VERSION, irDocumentSchema, verifyIrDocument } from "../compiler-ir/index.js";
+import { canonicalStringify, DIAGNOSTICS_FILE_VERSION, DiagnosticCollector, hasErrors, sortDiagnostics } from "../shared/index.js";
+import { INVENTORY_ADAPTERS } from "./adapters/inventory.js";
+import { discoverProject } from "./discovery/index.js";
+/**
+ * Orchestrates discover, extract and validate for every adapter, in a fixed order (adapter id, then
+ * source id). A failing adapter never aborts the run: it yields a `failed` IR document and an error
+ * diagnostic, because a missing source must not be read as proof that its facts do not exist.
+ * Stops at IR; reconciliation and contract generation belong to later phases.
+ */
+export async function compile(options) {
+    const clock = options.clock ?? (() => new Date().toISOString());
+    const signal = options.signal;
+    const collector = new DiagnosticCollector();
+    signal?.throwIfAborted();
+    const project = await discoverProject({ fs: options.fs, ...options.discovery });
+    collector.addAll(project.diagnostics);
+    const adapters = [...(options.adapters ?? INVENTORY_ADAPTERS)]
+        .filter((a) => !options.only || options.only.includes(a.id))
+        .sort((a, b) => (a.id < b.id ? -1 : a.id > b.id ? 1 : 0));
+    const planned = [];
+    const seen = new Set();
+    for (const adapter of adapters) {
+        signal?.throwIfAborted();
+        try {
+            const found = await adapter.discover({
+                fs: options.fs,
+                project,
+                ...(signal ? { signal } : {})
+            });
+            collector.addAll(found.diagnostics);
+            for (const source of [...found.sources].sort((a, b) => (a.id < b.id ? -1 : a.id > b.id ? 1 : 0))) {
+                if (seen.has(source.id)) {
+                    collector.error("compile.duplicate-source-id", `Source id ${source.id} from adapter ${adapter.id} is already in use; skipped`, { sourceId: source.id });
+                    continue;
+                }
+                seen.add(source.id);
+                planned.push({ adapter, source });
+            }
+        }
+        catch (error) {
+            collector.error("compile.adapter-failed", `Adapter ${adapter.id} failed during discovery: ${messageOf(error)}`);
+        }
+    }
+    const irDocuments = [];
+    const sources = [];
+    for (const { adapter, source } of planned) {
+        signal?.throwIfAborted();
+        const ir = await extractOne({ adapter, source, options, project, clock, collector });
+        irDocuments.push(ir);
+        sources.push({
+            id: source.id,
+            type: source.type,
+            adapterId: adapter.id,
+            adapterVersion: adapter.version,
+            inputHash: source.inputHash,
+            irContentHash: computeIrContentHash(ir),
+            completeness: ir.completeness
+        });
+    }
+    const diagnostics = dedupe(collector.toArray());
+    return { project, sources, irDocuments, diagnostics, ok: !hasErrors(diagnostics) };
+}
+/** Entries for the artifact generator: project discovery, one IR file per source, and diagnostics. */
+export function toArtifactEntries(result) {
+    return [
+        { path: "invariant.project.json", value: result.project },
+        ...result.irDocuments.map((ir) => ({
+            path: `ir/${ir.source.id}.ir.json`,
+            value: ir
+        })),
+        {
+            path: "invariant.diagnostics.json",
+            value: {
+                diagnosticsVersion: DIAGNOSTICS_FILE_VERSION,
+                diagnostics: result.diagnostics
+            }
+        }
+    ];
+}
+async function extractOne(input) {
+    const { adapter, source, options, project, clock, collector } = input;
+    const failed = (message) => failedDocument({ adapter, source, clock, message });
+    let ir;
+    try {
+        const result = await adapter.extract({ fs: options.fs, project, source, clock, ...(options.signal ? { signal: options.signal } : {}) }, source.config);
+        const parsed = irDocumentSchema.safeParse(result.ir);
+        if (!parsed.success) {
+            collector.error("compile.invalid-ir", `Adapter ${adapter.id} produced an invalid IR document for ${source.id}: ${parsed.error.issues[0]?.message ?? "schema error"}`, { sourceId: source.id });
+            return failed("invalid IR");
+        }
+        ir = canonicalizeIrDocument(parsed.data);
+    }
+    catch (error) {
+        if (options.signal?.aborted)
+            throw error;
+        collector.error("compile.adapter-failed", `Adapter ${adapter.id} failed extracting ${source.id}: ${messageOf(error)}`, { sourceId: source.id });
+        return failed(messageOf(error));
+    }
+    collector.addAll(verifyIrDocument(ir));
+    collector.addAll(ir.diagnostics);
+    try {
+        collector.addAll(await adapter.validate({ project, source, ir }));
+    }
+    catch (error) {
+        collector.error("compile.adapter-failed", `Adapter ${adapter.id} failed validating ${source.id}: ${messageOf(error)}`, { sourceId: source.id });
+    }
+    return ir;
+}
+function failedDocument(input) {
+    const { adapter, source, message } = input;
+    return {
+        irVersion: IR_VERSION,
+        source: {
+            id: source.id,
+            type: source.type,
+            location: source.location,
+            ...(source.version ? { version: source.version } : {}),
+            inputHash: source.inputHash,
+            adapter: { name: adapter.id, version: adapter.version }
+        },
+        capabilities: [],
+        completeness: "failed",
+        entities: [],
+        facts: [],
+        evidence: [],
+        diagnostics: [{ code: "compile.adapter-failed", severity: "error", message, sourceId: source.id }]
+    };
+}
+/**
+ * Drops duplicate diagnostics. The same finding is often reported once by discovery and again, with a
+ * `sourceId`, when an adapter forwards it into its IR; those are merged, keeping the attributed copy.
+ */
+function dedupe(diagnostics) {
+    const byKey = new Map();
+    for (const d of diagnostics) {
+        const { sourceId: _sourceId, ...rest } = d;
+        const key = canonicalStringify(rest);
+        const existing = byKey.get(key);
+        if (!existing || (existing.sourceId === undefined && d.sourceId !== undefined))
+            byKey.set(key, d);
+    }
+    return sortDiagnostics([...byKey.values()]);
+}
+function messageOf(error) {
+    return error instanceof Error ? error.message : String(error);
+}
+//# sourceMappingURL=compile.js.map

package/dist/compiler-core/component-facts.js

@@ -0,0 +1,123 @@
+const FACT_SEGMENT = /^[A-Za-z0-9_:-]+$/;
+/**
+ * Writes a component's facts with the neutral paths every framework adapter shares, so React, Angular
+ * and Vue describe equivalent concepts identically and keep framework detail under
+ * `extensions.<framework>`. Names that cannot be addressed by a fact path are reported through `skipped`.
+ */
+export class ComponentFacts {
+    skipped = [];
+    builder;
+    ref;
+    framework;
+    constructor(builder, ref, framework) {
+        this.builder = builder;
+        this.ref = ref;
+        this.framework = framework;
+    }
+    put(path, value, evidence, origin = "extracted") {
+        this.builder.fact(this.ref, path, value, evidence, { origin });
+    }
+    /** `implementations.<fw>.extensions.<fw>.<path>` */
+    ext(path, value, evidence) {
+        this.put(`implementations.${this.framework}.extensions.${this.framework}.${path}`, value, evidence);
+    }
+    /** The neutral link key: sources are matched on (file, localName), never on display names. */
+    link(file, localName, evidence) {
+        this.put(`implementations.${this.framework}.framework`, this.framework, evidence);
+        this.ext("file", file, evidence);
+        this.ext("localName", localName, evidence);
+    }
+    prop(spec, evidence, extra = {}) {
+        if (!this.addressable(spec.name, "prop"))
+            return;
+        const base = `props.${spec.name}`;
+        this.put(`${base}.type.text`, spec.typeText, evidence);
+        this.put(`${base}.type.kind`, spec.kind, evidence);
+        this.put(`${base}.required`, spec.required, evidence);
+        if (spec.default !== undefined)
+            this.put(`${base}.default`, spec.default, [evidence, ...(extra.default ?? [])]);
+        if (spec.defaultExpression !== undefined)
+            this.put(`${base}.extensions.${this.framework}.defaultExpression`, spec.defaultExpression, extra.default?.[0] ?? evidence);
+        if (spec.allowedValues)
+            this.put(`${base}.allowedValues`, spec.allowedValues, evidence);
+        if (spec.description)
+            this.put(`${base}.description`, spec.description, evidence, "authored");
+        if (spec.deprecated)
+            this.put(`${base}.deprecated`, spec.deprecated, evidence, "authored");
+        for (const [key, value] of Object.entries(spec.extensions ?? {}))
+            this.put(`${base}.extensions.${this.framework}.${key}`, value, evidence);
+    }
+    event(spec, evidence) {
+        if (!this.addressable(spec.name, "event"))
+            return;
+        const base = `events.${spec.name}`;
+        this.put(`${base}.declared`, true, evidence);
+        if (spec.payloadText)
+            this.put(`${base}.payload.text`, spec.payloadText, evidence);
+        if (spec.description)
+            this.put(`${base}.description`, spec.description, evidence, "authored");
+        if (spec.deprecated)
+            this.put(`${base}.deprecated`, spec.deprecated, evidence, "authored");
+        for (const [key, value] of Object.entries(spec.extensions ?? {}))
+            this.put(`${base}.extensions.${this.framework}.${key}`, value, evidence);
+    }
+    slot(spec, evidence) {
+        if (!this.addressable(spec.name, "slot"))
+            return;
+        const base = `slots.${spec.name}`;
+        this.put(`${base}.declared`, true, evidence);
+        if (spec.required !== undefined)
+            this.put(`${base}.required`, spec.required, evidence);
+        if (spec.description)
+            this.put(`${base}.description`, spec.description, evidence, "authored");
+        for (const [key, value] of Object.entries(spec.extensions ?? {}))
+            this.put(`${base}.extensions.${this.framework}.${key}`, value, evidence);
+    }
+    variant(spec, evidence) {
+        if (!this.addressable(spec.name, "variant"))
+            return;
+        const base = `variants.${spec.name}`;
+        this.put(`${base}.values`, spec.values, evidence);
+        if (spec.default !== undefined)
+            this.put(`${base}.default`, spec.default, evidence);
+        for (const [key, value] of Object.entries(spec.extensions ?? {}))
+            this.put(`${base}.extensions.${this.framework}.${key}`, value, evidence);
+    }
+    accessibility(info, evidence) {
+        if (info.role)
+            this.put("accessibility.role", info.role, evidence);
+        if (info.attributes.length > 0)
+            this.put("accessibility.attributes", info.attributes, evidence);
+    }
+    addressable(name, what) {
+        if (FACT_SEGMENT.test(name))
+            return true;
+        this.skipped.push(`${what} "${name}"`);
+        return false;
+    }
+}
+/** Variants from props typed as a union of two or more string literals (the same rule in every framework). */
+export function variantsFromProps(props) {
+    const out = [];
+    for (const p of props) {
+        const values = p.allowedValues;
+        if (p.kind !== "enum" || !values || values.length < 2 || !values.every((v) => typeof v === "string"))
+            continue;
+        const fallback = typeof p.default === "string" && values.includes(p.default) ? p.default : undefined;
+        out.push({ name: p.name, values: values, ...(fallback ? { default: fallback } : {}) });
+    }
+    return out.sort((a, b) => (a.name < b.name ? -1 : a.name > b.name ? 1 : 0));
+}
+/** `var(--x)` references in CSS or source text, with the first line each appears on. */
+export function cssVariableReferences(text) {
+    const seen = new Map();
+    text.split("\n").forEach((line, index) => {
+        for (const match of line.matchAll(/var\(\s*(--[\w-]+)/g))
+            if (!seen.has(match[1]))
+                seen.set(match[1], index + 1);
+    });
+    return [...seen]
+        .map(([name, line]) => ({ name, line }))
+        .sort((a, b) => (a.name < b.name ? -1 : a.name > b.name ? 1 : 0));
+}
+//# sourceMappingURL=component-facts.js.map

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

@@ -0,0 +1,66 @@
+import { cmp, hashText, posix, readBounded } from "./support.js";
+/** Markdown and MDX files outside ignored directories, with title and heading outline. */
+export async function discoverDocFiles(env) {
+    const out = [];
+    for (const file of env.files) {
+        if (!/\.(?:md|mdx)$/i.test(file))
+            continue;
+        const text = await readBounded(env, file);
+        if (text === undefined)
+            continue;
+        const { headings, title } = outline(text, env.limits.maxHeadings);
+        out.push({
+            path: file,
+            kind: kindOf(file),
+            ...(title ? { title } : {}),
+            headings,
+            lineCount: text.length === 0 ? 0 : text.split("\n").length,
+            contentHash: hashText(text)
+        });
+    }
+    return out.sort((a, b) => cmp(a.path, b.path));
+}
+function kindOf(file) {
+    const base = posix.basename(file);
+    if (/^readme(\.|$)/i.test(base))
+        return "readme";
+    if (/^changelog(\.|$)/i.test(base))
+        return "changelog";
+    return /\.mdx$/i.test(base) ? "mdx" : "markdown";
+}
+function outline(text, maxHeadings) {
+    const lines = text.split("\n");
+    let start = 0;
+    let frontmatterTitle;
+    if (lines[0]?.trim() === "---") {
+        const end = lines.findIndex((l, i) => i > 0 && l.trim() === "---");
+        if (end > 0) {
+            for (const line of lines.slice(1, end)) {
+                const match = /^title\s*:\s*(.+?)\s*$/.exec(line);
+                if (match)
+                    frontmatterTitle = match[1].replace(/^["']|["']$/g, "");
+            }
+            start = end + 1;
+        }
+    }
+    const headings = [];
+    let fence;
+    for (let i = start; i < lines.length && headings.length < maxHeadings; i++) {
+        const line = lines[i];
+        const fenceMatch = /^\s*(```+|~~~+)/.exec(line);
+        if (fenceMatch) {
+            const marker = fenceMatch[1].slice(0, 3);
+            fence = fence === undefined ? marker : fence === marker ? undefined : fence;
+            continue;
+        }
+        if (fence !== undefined)
+            continue;
+        const heading = /^(#{1,6})\s+(.+?)\s*#*\s*$/.exec(line);
+        if (heading)
+            headings.push({ level: heading[1].length, text: heading[2], line: i + 1 });
+    }
+    const firstH1 = headings.find((h) => h.level === 1)?.text;
+    const title = frontmatterTitle ?? firstH1;
+    return { headings, ...(title ? { title } : {}) };
+}
+//# sourceMappingURL=docs.js.map