@tsrx/core 0.1.22 → 0.1.25

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/transform/jsx/ast-builders.js

@@ -89,44 +89,6 @@ 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}
  */
@@ -342,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' || id.type === 'JSXIdentifier') {
-		return !!id.tracked;
-	}
-	if (id.type === 'MemberExpression' || id.type === 'JSXMemberExpression') {
-		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).
@@ -431,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]