svelte-docinfo 0.4.0 → 0.5.0

package/dist/postprocess.d.ts

@@ -13,7 +13,6 @@
  * @module
  */
 import type { DeclarationJson, ModuleJson } from './types.js';
-import type { ReExportInfo } from './declaration-build.js';
 import type { SourceFileInfo } from './source.js';
 /**
  * A duplicate declaration with its full metadata and module path.
@@ -27,6 +26,14 @@ export interface DuplicateDeclaration {
 /**
  * Find duplicate declaration names across modules.
  *
+ * A duplicate is two *different things* sharing a name in the flat namespace.
+ * Occurrences are compared by canonical identity — `aliasOf` chains are
+ * resolved first, so an alias and its canonical (or two aliases of the same
+ * canonical) are one thing, not a collision. Documenting a same-name re-export
+ * (which synthesizes an alias) or re-exporting a component under its own name
+ * (`export {default as Foo} from './Foo.svelte'`) therefore doesn't flag.
+ * When a name does flag, all occurrences are reported, aliases included.
+ *
  * Callers can decide how to handle duplicates (throw, warn, ignore).
  *
  * @returns `Map` of declaration names to their `DuplicateDeclaration` occurrences (only includes duplicates)
@@ -46,59 +53,59 @@ export interface DuplicateDeclaration {
  * ```
  */
 export declare const findDuplicates: (modules: Array<ModuleJson>) => Map<string, Array<DuplicateDeclaration>>;
+/**
+ * Code-unit string comparator for deterministic output ordering.
+ *
+ * Unlike `localeCompare` (host-locale/ICU-dependent, so byte-identical input
+ * can serialize in different orders on different machines), code-unit order is
+ * environment-independent — and it matches the default `Array.prototype.sort`
+ * used for `alsoExportedFrom`, `dependencies`, and `dependents`.
+ */
+export declare const compareStrings: (a: string, b: string) => number;
 /**
  * Sort modules alphabetically by path for deterministic output and cleaner diffs.
  *
+ * Code-unit order (`compareStrings`) so the output is environment-independent.
+ *
  * @param modules - the modules to sort
  * @returns a new sorted array (does not mutate input)
  */
 export declare const sortModules: (modules: Array<ModuleJson>) => Array<ModuleJson>;
 /**
- * A collected re-export with its source module context.
- *
- * Used during the two-phase re-export resolution:
- * 1. Phase 1: Collect re-exports from each module during analysis
- * 2. Phase 2: Group by original module and merge into `alsoExportedFrom`
- */
-export interface ReExportEntry {
-    /** The module that re-exports the declaration. */
-    reExportingModule: string;
-    /** The re-export info (name and original module). */
-    reExport: ReExportInfo;
-}
-/**
- * Build `alsoExportedFrom` arrays from collected re-export data.
- *
- * This function resolves the two-phase re-export problem:
+ * Build `alsoExportedFrom` arrays from the modules' forward re-export edges.
  *
- * **Problem**: When module A re-exports from module B, we discover this while
- * analyzing A, but need to update B's declarations. However, B may already be
- * processed or may be processed later.
- *
- * **Solution**: Collect all re-exports in phase 1, then merge them in phase 2
- * after all modules are analyzed.
+ * Each module carries its same-name re-export edges as `ModuleJson.reExports`
+ * (collected in phase 1); this phase-2 pass inverts them onto the canonical
+ * declarations so both directions of the same fact are queryable. Edges whose
+ * canonical module or declaration is absent from `modules` are skipped — the
+ * forward entry remains without a back-link (see `ReExportJson` for the
+ * presence caveats).
  *
  * Component-only fields on renamed component aliases (`props`,
  * `acceptsChildren`, etc.) are populated separately by `resolveComponentAliases`
  * — call it after this function. They split because they touch disjoint fields
  * and have different inputs.
  *
- * @param modules - the modules array with all modules (will be mutated)
- * @param collectedReExports - array of re-exports collected during phase 1
- * @mutates modules - unions new re-exporters into `declaration.alsoExportedFrom`
+ * @param modules - the modules array with all modules (will be mutated).
+ *   Must be parsed `ModuleJson`s — wire JSON strips empty arrays, so run
+ *   raw JSON through `AnalyzeResultJson.parse` first or `reExports` may be
+ *   `undefined`
+ * @mutates modules - unions re-exporters into `declaration.alsoExportedFrom`
  *   (deduped + sorted), so a second call with the same inputs is a no-op
  *
  * @example
  * ```ts
  * // helpers.ts exports: foo, bar
- * // index.ts does: export {foo, bar} from './files.js'
+ * // index.ts does: export {foo, bar} from './helpers.js'
+ * // (so index.ts's ModuleJson carries reExports:
+ * //   [{name: 'foo', module: 'helpers.ts'}, {name: 'bar', module: 'helpers.ts'}])
  * //
  * // After processing:
  * // - helpers.ts foo declaration gets: alsoExportedFrom: ['index.ts']
  * // - helpers.ts bar declaration gets: alsoExportedFrom: ['index.ts']
  * ```
  */
