svelte-shaker 0.6.0 → 0.7.0

package/dist/analyze.d.ts

@@ -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. */

package/dist/analyze.js

@@ -1,6 +1,7 @@
 import { parseCached, parseSvelte, walk, } from './parse.js';
 import { emptyPlan, } from './ir.js';
 import { computeDeadSpans, inSpans } from './dead.js';
+import { evaluate } from './eval.js';
 const isSvelte = (source) => source.endsWith('.svelte');
 /** Hard cap on fixpoint iterations: convergence is monotone (dead spans only
  * grow as profiles shrink), so this is reached only if something is non-monotone
@@ -672,18 +673,40 @@ function memberComponentTags(ast) {
  * 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 function readCallSite(component) {
     const attrs = component.attributes ?? [];
+    // Only spreads we CANNOT expand are opaque (may set any prop).  Classify first
+    // so `afterLastSpread` is measured against the last *unknown* spread, not a
+    // known object literal we are about to expand into explicit writes.
     let lastSpreadIndex = -1;
     for (let i = 0; i < attrs.length; i++) {
-        if (attrs[i].type === 'SpreadAttribute')
+        const attr = attrs[i];
+        if (attr.type === 'SpreadAttribute' && knownSpreadEntries(attr) === null)
             lastSpreadIndex = i;
     }
     const explicit = new Map();
     for (let i = 0; i < attrs.length; i++) {
         const attr = attrs[i];
+        if (attr.type === 'SpreadAttribute') {
+            // A known object-literal spread expands to one explicit write per key, at
+            // this spread's position; an unknown spread is opaque and handled by the
+            // `hadSpread`/`afterLastSpread` poisoning in `valueSetFor`.
+            const entries = knownSpreadEntries(attr);
+            if (entries) {
+                for (const [name, value] of entries) {
+                    explicit.set(name, value.known
+                        ? { value: value.value, dynamic: false, afterLastSpread: i > lastSpreadIndex }
+                        : dynamicWrite(i, lastSpreadIndex));
+                }
+            }
+            continue;
+        }
         const name = attr.name;
         if (attr.type === 'BindDirective') {
             // `bind:prop` is a used, dynamic two-way binding (docs §4.1).
@@ -759,6 +782,51 @@ function dynamicWrite(index, lastSpreadIndex) {
         afterLastSpread: index > lastSpreadIndex,
     };
 }
+/**
+ * The `[name, value]` entries a spread contributes IF it is a statically-known
+ * object literal whose complete key set we can see (docs §4.1 "object literal な
+ * spread はキー展開").  Returns `null` for any spread we cannot fully expand — an
+ * identifier/call (`{...rest}`), or an object literal carrying a nested spread
+ * (`{...{...x}}`), a computed key (`{...{[k]: 1}}`), or a getter/setter/method —
+ * because then we do not know the full set of props it sets and must treat it as
+ * opaque.  Each entry's value is `{known:true,value}` for a literal (so it folds)
+ * or `{known:false}` for a non-literal value (key known, value dynamic): both are
+ * sound, since the key set is fully known either way.
+ */
+function knownSpreadEntries(attr) {
+    const obj = attr.expression;
+    if (obj?.type !== 'ObjectExpression')
+        return null;
+    const entries = [];
+    for (const prop of obj.properties ?? []) {
+        // A nested spread, computed key, or accessor/method means the full key set is
+        // not statically knowable -> the whole spread is opaque.
+        if (prop.type !== 'Property')
+            return null;
+        if (prop.computed === true ||
+            prop.kind === 'get' ||
+            prop.kind === 'set' ||
+            prop.method === true)
+            return null;
+        const key = prop.key;
+        const name = key?.type === 'Identifier'
+            ? key.name
+            : key?.type === 'Literal' &&
+                (typeof key.value === 'string' || typeof key.value === 'number')
+                ? String(key.value)
+                : null;
+        if (name == null)
+            return null;
+        entries.push([name, evalToLiteral(prop.value)]);
+    }
+    return entries;
+}
+/** Constant-evaluate a spread property value with no environment (literals + the
+ * tiny pure operator fragment), as `{known:true,value}` or `{known:false}`. */
+function evalToLiteral(node) {
+    const r = evaluate(node, new Map());
+    return r.known ? { known: true, value: r.value } : { known: false };
+}
 /** Extract a literal from an attribute value, or `{ known:false }`. */
 function literalAttrValue(value) {
     if (value === true)

package/dist/parse.d.ts

@@ -67,6 +67,10 @@ export interface AnyNode {
     computed?: boolean | undefined;
     shorthand?: boolean | undefined;
     elseif?: boolean | undefined;
+    /** ObjectExpression `Property` accessor kind (`init` / `get` / `set`). */
+    kind?: string | undefined;
+    /** ObjectExpression `Property` shorthand-method flag (`{ m() {} }`). */
+    method?: boolean | undefined;
     value?: unknown;
 }
 export interface Root extends AnyNode {

package/dist/vite.js

@@ -1,5 +1,6 @@
 import * as fs from 'node:fs';
 import * as path from 'node:path';
+import { compile } from 'svelte/compiler';
 import { svelteShaker, svelteShakerWithMono } from './index.js';
 import { DevShaker } from './engine.js';
 import { collectSvelteFiles, fsResolve } from './scan.js';
@@ -9,6 +10,23 @@ import { tryLoadRsvelteParser } from './rsvelte-parse.js';
 function formatKB(bytes) {
     return `${(bytes / 1024).toFixed(2)} kB`;
 }
+/**
+ * Compiled-output size proxy: the bytes the Svelte compiler emits for `code`
+ * (client JS + scoped CSS).  This is the number that actually ships, so it
+ * captures what the SOURCE-byte total cannot: a dead `{#if}` arm or a removed
+ * `<style>` rule shrinks the compiled output far more than its few source bytes
+ * suggest.  Reporting-only; `null` if the (always valid) source fails to compile,
+ * so the caller can skip it without aborting the build.
+ */
+function compiledSize(code, id) {
+    try {
+        const { js, css } = compile(code, { generate: 'client', dev: false, filename: id });
+        return js.code.length + (css?.code.length ?? 0);
+    }
+    catch {
+        return null;
+    }
+}
 /**
  * Print what the shake saved.  Always emits a one-line whole-program summary;
  * when `verbose`, also lists each shrunk file (largest saving first).  Sizes are
@@ -43,6 +61,27 @@ function reportSizes(shaken, read, root, verbose, log) {
         const filePct = ((fileSaved / row.before) * 100).toFixed(1);
         log(`  ${rel}: ${formatKB(row.before)} → ${formatKB(row.after)} (-${filePct}%)`);
     }
+    // The source-byte delta UNDER-reports the real win: a folded dead branch or a
+    // removed `<style>` rule shrinks the compiled output much more than its source.
+    // Compiling is costly, so we only do it for the files that actually shrank, and
+    // only under `verbose` — it never affects the build, just the visible number.
+    let compiledBefore = 0;
+    let compiledAfter = 0;
+    for (const row of rows) {
+        const before = compiledSize(read(row.id), row.id);
+        const after = compiledSize(shaken[row.id], row.id);
+        if (before === null || after === null)
+            continue; // skip the un-compilable
+        compiledBefore += before;
+        compiledAfter += after;
+    }
+    if (compiledBefore > 0) {
+        const compiledSaved = compiledBefore - compiledAfter;
+        const compiledPct = ((compiledSaved / compiledBefore) * 100).toFixed(1);
+        log(`compiled output (js+css) of shaken files: ` +
+            `${formatKB(compiledBefore)} → ${formatKB(compiledAfter)} ` +
+            `(saved ${formatKB(compiledSaved)}, ${compiledPct}%)`);
+    }
 }
 /** Query flag a specialized-variant `.svelte` request carries (see below). */
 const VARIANT_QUERY = 'shaker_variant';

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "svelte-shaker",
-  "version": "0.6.0",
+  "version": "0.7.0",
   "description": "Tree shaking for Svelte components",
   "keywords": [
     "dead-code-elimination",