@tsrx/core 0.1.19 → 0.1.22

package/src/runtime/iterable.js

@@ -4,11 +4,12 @@
  * @param {Iterable<T> | Iterator<T>} iterable
  * @param {(item: T, index: number, is_last: boolean) => U} fn
  * @param {() => U | U[]} [tail]
+ * @param {() => U | U[]} [empty]
  * @returns {U[]}
  */
-export function map_iterable(iterable, fn, tail) {
+export function map_iterable(iterable, fn, tail, empty) {
 	if (Array.isArray(iterable)) {
-		return map_array(iterable, fn, tail);
+		return map_array(iterable, fn, tail, empty);
 	}
 
 	/** @type {Iterator<T>} */
@@ -25,14 +26,14 @@ export function map_iterable(iterable, fn, tail) {
 
 	var current = iterator.next();
 	if (current.done) {
-		if (!tail) {
+		if (!empty) {
 			return [];
 		}
-		var tail_value = tail();
-		if (Array.isArray(tail_value)) {
-			return tail_value;
+		var empty_value = empty();
+		if (Array.isArray(empty_value)) {
+			return empty_value;
 		}
-		return [tail_value];
+		return [empty_value];
 	}
 
 	var index = 0;
@@ -71,19 +72,20 @@ export function map_iterable(iterable, fn, tail) {
  * @param {Array<T>} array
  * @param {(item: T, index: number, is_last: boolean) => U} fn
  * @param {() => U | U[]} [tail]
+ * @param {() => U | U[]} [empty]
  * @returns {U[]}
  */
-function map_array(array, fn, tail) {
+function map_array(array, fn, tail, empty) {
 	var length = array.length;
 	if (length === 0) {
-		if (!tail) {
+		if (!empty) {
 			return [];
 		}
-		var tail_value = tail();
-		if (Array.isArray(tail_value)) {
-			return tail_value;
+		var empty_value = empty();
+		if (Array.isArray(empty_value)) {
+			return empty_value;
 		}
-		return [tail_value];
+		return [empty_value];
 	}
 	var result = [];
 	for (var i = 0; i < length; i++) {

package/src/scope.js

@@ -107,18 +107,28 @@ export function create_scopes(ast, root, parent, error_options) {
 			}
 		},
 
-		Element(node, { state, next }) {
-			const scope = state.scope.child();
-			scopes.set(node, scope);
+		JSXElement(node, { state, next }) {
+			if (node.metadata?.native_tsrx) {
+				const scope = state.scope.child();
+				scopes.set(node, scope);
 
-			next({ scope });
+				next({ scope });
+				return;
+			}
+
+			next();
 		},
 
-		Tsrx(node, { state, next }) {
-			const scope = state.scope.child();
-			scopes.set(node, scope);
+		JSXFragment(node, { state, next }) {
+			if (node.metadata?.native_tsrx) {
+				const scope = state.scope.child();
+				scopes.set(node, scope);
 
-			next({ scope });
+				next({ scope });
+				return;
+			}
+
+			next();
 		},
 
 		TSModuleDeclaration(node, { state, next }) {
@@ -169,6 +179,8 @@ export function create_scopes(ast, root, parent, error_options) {
 		ForInStatement: create_block_scope,
 		ForOfStatement: create_block_scope,
 		SwitchStatement: create_block_scope,
+		JSXForExpression: create_block_scope,
+		JSXSwitchExpression: create_block_scope,
 		BlockStatement(node, context) {
 			const parent = context.path.at(-1);
 			if (
@@ -192,13 +204,16 @@ export function create_scopes(ast, root, parent, error_options) {
 			for (const declarator of node.declarations) {
 				/** @type {Binding[]} */
 				const bindings = [];
-				const initial = /** @type {AST.Expression | AST.Tsx | AST.Tsrx | null} */ (declarator.init);
+				const initial = /** @type {AST.Expression | null} */ (declarator.init);
 
 				state.scope.declarators.set(declarator, bindings);
 
 				for (const id of extract_identifiers(declarator.id)) {
 					const binding = state.scope.declare(id, 'normal', node.kind, initial);
-					if (initial?.type === 'Tsx' || initial?.type === 'Tsrx') {
+					if (
+						(initial?.type === 'JSXElement' || initial?.type === 'JSXFragment') &&
+						initial.metadata?.native_tsrx
+					) {
 						binding.metadata = {
 							...(binding.metadata ?? {}),
 							is_template_value: true,

package/src/source-map-utils.js

@@ -14,7 +14,7 @@
  *   end_column: number,
  *   code: string,
  *   metadata: {
- *     css?: AST.Element['metadata']['css']
+ *     css?: AST.Node['metadata']['css']
  *   },
  * }} CodePosition
  * @typedef {{

package/src/transform/await.js

@@ -42,7 +42,11 @@ export function find_first_top_level_await(node, inside_nested_function) {
 		return null;
 	}
 
-	if (node.type === 'AwaitExpression' || (node.type === 'ForOfStatement' && node.await === true)) {
+	if (
+		node.type === 'AwaitExpression' ||
+		(node.type === 'ForOfStatement' && node.await === true) ||
+		(node.type === 'JSXForExpression' && node.await === true)
+	) {
 		return node;
 	}
 

package/src/transform/jsx/ast-builders.js

@@ -89,6 +89,44 @@ export function clone_jsx_name(name, source_node = name) {
 	return name;
 }
 
+/**
+ * Convert a JSX tag name back into a JavaScript expression. Dynamic element
+ * tags are parsed as JSX-shaped names, but the runtime alias needs ordinary JS.
+ *
+ * @param {any} name
+ * @returns {any}
+ */
+export function jsx_name_to_expression(name) {
+	if (!name) return name;
+	if (name.type === 'JSXIdentifier') {
+		return set_loc(
+			/** @type {any} */ ({
+				type: 'Identifier',
+				name: name.name,
+				metadata: name.metadata || { path: [] },
+			}),
+			name,
+		);
+	}
+	if (name.type === 'JSXMemberExpression') {
+		return set_loc(
+			/** @type {any} */ ({
+				type: 'MemberExpression',
+				object: jsx_name_to_expression(name.object),
+				property: jsx_name_to_expression(name.property),
+				computed: false,
+				optional: false,
+				metadata: name.metadata || { path: [] },
+			}),
+			name,
+		);
+	}
+	if (name.type === 'Identifier' || name.type === 'MemberExpression') {
+		return clone_expression_node(name);
+	}
+	return name;
+}
+
 /**
  * @returns {AST.Literal}
  */
@@ -242,12 +280,10 @@ export function is_jsx_child(node) {
 		t === 'JSXFragment' ||
 		t === 'JSXExpressionContainer' ||
 		t === 'JSXText' ||
-		t === 'Tsx' ||
-		t === 'Tsrx' ||
-		t === 'TsxCompat' ||
-		t === 'Element' ||
-		t === 'Text' ||
-		t === 'TSRXExpression' ||
+		t === 'JSXIfExpression' ||
+		t === 'JSXForExpression' ||
+		t === 'JSXSwitchExpression' ||
+		t === 'JSXTryExpression' ||
 		t === 'IfStatement' ||
 		t === 'ForOfStatement' ||
 		t === 'SwitchStatement' ||
@@ -256,8 +292,8 @@ export function is_jsx_child(node) {
 }
 
 /**
- * The parser represents `<>{expr}</>` / `<tsx>{expr}</tsx>` as a Tsx node,
- * and expression-position lowering unwraps that to the inner expression.
+ * Expression-position lowering unwraps single-expression native fragments to
+ * the inner expression.
  * When such a node appears directly in a component or statement render body,
  * the unwrapped expression is still render output rather than an executable
  * statement.
@@ -317,10 +353,10 @@ export function is_dynamic_element_id(id) {
 	if (!id || typeof id !== 'object') {
 		return false;
 	}
-	if (id.type === 'Identifier') {
+	if (id.type === 'Identifier' || id.type === 'JSXIdentifier') {
 		return !!id.tracked;
 	}
-	if (id.type === 'MemberExpression') {
+	if (id.type === 'MemberExpression' || id.type === 'JSXMemberExpression') {
 		return is_dynamic_element_id(id.object);
 	}
 	return false;
@@ -369,58 +405,6 @@ export function flatten_switch_consequent(consequent) {
 	return result;
 }
 
-/**
- * Compute fall-through expansions for each `case` in a `switch`. JavaScript
- * `switch` semantics say that once a case body executes, execution continues
- * into the bodies of subsequent cases until a `break` or terminal `return` is
- * hit. We pre-compute, per case, the flat list of statements that should run
- * when that case is the entry point — so downstream targets (which render each
- * case independently rather than executing fall-through at runtime) still
- * produce the right output.
- *
- * Walking right-to-left lets each case reuse the next case's already-expanded
- * tail without recomputation. Downstream nodes are deep-cloned when absorbed
- * so each case's expanded body owns its own AST subtree.
- *
- * @param {any[]} cases
- * @returns {Array<{ test: any, body: any[], source: any }>}
- */
-export function expand_switch_cases_for_fallthrough(cases) {
-	/** @type {Array<{ test: any, body: any[], source: any }>} */
-	const expanded = new Array(cases.length);
-	for (let i = cases.length - 1; i >= 0; i--) {
-		const consequent = flatten_switch_consequent(cases[i].consequent || []);
-		const body = [];
-		let has_terminal = false;
-		for (const child of consequent) {
-			if (child.type === 'BreakStatement') {
-				has_terminal = true;
-				break;
-			}
-			body.push(child);
-			if (child.type === 'ReturnStatement') {
-				has_terminal = true;
-				break;
-			}
-		}
-		// Strip locations from cloned downstream nodes. Only the original case
-		// (one entry up the chain) keeps `loc`/`start`/`end`; clones inlined
-		// into upstream cases would otherwise point editor IntelliSense at the
-		// same source range multiple times (one hover/go-to-definition per
-		// fall-through entry point), producing double/triple results in Volar.
-		const downstream =
-			!has_terminal && i + 1 < cases.length
-				? expanded[i + 1].body.map((n) => clone_expression_node(n, false))
-				: [];
-		expanded[i] = {
-			test: cases[i].test,
-			body: [...body, ...downstream],
-			source: cases[i],
-		};
-	}
-	return expanded;
-}
-
 /**
  * @param {AST.Expression | null | undefined} expression
  * @returns {boolean}

package/src/transform/jsx/helpers.js

@@ -4,9 +4,8 @@
 import tsx from 'esrap/languages/tsx';
 
 /**
- * Zimmerframe provides `path` as the ancestor chain (in original pre-transform
- * types, since visitors run bottom-up). A Tsx node whose parent is a ripple
- * `Element` will render as a JSX child of that element; anywhere else it
+ * Zimmerframe provides `path` as the ancestor chain. A native template node whose
+ * parent is another native template node renders as a JSX child; anywhere else it
  * renders as a standalone expression (e.g. a return value).
  *
  * @param {any[]} path
@@ -14,7 +13,11 @@ import tsx from 'esrap/languages/tsx';
  */
 export function in_jsx_child_context(path) {
 	const parent = path[path.length - 1];
-	return !!parent && parent.type === 'Element';
+	return (
+		!!parent &&
+		(parent.type === 'JSXElement' || parent.type === 'JSXFragment') &&
+		parent.metadata?.native_tsrx
+	);
 }
 
 /**
@@ -35,7 +38,7 @@ export function set_node_path_metadata(node, path) {
 }
 
 /**
- * Flatten a `<tsx>` / fragment node's children into a single expression. In a
+ * Flatten a JSX-compatible island's children into a single expression. In a
  * JSX-child position, a JSXExpressionContainer `{expr}` is valid and must stay
  * wrapped. In an expression position (e.g. `return ...`), `{expr}` parses as
  * a block/object literal, so unwrap to `expr`.