@component-compass/cli 0.1.23 → 0.1.25

package/dist/manifest/lazy-resolver.d.ts

@@ -1,123 +0,0 @@
-import { type IndexedComponent, type LazyResolverHit, type ManifestRef, type Diagnostic, type DiagnosticCollector } from "@component-compass/plugin-core";
-import type { ResolveImport } from "../walker/resolve-import.js";
-import type { EntryPackageTarget } from "../scan/entry-packages.js";
-export type CreateLazyResolverOptions = {
-    resolveImport: ResolveImport;
-    /**
-     * Anchor for eager loads via `.warm()`. Optional — `resolveLazyManifest`
-     * itself never reads it (resolution is anchored on the calling file). When
-     * absent, `.warm()` falls back to `process.cwd()`.
-     */
-    repoRoot?: string;
-    /**
-     * Optional shared diagnostic collector. If absent, the resolver creates
-     * its own internal collector accessible via `diagnostics()`.
-     */
-    collector?: DiagnosticCollector;
-    /**
-     * Glob patterns identifying packages whose manifests should be loaded.
-     * When set, the resolver loads manifests only for matching packages —
-     * non-matching packages still get identity resolution (`leafPackage` +
-     * `modulePath`) but `matched` is always null. When omitted or empty,
-     * manifest enrichment is fully disabled; identity resolution still runs.
-     * Use `["**"]` to enrich every package the resolver reaches (the
-     * single-star pattern `*` won't match scoped names like `@scope/pkg`
-     * because picomatch's `*` doesn't cross `/`).
-     */
-    manifestPatterns?: readonly string[];
-    /**
-     * Entry-package provenance capture. Fired once per cached
-     * resolution whose walk crossed from the specifier's package (`entry`,
-     * as found on disk at the resolved specifier target) to a different
-     * terminal leaf package. `target.modulePath` is the terminal file
-     * relative to the leaf root, extension intact.
-     */
-    onEntryPackage?: (entry: {
-        name: string;
-        dir: string;
-    }, target: EntryPackageTarget) => void;
-};
-export interface LazyResolver {
-    resolveLazyManifest(fromFile: string, specifier: string, exportName: string): LazyResolverHit | null;
-    /**
-     * Identical walk/cache/return to `resolveLazyManifest`, but any leaf
-     * manifest it loads (or upgrades on a cache hit — see the internal
-     * `hitCache` early-return) is marked snapshot-INELIGIBLE. For
-     * engine-adapter callers (e.g. `resolveExternalLeaf`) that need leaf
-     * identity + `lookupReactWrapper` hits without broadcasting an undeclared
-     * package's full CEM catalog into `snapshotComponents()` /
-     * `snapshotManifestRefs()`.
-     */
-    lookupExternalLeaf(fromFile: string, specifier: string, exportName: string): LazyResolverHit | null;
-    /**
-     * File-path-anchored local barrel walk. Given a known-local file and an
-     * export name, follows `export { X } from "./Y"` / `export * from "./Y"`
-     * chains to a terminal file (one with no matching re-export). Returns the
-     * `{ filePath, exportName }` pair the chain ended at; caller does the
-     * final byPath lookup to verify the file actually exports that name.
-     *
-     * Returns null when:
-     *   - the chain crosses out of the entry file's package (cross-package
-     *     boundary — caller emits unresolved-import)
-     *   - a cycle is detected (`cycle-detected` diagnostic emitted)
-     *   - MAX_REEXPORT_HOPS exceeded (`chain-too-deep` emitted)
-     *   - a re-export's `from` specifier fails to resolve
-     *
-     * Reuses the shared `parsedBarrel` AST cache. See ADR 0001 for why this
-     * lives on LazyResolver vs. a separate type.
-     */
-    resolveLocalExport(filePath: string, exportName: string): {
-        filePath: string;
-        exportName: string;
-    } | null;
-    snapshotComponents(): IndexedComponent[];
-    snapshotManifestRefs(): ManifestRef[];
-    diagnostics(): Diagnostic[];
-    /**
-     * Eagerly load each named package's root CEM/CCM (if present) so the
-     * `byTag` cache covers tag-only consumers (HTML / Vue templates with no
-     * JS-side import to prime the resolver). Returns a `WarmedResolver` that
-     * adds `lookupByTag` — the only way to obtain it. No barrel walking; just
-     * one leaf-load per package, mirroring the resolver's terminal-load step.
-     */
-    warm(packageNames: string[]): WarmedResolver;
-    /**
-     * Test-only hook: number of times the named barrel path was passed through
-     * the parse step. The resolver caches parsed barrel ASTs per absolute path,
-     * so on the happy path this is 1 regardless of how many import resolutions
-     * traverse the same barrel. Underscore-prefixed because production callers
-     * shouldn't depend on it.
-     */
-    _barrelParseCount(absPath: string): number;
-}
-export interface WarmedResolver extends LazyResolver {
-    /**
-     * Tag-only lookup against the CEM index loaded during `warm(...)` (and any
-     * subsequent `resolveLazyManifest` calls that walked into eligible
-     * packages). Returns null when no matching custom-element has been indexed,
-     * including for resolvers constructed without any `manifestPatterns`
-     * (identity-only mode — `warm(...)` is then a structural no-op).
-     */
-    lookupByTag(tagName: string): Extract<IndexedComponent, {
-        kind: "custom-element";
-    }> | null;
-    /**
-     * Look up the custom-element a React wrapper export maps to.
-     *
-     * **Direct CEM className match.**
-     * When `packageName` has a loaded CEM, scan its `components[]` for a
-     * custom-element whose `className === exportName`. Returns
-     * `{ tagName, packageName }` on match. This mirrors the className-equality
-     * second pass of `matchInLeaf`.
-     *
-     * Returns null when:
-     *   - `packageName` is not manifest-eligible (excluded by `manifestPatterns`)
-     *   - the package has no loaded CEM
-     *   - the package has a loaded CEM but no className match
-     */
-    lookupReactWrapper(packageName: string, exportName: string): {
-        tagName: string;
-        packageName: string;
-    } | null;
-}
-export declare function createLazyResolver(opts: CreateLazyResolverOptions): LazyResolver;