-export declare const mergeReExports: (modules: Array<ModuleJson>, collectedReExports: Array<ReExportEntry>) => void;
+export declare const mergeReExports: (modules: Array<ModuleJson>) => void;
 /**
  * Copy props/acceptsChildren/lang/etc. from canonical component declarations
  * onto synthesized component-aliased declarations.
@@ -142,4 +149,87 @@ export declare const resolveComponentAliases: (modules: Array<ModuleJson>) => vo
 export declare const computeDependents: (files: ReadonlyArray<SourceFileInfo>) => Array<SourceFileInfo & {
     dependents?: ReadonlyArray<string>;
 }>;
+/**
+ * One name on a module's resolved export surface.
+ */
+export interface ExportSurfaceEntry {
+    /**
+     * Exported name, in the docinfo model's terms — Svelte components appear
+     * under their filename-derived name (the model's convention for default
+     * exports of `.svelte` files), not `'default'`.
+     */
+    name: string;
+    /**
+     * How the name reaches this module's surface: an own declaration
+     * (including synthesized aliases), a same-name re-export edge, a direct
+     * external re-export, or projection through `export * from './x'`.
+     */
+    via: 'declaration' | 'reExport' | 'external' | 'star';
+    /** Canonical module path, when known (`undefined` for external entries). */
+    module?: string;
+    /** The canonical declaration, when present in the analyzed set. */
+    declaration?: DeclarationJson;
+    /** Package specifier for external entries (as written in the statement). */
+    specifier?: string;
+    /** Name inside the external package when renamed. */
+    originalName?: string;
+    /** Type-only re-export — the name is erased at runtime. */
+    typeOnly?: boolean;
+    /** For star-projected entries: the `starExports` target the name arrived through. */
+    starFrom?: string;
+}
+/**
+ * A module's resolved export surface — see `resolveExportSurface`.
+ */
+export interface ExportSurface {
+    /** Surface entries, sorted by `name` (code-unit order). */
+    entries: Array<ExportSurfaceEntry>;
+    /**
+     * Star targets (own or transitive) absent from the analyzed set — their
+     * projected names are unknown, so the surface is incomplete.
+     */
+    unresolvedStarExports: Array<string>;
+    /**
+     * External star specifiers reachable from this module (own or transitive)
+     * — their projected names are unknowable without analyzing the package.
+     */
+    externalStarExports: Array<string>;
+}
+/**
+ * Resolve a module's full export surface from the analyzed model, applying
+ * ES module semantics to star exports.
+ *
+ * Combines the module's own `declarations` (including synthesized aliases),
+ * `reExports` edges, `externalReExports`, and transitively-resolved
+ * `starExports` into one deduped, name-sorted list. The ES rules applied to
+ * star projection:
+ *
+ * - explicit exports (declarations, edges, externals) shadow star-projected
+ *   names
+ * - a name projected by two stars that resolve to *different* canonicals is
+ *   ambiguous and excluded (same canonical through a diamond is included
+ *   once)
+ * - `default` is never star-projected — including canonical Svelte component
+ *   declarations, which represent their file's default export. (Caveat: a
+ *   star-projected re-export edge whose canonical is a component is treated
+ *   as a default-slot re-export and skipped; a `<script module>` const
+ *   sharing the component's exact name would be skipped with it.)
+ *
+ * A Position-3 alias and its `reExports` edge are the same fact — the
+ * declaration entry wins, inheriting the edge's `typeOnly`.
+ *
+ * Cyclic star graphs terminate by contributing nothing along the back-edge
+ * (an approximation of ES fixpoint resolution — fine in practice). Surfaces
+ * resolved inside a cycle are path-relative and not memoized, so sibling
+ * star paths resolve independently rather than inheriting them. Star
+ * targets missing from `modules` are reported in `unresolvedStarExports`
+ * rather than guessed at; `externalStarExports` aggregates external star
+ * specifiers reachable from the module, whose names are unknowable.
+ *
+ * @param modules - the analyzed modules (parsed `ModuleJson`s — run wire
+ *   JSON through `AnalyzeResultJson.parse` first)
+ * @param path - the module to resolve, as a `ModuleJson.path` value
+ * @returns the resolved surface, or `null` when `path` isn't in `modules`
+ */
+export declare const resolveExportSurface: (modules: Array<ModuleJson>, path: string) => ExportSurface | null;
 //# sourceMappingURL=postprocess.d.ts.map

