svelte-shaker 0.15.1 → 0.15.2

package/dist/analyze.js

@@ -1,7 +1,7 @@
 import { parseCached, parseModuleProgram, walk, } from './parse.js';
 import { emptyPlan, } from './ir.js';
 import { computeDeadSpans, inSpans } from './dead.js';
-import { evaluate, setVar } from './eval.js';
+import { evaluate, setVar, unwrapTsAssertions } from './eval.js';
 const isSvelte = (source) => source.endsWith('.svelte');
 /** Floor for the fixpoint iteration bound (see {@link fixpointIterationBound}). */
 const MIN_FIXPOINT_ITERATIONS = 10;
@@ -856,6 +856,11 @@ function computeScriptConstEnv(ast, instance, moduleScript, propsDeclaration, wr
  * rune call — is evaluated verbatim, so a non-value rune simply falls to unknown.
  */
 function evalDeclaratorValue(init, env) {
+    // `const x = $state(0) as T` wraps the rune in a `TSAsExpression`; erase the
+    // (runtime-transparent) assertion first so the `$state`/`$state.raw` unwrap
+    // below and `evaluate` both see the real initializer, same as a parser that
+    // strips the assertion would.
+    init = unwrapTsAssertions(init) ?? undefined;
     if (isStateRuneCall(init)) {
         const arg = init?.arguments?.[0];
         if (arg == null)
@@ -1081,9 +1086,13 @@ function collectTemplateBindings(ast, instance, propsDeclaration) {
 function collectWrittenNames(node, out) {
     if (node.type === 'AssignmentExpression')
         addPatternNames(node.left, out);
-    else if (node.type === 'UpdateExpression' && node.argument?.type === 'Identifier') {
-        if (node.argument.name)
-            out.add(node.argument.name);
+    else if (node.type === 'UpdateExpression') {
+        // `x!++` keeps the `!` as a `TSNonNullExpression` around the target (only a
+        // bare `x = …` LHS is normalized to the identifier), so read through it or the
+        // write goes uncounted and the name is wrongly admitted as a constant.
+        const arg = unwrapTsAssertions(node.argument);
+        if (arg?.type === 'Identifier' && arg.name)
+            out.add(arg.name);
     }
 }
 /**
@@ -1091,6 +1100,11 @@ function collectWrittenNames(node, out) {
  * Handles bare identifiers, object/array destructuring, defaults and rest.
  */
 function addPatternNames(pattern, out) {
+    // A non-null-asserted assignment target keeps its `TSNonNullExpression` wrapper
+    // in every position but a bare `x = …` LHS — `x! += 1`, `[x!] = a`, `({k: x!} =
+    // o)` — so peel it here (the one choke point every pattern position recurses
+    // through) to count the write against the bare name.
+    pattern = unwrapTsAssertions(pattern) ?? undefined;
     if (!pattern)
         return;
     switch (pattern.type) {
@@ -1467,8 +1481,14 @@ function literalAttrValue(value) {
         const part = parts[0];
         if (part.type === 'Text')
             return { known: true, value: (part.data ?? part.raw ?? '') };
-        if (part.type === 'ExpressionTag' && part.expression?.type === 'Literal') {
-            return { known: true, value: part.expression.value };
+        if (part.type === 'ExpressionTag') {
+            // Recognize `prop={'x' as const}` as the literal it wraps, so the write is
+            // classified NON-dynamic identically to a parser that strips the assertion.
+            // Both paths already fold the value (via the expr fallback), but the
+            // `dynamic` flag itself must match — mono's `specializableShape` reads it.
+            const expr = unwrapTsAssertions(part.expression);
+            if (expr?.type === 'Literal')
+                return { known: true, value: expr.value };
         }
         return { known: false };
     }
@@ -1608,6 +1628,9 @@ function valueSetFor(decl, sites, ownerEnv) {
     return { values, dynamic, top };
 }
 function literalDefault(expr) {
+    // A default like `= 500 as const` reaches here as a `TSAsExpression`; the
+    // assertion erases at runtime, so read through it to the bare default value.
+    expr = unwrapTsAssertions(expr) ?? undefined;
     if (!expr)
         return { known: true, value: undefined }; // omitted default -> undefined
     if (expr.type === 'Literal')

package/dist/eval.d.ts

@@ -6,6 +6,21 @@ export type EvalResult = {
 } | {
     known: false;
 };
+/**
+ * Strip TypeScript assertion wrappers — `x as T` (`TSAsExpression`), `x!`
+ * (`TSNonNullExpression`), `x satisfies T` (`TSSatisfiesExpression`) — down to
+ * the runtime expression they wrap, recursing so `('a' as const)!` becomes `'a'`.
+ *
+ * These are compile-time-only type operators: they are erased before any code
+ * runs and do not touch the operand's value, so interpreting the operand IS
+ * interpreting the whole expression (docs/ARCHITECTURE.md §2.2 — the value the
+ * expression abstracts to is exactly the operand's). The engine runs on the
+ * `lang="ts"` source with types preserved (§6.3), so svelte/compiler hands it
+ * these nodes verbatim; a parser that erases them (rsvelte today) yields the bare
+ * operand instead. Unwrapping here folds both ASTs identically — the
+ * parser-neutrality contract every value-interpreting entry point relies on.
+ */
+export declare function unwrapTsAssertions(node: AnyNode | null | undefined): AnyNode | null | undefined;
 /**
  * A deliberately tiny, total constant evaluator over an ESTree expression,
  * given an environment of statically-known identifiers.  It never throws and

package/dist/eval.js

@@ -1,4 +1,27 @@
 const UNKNOWN = { known: false };
+/**
+ * Strip TypeScript assertion wrappers — `x as T` (`TSAsExpression`), `x!`
+ * (`TSNonNullExpression`), `x satisfies T` (`TSSatisfiesExpression`) — down to
+ * the runtime expression they wrap, recursing so `('a' as const)!` becomes `'a'`.
+ *
+ * These are compile-time-only type operators: they are erased before any code
+ * runs and do not touch the operand's value, so interpreting the operand IS
+ * interpreting the whole expression (docs/ARCHITECTURE.md §2.2 — the value the
+ * expression abstracts to is exactly the operand's). The engine runs on the
+ * `lang="ts"` source with types preserved (§6.3), so svelte/compiler hands it
+ * these nodes verbatim; a parser that erases them (rsvelte today) yields the bare
+ * operand instead. Unwrapping here folds both ASTs identically — the
+ * parser-neutrality contract every value-interpreting entry point relies on.
+ */
+export function unwrapTsAssertions(node) {
+    let current = node;
+    while (current?.type === 'TSAsExpression' ||
+        current?.type === 'TSNonNullExpression' ||
+        current?.type === 'TSSatisfiesExpression') {
+        current = current.expression;
+    }
+    return current;
+}
 /**
  * A deliberately tiny, total constant evaluator over an ESTree expression,
  * given an environment of statically-known identifiers.  It never throws and
@@ -9,6 +32,7 @@ const UNKNOWN = { known: false };
  * unknown on non-distributive ops), just without the interprocedural lattice.
  */
 export function evaluate(node, env) {
+    node = unwrapTsAssertions(node);
     if (!node)
         return UNKNOWN;
     switch (node.type) {
@@ -126,6 +150,7 @@ export function evaluateWithSets(node, constEnv, setEnv) {
 }
 /** Evaluate a boolean condition to a Kleene truth over the value sets. */
 function evalTri(node, constEnv, setEnv) {
+    node = unwrapTsAssertions(node);
     if (!node)
         return 'unknown';
     switch (node.type) {
@@ -193,8 +218,11 @@ function equalityTri(left, right, constEnv, setEnv, loose) {
  * set pass-through (analyze.ts) all decide it through this, so they stay in lockstep.
  */
 export function setVar(node, setEnv) {
-    if (node?.type === 'Identifier' && node.name && setEnv.has(node.name))
-        return setEnv.get(node.name);
+    // A `variant as const` / `variant!` reference is still a bare read of `variant`
+    // (the assertion erases at runtime), so it narrows like the identifier it wraps.
+    const bare = unwrapTsAssertions(node);
+    if (bare?.type === 'Identifier' && bare.name && setEnv.has(bare.name))
+        return setEnv.get(bare.name);
     return null;
 }
 /**

package/package.json

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