@tsrx/core 0.1.16 → 0.1.18

package/src/runtime/ref.js

@@ -2,6 +2,7 @@ import {
 	has_own_property,
 	get_descriptor,
 	has_prototype_accessor,
+	is_array,
 } from '@tsrx/core/runtime/language-helpers';
 
 const REF_VALUE = Symbol();
@@ -65,6 +66,25 @@ function is_ref_prop(value) {
  * @returns {void | (() => void)}
  */
 export function apply_ref_value(ref_value, node, set_ref_value) {
+	if (is_array(ref_value)) {
+		/** @type {Array<() => void>} */
+		const cleanups = [];
+		for (const item of ref_value) {
+			const cleanup = apply_ref_value(item, node);
+			if (typeof cleanup === 'function') {
+				cleanups.push(cleanup);
+			} else if (typeof item === 'function' && node !== null) {
+				cleanups.push(() => item(null));
+			}
+		}
+		if (cleanups.length > 0) {
+			return () => {
+				for (const cleanup of cleanups) cleanup();
+			};
+		}
+		return;
+	}
+
 	if (typeof ref_value === 'function') {
 		return ref_value(node);
 	}
@@ -217,6 +237,34 @@ export function normalize_spread_props(props, ...outer_refs) {
 	return next;
 }
 
+/**
+ * Normalize spread props for targets that read refs through an explicit
+ * `ref={normalized.ref}` attribute. The returned `ref` stays readable for that
+ * attribute but is non-enumerable so `{...normalized}` does not also pass it as
+ * a DOM prop.
+ *
+ * @param {Record<string | symbol, any> | null | undefined} props
+ * @param {...any} outer_refs
+ * @returns {Record<string | symbol, any> | null | undefined}
+ */
+export function normalize_spread_props_for_ref_attr(props, ...outer_refs) {
+	const next = normalize_spread_props(props, ...outer_refs);
+	if (next == null || !has_own_property.call(next, 'ref')) {
+		return next;
+	}
+
+	const ref = next.ref;
+	const without_ref = { ...next };
+	delete without_ref.ref;
+	Object.defineProperty(without_ref, 'ref', {
+		value: ref,
+		enumerable: false,
+		configurable: true,
+		writable: true,
+	});
+	return without_ref;
+}
+
 /**
  * @param {object} value
  * @param {'current' | 'value'} key

package/src/scope.js

@@ -107,19 +107,6 @@ export function create_scopes(ast, root, parent, error_options) {
 			}
 		},
 
-		Component(node, { state, next }) {
-			const scope = state.scope.child();
-			scopes.set(node, scope);
-
-			// Only declare the component name if it has an id (not anonymous)
-			if (node.id) {
-				scope.declare(node.id, 'normal', 'component');
-			}
-
-			add_params(scope, node.params);
-			next({ scope });
-		},
-
 		Element(node, { state, next }) {
 			const scope = state.scope.child();
 			scopes.set(node, scope);

package/src/transform/await.js

@@ -2,7 +2,7 @@
  * @param {any[]} body_nodes
  * @returns {any | null}
  */
-export function find_first_top_level_await_in_component_body(body_nodes) {
+export function find_first_top_level_await_in_tsrx_function_body(body_nodes) {
 	for (const node of body_nodes) {
 		const found = find_first_top_level_await(node, false);
 		if (found) return found;

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

@@ -248,7 +248,6 @@ export function is_jsx_child(node) {
 		t === 'Element' ||
 		t === 'Text' ||
 		t === 'TSRXExpression' ||
-		t === 'Html' ||
 		t === 'IfStatement' ||
 		t === 'ForOfStatement' ||
 		t === 'SwitchStatement' ||
@@ -449,10 +448,9 @@ function is_static_string_expression(expression) {
  * 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>`) and inline literal arguments to the explicit
- * `{text ...}` intrinsic (`<b>{text 'hello'}</b>`). Identifiers and any
- * other expression type still get the ternary because the AST alone can't
- * prove they're non-null strings.
+ * 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.
  *
  * @param {AST.Expression} expression
  * @param {any} [source_node]

package/src/transform/jsx/helpers.js

@@ -53,8 +53,7 @@ export function tsx_node_to_jsx_expression(node, in_jsx_child = false) {
  * Default `node.metadata` to `{ path: [] }` if missing, then continue the
  * walk. Use as the `FunctionDeclaration` / `FunctionExpression` /
  * `ArrowFunctionExpression` visitor in a zimmerframe walk so that downstream
- * consumers (e.g. `segments.js` reading `node.value.metadata.is_component`
- * on class methods) don't trip on an undefined metadata object.
+ * consumers don't trip on an undefined metadata object.
  *
  * Ripple's analyze phase does this via `visit_function`; the tsrx-* targets
  * have no analyze phase, so we default metadata during the main walk.