@tsrx/core 0.1.20 → 0.1.24

package/src/runtime/html.js

@@ -1,3 +1,3 @@
-export { is_boolean_attribute } from '../utils/dom.js';
+export { is_boolean_attribute, is_void_element } from '../utils/dom.js';
 export { escape, escape_script } from '../utils/escaping.js';
 export { normalize_css_property_name } from '../utils/normalize_css_property_name.js';

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/runtime/language-helpers.js

@@ -89,3 +89,42 @@ export function iterable_array_from(iterable, index = 0) {
 	}
 	return result;
 }
+
+/**
+ * Creates a shallow forwarding object without one prop. Values are exposed through
+ * getters so compiler-emitted reactive prop accessors are not snapshotted.
+ * @param {Record<PropertyKey, any> | null | undefined} props
+ * @param {PropertyKey} exclude_prop
+ * @returns {Record<PropertyKey, any>}
+ */
+export function exclude_prop_from_object(props, exclude_prop) {
+	/** @type {Record<PropertyKey, any>} */
+	const next = {};
+	if (props == null) return next;
+
+	for (const prop of Reflect.ownKeys(props)) {
+		if (prop === exclude_prop) continue;
+
+		const descriptor = get_descriptor(props, prop);
+		if (!descriptor?.enumerable) continue;
+
+		/** @type {PropertyDescriptor} */
+		const forwarding_descriptor = {
+			enumerable: true,
+			configurable: true,
+			get() {
+				return props[prop];
+			},
+		};
+
+		if (descriptor.writable === true || typeof descriptor.set === 'function') {
+			forwarding_descriptor.set = (value) => {
+				props[prop] = value;
+			};
+		}
+
+		define_property(next, prop, forwarding_descriptor);
+	}
+
+	return next;
+}

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();
 		},
 
-		TsrxFragment(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.TsrxFragment | 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 === 'TsrxFragment') {
+					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

@@ -242,11 +242,10 @@ export function is_jsx_child(node) {
 		t === 'JSXFragment' ||
 		t === 'JSXExpressionContainer' ||
 		t === 'JSXText' ||
-		t === 'TsrxFragment' ||
-		t === 'TsxCompat' ||
-		t === 'Element' ||
-		t === 'Text' ||
-		t === 'TSRXExpression' ||
+		t === 'JSXIfExpression' ||
+		t === 'JSXForExpression' ||
+		t === 'JSXSwitchExpression' ||
+		t === 'JSXTryExpression' ||
 		t === 'IfStatement' ||
 		t === 'ForOfStatement' ||
 		t === 'SwitchStatement' ||
@@ -305,26 +304,6 @@ export function is_bare_render_expression(node) {
 	}
 }
 
-/**
- * A dynamic element id is one whose identifier is `tracked` — i.e. it was
- * introduced by reactive destructuring so its value can change at runtime.
- *
- * @param {any} id
- * @returns {boolean}
- */
-export function is_dynamic_element_id(id) {
-	if (!id || typeof id !== 'object') {
-		return false;
-	}
-	if (id.type === 'Identifier') {
-		return !!id.tracked;
-	}
-	if (id.type === 'MemberExpression') {
-		return is_dynamic_element_id(id.object);
-	}
-	return false;
-}
-
 /**
  * Gather the params a `for (x of y; index i)` loop should expose to its body
  * JSX (value first, optional index second).
@@ -368,58 +347,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}
@@ -446,10 +373,8 @@ function is_static_string_expression(expression) {
  * When the expression is statically a non-null string at the AST level —
  * a string `Literal` (`"hello"`, `'hello'`) or a `TemplateLiteral` with no
  * interpolations (`` `hello` ``) — the coercion is provably a no-op and
- * the literal is emitted as-is. This covers both direct double-quoted
- * children (`<b>"hello"</b>`). Identifiers and any other expression type
- * still get the ternary because the AST alone can't prove they're non-null
- * strings.
+ * the literal is emitted as-is. Identifiers and any other expression type still
+ * get the ternary because the AST alone can't prove they're non-null strings.
  *
  * @param {AST.Expression} expression
  * @param {any} [source_node]

package/src/transform/jsx/helpers.js

@@ -4,17 +4,20 @@
 import tsx from 'esrap/languages/tsx';
 
 /**
- * Zimmerframe provides `path` as the ancestor chain (in original pre-transform
- * types, since visitors run bottom-up). A native template node whose parent is
- * a ripple `Element` will render as a JSX child of that element; anywhere else
- * it renders as a standalone expression (e.g. a return value).
+ * 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
  * @returns {boolean}
  */
 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
+	);
 }
 
 /**