svelte-shaker 0.9.0 → 0.9.2

package/dist/analyze.js

@@ -567,6 +567,9 @@ function collectEscapedComponents(ast, imports, importedLocals, namespaceLocals)
     };
     walk(ast.fragment, { parent: null }, {
         _(node, { state, next }) {
+            // Type-only subtrees are erased at compile — never a runtime escape.
+            if (isTypeOnlyNode(node))
+                return;
             if (node.type === 'Identifier' &&
                 node.name &&
                 importedLocals.has(node.name) &&
@@ -581,6 +584,11 @@ function collectEscapedComponents(ast, imports, importedLocals, namespaceLocals)
     if (ast.instance) {
         walk(ast.instance, { parent: null }, {
             _(node, { state, next }) {
+                // Skip TS type positions: an identifier in `ComponentProps<typeof X>`
+                // or `: Props` is type-level (erased at compile), not a value read, so
+                // descending would falsely flag the component as escaped.
+                if (isTypeOnlyNode(node))
+                    return;
                 if (node.type === 'Identifier' &&
                     node.name &&
                     (imports.has(node.name) || namespaceLocals.has(node.name)) &&
@@ -594,6 +602,23 @@ function collectEscapedComponents(ast, imports, importedLocals, namespaceLocals)
     }
     return escaped;
 }
+/**
+ * A TS type-only subtree the escape walk must NOT descend into: every `TSType*`
+ * node (type annotations, type references/queries, type-argument and
+ * type-parameter lists, …) plus `interface` declarations.  Identifiers inside
+ * them — e.g. `Button` in `ComponentProps<typeof Button>['pattern']`, or `Props`
+ * in `: Props` — are type-level, erased at compile, never runtime value reads, so
+ * descending would falsely flag the component as escaped and bail it whole.
+ *
+ * `TSAsExpression` / `TSSatisfiesExpression` / `TSNonNullExpression` /
+ * `TSInstantiationExpression` are deliberately NOT pruned: they wrap a real
+ * runtime expression (`Button as T` IS a value use of `Button`), and their own
+ * type child is itself a `TSType*` node this prunes.
+ */
+function isTypeOnlyNode(node) {
+    return (typeof node.type === 'string' &&
+        (node.type.startsWith('TSType') || node.type === 'TSInterfaceDeclaration'));
+}
 /**
  * Is this Identifier used as a runtime *value* (so a component name here would
  * escape)?  Property keys, member names and import/export specifier slots are

package/dist/transform.js

@@ -274,12 +274,17 @@ outDead) {
  * or gain a space.
  */
 function foldIfBlocks(fragment, env, setEnv, code, s, dead) {
-    walk(fragment, { parent: null, preserve: hasPreserveWhitespaceOption(fragment) }, {
+    walk(fragment, { parent: null, preserve: hasPreserveWhitespaceOption(fragment), element: null }, {
         _(node, { state, next }) {
             if (node.type !== 'IfBlock') {
-                // Descend, recording this node as the children's parent and whether it
-                // opens a preserved-whitespace context for them.
-                next({ parent: node, preserve: state.preserve || isPreserveElement(node) });
+                // Descend, recording this node as the children's parent, whether it
+                // opens a preserved-whitespace context, and the content-model element
+                // their seam would land in (for the `{" "}` validity check).
+                next({
+                    parent: node,
+                    preserve: state.preserve || isPreserveElement(node),
+                    element: childParentElement(node, state.element),
+                });
                 return;
             }
             // `elseif` IfBlocks are the *continuation* of a chain we already own from
@@ -294,9 +299,12 @@ function foldIfBlocks(fragment, env, setEnv, code, s, dead) {
                 // node as its children's parent), so its `nodes` are the chain's siblings.
                 index: state.parent?.nodes?.indexOf(node) ?? -1,
                 preserve: state.preserve,
+                element: state.element,
             });
+            // kept head: descend for nested blocks. The `{#if}` is transparent to the
+            // content model, so children stay in the same parent element.
             if (decision.recurse)
-                next({ parent: node, preserve: state.preserve }); // kept head: descend for nested blocks
+                next({ parent: node, preserve: state.preserve, element: state.element });
             // otherwise the subtree is gone or re-emitted verbatim — do not recurse.
         },
     });
@@ -366,10 +374,12 @@ function isFullRemoval(decision) {
  * edge-trimmed, so it renders exactly one space wherever it lands, matching the
  * original.  Otherwise plain deletion already preserves space presence (only the
  * run LENGTH can differ, which the SSR oracle normalizes).  Never compensate
- * under preserved whitespace — there plain deletion is byte-exact.
+ * under preserved whitespace — there plain deletion is byte-exact — nor inside a
+ * text-free parent (`<tr>`, `<tbody>`, …), where Svelte rejects the `{" "}` text
+ * child outright and the whitespace rendered nothing to begin with.
  */
 function removeChain(removed, span, code, s, dead, ctx) {
-    if (!ctx.preserve && ctx.parent?.nodes && ctx.index >= 0) {
+    if (!ctx.preserve && !isTextFreeParent(ctx.element) && ctx.parent?.nodes && ctx.index >= 0) {
         const seam = analyzeSeam(ctx.parent.nodes, ctx.index, span, code, dead);
         if (seam) {
             s.overwrite(seam[0], seam[1], '{" "}');
@@ -431,6 +441,49 @@ function isRenderingSibling(node, code) {
 function isPreserveElement(node) {
     return node.type === 'RegularElement' && (node.name === 'pre' || node.name === 'textarea');
 }
+/**
+ * Parent elements whose HTML content model forbids a text child: Svelte's
+ * `is_tag_valid_with_parent('#text', …)` rejects a `#text`/`{" "}` here with
+ * `node_invalid_placement` — these are exactly its `disallowed_children` entries
+ * that carry an `only` list (html/head/frameset/#document can't appear as
+ * elements inside a component, so only the table parts remain).  Svelte never
+ * renders inter-child whitespace inside them either, so a removed chain's seam
+ * needs plain deletion: emitting the `{" "}` compensation would produce a
+ * component that fails to compile. See {@link removeChain}.
+ */
+const TEXT_FREE_PARENTS = new Set(['table', 'thead', 'tbody', 'tfoot', 'tr', 'colgroup']);
+/**
+ * Node types that reset the content-model parent to "unknown" (text allowed
+ * again), mirroring svelte's `parent_element: null` reset in the SvelteElement /
+ * SvelteFragment / SnippetBlock / Component visitors.  A `{" "}` seam in any of
+ * these contexts is valid, so the seam compensation may proceed.
+ */
+const PARENT_ELEMENT_RESET = new Set([
+    'SvelteElement',
+    'SvelteFragment',
+    'SnippetBlock',
+    'Component',
+    'SvelteSelf',
+    'SvelteComponent',
+]);
+/**
+ * The content-model parent element a seam would land in for `node`'s children,
+ * given the element the walk is currently inside.  Mirrors svelte's
+ * `parent_element` threading: a `RegularElement` becomes the parent, the reset
+ * node types clear it, and every other node (Fragment, blocks, …) is transparent
+ * and inherits.  `null` means "text allowed" (root or a reset context).
+ */
+function childParentElement(node, current) {
+    if (node.type === 'RegularElement')
+        return node.name ?? null;
+    if (PARENT_ELEMENT_RESET.has(node.type))
+        return null;
+    return current;
+}
+/** True when an `{" "}` seam would be an invalid text child of `element`. */
+function isTextFreeParent(element) {
+    return element !== null && TEXT_FREE_PARENTS.has(element);
+}
 /** Does the component opt into preserved whitespace via `<svelte:options>`? */
 function hasPreserveWhitespaceOption(fragment) {
     let preserve = false;

package/package.json

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