@tsrx/solid 0.0.24 → 0.0.26

package/package.json

@@ -3,7 +3,7 @@
   "description": "Solid compiler built on @tsrx/core",
   "license": "MIT",
   "author": "Dominic Gannaway",
-  "version": "0.0.24",
+  "version": "0.0.26",
   "type": "module",
   "publishConfig": {
     "access": "public"
@@ -22,7 +22,7 @@
   "dependencies": {
     "esrap": "^2.1.0",
     "zimmerframe": "^1.1.2",
-    "@tsrx/core": "0.0.24"
+    "@tsrx/core": "0.0.26"
   },
   "peerDependencies": {
     "solid-js": ">=1.8 || >=2.0.0-beta"

package/src/transform.js

@@ -164,13 +164,13 @@ function get_await_keyword_start(await_node, source) {
 	return await_node?.start ?? 0;
 }
 // =====================================================================
-// Component → FunctionDeclaration
+// Component → FunctionDeclaration / FunctionExpression / ArrowFunctionExpression
 // =====================================================================
 
 /**
  * @param {any} component
  * @param {TransformContext} transform_context
- * @returns {AST.FunctionDeclaration}
+ * @returns {AST.FunctionDeclaration | AST.FunctionExpression | AST.ArrowFunctionExpression}
  */
 function component_to_function_declaration(component, transform_context) {
 	const params = component.params || [];
@@ -233,6 +233,10 @@ function component_to_function_declaration(component, transform_context) {
 		const collect = (nodes, outer, jsx_bucket) => {
 			for (const child of nodes) {
 				if (is_jsx_child(child)) {
+					if (get_returning_if_info(child) !== null) {
+						jsx_bucket.push(child);
+						continue;
+					}
 					if (early_interleaved) {
 						const jsx = to_jsx_child(child, transform_context);
 						if (is_capturable_jsx_child(jsx)) {
@@ -260,11 +264,11 @@ function component_to_function_declaration(component, transform_context) {
 			transform_context.needs_show = true;
 			const branch_body = body_to_jsx_child(early_info.consequent_body, transform_context);
 			const fallback_body =
-				after_jsx.length > 0 ? body_to_jsx_child(after_jsx, transform_context) : null;
+				after_jsx.length > 0 ? body_to_early_return_jsx_child(after_jsx, transform_context) : null;
 			next_body.push(build_show_element(early_if.test, branch_body, fallback_body));
 		} else if (after_jsx.length > 0) {
 			transform_context.needs_show = true;
-			const show_body = body_to_jsx_child(after_jsx, transform_context);
+			const show_body = body_to_early_return_jsx_child(after_jsx, transform_context);
 			next_body.push(build_show_element(negate_expression(early_if.test), show_body, null));
 		}
 
@@ -316,21 +320,54 @@ function component_to_function_declaration(component, transform_context) {
 	const final_body =
 		lazy_bindings.size > 0 ? apply_lazy_transforms(body_block, lazy_bindings) : body_block;
 
-	const fn = /** @type {any} */ ({
-		type: 'FunctionDeclaration',
-		id: component.id,
-		typeParameters: component.typeParameters,
-		params: final_params,
-		body: final_body,
-		async: false,
-		generator: false,
-		metadata: {
-			path: [],
-			is_component: true,
-		},
-	});
+	/** @type {AST.FunctionDeclaration | AST.FunctionExpression | AST.ArrowFunctionExpression} */
+	let fn;
 
-	if (fn.id) {
+	if (component.id) {
+		fn = /** @type {any} */ ({
+			type: 'FunctionDeclaration',
+			id: component.id,
+			typeParameters: component.typeParameters,
+			params: final_params,
+			body: final_body,
+			async: false,
+			generator: false,
+			metadata: {
+				path: [],
+				is_component: true,
+			},
+		});
+	} else if (component.metadata?.arrow) {
+		fn = /** @type {any} */ ({
+			type: 'ArrowFunctionExpression',
+			typeParameters: component.typeParameters,
+			params: final_params,
+			body: final_body,
+			async: false,
+			generator: false,
+			expression: false,
+			metadata: {
+				path: [],
+				is_component: true,
+			},
+		});
+	} else {
+		fn = /** @type {any} */ ({
+			type: 'FunctionExpression',
+			id: null,
+			typeParameters: component.typeParameters,
+			params: final_params,
+			body: final_body,
+			async: false,
+			generator: false,
+			metadata: {
+				path: [],
+				is_component: true,
+			},
+		});
+	}
+
+	if (fn.type === 'FunctionDeclaration' && fn.id) {
 		fn.id.metadata = /** @type {AST.Identifier['metadata']} */ ({
 			...fn.id.metadata,
 			is_component: true,
@@ -489,6 +526,45 @@ function body_to_jsx_child(body_nodes, transform_context) {
 	});
 }
 
+/**
+ * Lower render-continuation bodies that may contain additional early-return
+ * guards. Sequential guards need to nest the remaining continuation instead
+ * of rendering later children beside a `<Show>` for the guard itself.
+ *
+ * @param {any[]} body_nodes
+ * @param {TransformContext} transform_context
+ * @returns {any}
+ */
+function body_to_early_return_jsx_child(body_nodes, transform_context) {
+	const early_idx = body_nodes.findIndex((node) => get_returning_if_info(node) !== null);
+	if (early_idx === -1) {
+		return body_to_jsx_child(body_nodes, transform_context);
+	}
+
+	const early_if = /** @type {any} */ (body_nodes[early_idx]);
+	const early_info = /** @type {{ consequent_body: any[], return_index: number }} */ (
+		get_returning_if_info(early_if)
+	);
+	const before = body_nodes.slice(0, early_idx);
+	const after = body_nodes.slice(early_idx + 1);
+	const branch_has_content_before_return = early_info.return_index > 0;
+	const children = [...before];
+
+	if (branch_has_content_before_return) {
+		transform_context.needs_show = true;
+		const branch_body = body_to_jsx_child(early_info.consequent_body, transform_context);
+		const fallback_body =
+			after.length > 0 ? body_to_early_return_jsx_child(after, transform_context) : null;
+		children.push(build_show_element(early_if.test, branch_body, fallback_body));
+	} else if (after.length > 0) {
+		transform_context.needs_show = true;
+		const show_body = body_to_early_return_jsx_child(after, transform_context);
+		children.push(build_show_element(negate_expression(early_if.test), show_body, null));
+	}
+
+	return body_to_jsx_child(children, transform_context);
+}
+
 /**
  * @param {any} node
  * @returns {boolean}
@@ -792,11 +868,15 @@ function get_returning_if_info(node) {
  * @returns {any}
  */
 function negate_expression(expr) {
+	if (expr?.type === 'UnaryExpression' && expr.operator === '!') {
+		return clone_expression_node(expr.argument);
+	}
+
 	return {
 		type: 'UnaryExpression',
 		operator: '!',
 		prefix: true,
-		argument: expr,
+		argument: clone_expression_node(expr),
 		metadata: { path: [] },
 	};
 }