@component-compass/cli 0.1.22 → 0.1.24

package/dist/manifest/lazy-resolver.js

@@ -1,712 +0,0 @@
-import { existsSync, readFileSync, statSync } from "node:fs";
-import { createRequire } from "node:module";
-import { dirname, extname, isAbsolute, join, relative, resolve as pathResolve } from "node:path";
-import picomatch from "picomatch";
-import { parse as babelParse } from "@babel/parser";
-import { posixPath } from "@component-compass/plugin-core";
-import { validateManifest, createDiagnosticCollector, } from "@component-compass/plugin-core";
-import { parseBarrelTopLevel, parseBarrelTopLevelFromAst, } from "./barrel-parser.js";
-/**
- * Hard ceiling on re-export hops a single resolution may walk. Real chains
- * top out around 10 hops (deep barrel piles); 32 is a pathological-input
- * safety net. When this fires we emit a `chain-too-deep` diagnostic and
- * treat the current file as terminal so the user sees a signal rather than
- * a silent wrong-leaf attribution.
- */
-const MAX_REEXPORT_HOPS = 32;
-export function createLazyResolver(opts) {
-    const { resolveImport } = opts;
-    const repoRoot = opts.repoRoot;
-    // Repo-root-relative POSIX path for output stability (so manifestRef.path
-    // and diagnostic.resolvedFile hash/diff identically across machines).
-    // Falls back to the absolute path when no repoRoot was provided (unit
-    // tests).
-    const toRelPath = (abs) => repoRoot && isAbsolute(abs) ? posixPath(relative(repoRoot, abs)) : abs;
-    // `manifestPatterns` is the per-package gate for manifest IO (CEM/CCM loads,
-    // byTag indexing, snapshot views). Undefined or empty array disables manifest
-    // enrichment entirely; identity resolution (`leafPackage` + `modulePath`)
-    // runs independently. Use `['**']` to opt every package into enrichment —
-    // `'*'` won't match scoped names like `@scope/pkg` since picomatch's `*`
-    // doesn't cross `/`.
-    const manifestPatterns = opts.manifestPatterns ?? [];
-    const manifestMatchers = manifestPatterns.map((p) => picomatch(p));
-    const isManifestEligible = (pkgName) => manifestMatchers.length > 0 && manifestMatchers.some((m) => m(pkgName));
-    // (absoluteFilePath::exportName) → cached hit (or null for negative cache).
-    const hitCache = new Map();
-    // tagName → custom-element entry (populated as authored manifests load).
-    const byTag = new Map();
-    // Leaf packages whose authored manifest has been loaded. `snapshotEligible`
-    // scopes participation in `snapshotComponents()` / `snapshotManifestRefs()`
-    // — warm-path and Vue-lane visits are eligible, lookup-only
-    // engine-adapter visits are not. Sticky: once true, never flips back.
-    const visitedLeafs = new Map();
-    const collector = opts.collector ?? createDiagnosticCollector();
-    // Parsed barrel AST per absolute path. Deep re-export chains (wrapper-style
-    // design-system monorepos: `webc` → `web-button` → leaf) revisit the same barrel
-    // many times across one scan; caching the parsed AST collapses the cost to
-    // one parse per file regardless of fan-in.
-    const barrelAstCache = new Map();
-    const barrelParseCounts = new Map();
-    function parsedBarrel(absPath, source) {
-        const hit = barrelAstCache.get(absPath);
-        if (hit)
-            return hit;
-        const ext = extname(absPath).toLowerCase();
-        const plugins = ["typescript", "decorators-legacy", "classProperties"];
-        if (ext !== ".ts")
-            plugins.push("jsx");
-        const ast = babelParse(source, { sourceType: "module", plugins, errorRecovery: true });
-        barrelAstCache.set(absPath, ast);
-        barrelParseCounts.set(absPath, (barrelParseCounts.get(absPath) ?? 0) + 1);
-        return ast;
-    }
-    function loadLeafManifest(leafPackage, leafDir, opts) {
-        const { snapshotEligible } = opts;
-        const cached = visitedLeafs.get(leafPackage);
-        if (cached) {
-            // Sticky upgrade: a snapshot-eligible revisit (warm/Vue) flips an
-            // ineligible entry (prior engine lookup) to eligible; never the
-            // reverse.
-            cached.snapshotEligible = cached.snapshotEligible || snapshotEligible;
-            return cached.components;
-        }
-        const cemPath = join(leafDir, "custom-elements.json");
-        const ccmPath = join(leafDir, "component-compass-manifest.json");
-        let components = [];
-        let manifestPath = null;
-        let manifestSource = null;
-        let pkgVersion;
-        try {
-            const raw = readFileSync(join(leafDir, "package.json"), "utf8");
-            const pkg = JSON.parse(raw);
-            pkgVersion = pkg.version;
-        }
-        catch {
-            // Best-effort; leave undefined.
-        }
-        if (existsSync(cemPath)) {
-            try {
-                const raw = readFileSync(cemPath, "utf8");
-                const cem = JSON.parse(raw);
-                components = absorbCemDeclarations(cem, leafPackage);
-                manifestPath = cemPath;
-                manifestSource = "cem";
-            }
-            catch {
-                // Treat malformed CEM as no manifest.
-            }
-        }
-        else if (existsSync(ccmPath)) {
-            try {
-                const raw = readFileSync(ccmPath, "utf8");
-                const parsed = JSON.parse(raw);
-                const v = validateManifest(parsed);
-                if (v.ok) {
-                    components = absorbCcmComponents(v.data, leafPackage);
-                    manifestPath = ccmPath;
-                    manifestSource = v.data.source;
-                }
-            }
-            catch {
-                // Treat malformed CCM as no manifest.
-            }
-        }
-        if (!manifestPath || !manifestSource) {
-            visitedLeafs.set(leafPackage, {
-                components: [],
-                manifestRef: { source: "cem", packageName: leafPackage, path: "", version: pkgVersion ?? null },
-                snapshotEligible,
-            });
-            return [];
-        }
-        // Index custom elements by tagName.
-        for (const c of components) {
-            if (c.kind === "custom-element")
-                byTag.set(c.tagName, c);
-        }
-        visitedLeafs.set(leafPackage, {
-            components,
-            manifestRef: {
-                source: manifestSource,
-                packageName: leafPackage,
-                path: toRelPath(manifestPath),
-                version: pkgVersion ?? null,
-            },
-            snapshotEligible,
-        });
-        return components;
-    }
-    function findPackageRoot(absFile) {
-        let dir = dirname(absFile);
-        while (dir !== dirname(dir)) {
-            const pkgJson = join(dir, "package.json");
-            if (existsSync(pkgJson)) {
-                try {
-                    const pkg = JSON.parse(readFileSync(pkgJson, "utf8"));
-                    if (pkg.name)
-                        return { name: pkg.name, dir };
-                }
-                catch {
-                    // Continue walking if unreadable.
-                }
-            }
-            dir = dirname(dir);
-        }
-        return null;
-    }
-    function matchInLeaf(components, exportName) {
-        // First pass: react/vue components match on their declared export name.
-        for (const c of components) {
-            if (c.kind === "react-component" || c.kind === "vue-component") {
-                if (c.export === exportName)
-                    return c;
-            }
-        }
-        // Second pass: className-equality match for custom-elements. Scoped to
-        // THIS leaf only — never iterates a global byTag map, which cannot tell
-        // which leaf a name belongs to. Safe because the resolver has already traversed the chain
-        // to a specific leaf package; if that leaf's CEM declares a custom-element
-        // class with exactly this name, the consumer's import is the React wrapper
-        // for it.
-        for (const c of components) {
-            if (c.kind === "custom-element" && c.className === exportName)
-                return c;
-        }
-        return null;
-    }
-    // Shared walk/cache/return for `resolveLazyManifest` and
-    // `lookupExternalLeaf`. `snapshotEligible` is the only difference
-    // between the two public entry points: it decides whether the leaf
-    // manifest this call loads (or upgrades, on a cache hit below) counts
-    // toward `snapshotComponents()` / `snapshotManifestRefs()`.
-    function resolveLeaf(fromFile, specifier, exportName, options) {
-        const initialAbs = resolveImport(fromFile, specifier);
-        if (!initialAbs)
-            return null;
-        // Workspace identity rule: workspace packages that carry a `name` field in
-        // their package.json get external-style identity (packageName + exportName
-        // keys), making them cross-repo joinable just like node_modules deps.
-        // findPackageRoot skips package.json files without a `name` field, so
-        // any package it returns is guaranteed to carry an identity key.
-        //
-        // When the resolved target lands inside a named workspace package, fall
-        // through to the normal resolution path — the lazy resolver will walk the
-        // re-export chain and emit { leafPackage, modulePath } exactly as it does
-        // for node_modules packages.
-        // Resolved file lives in the same package as the importer (e.g.
-        // `../components/Foo.vue` from a sibling file in the consumer repo).
-        // The lazy resolver's contract is "external packages are opaque tuples";
-        // local files belong to the local-detection pipeline. Return null so the
-        // engine's import-resolution / localIndex path handles it. Different
-        // package names — whether resolved through node_modules or through a
-        // yarn workspace symlink — are external and continue normal resolution.
-        const fromPkg = findPackageRoot(fromFile);
-        const initialPkg = findPackageRoot(initialAbs);
-        if (fromPkg && initialPkg && fromPkg.name === initialPkg.name) {
-            return null;
-        }
-        // Entry-package provenance: the resolved specifier target sits inside
-        // the ENTRY package's
-        // installed copy — its package root is the wrapper identity + the dir
-        // whose package.json carries the installed version. Only meaningful when
-        // onEntryPackage is set (see the record call below); reuses `initialPkg`
-        // computed above rather than re-walking the same directory chain.
-        const entryRoot = opts.onEntryPackage ? initialPkg : null;
-        const cacheKey = `${initialAbs}::${exportName}`;
-        if (hitCache.has(cacheKey)) {
-            const cachedHit = hitCache.get(cacheKey) ?? null;
-            // Cache-hit upgrade: a snapshot-eligible caller (warm/Vue) landing on a
-            // hit previously resolved only by a lookup-only caller (engine leaf
-            // lookup) must retroactively flip the leaf eligible — otherwise call
-            // order decides whether the Vue lane's snapshot output changes vs main.
-            // The reverse order needs no handling: the flag is already true and
-            // sticky (never downgraded).
-            if (options.snapshotEligible && cachedHit) {
-                const leafEntry = visitedLeafs.get(cachedHit.leafPackage);
-                if (leafEntry)
-                    leafEntry.snapshotEligible = true;
-            }
-            return cachedHit;
-        }
-        const visited = new Set();
-        let currentAbs = initialAbs;
-        let currentExport = exportName;
-        // Walk the re-export chain. If we advance MAX_REEXPORT_HOPS times without
-        // the chain naturally terminating (i.e. the next file would also be a
-        // barrel carrying our export), surface `chain-too-deep` and treat the
-        // current file as terminal so a wrong-leaf attribution is never silent.
-        let hops = 0;
-        while (true) {
-            const visitKey = `${currentAbs}::${currentExport}`;
-            if (visited.has(visitKey)) {
-                const cyclePkg = findPackageRoot(currentAbs)?.name;
-                collector.emit({
-                    code: "cycle-detected",
-                    severity: "warning",
-                    filePath: toRelPath(currentAbs),
-                    exportName: currentExport,
-                    ...(cyclePkg !== undefined ? { packageName: cyclePkg } : {}),
-                });
-                hitCache.set(cacheKey, null);
-                return null;
-            }
-            visited.add(visitKey);
-            const source = safeReadFile(currentAbs);
-            if (source === null)
-                break;
-            let reExports;
-            try {
-                const ast = parsedBarrel(currentAbs, source);
-                reExports = parseBarrelTopLevelFromAst(ast);
-            }
-            catch {
-                // parseByExt throws on unrecoverable syntax — fall back to the
-                // source-level parse, which swallows parse errors and returns an
-                // empty array so the chain terminates gracefully on garbage files.
-                reExports = parseBarrelTopLevel(source);
-            }
-            // unsupported barrel forms (try/switch-wrapped, dynamic re-exports etc.)
-            // are silently treated as terminal — the resolver returns identity from
-            // the current file and the parser falls back to opaque emission.
-            if (reExports.length === 0)
-                break; // terminal
-            // Find the re-export that carries `currentExport`.
-            const next = pickReExportFor(reExports, currentExport);
-            if (!next)
-                break; // terminal — none of the re-exports carry this export
-            const nextAbs = resolveImport(currentAbs, next.from);
-            if (!nextAbs)
-                break; // unresolvable next hop → treat current as terminal
-            // We're about to advance. If we've already consumed our budget, bail
-            // out with a diagnostic instead. `currentAbs` stays on the last barrel
-            // we successfully read so package-root walk continues from there.
-            if (hops >= MAX_REEXPORT_HOPS) {
-                const deepPkg = findPackageRoot(currentAbs)?.name;
-                collector.emit({
-                    code: "chain-too-deep",
-                    severity: "warning",
-                    filePath: toRelPath(currentAbs),
-                    exportName: currentExport,
-                    depth: MAX_REEXPORT_HOPS,
-                    ...(deepPkg !== undefined ? { packageName: deepPkg } : {}),
-                });
-                break;
-            }
-            currentAbs = nextAbs;
-            currentExport = next.targetExport;
-            hops++;
-        }
-        // Walk up to the package root of currentAbs.
-        const pkg = findPackageRoot(currentAbs);
-        if (!pkg) {
-            hitCache.set(cacheKey, null);
-            return null;
-        }
-        const modulePath = posixPath(relative(pkg.dir, currentAbs));
-        // Fire onEntryPackage only when the walk actually crossed a
-        // package boundary (entry package name !== terminal leaf package name).
-        // Direct imports into the leaf (entryRoot.name === pkg.name) never record.
-        const recordEntry = () => {
-            if (!opts.onEntryPackage || !entryRoot || entryRoot.name === pkg.name)
-                return;
-            const target = exportName === ""
-                ? { kind: "leaf-package", leafPackage: pkg.name }
-                : { kind: "identity", leafPackage: pkg.name, modulePath, exportName: currentExport };
-            opts.onEntryPackage({ name: entryRoot.name, dir: entryRoot.dir }, target);
-        };
-        // Per-package manifest gate. Identity is now computed; if the package
-        // is excluded by manifestPatterns (or no patterns set), short-circuit to
-        // identity-only emission. Caller gets {leafPackage, modulePath, matched:
-        // null}; parser falls back to opaque opportunistic emission with manifest: null.
-        if (!isManifestEligible(pkg.name)) {
-            const identityOnlyHit = {
-                leafPackage: pkg.name,
-                modulePath,
-                exportName: currentExport,
-                matched: null,
-            };
-            recordEntry();
-            hitCache.set(cacheKey, identityOnlyHit);
-            return identityOnlyHit;
-        }
-        const components = loadLeafManifest(pkg.name, pkg.dir, {
-            snapshotEligible: options.snapshotEligible,
-        });
-        const matched = matchInLeaf(components, currentExport);
-        const hit = { leafPackage: pkg.name, modulePath, exportName: currentExport, matched };
-        recordEntry();
-        hitCache.set(cacheKey, hit);
-        return hit;
-    }
-    function resolveLazyManifest(fromFile, specifier, exportName) {
-        return resolveLeaf(fromFile, specifier, exportName, { snapshotEligible: true });
-    }
-    // Engine-adapter entry point: identical walk/cache/return to
-    // `resolveLazyManifest`, but snapshot-INELIGIBLE — see `resolveLeaf`.
-    //
-    // ORDERING DEPENDENCY: leaf loads triggered here still index tags into the
-    // shared `byTag` map. That never leaks into tag-lane output only because
-    // every plugin.parse() (the sole lookupByTag consumer) completes before the
-    // engine resolve phase that calls this. If parse and resolve ever
-    // interleave (e.g. a per-file single-pass refactor), byTag population must
-    // be scoped to snapshot-eligible visits too — nothing needs it unscoped
-    // (lookupReactWrapper reads visitedLeafs.components, not byTag).
-    function lookupExternalLeaf(fromFile, specifier, exportName) {
-        return resolveLeaf(fromFile, specifier, exportName, { snapshotEligible: false });
-    }
-    function resolveLocalExport(filePath, exportName) {
-        // Accept either repo-relative or absolute input; normalise to absolute for
-        // the walk. Output is always repo-relative POSIX so the caller's
-        // `localIndex.byPath` lookup matches the same key form local-index uses.
-        const entryAbs = isAbsolute(filePath)
-            ? filePath
-            : (repoRoot ? pathResolve(repoRoot, filePath) : filePath);
-        const entryPkg = findPackageRoot(entryAbs);
-        const visited = new Set();
-        let currentAbs = entryAbs;
-        let currentExport = exportName;
-        let hops = 0;
-        while (true) {
-            const visitKey = `${currentAbs}::${currentExport}`;
-            if (visited.has(visitKey)) {
-                const cyclePkg = findPackageRoot(currentAbs)?.name;
-                collector.emit({
-                    code: "cycle-detected",
-                    severity: "warning",
-                    filePath: toRelPath(currentAbs),
-                    exportName: currentExport,
-                    ...(cyclePkg !== undefined ? { packageName: cyclePkg } : {}),
-                });
-                return null;
-            }
-            visited.add(visitKey);
-            const source = safeReadFile(currentAbs);
-            if (source === null)
-                return null;
-            let reExports;
-            try {
-                const ast = parsedBarrel(currentAbs, source);
-                reExports = parseBarrelTopLevelFromAst(ast);
-            }
-            catch {
-                reExports = parseBarrelTopLevel(source);
-            }
-            if (reExports.length === 0) {
-                return { filePath: toRelPath(currentAbs), exportName: currentExport };
-            }
-            const next = pickReExportFor(reExports, currentExport);
-            if (!next) {
-                return { filePath: toRelPath(currentAbs), exportName: currentExport };
-            }
-            const nextAbs = resolveImport(currentAbs, next.from);
-            if (!nextAbs)
-                return null;
-            const nextPkg = findPackageRoot(nextAbs);
-            if (entryPkg && nextPkg && entryPkg.name !== nextPkg.name) {
-                return null;
-            }
-            if (hops >= MAX_REEXPORT_HOPS) {
-                const deepPkg = findPackageRoot(currentAbs)?.name;
-                collector.emit({
-                    code: "chain-too-deep",
-                    severity: "warning",
-                    filePath: toRelPath(currentAbs),
-                    exportName: currentExport,
-                    depth: MAX_REEXPORT_HOPS,
-                    ...(deepPkg !== undefined ? { packageName: deepPkg } : {}),
-                });
-                return null;
-            }
-            currentAbs = nextAbs;
-            currentExport = next.targetExport;
-            hops++;
-        }
-    }
-    function lookupByTag(tagName) {
-        return byTag.get(tagName) ?? null;
-    }
-    function lookupReactWrapper(packageName, exportName) {
-        if (!isManifestEligible(packageName))
-            return null;
-        const cached = visitedLeafs.get(packageName);
-        if (!cached)
-            return null;
-        for (const c of cached.components) {
-            if (c.kind === "custom-element" && c.className === exportName) {
-                return { tagName: c.tagName, packageName };
-            }
-        }
-        return null;
-    }
-    function snapshotComponents() {
-        const out = [];
-        for (const v of visitedLeafs.values()) {
-            if (!v.snapshotEligible)
-                continue;
-            out.push(...v.components);
-        }
-        return out;
-    }
-    function snapshotManifestRefs() {
-        const out = [];
-        for (const v of visitedLeafs.values()) {
-            if (!v.snapshotEligible)
-                continue;
-            if (v.manifestRef.path)
-                out.push(v.manifestRef);
-        }
-        return out;
-    }
-    function eagerLoadRoots(packageNames) {
-        // Anchor at <repoRoot>/_ so Node's resolution walks up through
-        // <repoRoot>/node_modules and parents, mirroring resolve-import.ts.
-        const anchor = pathResolve(opts.repoRoot ?? process.cwd(), "_");
-        const requireFromRepo = createRequire(anchor);
-        for (const name of packageNames) {
-            if (visitedLeafs.has(name))
-                continue;
-            // Honour the per-package manifest gate. Packages excluded by
-            // manifestPatterns don't get their CEM eagerly loaded — keeps the
-            // byTag map empty for them so HTML/Vue-template tag lookups also
-            // return null.
-            if (!isManifestEligible(name))
-                continue;
-            try {
-                const pkgJsonPath = requireFromRepo.resolve(`${name}/package.json`);
-                loadLeafManifest(name, dirname(pkgJsonPath), { snapshotEligible: true });
-            }
-            catch {
-                // Package not installed or its package.json not exposed via exports —
-                // skip silently. Warm-up is best-effort; missing entries are fine.
-            }
-        }
-    }
-    // The factory returns a LazyResolver. `lookupByTag` is captured in a closure
-    // and only attached when the caller goes through `.warm(...)` to obtain a
-    // WarmedResolver. Calling `.warm([])` on an identity-only resolver returns a
-    // structurally-valid WarmedResolver whose `lookupByTag` always returns null
-    // (the byTag map stays empty when no manifestPatterns match).
-    const base = {
-        resolveLazyManifest,
-        lookupExternalLeaf,
-        resolveLocalExport,
-        snapshotComponents,
-        snapshotManifestRefs,
-        diagnostics: () => collector.drain(),
-        warm(packageNames) {
-            eagerLoadRoots(packageNames);
-            return {
-                ...base,
-                lookupByTag,
-                lookupReactWrapper,
-            };
-        },
-        _barrelParseCount(absPath) {
-            return barrelParseCounts.get(absPath) ?? 0;
-        },
-    };
-    return base;
-}
-// ---------------------------------------------------------------------------
-// Helpers
-// ---------------------------------------------------------------------------
-function safeReadFile(path) {
-    try {
-        if (!statSync(path).isFile())
-            return null;
-        return readFileSync(path, "utf8");
-    }
-    catch {
-        return null;
-    }
-}
-function pickReExportFor(reExports, exportName) {
-    // Named re-export carrying our export wins over star re-exports.
-    for (const re of reExports) {
-        if (re.kind === "named") {
-            const found = re.names.find((n) => n.exported === exportName);
-            if (found)
-                return { from: re.from, targetExport: found.local };
-        }
-    }
-    // Star re-export: any star may carry the export; resolver tries the first
-    // and its terminal will tell us whether the leaf has it. v1 picks the first
-    // star — multi-star ambiguity in the same file is rare and a `barrel-
-    // unsupported-form` diagnostic could be added in a patch if real cases
-    // surface.
-    for (const re of reExports) {
-        if (re.kind === "star")
-            return { from: re.from, targetExport: exportName };
-    }
-    return null;
-}
-function absorbCemDeclarations(cem, packageName) {
-    const out = [];
-    for (const mod of cem.modules ?? []) {
-        for (const decl of mod.declarations ?? []) {
-            const d = decl;
-            if (!d.customElement || !d.tagName || !d.name)
-                continue;
-            const props = buildPropsFromCem(d);
-            const events = buildEventsFromCem(d);
-            const slots = buildSlotsFromCem(d);
-            const componentLifecycle = buildLifecycleFromDeprecated(d.deprecated);
-            const entry = {
-                kind: "custom-element",
-                tagName: d.tagName,
-                source: { type: "external", package: packageName },
-                props,
-                events,
-                slots,
-                className: d.name,
-            };
-            if (d.description !== undefined)
-                entry.description = d.description;
-            if (componentLifecycle !== undefined)
-                entry.lifecycle = componentLifecycle;
-            out.push(entry);
-        }
-    }
-    return out;
-}
-function buildPropsFromCem(decl) {
-    const props = [];
-    const seen = new Set();
-    // Pass 1: `attributes[]` are the canonical source for prop names + values.
-    for (const attr of decl.attributes ?? []) {
-        if (!attr.name || seen.has(attr.name))
-            continue;
-        seen.add(attr.name);
-        props.push(buildPropFromCemField(attr));
-    }
-    // Pass 2: `members[]` of `kind: "field"` fall through for any field that
-    // doesn't have an attribute counterpart (DOM-only properties). Mirror the
-    // privacy gate from before — private fields stay out.
-    for (const member of decl.members ?? []) {
-        if (member.kind !== "field" || member.privacy === "private")
-            continue;
-        if (!member.name || seen.has(member.name))
-            continue;
-        seen.add(member.name);
-        props.push(buildPropFromCemField(member));
-    }
-    return props;
-}
-function buildPropFromCemField(field) {
-    // `field.name` is asserted by the caller (gating happens in the loops above).
-    const prop = { name: field.name };
-    if (field.type?.text !== undefined)
-        prop.type = field.type.text;
-    // CEM declares `default` as the source-form string of the field's
-    // initializer (e.g. "'medium'" for a string literal, "42" for a
-    // number). Pass through as-is; rollup's `defaultApplied` matcher
-    // only checks for !== undefined, and richer coercion is a separate
-    // display concern tracked downstream.
-    if (field.default !== undefined)
-        prop.default = field.default;
-    if (field.description !== undefined)
-        prop.description = field.description;
-    const values = parseStringUnionValues(field.type?.text);
-    if (values !== undefined)
-        prop.values = values;
-    const lifecycle = buildLifecycleFromDeprecated(field.deprecated);
-    if (lifecycle !== undefined)
-        prop.lifecycle = lifecycle;
-    return prop;
-}
-function buildEventsFromCem(decl) {
-    const events = [];
-    for (const e of decl.events ?? []) {
-        if (!e.name)
-            continue;
-        const event = { name: e.name };
-        if (e.type?.text !== undefined)
-            event.payloadType = e.type.text;
-        if (e.description !== undefined)
-            event.description = e.description;
-        const lifecycle = buildLifecycleFromDeprecated(e.deprecated);
-        if (lifecycle !== undefined)
-            event.lifecycle = lifecycle;
-        events.push(event);
-    }
-    return events;
-}
-function buildSlotsFromCem(decl) {
-    const slots = [];
-    for (const s of decl.slots ?? []) {
-        const slot = { name: s.name ?? "" };
-        if (s.description !== undefined)
-            slot.description = s.description;
-        const lifecycle = buildLifecycleFromDeprecated(s.deprecated);
-        if (lifecycle !== undefined)
-            slot.lifecycle = lifecycle;
-        slots.push(slot);
-    }
-    return slots;
-}
-/**
- * CEM `deprecated` is `true` (deprecated, no reason) or a reason string.
- * Both shape into a `Lifecycle` with status: "deprecated"; `false` / undefined
- * leave the lifecycle unset (consumers default to "stable" when absent).
- */
-function buildLifecycleFromDeprecated(deprecated) {
-    if (deprecated === undefined || deprecated === false)
-        return undefined;
-    if (typeof deprecated === "string") {
-        return { status: "deprecated", deprecationReason: deprecated };
-    }
-    return { status: "deprecated" };
-}
-/**
- * Parse a CEM `type.text` like `"'small' | 'medium' | 'large'"` into the
- * declared allowed values `["small", "medium", "large"]`. Only returns a
- * result when EVERY `|`-separated part is a single-quoted or double-quoted
- * string literal (mixed unions like `"'small' | number"` return undefined).
- */
-function parseStringUnionValues(typeText) {
-    if (!typeText)
-        return undefined;
-    const parts = typeText.split("|").map((s) => s.trim());
-    const stringLiterals = parts
-        .map((p) => {
-        const m = /^['"](.*)['"]$/.exec(p);
-        return m ? m[1] : null;
-    })
-        .filter((v) => v !== null);
-    return stringLiterals.length === parts.length && stringLiterals.length > 0
-        ? stringLiterals
-        : undefined;
-}
-function absorbCcmComponents(manifest, packageName) {
-    const out = [];
-    for (const c of manifest.components) {
-        if (c.kind === "custom-element")
-            continue;
-        if (c.kind !== "react-component" && c.kind !== "vue-component")
-            continue;
-        if (!c.export)
-            continue;
-        const externalSrc = { type: "external", package: packageName };
-        // Thread `default` and `type` from each CCM-declared prop through to the
-        // absorbed IndexedComponent. Mirrors `absorbCemDeclarations`' members[]
-        // handling so the `defaultApplied` rollup matcher fires for CCM-sourced
-        // consumers (hand-authored component-compass-manifest.json) on parity with
-        // CEM-sourced ones.
-        const props = (c.props ?? []).map((p) => {
-            const absorbed = { name: p.name };
-            if (p.type !== undefined)
-                absorbed.type = p.type;
-            if (p.default !== undefined)
-                absorbed.default = p.default;
-            return absorbed;
-        });
-        out.push({
-            kind: c.kind,
-            export: c.export,
-            source: externalSrc,
-            props,
-        });
-    }
-    return out;
-}
-//# sourceMappingURL=lazy-resolver.js.map