package/dist/postprocess.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"postprocess.d.ts","sourceRoot":"../src/lib/","sources":["../src/lib/postprocess.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;GAaG;AAEH,OAAO,KAAK,EAA2B,eAAe,EAAE,UAAU,EAAC,MAAM,YAAY,CAAC;AACtF,OAAO,KAAK,EAAC,YAAY,EAAC,MAAM,wBAAwB,CAAC;AACzD,OAAO,KAAK,EAAC,cAAc,EAAC,MAAM,aAAa,CAAC;AAuBhD;;GAEG;AACH,MAAM,WAAW,oBAAoB;IACpC,qCAAqC;IACrC,WAAW,EAAE,eAAe,CAAC;IAC7B,qDAAqD;IACrD,MAAM,EAAE,MAAM,CAAC;CACf;AAED;;;;;;;;;;;;;;;;;;;;GAoBG;AACH,eAAO,MAAM,cAAc,GAC1B,SAAS,KAAK,CAAC,UAAU,CAAC,KACxB,GAAG,CAAC,MAAM,EAAE,KAAK,CAAC,oBAAoB,CAAC,CA4BzC,CAAC;AAEF;;;;;GAKG;AACH,eAAO,MAAM,WAAW,GAAI,SAAS,KAAK,CAAC,UAAU,CAAC,KAAG,KAAK,CAAC,UAAU,CAExE,CAAC;AAEF;;;;;;GAMG;AACH,MAAM,WAAW,aAAa;IAC7B,kDAAkD;IAClD,iBAAiB,EAAE,MAAM,CAAC;IAC1B,qDAAqD;IACrD,QAAQ,EAAE,YAAY,CAAC;CACvB;AAED;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA+BG;AACH,eAAO,MAAM,cAAc,GAC1B,SAAS,KAAK,CAAC,UAAU,CAAC,EAC1B,oBAAoB,KAAK,CAAC,aAAa,CAAC,KACtC,IAkCF,CAAC;AAEF;;;;;;;;;;;;;;GAcG;AACH,eAAO,MAAM,uBAAuB,GAAI,SAAS,KAAK,CAAC,UAAU,CAAC,KAAG,IAoDpE,CAAC;AAEF;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AACH,eAAO,MAAM,iBAAiB,GAC7B,OAAO,aAAa,CAAC,cAAc,CAAC,KAClC,KAAK,CAAC,cAAc,GAAG;IAAC,UAAU,CAAC,EAAE,aAAa,CAAC,MAAM,CAAC,CAAA;CAAC,CAwD7D,CAAC"}
+{"version":3,"file":"postprocess.d.ts","sourceRoot":"../src/lib/","sources":["../src/lib/postprocess.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;GAaG;AAEH,OAAO,KAAK,EAA2B,eAAe,EAAE,UAAU,EAAC,MAAM,YAAY,CAAC;AACtF,OAAO,KAAK,EAAC,cAAc,EAAC,MAAM,aAAa,CAAC;AAuBhD;;GAEG;AACH,MAAM,WAAW,oBAAoB;IACpC,qCAAqC;IACrC,WAAW,EAAE,eAAe,CAAC;IAC7B,qDAAqD;IACrD,MAAM,EAAE,MAAM,CAAC;CACf;AA6CD;;;;;;;;;;;;;;;;;;;;;;;;;;;;GA4BG;AACH,eAAO,MAAM,cAAc,GAC1B,SAAS,KAAK,CAAC,UAAU,CAAC,KACxB,GAAG,CAAC,MAAM,EAAE,KAAK,CAAC,oBAAoB,CAAC,CAwCzC,CAAC;AAEF;;;;;;;GAOG;AACH,eAAO,MAAM,cAAc,GAAI,GAAG,MAAM,EAAE,GAAG,MAAM,KAAG,MAAsC,CAAC;AAE7F;;;;;;;GAOG;AACH,eAAO,MAAM,WAAW,GAAI,SAAS,KAAK,CAAC,UAAU,CAAC,KAAG,KAAK,CAAC,UAAU,CAExE,CAAC;AAEF;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAiCG;AACH,eAAO,MAAM,cAAc,GAAI,SAAS,KAAK,CAAC,UAAU,CAAC,KAAG,IAmC3D,CAAC;AAEF;;;;;;;;;;;;;;GAcG;AACH,eAAO,MAAM,uBAAuB,GAAI,SAAS,KAAK,CAAC,UAAU,CAAC,KAAG,IAoDpE,CAAC;AAEF;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AACH,eAAO,MAAM,iBAAiB,GAC7B,OAAO,aAAa,CAAC,cAAc,CAAC,KAClC,KAAK,CAAC,cAAc,GAAG;IAAC,UAAU,CAAC,EAAE,aAAa,CAAC,MAAM,CAAC,CAAA;CAAC,CAwD7D,CAAC;AAEF;;GAEG;AACH,MAAM,WAAW,kBAAkB;IAClC;;;;OAIG;IACH,IAAI,EAAE,MAAM,CAAC;IACb;;;;OAIG;IACH,GAAG,EAAE,aAAa,GAAG,UAAU,GAAG,UAAU,GAAG,MAAM,CAAC;IACtD,4EAA4E;IAC5E,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,mEAAmE;IACnE,WAAW,CAAC,EAAE,eAAe,CAAC;IAC9B,4EAA4E;IAC5E,SAAS,CAAC,EAAE,MAAM,CAAC;IACnB,qDAAqD;IACrD,YAAY,CAAC,EAAE,MAAM,CAAC;IACtB,2DAA2D;IAC3D,QAAQ,CAAC,EAAE,OAAO,CAAC;IACnB,qFAAqF;IACrF,QAAQ,CAAC,EAAE,MAAM,CAAC;CAClB;AAED;;GAEG;AACH,MAAM,WAAW,aAAa;IAC7B,2DAA2D;IAC3D,OAAO,EAAE,KAAK,CAAC,kBAAkB,CAAC,CAAC;IACnC;;;OAGG;IACH,qBAAqB,EAAE,KAAK,CAAC,MAAM,CAAC,CAAC;IACrC;;;OAGG;IACH,mBAAmB,EAAE,KAAK,CAAC,MAAM,CAAC,CAAC;CACnC;AAcD;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAmCG;AACH,eAAO,MAAM,oBAAoB,GAChC,SAAS,KAAK,CAAC,UAAU,CAAC,EAC1B,MAAM,MAAM,KACV,aAAa,GAAG,IA+IlB,CAAC"}

package/dist/postprocess.js

@@ -32,9 +32,56 @@ const posixifyArray = (arr) => {
     }
     return changed ?? arr;
 };
