svelte-shaker 0.5.2 → 0.6.0

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

@@ -1,6 +1,6 @@
 import type MagicString from 'magic-string';
-import type { ComponentPlan } from './ir';
-import type { FileModel } from './analyze';
+import type { ComponentPlan } from './ir.js';
+import type { FileModel } from './analyze.js';
 /**
  * The set of class names any element this component renders could carry.
  * `unbounded` means at least one element has a class source we cannot enumerate

package/dist/css.js

@@ -0,0 +1,256 @@
+// ----------------------------------------------------------------------
+// CSS rule removal (docs/ARCHITECTURE.md §3 "L1.5", "CSS (shaker 独自の価値)").
+//
+// The headline differentiator: drop `<style>` rules that target a class the
+// component can PROVABLY never produce, given the value sets we computed.
+// Svelte's own unused-CSS pruning keeps `.btn-danger` for an interpolated
+// `class="btn btn-{variant}"` because it cannot see that `variant ∈
+// {primary,secondary}`; rollup cannot either (the class only exists at runtime).
+// We can, because we know the reachable value set of `variant`.
+//
+// SOUNDNESS (the whole contract): a rule is removed ONLY when the component's
+// set of possible class names is BOUNDED (every class source enumerable) and the
+// rule's every selector references a class that is NOT in that bounded set and
+// the rule has no `:global(...)`.  A removed rule therefore targets a class no
+// element can ever carry, so it could never have matched any element this
+// component renders — removing it cannot change the rendered styling of any
+// element that can actually occur.  When anything is uncertain, we KEEP the rule.
+// ----------------------------------------------------------------------
+import { walk } from './parse.js';
+import { evaluate } from './eval.js';
+/** Cap on the cartesian product of interpolated parts; over it -> unbounded. */
+const MAX_CLASS_COMBOS = 64;
+/**
+ * Compute the component's possible class set (docs §3, step 1).  Sources:
+ *  - static `class="a b"`  -> the literal tokens,
+ *  - `class:foo` directive -> `foo` is always possible (regardless of its cond),
+ *  - `class="x-{expr}"` / `class={expr}` where every interpolated `expr` is
+ *    foldable (constFold) or narrowable (narrow set) -> enumerate the tokens,
+ *  - ANY unbounded source (`class={nonFoldable}`, or a `{...spread}` that could
+ *    carry `class`) -> the whole set is unbounded.
+ */
+export function computePossibleClasses(model, plan) {
+    const classes = new Set();
+    let unbounded = false;
+    const env = plan.constFold;
+    const setEnv = plan.narrow;
+    walk(model.ast.fragment, null, {
+        _(node, { next }) {
+            if (!isElementLike(node.type)) {
+                next();
+                return;
+            }
+            for (const attr of node.attributes ?? []) {
+                // Any spread could carry a `class` -> we can no longer enumerate.
+                if (attr.type === 'SpreadAttribute') {
+                    unbounded = true;
+                    continue;
+                }
+                if (attr.type === 'ClassDirective') {
+                    // `class:foo={cond}` toggles `foo`; `foo` is always a possible class.
+                    if (attr.name)
+                        classes.add(attr.name);
+                    continue;
+                }
+                if (attr.type !== 'Attribute' || attr.name !== 'class')
+                    continue;
+                const result = classTokensFromAttr(attr.value, env, setEnv);
+                if (result === UNBOUNDED)
+                    unbounded = true;
+                else
+                    for (const c of result)
+                        classes.add(c);
+            }
+            next();
+        },
+    });
+    return { classes, unbounded };
+}
+/** Sentinel: this class source cannot be enumerated. */
+const UNBOUNDED = Symbol('unbounded-class-source');
+/**
+ * Class tokens contributed by one `class=` attribute value, or {@link UNBOUNDED}
+ * if any interpolated part is not statically enumerable.  Builds the cartesian
+ * product of each part's possible strings, then splits each candidate on
+ * whitespace into individual class tokens.
+ */
+function classTokensFromAttr(value, env, setEnv) {
+    // `class` with `value === true` is the `{class}` shorthand (i.e. `class={class}`)
+    // — a dynamic binding we cannot enumerate.
+    if (value === true)
+        return UNBOUNDED;
+    if (value == null)
+        return new Set();
+    const parts = (Array.isArray(value) ? value : [value]);
+    // Each part yields a set of possible string fragments; the attribute's
+    // possible full strings are the cartesian product (concatenated in order).
+    let combos = [''];
+    for (const part of parts) {
+        const frags = partStrings(part, env, setEnv);
+        if (frags === UNBOUNDED)
+            return UNBOUNDED;
+        const nextCombos = [];
+        for (const base of combos)
+            for (const f of frags) {
+                nextCombos.push(base + f);
+                if (nextCombos.length > MAX_CLASS_COMBOS)
+                    return UNBOUNDED;
+            }
+        combos = nextCombos;
+    }
+    const tokens = new Set();
+    for (const combo of combos)
+        for (const tok of combo.split(/\s+/))
+            if (tok)
+                tokens.add(tok);
+    return tokens;
+}
+/** The possible string values of one attribute part (Text or ExpressionTag). */
+function partStrings(part, env, setEnv) {
+    if (part.type === 'Text') {
+        return new Set([(part.data ?? part.raw ?? '')]);
+    }
+    if (part.type === 'ExpressionTag') {
+        return expressionStrings(part.expression, env, setEnv);
+    }
+    // Unknown part kind (e.g. MustacheTag in older trees): be conservative.
+    return UNBOUNDED;
+}
+/**
+ * The possible string values of an interpolated `{expr}` in a class attribute.
+ * A bare set-var enumerates its reachable literals; anything else must be a
+ * provable constant (constFold / literal).  Non-string literals are stringified
+ * the way the DOM would (`String(value)`); anything unprovable is {@link
+ * UNBOUNDED}.
+ */
+function expressionStrings(expr, env, setEnv) {
+    if (!expr)
+        return UNBOUNDED;
+    // A narrowable prop used directly: enumerate its reachable value set.
+    if (expr.type === 'Identifier' && expr.name && setEnv.has(expr.name)) {
+        const out = new Set();
+        for (const v of setEnv.get(expr.name))
+            out.add(stringifyLiteral(v));
+        return out;
+    }
+    // Otherwise it must fold to a single constant (constFold prop or literal expr).
+    // We reuse the same sound evaluator the branch folding uses.
+    const folded = evaluate(expr, env);
+    if (folded.known)
+        return new Set([stringifyLiteral(folded.value)]);
+    return UNBOUNDED;
+}
+/** How a class fragment renders into the DOM `class` attribute string. */
+function stringifyLiteral(v) {
+    // `null`/`undefined`/`false` interpolated into a string become "null"/"undefined"/"false".
+    // Svelte concatenates the template, so this matches `String(v)`.
+    return String(v);
+}
+function isElementLike(type) {
+    // Components can also forward a `class` to a root element, and `<svelte:element>`
+    // is dynamic markup — treat all of these as class-bearing for soundness.
+    return (type === 'RegularElement' ||
+        type === 'SvelteElement' ||
+        type === 'Component' ||
+        type === 'SvelteComponent' ||
+        type === 'SvelteSelf');
+}
+// ----------------------------------------------------------------------
+// Rule removal
+// ----------------------------------------------------------------------
+/**
+ * Remove provably-dead top-level `<style>` rules via MagicString span removal
+ * (docs §3, step 2/3).  A rule is removed ONLY when the possible class set is
+ * bounded, the rule contains no `:global(...)` anywhere, and EVERY selector in
+ * the rule's selector list contains at least one class `.C` with `C` absent from
+ * the possible set (so no selector in the list can match any element this
+ * component can render).  Anything else is KEPT.  Returns the number removed.
+ */
+export function shakeCss(model, plan, s) {
+    const css = model.ast.css;
+    if (!css || !css.children)
+        return 0;
+    const possible = computePossibleClasses(model, plan);
+    // If we cannot bound the class set, every interpolated class might exist:
+    // removing nothing is the only sound choice.
+    if (possible.unbounded)
+        return 0;
+    let removed = 0;
+    for (const child of css.children) {
+        // Only top-level Rules are considered.  Atrules (`@media`, `@keyframes`, …)
+        // are left entirely to Svelte's own pruning: removing a `@media` because one
+        // inner rule is dead would be unsound, and keyframes never reference classes.
+        if (child.type !== 'Rule')
+            continue;
+        if (isRuleDead(child, possible.classes)) {
+            removeRule(model.code, child, css.children, s);
+            removed += 1;
+        }
+    }
+    return removed;
+}
+/**
+ * Is this whole rule provably dead given the bounded possible class set?
+ *
+ * A rule is dead iff it contains NO `:global(...)` anywhere AND every selector in
+ * its selector list is dead — where a selector (ComplexSelector) is dead iff at
+ * least one class `.C` it requires is NOT in the possible set.  Requiring a
+ * provably-absent class anywhere in the compound/combinator chain means the whole
+ * complex selector can never match (every class in the chain must be present on
+ * some element for it to match).  If a complex selector references no class at
+ * all (pure element/id/attribute/pseudo), it is NOT dead — we never remove such
+ * rules.  An empty selector list is treated as not-dead (keep).
+ */
+function isRuleDead(rule, possible) {
+    if (hasGlobal(rule))
+        return false;
+    const complexes = rule.prelude?.children ?? [];
+    if (complexes.length === 0)
+        return false;
+    return complexes.every((complex) => isComplexDead(complex, possible));
+}
+/**
+ * A ComplexSelector is dead iff it requires (via a `ClassSelector`) at least one
+ * class that the component can never produce.  Every class named in the chain
+ * must be present on a matching element, so a single absent required class makes
+ * the whole selector unmatchable.
+ */
+function isComplexDead(complex, possible) {
+    let dead = false;
+    for (const rel of complex.children ?? []) {
+        for (const sel of rel.selectors ?? []) {
+            if (sel.type === 'ClassSelector' && sel.name && !possible.has(sel.name)) {
+                dead = true;
+            }
+        }
+    }
+    return dead;
+}
+/** Does any selector in this rule use `:global(...)`?  If so we never touch it. */
+function hasGlobal(rule) {
+    let found = false;
+    walk(rule, null, {
+        _(node, { next }) {
+            if (node.type === 'PseudoClassSelector' && node.name === 'global')
+                found = true;
+            next();
+        },
+    });
+    return found;
+}
+/**
+ * Remove a rule's source span, eating the run of whitespace before it so the
+ * `<style>` body stays tidy and Svelte still parses what remains.
+ */
+function removeRule(code, rule, siblings, s) {
+    const i = siblings.indexOf(rule);
+    const prev = siblings[i - 1];
+    // Start just after the previous sibling (or after the leading whitespace at
+    // the top of the stylesheet); end at the rule's end.  This removes the rule
+    // and the blank line/indentation that preceded it.
+    let start = rule.start;
+    const floor = prev ? prev.end : 0;
+    while (start > floor && /\s/.test(code[start - 1]))
+        start -= 1;
+    s.remove(start, rule.end);
+}

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

