svelte-shaker 0.5.2 → 0.7.0

package/dist/{types/src/analyze.d.ts → analyze.d.ts}

@@ -1,6 +1,6 @@
-import { type AnyNode, type Parse, type ParseCache, type Root } from './parse';
-import { type AnalyzeInput, type ComponentId, type ComponentPlan, type Literal } from './ir';
-import { type Span } from './dead';
+import { type AnyNode, type Parse, type ParseCache, type Root } from './parse.js';
+import { type AnalyzeInput, type ComponentId, type ComponentPlan, type Literal } from './ir.js';
+import { type Span } from './dead.js';
 export type Resolve = (source: string, importer: ComponentId) => Promise<ComponentId | null> | ComponentId | null;
 export type ReadFile = (id: ComponentId) => Promise<string> | string;
 /** One declared prop in a `$props()` destructuring. */
@@ -81,11 +81,15 @@ export interface ChildCall {
 }
 /**
  * One value passed explicitly to a prop at one call site, after last-write-wins
- * has been resolved (`{...obj}` aside).  `dynamic` means the attribute had a
- * non-literal value (`bind:`, dynamic expression): used, value not statically
- * known.  `afterLastSpread` records whether this explicit write happened after
- * the site's last `{...spread}` — only then can a spread not silently override
- * it (docs §4.1, "後勝ち順序で救う").
+ * has been resolved.  An explicit write is either a real attribute (`a={1}`) OR a
+ * key expanded out of a statically-known object-literal spread (`{...{a:1}}`,
+ * docs §4.1) — both name a prop and a value the same way.  `dynamic` means the
+ * value is non-literal (`bind:`, a dynamic expression, or a spread key whose
+ * value is non-literal): used, value not statically known.  `afterLastSpread`
+ * records whether this write happened after the site's last *unknown* spread (one
+ * we could not expand) — only then can no spread silently override it (docs §4.1,
+ * "後勝ち順序で救う").  A known object-literal spread is expanded, not opaque, so
+ * it never counts as an "unknown spread" here.
  */
 export interface ExplicitProp {
     value: Literal;
@@ -94,7 +98,12 @@ export interface ExplicitProp {
 }
 /** How a child component is called at one `<Child .../>` site. */
 export interface CallSite {
-    /** Did this site have at least one `{...spread}` attribute? */
+    /**
+     * Did this site have at least one spread we could NOT statically expand (an
+     * identifier / call / `{...{…computed/nested…}}`)?  A fully-known object-literal
+     * spread is expanded into {@link ExplicitProp} writes instead, so it does not
+     * set this — only an opaque spread, which may set any prop, does (docs §4.1).
+     */
     hadSpread: boolean;
     /** Last-write-wins explicit props at this site, keyed by prop name. */
     explicit: Map<string, ExplicitProp>;
@@ -160,7 +169,11 @@ export declare function remapToLocalNames<V>(map: Map<string, V>, model: FileMod
  * Read one `<Child .../>` into a {@link CallSite}.  Attributes are in source
  * order, so we resolve last-write-wins (a later `a={…}` overrides an earlier
  * one) and record, per prop, whether its winning write came *after* the last
- * spread — the only case a spread cannot silently override it (docs §4.1).
+ * *unknown* spread — the only case a spread cannot silently override it (docs
+ * §4.1).  A statically-known object-literal spread (`{...{a:1, b:2}}`) is not
+ * opaque: we expand its keys into explicit writes at the spread's position, so it
+ * both contributes those literals AND does not poison props it cannot set (docs
+ * §4.1, "{...obj} が object literal ならキー展開").
  */
 export declare function readCallSite(component: AnyNode): CallSite;
 /** Decide what to fold for one component from its global usage. */