@sigil-dev/compiler 0.9.6 → 0.9.7

package/src/babel/jsx/children.ts

@@ -1,108 +1,108 @@
-import { types as t } from "@babel/core";
-import { processElement } from "./element";
-import { processFragment } from "./fragment";
-
-/**
- * Collect children from a JSX element into a children expression.
- * Returns null if no meaningful children exist.
- *
- * DOM mode evaluates each JSX child immediately — the component receives real
- * nodes. Hydrate mode emits thunks instead: a component's children live inside
- * *its* root element, a subtree the call site cannot see, so they must claim
- * from the pool that `hydrateSlot` pushes at the `{children}` site rather than
- * from the caller's pool. Evaluating them eagerly here made them steal the
- * component's own SSR root and re-render it (double render).
- */
-export function collectChildren(
-	node: t.JSXElement,
-	_statements: t.Statement[],
-	genId: () => string,
-	signals: Set<string>,
-	hash?: string,
-	hydrate?: boolean,
-	nodesVar?: string,
-): t.Expression | null {
-	const childrenElements: t.Expression[] = [];
-	let hasOnlyText = true;
-	// Deferred children open their own scope from the hydration stack.
-	const childNodesVar = hydrate ? "__nodes" : nodesVar;
-
-	for (const child of node.children) {
-		if (t.isJSXText(child)) {
-			const text = child.value.trim();
-			if (!text) continue;
-			childrenElements.push(t.stringLiteral(text));
-			continue;
-		}
-
-		let jsx: t.JSXElement | t.JSXFragment | null = null;
-		if (t.isJSXElement(child) || t.isJSXFragment(child)) {
-			jsx = child;
-		} else if (t.isJSXExpressionContainer(child)) {
-			const expr = child.expression;
-			if (t.isJSXEmptyExpression(expr)) continue;
-			if (t.isJSXElement(expr) || t.isJSXFragment(expr)) {
-				jsx = expr;
-			} else {
-				// Plain expression child — pass the value straight through.
-				hasOnlyText = false;
-				childrenElements.push(expr);
-				continue;
-			}
-		} else {
-			continue;
-		}
-
-		hasOnlyText = false;
-		const childStatements: t.Statement[] = [];
-		const childVar = t.isJSXElement(jsx)
-			? processElement(
-					jsx,
-					childStatements,
-					genId,
-					signals,
-					hash,
-					hydrate,
-					childNodesVar,
-				)
-			: processFragment(
-					jsx,
-					childStatements,
-					genId,
-					signals,
-					hash,
-					hydrate,
-					childNodesVar,
-				);
-
-		const body: t.Statement[] = [];
-		if (hydrate) {
-			// const __nodes = getHydrationNodes() — resolved when the thunk runs
-			body.push(
-				t.variableDeclaration("const", [
-					t.variableDeclarator(
-						t.identifier("__nodes"),
-						t.callExpression(t.identifier("getHydrationNodes"), []),
-					),
-				]),
-			);
-		}
-		body.push(...childStatements, t.returnStatement(t.identifier(childVar)));
-		const thunk = t.arrowFunctionExpression([], t.blockStatement(body));
-		childrenElements.push(hydrate ? thunk : t.callExpression(thunk, []));
-	}
-
-	if (childrenElements.length === 0) return null;
-	// Build the inner value: string for single text, array otherwise
-	let inner: t.Expression;
-	if (
-		childrenElements.length === 1 &&
-		hasOnlyText &&
-		t.isStringLiteral(childrenElements[0])
-	) {
-		inner = childrenElements[0];
-	} else {
-		inner = t.arrayExpression(childrenElements);
-	}
-	return inner;
-}
+import { types as t } from "@babel/core";
+import { processElement } from "./element";
+import { processFragment } from "./fragment";
+
+/**
+ * Collect children from a JSX element into a children expression.
+ * Returns null if no meaningful children exist.
+ *
+ * DOM mode evaluates each JSX child immediately — the component receives real
+ * nodes. Hydrate mode emits thunks instead: a component's children live inside
+ * *its* root element, a subtree the call site cannot see, so they must claim
+ * from the pool that `hydrateSlot` pushes at the `{children}` site rather than
+ * from the caller's pool. Evaluating them eagerly here made them steal the
+ * component's own SSR root and re-render it (double render).
+ */
+export function collectChildren(
+	node: t.JSXElement,
+	_statements: t.Statement[],
+	genId: () => string,
+	signals: Set<string>,
+	hash?: string,
+	hydrate?: boolean,
+	nodesVar?: string,
+): t.Expression | null {
+	const childrenElements: t.Expression[] = [];
+	let hasOnlyText = true;
+	// Deferred children open their own scope from the hydration stack.
+	const childNodesVar = hydrate ? "__nodes" : nodesVar;
+
+	for (const child of node.children) {
+		if (t.isJSXText(child)) {
+			const text = child.value.trim();
+			if (!text) continue;
+			childrenElements.push(t.stringLiteral(text));
+			continue;
+		}
+
+		let jsx: t.JSXElement | t.JSXFragment | null = null;
+		if (t.isJSXElement(child) || t.isJSXFragment(child)) {
+			jsx = child;
+		} else if (t.isJSXExpressionContainer(child)) {
+			const expr = child.expression;
+			if (t.isJSXEmptyExpression(expr)) continue;
+			if (t.isJSXElement(expr) || t.isJSXFragment(expr)) {
+				jsx = expr;
+			} else {
+				// Plain expression child — pass the value straight through.
+				hasOnlyText = false;
+				childrenElements.push(expr);
+				continue;
+			}
+		} else {
+			continue;
+		}
+
+		hasOnlyText = false;
+		const childStatements: t.Statement[] = [];
+		const childVar = t.isJSXElement(jsx)
+			? processElement(
+					jsx,
+					childStatements,
+					genId,
+					signals,
+					hash,
+					hydrate,
+					childNodesVar,
+				)
+			: processFragment(
+					jsx,
+					childStatements,
+					genId,
+					signals,
+					hash,
+					hydrate,
+					childNodesVar,
+				);
+
+		const body: t.Statement[] = [];
+		if (hydrate) {
+			// const __nodes = getHydrationNodes() — resolved when the thunk runs
+			body.push(
+				t.variableDeclaration("const", [
+					t.variableDeclarator(
+						t.identifier("__nodes"),
+						t.callExpression(t.identifier("getHydrationNodes"), []),
+					),
+				]),
+			);
+		}
+		body.push(...childStatements, t.returnStatement(t.identifier(childVar)));
+		const thunk = t.arrowFunctionExpression([], t.blockStatement(body));
+		childrenElements.push(hydrate ? thunk : t.callExpression(thunk, []));
+	}
+
+	if (childrenElements.length === 0) return null;
+	// Build the inner value: string for single text, array otherwise
+	let inner: t.Expression;
+	if (
+		childrenElements.length === 1 &&
+		hasOnlyText &&
+		t.isStringLiteral(childrenElements[0])
+	) {
+		inner = childrenElements[0];
+	} else {
+		inner = t.arrayExpression(childrenElements);
+	}
+	return inner;
+}