svelte-shaker 0.9.0 → 0.9.1

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.1",
   "description": "Tree shaking for Svelte components",
   "keywords": [
     "dead-code-elimination",