@sigil-dev/compiler 0.9.1 → 0.9.3

package/src/babel/jsx/children.ts

@@ -1,124 +1,124 @@
-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.
- */
-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;
-
-	for (const child of node.children) {
-		if (t.isJSXText(child)) {
-			const text = child.value.trim();
-			if (!text) continue;
-			childrenElements.push(t.stringLiteral(text));
-		} else if (t.isJSXElement(child) || t.isJSXFragment(child)) {
-			hasOnlyText = false;
-			const childStatements: t.Statement[] = [];
-			let childVar: string;
-			if (t.isJSXElement(child)) {
-				childVar = processElement(
-					child,
-					childStatements,
-					genId,
-					signals,
-					hash,
-					hydrate,
-					nodesVar,
-				);
-			} else {
-				childVar = processFragment(
-					child,
-					childStatements,
-					genId,
-					signals,
-					hash,
-					hydrate,
-					nodesVar,
-				);
-			}
-			// Build an IIFE from the child statements
-			childrenElements.push(
-				t.callExpression(
-					t.arrowFunctionExpression(
-						[],
-						t.blockStatement([
-							...childStatements,
-							t.returnStatement(t.identifier(childVar)),
-						]),
-					),
-					[],
-				),
-			);
-		} else if (t.isJSXExpressionContainer(child)) {
-			const expr = child.expression as t.Expression;
-			if (t.isJSXElement(expr) || t.isJSXFragment(expr)) {
-				hasOnlyText = false;
-				const childStatements: t.Statement[] = [];
-				let childVar: string;
-				if (t.isJSXElement(expr)) {
-					childVar = processElement(
-						expr,
-						childStatements,
-						genId,
-						signals,
-						hash,
-						hydrate,
-						nodesVar,
-					);
-				} else {
-					childVar = processFragment(
-						expr,
-						childStatements,
-						genId,
-						signals,
-						hash,
-						hydrate,
-						nodesVar,
-					);
-				}
-				childrenElements.push(
-					t.callExpression(
-						t.arrowFunctionExpression(
-							[],
-							t.blockStatement([
-								...childStatements,
-								t.returnStatement(t.identifier(childVar)),
-							]),
-						),
-						[],
-					),
-				);
-			} else {
-				hasOnlyText = false;
-				// For dynamic expressions, just pass the expression directly
-				childrenElements.push(expr);
-			}
-		}
-	}
-
-	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.
+ */
+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;
+
+	for (const child of node.children) {
+		if (t.isJSXText(child)) {
+			const text = child.value.trim();
+			if (!text) continue;
+			childrenElements.push(t.stringLiteral(text));
+		} else if (t.isJSXElement(child) || t.isJSXFragment(child)) {
+			hasOnlyText = false;
+			const childStatements: t.Statement[] = [];
+			let childVar: string;
+			if (t.isJSXElement(child)) {
+				childVar = processElement(
+					child,
+					childStatements,
+					genId,
+					signals,
+					hash,
+					hydrate,
+					nodesVar,
+				);
+			} else {
+				childVar = processFragment(
+					child,
+					childStatements,
+					genId,
+					signals,
+					hash,
+					hydrate,
+					nodesVar,
+				);
+			}
+			// Build an IIFE from the child statements
+			childrenElements.push(
+				t.callExpression(
+					t.arrowFunctionExpression(
+						[],
+						t.blockStatement([
+							...childStatements,
+							t.returnStatement(t.identifier(childVar)),
+						]),
+					),
+					[],
+				),
+			);
+		} else if (t.isJSXExpressionContainer(child)) {
+			const expr = child.expression as t.Expression;
+			if (t.isJSXElement(expr) || t.isJSXFragment(expr)) {
+				hasOnlyText = false;
+				const childStatements: t.Statement[] = [];
+				let childVar: string;
+				if (t.isJSXElement(expr)) {
+					childVar = processElement(
+						expr,
+						childStatements,
+						genId,
+						signals,
+						hash,
+						hydrate,
+						nodesVar,
+					);
+				} else {
+					childVar = processFragment(
+						expr,
+						childStatements,
+						genId,
+						signals,
+						hash,
+						hydrate,
+						nodesVar,
+					);
+				}
+				childrenElements.push(
+					t.callExpression(
+						t.arrowFunctionExpression(
+							[],
+							t.blockStatement([
+								...childStatements,
+								t.returnStatement(t.identifier(childVar)),
+							]),
+						),
+						[],
+					),
+				);
+			} else {
+				hasOnlyText = false;
+				// For dynamic expressions, just pass the expression directly
+				childrenElements.push(expr);
+			}
+		}
+	}
+
+	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;
+}