@tsrx/core 0.0.27 → 0.1.0

package/src/transform/segments.js

@@ -562,16 +562,17 @@ export function convert_source_map_to_mappings(
 			} else if (node.type === 'JSXIdentifier') {
 				// JSXIdentifiers can also be capitalized (for dynamic components)
 				if (node.loc && node.name) {
-					if (node.metadata?.is_capitalized) {
-						tokens.push({
-							source: node.metadata.source_name,
-							generated: node.name,
-							loc: node.loc,
-							metadata: {},
-						});
-					} else {
-						tokens.push({ source: node.name, generated: node.name, loc: node.loc, metadata: {} });
+					/** @type {Token} */
+					const token = {
+						source: node.metadata?.is_capitalized ? node.metadata.source_name : node.name,
+						generated: node.name,
+						loc: node.loc,
+						metadata: {},
+					};
+					if (node.metadata?.disable_verification) {
+						token.mappingData = { ...mapping_data, verification: false };
 					}
+					tokens.push(token);
 				}
 				return; // Leaf node, don't traverse further
 			} else if (node.type === 'Literal') {
@@ -866,6 +867,15 @@ export function convert_source_map_to_mappings(
 					// but since we already map the opening - start, we just need the proper end
 					// and it was causing some issues with mappings
 					mapping.generatedLengths = [mapping.generatedLengths[0] + 1];
+					if (!closing && opening.selfClosing) {
+						const generated_close_length = '/>;'.length;
+						mapping.sourceOffsets = [/** @type {AST.NodeWithLocation} */ (opening).end - 2];
+						mapping.lengths = ['/>'.length];
+						mapping.generatedOffsets = [
+							mapping.generatedOffsets[0] + mapping.generatedLengths[0] - generated_close_length,
+						];
+						mapping.generatedLengths = [generated_close_length];
+					}
 					mappings.push(mapping);
 				}
 

package/types/index.d.ts

@@ -205,6 +205,7 @@ declare module 'estree' {
 	interface NodeMap {
 		Component: Component;
 		Tsx: Tsx;
+		Tsrx: Tsrx;
 		TsxCompat: TsxCompat;
 		TSRXExpression: TSRXExpression;
 		Html: Html;
@@ -213,6 +214,7 @@ declare module 'estree' {
 		Text: TextNode;
 		Attribute: Attribute;
 		RefAttribute: RefAttribute;
+		RefExpression: RefExpression;
 		SpreadAttribute: SpreadAttribute;
 		ParenthesizedExpression: ParenthesizedExpression;
 		ScriptContent: ScriptContent;
@@ -220,6 +222,7 @@ declare module 'estree' {
 
 	interface ExpressionMap {
 		Style: Style;
+		RefExpression: RefExpression;
 		Text: TextNode;
 		JSXEmptyExpression: ESTreeJSX.JSXEmptyExpression;
 		ParenthesizedExpression: ParenthesizedExpression;
@@ -344,6 +347,16 @@ declare module 'estree' {
 		closingElement: ESTreeJSX.JSXClosingElement;
 	}
 
+	interface Tsrx extends AST.BaseNode {
+		type: 'Tsrx';
+		attributes: Array<any>;
+		children: AST.Node[];
+		selfClosing?: boolean;
+		unclosed?: boolean;
+		openingElement: ESTreeJSX.JSXOpeningElement;
+		closingElement: ESTreeJSX.JSXClosingElement;
+	}
+
 	interface TsxCompat extends AST.BaseNode {
 		type: 'TsxCompat';
 		kind: string;
@@ -437,6 +450,12 @@ declare module 'estree' {
 		loc?: AST.SourceLocation;
 	}
 
+	interface RefExpression extends AST.BaseNode {
+		type: 'RefExpression';
+		argument: AST.Expression;
+		loc?: AST.SourceLocation;
+	}
+
 	interface SpreadAttribute extends AST.BaseNode {
 		type: 'SpreadAttribute';
 		argument: AST.Expression;
@@ -471,7 +490,7 @@ declare module 'estree' {
 
 	export type TSRXStatement = AST.Statement | TSESTree.Statement;
 
-	export type NodeWithChildren = AST.Element | AST.Tsx | AST.TsxCompat;
+	export type NodeWithChildren = AST.Element | AST.Tsx | AST.Tsrx | AST.TsxCompat;
 
 	export namespace CSS {
 		export interface BaseNode extends AST.NodeWithMaybeComments {

package/types/jsx-platform.d.ts

@@ -36,6 +36,8 @@ export interface JsxTransformContext {
 	needs_error_boundary: boolean;
 	needs_suspense: boolean;
 	needs_merge_refs: boolean;
+	needs_ref_prop: boolean;
+	needs_normalize_spread_props: boolean;
 	needs_fragment: boolean;
 	module_scoped_hook_components: boolean;
 	helper_state: {
@@ -290,9 +292,14 @@ export interface JsxPlatform {
 		 * Module to import `mergeRefs` from when an element has more than one
 		 * `ref` attribute and the platform uses the `'merge-refs'` strategy.
 		 * Required when `jsx.multiRefStrategy === 'merge-refs'`; ignored
-		 * otherwise. React: `'@tsrx/react/merge-refs'`. Preact: `'@tsrx/preact/merge-refs'`.
+		 * otherwise. React: `'@tsrx/react/ref'`. Preact: `'@tsrx/preact/ref'`.
 		 */
 		mergeRefs?: string;
+		/**
+		 * Module to import named-ref-prop helpers from when compiling
+		 * `prop={ref expr}` or normalizing host spreads containing named refs.
+		 */
+		refProp?: string;
 	};
 
 	jsx: {
@@ -320,6 +327,12 @@ export interface JsxPlatform {
 		 *   unchanged. The platform's runtime is responsible.
 		 */
 		multiRefStrategy?: 'merge-refs' | 'array';
+		/**
+		 * Some JSX runtimes do not apply a `ref` that arrives through a props
+		 * spread. In that case, host spread normalization also emits an
+		 * explicit `ref={normalized.ref}` attribute.
+		 */
+		hostSpreadRefStrategy?: 'explicit-ref-attr';
 	};
 
 	validation: {

package/types/parse.d.ts

@@ -1172,7 +1172,7 @@ export namespace Parse {
 		 */
 		parseTopLevel(node: AST.Program): AST.Program;
 
-		parseElement(): AST.Element | AST.Tsx | AST.TsxCompat;
+		parseElement(): AST.Element | AST.Tsx | AST.Tsrx | AST.TsxCompat;
 
 		parseDoubleQuotedTextChild(): AST.TextNode;
 

package/types/runtime/ref.d.ts

@@ -0,0 +1,32 @@
+export type MergeableRefCallback<T> = {
+	bivarianceHack(node: T | null): void | (() => void);
+}['bivarianceHack'];
+export type MergeableRefObject<T> = { current: T | null };
+export type MergeableVueRef<T> = { value: T | null };
+export type RefProp<T = unknown> = (node: T | null) => void | (() => void);
+
+export type MergeableRef<T> =
+	| MergeableRefCallback<T>
+	| MergeableRefObject<T>
+	| MergeableVueRef<T>
+	| null
+	| undefined;
+
+export function mergeRefs<T = any>(...refs: Array<MergeableRef<T>>): (node: T | null) => () => void;
+export function isRefProp(value: unknown): boolean;
+export function create_ref_prop<T>(
+	get_ref_value: () => T,
+	set_ref_value?: (value: T) => void,
+): RefProp<T>;
+export function apply_ref_value<T>(
+	ref_value: unknown,
+	node: T | null,
+	set_ref_value?: (value: T) => void,
+): void | (() => void);
+export function merge_ref_props<T = any>(
+	...refs: unknown[]
+): undefined | ((node: T | null) => void | (() => void));
+export function normalize_spread_props<T extends Record<PropertyKey, any> | null | undefined>(
+	props: T,
+	...outer_refs: unknown[]
+): T | Record<PropertyKey, any>;

package/src/runtime/merge-refs.js

@@ -1,61 +0,0 @@
-/**
- * Merge multiple refs (function refs and ref objects) into a single
- * callback ref. Used by the tsrx-react, tsrx-preact, and tsrx-vue
- * compilers when an element has more than one `ref` attribute, since
- * those runtimes treat duplicate `ref` props as a regular duplicate-prop
- * collision (last wins) rather than running both. Solid does not use this
- * helper — its native runtime accepts an array of refs and the compiler
- * emits an array literal directly.
- *
- * The returned callback ref handles four cases per input:
- * - `null` / `undefined`: skipped.
- * - function ref: invoked with the node. If it returns a function, that
- *   return value is treated as a React 19 cleanup. Otherwise we record a
- *   cleanup that calls the ref with `null` so the legacy unmount contract
- *   still fires.
- * - React-style ref object (`{ current }`): assigned on mount, cleared
- *   on unmount.
- * - Vue-style ref object (`{ value }`, e.g. `ref()` / `useTemplateRef()`):
- *   assigned on mount, cleared on unmount.
- *
- * The merged ref always returns a cleanup. Under React 19 the cleanup
- * runs on unmount and the inner refs are not separately re-invoked with
- * `null`. Under older React, Preact, and Vue the cleanup return value
- * is ignored, so the runtime instead invokes the merged ref a second
- * time with `null` — which re-runs the loop body, calling each inner
- * with `null` and clearing each ref object. Either way every inner ref
- * sees a balanced mount/unmount.
- *
- * @param {...((node: any) => void | (() => void)) | { current: any } | { value: any } | null | undefined} refs
- * @returns {(node: any) => (() => void)}
- */
-export function mergeRefs(...refs) {
-	return (node) => {
-		/** @type {Array<() => void>} */
-		const cleanups = [];
-		for (const ref of refs) {
-			if (ref == null) continue;
-			if (typeof ref === 'function') {
-				const result = ref(node);
-				if (typeof result === 'function') {
-					cleanups.push(result);
-				} else {
-					cleanups.push(() => ref(null));
-				}
-			} else if ('current' in ref) {
-				ref.current = node;
-				cleanups.push(() => {
-					ref.current = null;
-				});
-			} else if ('value' in ref) {
-				ref.value = node;
-				cleanups.push(() => {
-					ref.value = null;
-				});
-			}
-		}
-		return () => {
-			for (const cleanup of cleanups) cleanup();
-		};
-	};
-}

package/types/runtime/merge-refs.d.ts

@@ -1,12 +0,0 @@
-export type MergeableRefCallback<T> = (node: T | null) => void | (() => void);
-export type MergeableRefObject<T> = { current: T | null };
-export type MergeableVueRef<T> = { value: T | null };
-
-export type MergeableRef<T> =
-	| MergeableRefCallback<T>
-	| MergeableRefObject<T>
-	| MergeableVueRef<T>
-	| null
-	| undefined;
-
-export function mergeRefs<T = any>(...refs: Array<MergeableRef<T>>): (node: T | null) => () => void;