@@ -1,5 +1,5 @@
-import { type AnyNode } from './parse';
-import type { Literal } from './ir';
+import { type AnyNode } from './parse.js';
+import type { Literal } from './ir.js';
 export type Span = [number, number];
 /** One arm of an `{#if}` / `{:else if}` chain in source order. */
 interface ChainArm {

package/dist/dead.js

@@ -0,0 +1,195 @@
+// ----------------------------------------------------------------------
+// Shared `{#if}`-folding predicate (docs/ARCHITECTURE.md §3, §13).
+//
+// Both the transform (which *edits* the source) and the analysis fixpoint
+// (which needs to know *which call sites disappear*) must agree, to the byte,
+// on what folds away — otherwise the fixpoint could exclude a call site the
+// transform actually keeps (unsound) or keep one the transform removes (misses
+// a cascade).  So the decision for a single if/else-if chain lives here, once,
+// and is consumed by both:
+//   - transform.ts turns a `ChainDecision` into MagicString edits.
+//   - computeDeadSpans() turns the same decisions into the spans of source that
+//     genuinely vanish from the output (used to drop call sites in dead code).
+// ----------------------------------------------------------------------
+import { walk } from './parse.js';
+import { evaluateWithSets } from './eval.js';
+/**
+ * Collect the arms of an `{#if}` / `{:else if}` chain in source order, plus the
+ * trailing `{:else}` fragment if present.  Each arm carries its own IfBlock node
+ * (the head, or an `elseif` continuation).
+ */
+export function collectChain(top) {
+    const arms = [];
+    let cur = top;
+    let elseFrag;
+    while (cur) {
+        arms.push({ block: cur, test: cur.test, consequent: cur.consequent });
+        const alt = cur.alternate;
+        // `{:else if}` is encoded as an alternate Fragment whose only node is an
+        // IfBlock with `elseif === true`; a plain `{:else}` is any other Fragment.
+        const elseif = alt?.type === 'Fragment' &&
+            alt.nodes?.length === 1 &&
+            alt.nodes[0]?.type === 'IfBlock' &&
+            alt.nodes[0].elseif === true
+            ? alt.nodes[0]
+            : undefined;
+        if (elseif) {
+            cur = elseif;
+        }
+        else {
+            if (alt?.type === 'Fragment')
+                elseFrag = alt;
+            cur = undefined;
+        }
+    }
+    return elseFrag ? { arms, elseFrag } : { arms };
+}
+/**
+ * Decide how one if/else-if chain folds against `env` (constFold) and `setEnv`
+ * (value sets).  Soundness: an arm is dropped only when its test is provably
+ * FALSE for every reachable value; the chain collapses to a consequent only when
+ * an arm is provably TRUE and every earlier arm is provably FALSE.  Otherwise
+ * the head is kept and callers recurse for nested blocks.
+ *
+ * This is the single source of truth used by BOTH the transform and the
+ * analysis fixpoint, so they can never disagree on what folds.
+ */
+export function decideChain(top, env, setEnv) {
+    const { arms, elseFrag } = collectChain(top);
+    const span = [top.start, top.end];
+    // An `{#if}` test fires on truthiness; a known result (const literal OR a
+    // proven set-boolean) settles the arm, anything else leaves it live.
+    const truth = arms.map((a) => evaluateWithSets(a.test, env, setEnv));
+    const isTrue = (t) => t.known && Boolean(t.value);
+    const isFalse = (t) => t.known && !t.value;
+    // (a) An arm is provably TRUE and every earlier arm is provably FALSE -> that
+    // arm is always taken: collapse the whole chain to its consequent.
+    let allEarlierFalse = true;
+    for (let i = 0; i < arms.length; i++) {
+        const t = truth[i];
+        if (isTrue(t) && allEarlierFalse) {
+            const consequent = arms[i].consequent;
+            return {
+                span,
+                kept: consequent,
+                removed: aroundKept(span, fragmentSpan(consequent)),
+                recurse: false, // re-emitted verbatim; transform does not re-walk it
+            };
+        }
+        if (!isFalse(t))
+            allEarlierFalse = false;
+    }
+    // (b) Otherwise keep the arms that are not provably false.
+    const firstKept = truth.findIndex((t) => !isFalse(t));
+    if (firstKept === -1) {
+        // Every arm is provably false: only the `{:else}` (if any) can render.
+        if (elseFrag) {
+            return {
+                span,
+                kept: elseFrag,
+                removed: aroundKept(span, fragmentSpan(elseFrag)),
+                recurse: false,
+            };
+        }
+        return { span, kept: undefined, removed: [span], recurse: false };
+    }
+    if (firstKept === 0) {
+        // Head survives in place: only later provably-false arms are removed, and
+        // nested `{#if}` inside the kept arms must still be folded -> recurse.
+        return {
+            span,
+            kept: undefined,
+            removed: deadTail(arms, truth, firstKept),
+            recurse: true,
+        };
+    }
+    // Head (and maybe more) is provably false: delete the dead prefix and promote
+    // the first surviving arm from `{:else if …}` to `{#if …}`.  The promoted arm
+    // is re-emitted verbatim, so we do not recurse into it.
+    const kept = arms[firstKept].block;
+    const removed = [[span[0], kept.start], ...deadTail(arms, truth, firstKept)];
+    return {
+        span,
+        kept: undefined,
+        removed,
+        recurse: false,
+        // `{:else if ` -> `{#if ` (header runs from the block start to its test).
+        headerRewrite: { from: kept.start, to: kept.test.start, text: '{#if ' },
+    };
+}
+/** The two ranges of `span` that fall outside the kept inner `[s, e]`. */
+function aroundKept(span, inner) {
+    if (!inner)
+        return [span]; // empty consequent -> the whole chain is removed
+    const out = [];
+    if (span[0] < inner[0])
+        out.push([span[0], inner[0]]);
+    if (inner[1] < span[1])
+        out.push([inner[1], span[1]]);
+    return out;
+}
+/** Source span covered by a fragment's nodes, or `null` if it is empty. */
+function fragmentSpan(fragment) {
+    const nodes = fragment?.nodes ?? [];
+    if (nodes.length === 0)
+        return null;
+    return [nodes[0].start, nodes[nodes.length - 1].end];
+}
+/**
+ * Removed ranges for provably-false arms AFTER `from` in a chain whose head we
+ * keep.  Each dead arm spans from its own block start up to the next arm's block
+ * start (or, for the last arm, up to the end of its consequent) — matching the
+ * transform's surgical deletion exactly.
+ */
+function deadTail(arms, truth, from) {
+    const removed = [];
+    for (let i = from + 1; i < arms.length; i++) {
+        const t = truth[i];
+        if (!(t.known && !t.value))
+            continue; // not provably dead -> keep
+        const arm = arms[i];
+        const nextBlock = arms[i + 1]?.block;
+        const end = nextBlock ? nextBlock.start : consequentEnd(arm.consequent, arm.block.end);
+        removed.push([arm.block.start, end]);
+    }
+    return removed;
+}
+/** End offset of a consequent fragment (its last node), or a fallback. */
+export function consequentEnd(fragment, fallback) {
+    const nodes = fragment?.nodes ?? [];
+    return nodes.length ? nodes[nodes.length - 1].end : fallback;
+}
+/** Is `node` fully contained in any of the given spans? */
+export function inSpans(node, spans) {
+    return spans.some(([a, b]) => node.start >= a && node.end <= b);
+}
+/**
+ * Compute the source spans that genuinely vanish from a component's output when
+ * its plan is applied — i.e. the markup deleted by dead-`{#if}` folding.  This
+ * is the SAME predicate the transform uses (both go through {@link decideChain}),
+ * so a call site is excluded from a child's prop profile iff the transform would
+ * actually delete it (docs §2.1 cascade).
+ *
+ * We mirror the transform's walk: a chain whose head we keep is recursed into
+ * (nested blocks can still fold); a chain we rewrote/collapsed is not, and its
+ * span is skipped on later visits via `inSpans`.
+ */
+export function computeDeadSpans(fragment, env, setEnv) {
+    if (env.size === 0 && setEnv.size === 0)
+        return [];
+    const dead = [];
+    walk(fragment, null, {
+        IfBlock(node, { next }) {
+            // `elseif` IfBlocks are the continuation of a chain we already own from
+            // its head; skip them.  Also skip any block inside a region we removed.
+            if (node.elseif || inSpans(node, dead))
+                return;
+            const decision = decideChain(node, env, setEnv);
+            for (const r of decision.removed)
+                dead.push(r);
+            if (decision.recurse)
+                next();
+        },
+    });
+    return dead;
+}

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

@@ -1,6 +1,6 @@
-import { type ReadFile, type Resolve } from './analyze';
-import type { Parse } from './parse';
-import type { ComponentId, EditResult } from './ir';
+import { type ReadFile, type Resolve } from './analyze.js';
+import type { Parse } from './parse.js';
+import type { ComponentId, EditResult } from './ir.js';
 /**
  * dev shake granularity (docs/RUST-MIGRATION.md §3 M2 / ARCHITECTURE §6.2):
  *  - `'coarse'`     — every change re-reads, re-parses, and re-analyzes the whole

package/dist/engine.js

@@ -0,0 +1,109 @@
+import { analyzeInput, buildAnalyzeInput } from './analyze.js';
+import { transformAll } from './transform.js';
+/**
+ * A long-lived, incremental whole-program shaker for `vite dev` (docs §2.1, §3
+ * M2).  Construct it with the FULL file set (the Shell's FS scan — the call-site
+ * completeness boundary, ARCHITECTURE §6.2) and the same `resolve`/`readFile` the
+ * build path uses; call {@link init} once, then {@link update} on every file
+ * change.  `update` returns the components whose SLIMMED OUTPUT changed, which the
+ * Shell turns into the widened HMR boundary.
+ *
+ * L2 monomorphization is intentionally NOT applied in dev (its net-win gate is a
+ * whole-program measurement that is expensive to keep incrementally correct); dev
+ * covers L0/L1/L1.5 only (docs §5 risks).
+ */
+export class DevShaker {
+    entries = new Set();
+    resolve;
+    readFile;
+    mode;
+    /** Non-default parser (e.g. rsvelte), or `undefined` for svelte/compiler. */
+    parse;
+    /** Content-keyed AST cache — only changed files re-parse (§2.2). */
+    parseCache = new Map();
+    /** Last-seen source per file, so an update re-reads only what changed. */
+    codeCache = new Map();
+    /** Current slimmed output per `.svelte` id (the live shake result). */
+    output = {};
+    constructor(files, resolve, readFile, mode = 'incremental', parse) {
+        for (const id of Array.isArray(files) ? files : [files])
+            this.entries.add(id);
+        this.resolve = resolve;
+        this.readFile = readFile;
+        this.mode = mode;
+        this.parse = parse;
+    }
+    /** Full initial shake of the program.  Returns the slimmed source per file. */
+    async init() {
+        this.output = await this.shake();
+        return this.output;
+    }
+    /** The current slimmed source for a file, or `undefined` if not in the program. */
+    get(id) {
+        return this.output[id];
+    }
+    /** A copy of the current whole-program output (every file's slimmed source). */
+    snapshot() {
+        return { ...this.output };
+    }
+    /**
+     * Apply a batch of file changes and re-shake.  Returns the delta: the
+     * components whose output changed (a superset of the edited files — a call-site
+     * edit can change a child's residual) and the ones no longer in the program.
+     */
+    async update(change) {
+        const incremental = this.mode === 'incremental';
+        for (const id of change.removed ?? []) {
+            this.entries.delete(id);
+            this.codeCache.delete(id);
+            this.parseCache.delete(id);
+        }
+        for (const id of change.added ?? []) {
+            this.entries.add(id);
+            if (incremental)
+                this.codeCache.set(id, await this.readFile(id));
+        }
+        for (const id of change.changed ?? []) {
+            // Re-read into the code cache; `parseCached` re-parses on the content
+            // mismatch, so no explicit parse-cache invalidation is needed here.
+            if (incremental)
+                this.codeCache.set(id, await this.readFile(id));
+        }
+        const prev = this.output;
+        const next = await this.shake();
+        this.output = next;
+        const changed = {};
+        for (const id of Object.keys(next)) {
+            if (prev[id] !== next[id])
+                changed[id] = next[id];
+        }
+        const removed = Object.keys(prev).filter((id) => !(id in next));
+        return { changed, removed };
+    }
+    /**
+     * Run the whole-program shake.  In `'incremental'` mode it reads through the
+     * code/parse caches (so unchanged files are neither re-read nor re-parsed); in
+     * `'coarse'` mode it bypasses both for a from-scratch rebuild.  Both produce
+     * identical output — only the work differs.
+     */
+    async shake() {
+        const useCache = this.mode === 'incremental';
+        const read = useCache ? this.cachedReadFile : this.readFile;
+        // Share one cache between the crawl and the analysis so a non-default parser
+        // runs once per file (persistent in incremental, a throwaway in coarse). With
+        // the default parser this stays `undefined` in coarse mode — unchanged.
+        const parseCache = useCache ? this.parseCache : this.parse ? new Map() : undefined;
+        const input = await buildAnalyzeInput([...this.entries], this.resolve, read, parseCache, this.parse);
+        const { models, plans } = analyzeInput(input, parseCache);
+        return transformAll(models, plans);
+    }
+    /** Read through the code cache, disk-reading and caching on a miss. */
+    cachedReadFile = async (id) => {
+        const cached = this.codeCache.get(id);
+        if (cached !== undefined)
+            return cached;
+        const code = await this.readFile(id);
+        this.codeCache.set(id, code);
+        return code;
+    };
+}

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

@@ -1,5 +1,5 @@
-import type { AnyNode } from './parse';
-import type { Literal } from './ir';
+import type { AnyNode } from './parse.js';
+import type { Literal } from './ir.js';
 export type EvalResult = {
     known: true;
     value: Literal;