+/**
+ * Build the `(module, name)` → declaration lookup used for `aliasOf`-chain
+ * walking. Key format: `` `${modulePath}\n${name}` `` — `\n` can't appear in
+ * either part.
+ */
+const buildDeclarationIndex = (modules) => {
+    const byIdentity = new Map();
+    for (const mod of modules) {
+        for (const declaration of mod.declarations) {
+            byIdentity.set(`${mod.path}\n${declaration.name}`, declaration);
+        }
+    }
+    return byIdentity;
+};
+/**
+ * Resolve a declaration to its canonical identity. A same-name re-export of
+ * an intermediate rename produces an alias pointing at another alias, so a
+ * single hop isn't enough — follow the chain through declarations present in
+ * the index. The terminal is the declaration *object* when it's in the set
+ * (object identity keeps two same-`(module, name)` declarations distinct in
+ * pathological inputs), else the dangling `(module, name)` key (two aliases
+ * of the same absent canonical still resolve to one identity). The visited
+ * set guards malformed cyclic input.
+ */
+const resolveCanonicalIdentity = (byIdentity, modulePath, declaration) => {
+    let current = declaration;
+    const visited = new Set([`${modulePath}\n${declaration.name}`]);
+    while (current.aliasOf) {
+        const nextKey = `${current.aliasOf.module}\n${current.aliasOf.name}`;
+        if (visited.has(nextKey))
+            return nextKey;
+        visited.add(nextKey);
+        const next = byIdentity.get(nextKey);
+        if (!next)
+            return nextKey;
+        current = next;
+    }
+    return current;
+};
 /**
  * Find duplicate declaration names across modules.
  *
+ * A duplicate is two *different things* sharing a name in the flat namespace.
+ * Occurrences are compared by canonical identity — `aliasOf` chains are
+ * resolved first, so an alias and its canonical (or two aliases of the same
+ * canonical) are one thing, not a collision. Documenting a same-name re-export
+ * (which synthesizes an alias) or re-exporting a component under its own name
+ * (`export {default as Foo} from './Foo.svelte'`) therefore doesn't flag.
+ * When a name does flag, all occurrences are reported, aliases included.
+ *
  * Callers can decide how to handle duplicates (throw, warn, ignore).
  *
  * @returns `Map` of declaration names to their `DuplicateDeclaration` occurrences (only includes duplicates)
@@ -54,10 +101,13 @@ const posixifyArray = (arr) => {
  * ```
  */
 export const findDuplicates = (modules) => {
+    const byIdentity = buildDeclarationIndex(modules);
+    const resolveCanonical = (modulePath, declaration) => resolveCanonicalIdentity(byIdentity, modulePath, declaration);
+    // Collect declaration names with their canonical identities. The default
+    // slot is module-scoped per the JS spec — every module can have its own
+    // `'default'` and they don't collide — so skip `name === 'default'`
+    // entries from this flat-namespace check.
     const allOccurrences = new Map();
-    // Collect declaration names. The default slot is module-scoped per the JS
-    // spec — every module can have its own `'default'` and they don't collide
-    // — so skip `name === 'default'` entries from this flat-namespace check.
     for (const mod of modules) {
         for (const declaration of mod.declarations) {
             if (declaration.name === 'default')
@@ -68,74 +118,90 @@ export const findDuplicates = (modules) => {
             allOccurrences.get(declaration.name).push({
                 declaration,
                 module: mod.path,
+                canonical: resolveCanonical(mod.path, declaration),
             });
         }
     }
-    // Filter to only duplicates
+    // A name is duplicated only when its occurrences span >1 canonical identity
     const duplicates = new Map();
     for (const [name, occurrences] of allOccurrences) {
-        if (occurrences.length > 1) {
-            duplicates.set(name, occurrences);
+        const identities = new Set(occurrences.map((o) => o.canonical));
+        if (identities.size > 1) {
+            duplicates.set(name, occurrences.map(({ declaration, module }) => ({ declaration, module })));
         }
     }
     return duplicates;
 };
+/**
+ * Code-unit string comparator for deterministic output ordering.
+ *
+ * Unlike `localeCompare` (host-locale/ICU-dependent, so byte-identical input
+ * can serialize in different orders on different machines), code-unit order is
+ * environment-independent — and it matches the default `Array.prototype.sort`
+ * used for `alsoExportedFrom`, `dependencies`, and `dependents`.
+ */
+export const compareStrings = (a, b) => (a < b ? -1 : a > b ? 1 : 0);
 /**
  * Sort modules alphabetically by path for deterministic output and cleaner diffs.
  *
+ * Code-unit order (`compareStrings`) so the output is environment-independent.
+ *
  * @param modules - the modules to sort
  * @returns a new sorted array (does not mutate input)
  */
 export const sortModules = (modules) => {
-    return modules.slice().sort((a, b) => a.path.localeCompare(b.path));
+    return modules.slice().sort((a, b) => compareStrings(a.path, b.path));
 };
 /**
- * Build `alsoExportedFrom` arrays from collected re-export data.
- *
- * This function resolves the two-phase re-export problem:
- *
- * **Problem**: When module A re-exports from module B, we discover this while
- * analyzing A, but need to update B's declarations. However, B may already be
- * processed or may be processed later.
+ * Build `alsoExportedFrom` arrays from the modules' forward re-export edges.
  *
- * **Solution**: Collect all re-exports in phase 1, then merge them in phase 2
- * after all modules are analyzed.
+ * Each module carries its same-name re-export edges as `ModuleJson.reExports`
+ * (collected in phase 1); this phase-2 pass inverts them onto the canonical
+ * declarations so both directions of the same fact are queryable. Edges whose
+ * canonical module or declaration is absent from `modules` are skipped — the
+ * forward entry remains without a back-link (see `ReExportJson` for the
+ * presence caveats).
  *
  * Component-only fields on renamed component aliases (`props`,
  * `acceptsChildren`, etc.) are populated separately by `resolveComponentAliases`
  * — call it after this function. They split because they touch disjoint fields
  * and have different inputs.
  *
- * @param modules - the modules array with all modules (will be mutated)
- * @param collectedReExports - array of re-exports collected during phase 1
- * @mutates modules - unions new re-exporters into `declaration.alsoExportedFrom`
+ * @param modules - the modules array with all modules (will be mutated).
+ *   Must be parsed `ModuleJson`s — wire JSON strips empty arrays, so run
+ *   raw JSON through `AnalyzeResultJson.parse` first or `reExports` may be
+ *   `undefined`
+ * @mutates modules - unions re-exporters into `declaration.alsoExportedFrom`
  *   (deduped + sorted), so a second call with the same inputs is a no-op
  *
  * @example
  * ```ts
  * // helpers.ts exports: foo, bar
- * // index.ts does: export {foo, bar} from './files.js'
+ * // index.ts does: export {foo, bar} from './helpers.js'
+ * // (so index.ts's ModuleJson carries reExports:
+ * //   [{name: 'foo', module: 'helpers.ts'}, {name: 'bar', module: 'helpers.ts'}])
  * //
  * // After processing:
  * // - helpers.ts foo declaration gets: alsoExportedFrom: ['index.ts']
  * // - helpers.ts bar declaration gets: alsoExportedFrom: ['index.ts']
  * ```
  */
-export const mergeReExports = (modules, collectedReExports) => {
-    // Group re-exports by `(originalModule, name)`. The default slot keys as
+export const mergeReExports = (modules) => {
+    // Group edges by `(canonical module, name)`. The default slot keys as
     // `'default'` like any other name — each module owns its own default slot,
     // so the per-module map prevents cross-module collisions naturally.
     const reExportMap = new Map();
-    for (const { reExportingModule, reExport } of collectedReExports) {
-        const { name, originalModule } = reExport;
-        if (!reExportMap.has(originalModule)) {
-            reExportMap.set(originalModule, new Map());
-        }
-        const moduleMap = reExportMap.get(originalModule);
-        if (!moduleMap.has(name)) {
-            moduleMap.set(name, []);
+    for (const mod of modules) {
+        for (const { name, module: originalModule } of mod.reExports) {
+            if (!reExportMap.has(originalModule)) {
+                reExportMap.set(originalModule, new Map());
+            }
+            const moduleMap = reExportMap.get(originalModule);
+            if (!moduleMap.has(name)) {
+                moduleMap.set(name, []);
+            }
+            moduleMap.get(name).push(mod.path);
         }
-        moduleMap.get(name).push(reExportingModule);
     }
     // Merge into original declarations
     for (const mod of modules) {
@@ -303,3 +369,185 @@ export const computeDependents = (files) => {
         };
     });
 };
+/**
+ * Resolve a module's full export surface from the analyzed model, applying
+ * ES module semantics to star exports.
+ *
+ * Combines the module's own `declarations` (including synthesized aliases),
+ * `reExports` edges, `externalReExports`, and transitively-resolved
+ * `starExports` into one deduped, name-sorted list. The ES rules applied to
+ * star projection:
+ *
+ * - explicit exports (declarations, edges, externals) shadow star-projected
+ *   names
+ * - a name projected by two stars that resolve to *different* canonicals is
+ *   ambiguous and excluded (same canonical through a diamond is included
+ *   once)
+ * - `default` is never star-projected — including canonical Svelte component
+ *   declarations, which represent their file's default export. (Caveat: a
+ *   star-projected re-export edge whose canonical is a component is treated
+ *   as a default-slot re-export and skipped; a `<script module>` const
+ *   sharing the component's exact name would be skipped with it.)
+ *
+ * A Position-3 alias and its `reExports` edge are the same fact — the
+ * declaration entry wins, inheriting the edge's `typeOnly`.
+ *
+ * Cyclic star graphs terminate by contributing nothing along the back-edge
+ * (an approximation of ES fixpoint resolution — fine in practice). Surfaces
+ * resolved inside a cycle are path-relative and not memoized, so sibling
+ * star paths resolve independently rather than inheriting them. Star
+ * targets missing from `modules` are reported in `unresolvedStarExports`
+ * rather than guessed at; `externalStarExports` aggregates external star
+ * specifiers reachable from the module, whose names are unknowable.
+ *
+ * @param modules - the analyzed modules (parsed `ModuleJson`s — run wire
+ *   JSON through `AnalyzeResultJson.parse` first)
+ * @param path - the module to resolve, as a `ModuleJson.path` value
+ * @returns the resolved surface, or `null` when `path` isn't in `modules`
+ */
+export const resolveExportSurface = (modules, path) => {
+    const byPath = new Map(modules.map((m) => [m.path, m]));
+    if (!byPath.has(path))
+        return null;
+    const byIdentity = buildDeclarationIndex(modules);
+    const cache = new Map();
+    const visiting = new Set();
+    const emptySurface = () => ({
+        entries: new Map(),
+        unresolvedStars: new Set(),
+        externalStars: new Set(),
+    });
+    // Only surfaces resolved without hitting a cycle back-edge are memoized.
+    // A surface computed while one of its star ancestors is mid-resolution is
+    // relative to that path — it can carry names a full resolution would
+    // exclude as ambiguous (the back-edge contributed nothing to weigh them
+    // against). Caching it would leak the path-relative answer to sibling
+    // star paths; tainted surfaces are instead recomputed per consumer.
+    // Recomputation is bounded by `visiting` and only occurs inside cyclic
+    // clusters, which are pathological to begin with.
+    const resolveModule = (modulePath) => {
+        const cached = cache.get(modulePath);
+        if (cached)
+            return { surface: cached, tainted: false };
+        // Cycle break: a star back-edge contributes nothing
+        if (visiting.has(modulePath))
+            return { surface: emptySurface(), tainted: true };
+        visiting.add(modulePath);
+        const mod = byPath.get(modulePath);
+        const surface = emptySurface();
+        let tainted = false;
+        const { entries } = surface;
+        // 1. Own declarations — including synthesized aliases and `default`
+        const edgesByName = new Map(mod.reExports.map((e) => [e.name, e]));
+        for (const declaration of mod.declarations) {
+            // A Position-3 alias duplicates its edge; carry the edge's typeOnly
+            const matchingEdge = declaration.aliasOf &&
+                edgesByName.get(declaration.name)?.module === declaration.aliasOf.module
+                ? edgesByName.get(declaration.name)
+                : undefined;
+            entries.set(declaration.name, {
+                entry: {
+                    name: declaration.name,
+                    via: 'declaration',
+                    module: modulePath,
+                    declaration,
+                    ...(matchingEdge?.typeOnly ? { typeOnly: true } : {}),
+                },
+                identity: resolveCanonicalIdentity(byIdentity, modulePath, declaration),
+            });
+        }
+        // 2. Same-name re-export edges not already covered by a declaration.
+        // Edges can collide on `name` (Svelte default re-keying — see
+        // `ReExportJson`); the surface is keyed by name, so the first edge in
+        // sort order wins and the collider is dropped
+        for (const edge of mod.reExports) {
+            if (entries.has(edge.name))
+                continue;
+            const canonical = byIdentity.get(`${edge.module}\n${edge.name}`);
+            entries.set(edge.name, {
+                entry: {
+                    name: edge.name,
+                    via: 'reExport',
+                    module: edge.module,
+                    ...(canonical ? { declaration: canonical } : {}),
+                    ...(edge.typeOnly ? { typeOnly: true } : {}),
+                },
+                identity: canonical
+                    ? resolveCanonicalIdentity(byIdentity, edge.module, canonical)
+                    : `${edge.module}\n${edge.name}`,
+            });
+        }
+        // 3. Direct external re-exports
+        for (const external of mod.externalReExports) {
+            if (entries.has(external.name))
+                continue;
+            entries.set(external.name, {
+                entry: {
+                    name: external.name,
+                    via: 'external',
+                    specifier: external.specifier,
+                    ...(external.originalName !== undefined ? { originalName: external.originalName } : {}),
+                    ...(external.typeOnly ? { typeOnly: true } : {}),
+                },
+                identity: `ext\n${external.specifier}\n${external.originalName ?? external.name}`,
+            });
+        }
+        // 4. External stars — names unknowable, surface incompleteness recorded
+        for (const specifier of mod.externalStarExports) {
+            surface.externalStars.add(specifier);
+        }
+        // 5. Star projection, with ES shadowing and ambiguity rules
+        const excluded = new Set();
+        for (const target of mod.starExports) {
+            if (!byPath.has(target)) {
+                surface.unresolvedStars.add(target);
+                continue;
+            }
+            const resolved = resolveModule(target);
+            if (resolved.tainted)
+                tainted = true;
+            const sub = resolved.surface;
+            for (const star of sub.unresolvedStars)
+                surface.unresolvedStars.add(star);
+            for (const star of sub.externalStars)
+                surface.externalStars.add(star);
+            for (const { entry, identity } of sub.entries.values()) {
+                // `default` never projects — nor do canonical Svelte components,
+                // which represent their file's default export (whether reached
+                // as a declaration or through a re-export edge)
+                if (entry.name === 'default')
+                    continue;
+                if (entry.declaration?.kind === 'component' && !entry.declaration.aliasOf)
+                    continue;
+                if (excluded.has(entry.name))
+                    continue;
+                const existing = entries.get(entry.name);
+                if (existing) {
+                    // Explicit exports shadow; identical canonicals (diamond) merge
+                    if (existing.entry.via !== 'star' || existing.identity === identity)
+                        continue;
+                    // Ambiguous between two stars — excluded per ES semantics
+                    entries.delete(entry.name);
+                    excluded.add(entry.name);
+                    continue;
+                }
+                entries.set(entry.name, {
+                    entry: { ...entry, via: 'star', starFrom: target },
+                    identity,
+                });
+            }
+        }
+        visiting.delete(modulePath);
+        if (!tainted)
+            cache.set(modulePath, surface);
+        return { surface, tainted };
+    };
+    const resolved = resolveModule(path).surface;
+    return {
+        entries: Array.from(resolved.entries.values())
+            .map(({ entry }) => entry)
+            .sort((a, b) => compareStrings(a.name, b.name)),
+        unresolvedStarExports: Array.from(resolved.unresolvedStars).sort(),
+        externalStarExports: Array.from(resolved.externalStars).sort(),
+    };
+};

package/dist/svelte.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"svelte.d.ts","sourceRoot":"../src/lib/","sources":["../src/lib/svelte.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AAEH,OAAO,EAAC,QAAQ,EAAsB,MAAM,2BAA2B,CAAC;AAGxE,OAAO,EAAE,MAAM,YAAY,CAAC;AAE5B,OAAO,KAAK,EAA2C,kBAAkB,EAAC,MAAM,YAAY,CAAC;AAC7F,OAAO,KAAK,EAGX,cAAc,EACd,MAAM,wBAAwB,CAAC;AAKhC,OAAO,EAAC,KAAK,cAAc,EAA0C,MAAM,aAAa,CAAC;AACzF,OAAO,EAAC,KAAK,mBAAmB,EAAsB,MAAM,oBAAoB,CAAC;AACjF,OAAO,EAAC,KAAK,UAAU,EAAC,MAAM,kBAAkB,CAAC;AAGjD,0FAA0F;AAC1F,KAAK,SAAS,GAAG,YAAY,CAAC,OAAO,QAAQ,CAAC,CAAC;AAE/C;;;;;GAKG;AACH,MAAM,WAAW,iBAAiB;IACjC,gEAAgE;IAChE,WAAW,EAAE,MAAM,CAAC;IACpB,iDAAiD;IACjD,OAAO,EAAE,MAAM,CAAC;IAChB,2EAA2E;IAC3E,SAAS,EAAE,SAAS,GAAG,IAAI,CAAC;IAC5B,sGAAsG;IACtG,IAAI,EAAE,IAAI,GAAG,SAAS,CAAC;CACvB;AAED;;;;;;;;;GASG;AACH,MAAM,WAAW,eAAe;IAC/B,OAAO,EAAE,iBAAiB,GAAG,SAAS,CAAC;IACvC,WAAW,EAAE,KAAK,CAAC,UAAU,CAAC,CAAC;CAC/B;AAED;;;;;;;;;;;;;;;;;;GAkBG;AACH,eAAO,MAAM,qBAAqB,GAAI,YAAY,cAAc,KAAG,eAoDlE,CAAC;AAkHF;;;;;;;GAOG;AACH,eAAO,MAAM,oBAAoB,GAAI,cAAc,MAAM,KAAG,MAAM,GAAG,SAcpE,CAAC;AAEF;;;;;;;;;GASG;AACH,eAAO,MAAM,wBAAwB,GAAI,cAAc,MAAM,KAAG,MAAM,GAAG,SA0BxE,CAAC;AAEF;;;;;;;;GAQG;AACH,eAAO,MAAM,0BAA0B,GAAI,eAAe,MAAM,KAAG,MAAM,GAAG,SAU3E,CAAC;AA0PF;;;;;;GAMG;AACH,eAAO,MAAM,mBAAmB,GAAI,YAAY,MAAM,KAAG,OAExD,CAAC;AAEF;;;;;;;;;;;;GAYG;AACH,eAAO,MAAM,wBAAwB,GACpC,aAAa,EAAE,CAAC,IAAI,EACpB,SAAS,EAAE,CAAC,WAAW,KACrB,KAAK,CAAC,kBAAkB,CAqB1B,CAAC;AAEF;;;;;;;;;;GAUG;AACH,eAAO,MAAM,mBAAmB,GAAI,YAAY,MAAM,KAAG,OAKxD,CAAC;AAEF;;;;;;GAMG;AACH,eAAO,MAAM,8BAA8B,GAAI,YAAY,KAAK,CAAC,kBAAkB,CAAC,KAAG,MAGtF,CAAC;AA8NF;;;;;;;;;;;;;;;;;;GAkBG;AACH,eAAO,MAAM,mBAAmB,GAC/B,YAAY,cAAc,GAAG;IAAC,UAAU,CAAC,EAAE,aAAa,CAAC,MAAM,CAAC,CAAA;CAAC,EACjE,YAAY,MAAM,EAClB,SAAS,EAAE,CAAC,WAAW,EACvB,SAAS,mBAAmB,EAC5B,aAAa,KAAK,CAAC,UAAU,CAAC,EAC9B,SAAS,EAAE,CAAC,OAAO,EACnB,aAAa,iBAAiB,KAC5B,cAAc,GAAG,SAuNnB,CAAC"}
+{"version":3,"file":"svelte.d.ts","sourceRoot":"../src/lib/","sources":["../src/lib/svelte.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;GAuBG;AAEH,OAAO,EAAC,QAAQ,EAAsB,MAAM,2BAA2B,CAAC;AAGxE,OAAO,EAAE,MAAM,YAAY,CAAC;AAE5B,OAAO,KAAK,EAA2C,kBAAkB,EAAC,MAAM,YAAY,CAAC;AAC7F,OAAO,KAAK,EAGX,cAAc,EACd,MAAM,wBAAwB,CAAC;AAKhC,OAAO,EAAC,KAAK,cAAc,EAA0C,MAAM,aAAa,CAAC;AACzF,OAAO,EAAC,KAAK,mBAAmB,EAAsB,MAAM,oBAAoB,CAAC;AACjF,OAAO,EAAC,KAAK,UAAU,EAAC,MAAM,kBAAkB,CAAC;AAGjD,0FAA0F;AAC1F,KAAK,SAAS,GAAG,YAAY,CAAC,OAAO,QAAQ,CAAC,CAAC;AAE/C;;;;;GAKG;AACH,MAAM,WAAW,iBAAiB;IACjC,gEAAgE;IAChE,WAAW,EAAE,MAAM,CAAC;IACpB,iDAAiD;IACjD,OAAO,EAAE,MAAM,CAAC;IAChB,2EAA2E;IAC3E,SAAS,EAAE,SAAS,GAAG,IAAI,CAAC;IAC5B,sGAAsG;IACtG,IAAI,EAAE,IAAI,GAAG,SAAS,CAAC;CACvB;AAED;;;;;;;;;GASG;AACH,MAAM,WAAW,eAAe;IAC/B,OAAO,EAAE,iBAAiB,GAAG,SAAS,CAAC;IACvC,WAAW,EAAE,KAAK,CAAC,UAAU,CAAC,CAAC;CAC/B;AAED;;;;;;;;;;;;;;;;;;GAkBG;AACH,eAAO,MAAM,qBAAqB,GAAI,YAAY,cAAc,KAAG,eAoDlE,CAAC;AAkHF;;;;;;;GAOG;AACH,eAAO,MAAM,oBAAoB,GAAI,cAAc,MAAM,KAAG,MAAM,GAAG,SAcpE,CAAC;AAEF;;;;;;;;;GASG;AACH,eAAO,MAAM,wBAAwB,GAAI,cAAc,MAAM,KAAG,MAAM,GAAG,SA0BxE,CAAC;AAEF;;;;;;;;GAQG;AACH,eAAO,MAAM,0BAA0B,GAAI,eAAe,MAAM,KAAG,MAAM,GAAG,SAU3E,CAAC;AA0PF;;;;;;GAMG;AACH,eAAO,MAAM,mBAAmB,GAAI,YAAY,MAAM,KAAG,OAExD,CAAC;AAEF;;;;;;;;;;;;GAYG;AACH,eAAO,MAAM,wBAAwB,GACpC,aAAa,EAAE,CAAC,IAAI,EACpB,SAAS,EAAE,CAAC,WAAW,KACrB,KAAK,CAAC,kBAAkB,CAqB1B,CAAC;AAEF;;;;;;;;;;GAUG;AACH,eAAO,MAAM,mBAAmB,GAAI,YAAY,MAAM,KAAG,OAKxD,CAAC;AAEF;;;;;;GAMG;AACH,eAAO,MAAM,8BAA8B,GAAI,YAAY,KAAK,CAAC,kBAAkB,CAAC,KAAG,MAGtF,CAAC;AA8NF;;;;;;;;;;;;;;;;;;GAkBG;AACH,eAAO,MAAM,mBAAmB,GAC/B,YAAY,cAAc,GAAG;IAAC,UAAU,CAAC,EAAE,aAAa,CAAC,MAAM,CAAC,CAAA;CAAC,EACjE,YAAY,MAAM,EAClB,SAAS,EAAE,CAAC,WAAW,EACvB,SAAS,mBAAmB,EAC5B,aAAa,KAAK,CAAC,UAAU,CAAC,EAC9B,SAAS,EAAE,CAAC,OAAO,EACnB,aAAa,iBAAiB,KAC5B,cAAc,GAAG,SAoQnB,CAAC"}