@tsrx/core 0.0.13 → 0.0.14

package/src/transform/lazy.js

@@ -26,7 +26,7 @@
  */
 
 /**
- * @typedef {{ source_name: string, read: () => any }} LazyBinding
+ * @typedef {{ source_name: string, read: (reference?: any) => any }} LazyBinding
  */
 
 /**
@@ -46,12 +46,169 @@ function generate_lazy_id(context) {
 	return `__lazy${context.lazy_next_id++}`;
 }
 
+/**
+ * @param {any} node
+ * @param {any} [loc_info]
+ * @returns {any}
+ */
+function set_source_location(node, loc_info) {
+	if (loc_info?.loc) {
+		node.start = loc_info.start;
+		node.end = loc_info.end;
+		node.loc = loc_info.loc;
+	}
+	return node;
+}
+
 /**
  * @param {string} name
+ * @param {any} [loc_info]
+ * @param {string} [source_name]
+ * @param {number} [source_length]
  * @returns {any}
  */
-function create_generated_identifier(name) {
-	return /** @type {any} */ ({ type: 'Identifier', name, metadata: { path: [] } });
+function create_generated_identifier(name, loc_info, source_name, source_length) {
+	const id = /** @type {any} */ ({ type: 'Identifier', name, metadata: { path: [] } });
+	if (source_name && source_name !== name) id.metadata.source_name = source_name;
+	if (source_length != null) id.metadata.source_length = source_length;
+	return set_source_location(id, loc_info);
+}
+
+/**
+ * @param {any} pattern
+ * @returns {{ start: number, end: number, loc: any, source_length: number } | null}
+ */
+function get_lazy_pattern_mapping_range(pattern) {
+	if (!pattern.loc) return null;
+
+	const end = pattern.typeAnnotation?.start ?? pattern.end;
+	const end_loc = pattern.typeAnnotation?.loc?.start ?? pattern.loc.end;
+	return {
+		start: pattern.start,
+		end,
+		loc: {
+			start: pattern.loc.start,
+			end: end_loc,
+		},
+		source_length: end - pattern.start,
+	};
+}
+
+/**
+ * Synthesize an object-shaped annotation for untyped lazy object params so the
+ * virtual TSX can expose prop names to TypeScript completions.
+ *
+ * @param {any} pattern
+ * @returns {any | null}
+ */
+function create_lazy_object_type_annotation(pattern) {
+	if (pattern.type !== 'ObjectPattern') return null;
+
+	const members = [];
+	for (const prop of pattern.properties || []) {
+		if (prop.type === 'RestElement' || prop.computed) continue;
+
+		const key = prop.key;
+		if (key.type !== 'Identifier' && key.type !== 'Literal') continue;
+
+		members.push({
+			type: 'TSPropertySignature',
+			key:
+				key.type === 'Identifier'
+					? create_generated_identifier(key.name, key)
+					: set_source_location({ ...key, metadata: { path: [] } }, key),
+			computed: false,
+			optional: false,
+			readonly: false,
+			static: false,
+			kind: 'init',
+			typeAnnotation: {
+				type: 'TSTypeAnnotation',
+				typeAnnotation: {
+					type: 'TSAnyKeyword',
+					metadata: { path: [] },
+				},
+				metadata: { path: [] },
+			},
+			metadata: { path: [] },
+		});
+	}
+
+	if (members.length === 0) return null;
+
+	return {
+		type: 'TSTypeAnnotation',
+		typeAnnotation: {
+			type: 'TSTypeLiteral',
+			members,
+			metadata: { path: [] },
+		},
+		metadata: { path: [] },
+	};
+}
+
+/**
+ * @param {any} node
+ * @returns {string | null}
+ */
+function get_static_property_name(node) {
+	if (node.type === 'Identifier') return node.name;
+	if (node.type === 'Literal') return String(node.value);
+	return null;
+}
+
+/**
+ * @param {any} type_annotation
+ * @returns {Map<string, any>}
+ */
+function get_type_property_keys(type_annotation) {
+	const keys = new Map();
+	const members = type_annotation?.typeAnnotation?.members;
+	if (!Array.isArray(members)) return keys;
+
+	for (const member of members) {
+		if (member.type !== 'TSPropertySignature' || !member.key) continue;
+		const name = get_static_property_name(member.key);
+		if (name != null && !keys.has(name)) keys.set(name, member.key);
+	}
+
+	return keys;
+}
+
+/**
+ * Store extra mappings from lazy object binding identifiers to generated type
+ * property keys. Parser diagnostics for duplicate bindings point at the binding
+ * names (`&{ a: value, value }`), while the virtual param only exposes object
+ * properties (`__lazy0: { a: ...; value: ... }`).
+ *
+ * @param {any} lazy_id
+ * @param {any} pattern
+ */
+function set_lazy_param_binding_mappings(lazy_id, pattern) {
+	if (pattern.type !== 'ObjectPattern') return;
+
+	const type_keys = get_type_property_keys(lazy_id.typeAnnotation);
+	if (type_keys.size === 0) return;
+
+	const mappings = [];
+	for (const prop of pattern.properties || []) {
+		if (prop.type === 'RestElement' || prop.computed) continue;
+
+		const value = prop.value;
+		const actual = value.type === 'AssignmentPattern' ? value.left : value;
+		if (actual.type !== 'Identifier' || !actual.loc) continue;
+
+		const key_name = get_static_property_name(prop.key);
+		const generated = key_name == null ? null : type_keys.get(key_name);
+		if (generated?.loc) {
+			generated.metadata = { ...generated.metadata, disable_verification: true };
+			mappings.push({ source: actual, generated });
+		}
+	}
+
+	if (mappings.length > 0) {
+		lazy_id.metadata.lazy_param_binding_mappings = mappings;
+	}
 }
 
 /**
@@ -76,12 +233,13 @@ export function collect_lazy_bindings(pattern, source_name, lazy_bindings) {
 				const computed = prop.computed || key.type !== 'Identifier';
 				lazy_bindings.set(actual.name, {
 					source_name,
-					read: () => ({
+					read: (reference) => ({
 						type: 'MemberExpression',
 						object: create_generated_identifier(source_name),
-						property: computed
-							? { ...key }
-							: { type: 'Identifier', name: key.name, metadata: { path: [] } },
+						property:
+							computed || key.type !== 'Identifier'
+								? { ...key }
+								: create_generated_identifier(key.name, reference, reference?.name),
 						computed,
 						optional: false,
 						metadata: { path: [] },
@@ -491,7 +649,7 @@ export function apply_lazy_transforms(node, lazy_bindings) {
 		const binding = /** @type {LazyBinding} */ (lazy_bindings.get(node.left.name));
 		return {
 			...node,
-			left: binding.read(),
+			left: binding.read(node.left),
 			right: apply_lazy_transforms(node.right, lazy_bindings),
 		};
 	}
@@ -502,7 +660,7 @@ export function apply_lazy_transforms(node, lazy_bindings) {
 		lazy_bindings.has(node.argument.name)
 	) {
 		const binding = /** @type {LazyBinding} */ (lazy_bindings.get(node.argument.name));
-		return { ...node, argument: binding.read() };
+		return { ...node, argument: binding.read(node.argument) };
 	}
 
 	// Replace lazy variable declaration patterns with generated identifiers.
@@ -520,14 +678,14 @@ export function apply_lazy_transforms(node, lazy_bindings) {
 	if (node.type === 'Property' && node.shorthand && node.value?.type === 'Identifier') {
 		const binding = lazy_bindings.get(node.value.name);
 		if (binding) {
-			return { ...node, shorthand: false, value: binding.read() };
+			return { ...node, shorthand: false, value: binding.read(node.value) };
 		}
 	}
 
 	// Bare identifier reference.
 	if (node.type === 'Identifier' && lazy_bindings.has(node.name)) {
 		const binding = /** @type {LazyBinding} */ (lazy_bindings.get(node.name));
-		return binding.read();
+		return binding.read(node);
 	}
 
 	// JSXIdentifier is a label (component/element name), never a reference.
@@ -654,8 +812,22 @@ export function replace_lazy_params(params) {
 			pattern.lazy &&
 			pattern.metadata?.lazy_id
 		) {
-			const lazy_id = create_generated_identifier(pattern.metadata.lazy_id);
-			if (pattern.typeAnnotation) lazy_id.typeAnnotation = pattern.typeAnnotation;
+			const pattern_range = get_lazy_pattern_mapping_range(pattern);
+			const lazy_id = pattern_range
+				? create_generated_identifier(
+						pattern.metadata.lazy_id,
+						pattern_range,
+						undefined,
+						pattern_range.source_length,
+					)
+				: create_generated_identifier(pattern.metadata.lazy_id);
+			if (pattern.typeAnnotation) {
+				lazy_id.typeAnnotation = pattern.typeAnnotation;
+			} else {
+				const type_annotation = create_lazy_object_type_annotation(pattern);
+				if (type_annotation) lazy_id.typeAnnotation = type_annotation;
+			}
+			set_lazy_param_binding_mappings(lazy_id, pattern);
 			if (param.type === 'AssignmentPattern') return { ...param, left: lazy_id };
 			return lazy_id;
 		}

package/src/transform/segments.js

@@ -27,6 +27,7 @@
 	loc: AST.SourceLocation;
 	metadata: PluginActionOverrides;
 	end_loc?: AST.SourceLocation;
+	sourceLength?: number;
 	mappingData?: Partial<VolarCodeMapping['data']>;
 }} Token;
 @typedef {{
@@ -55,6 +56,15 @@ import {
 } from '../source-map-utils.js';
 
 const LABEL_TO_COMPONENT_REPLACE_REGEX = /(function|\((property|method)\))/;
+const LAZY_PARAM_IDENTIFIER_REGEX = /^__lazy\d+$/;
+
+/**
+ * @param {string} value
+ * @returns {string}
+ */
+function escape_regex(value) {
+	return value.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+}
 
 /**
  * @param {string} content
@@ -67,6 +77,51 @@ function replace_label_to_component(content) {
 	});
 }
 
+/**
+ * @param {string} lazy_id
+ * @param {(content: string) => string} [base_hover]
+ * @returns {(content: string) => string}
+ */
+function create_lazy_param_hover_replacement(lazy_id, base_hover) {
+	const lazy_param_regex = new RegExp(`\\b${escape_regex(lazy_id)}\\s*:\\s*`, 'g');
+
+	return (content) => {
+		const next = base_hover ? base_hover(content) : content;
+		return next.replace(lazy_param_regex, '&');
+	};
+}
+
+/**
+ * @param {AST.Parameter[] | undefined} params
+ * @param {(content: string) => string} [base_hover]
+ * @returns {((content: string) => string) | undefined}
+ */
+function create_function_hover_replacement(params, base_hover) {
+	const lazy_ids =
+		params
+			?.filter(
+				(param) =>
+					param.type === 'Identifier' &&
+					param.metadata?.source_length != null &&
+					LAZY_PARAM_IDENTIFIER_REGEX.test(param.name),
+			)
+			.map((param) => /** @type {AST.Identifier} */ (param).name) ?? [];
+
+	if (lazy_ids.length === 0) return base_hover;
+
+	const lazy_param_regexes = lazy_ids.map(
+		(lazy_id) => new RegExp(`\\b${escape_regex(lazy_id)}\\s*:\\s*`, 'g'),
+	);
+
+	return (content) => {
+		let next = base_hover ? base_hover(content) : content;
+		for (const regex of lazy_param_regexes) {
+			next = next.replace(regex, '&');
+		}
+		return next;
+	};
+}
+
 /**
  * @param {string} [hash]
  * @param {string} [fallback]
@@ -423,6 +478,7 @@ export function convert_source_map_to_mappings(
 							generated: node.name,
 							loc: node.loc,
 							metadata: {},
+							sourceLength: node.metadata.source_length,
 						};
 					} else {
 						token = {
@@ -430,6 +486,7 @@ export function convert_source_map_to_mappings(
 							generated: node.name,
 							loc: node.loc,
 							metadata: {},
+							sourceLength: node.metadata?.source_length,
 						};
 					}
 
@@ -437,7 +494,36 @@ export function convert_source_map_to_mappings(
 						// only if the node has a component as the parent
 						token.metadata.hover = replace_label_to_component;
 					}
+					if (node.metadata?.source_length != null && LAZY_PARAM_IDENTIFIER_REGEX.test(node.name)) {
+						token.metadata.hover = create_lazy_param_hover_replacement(
+							node.name,
+							node.metadata?.lazy_param_is_component ? replace_label_to_component : undefined,
+						);
+					}
+					if (node.metadata?.disable_verification) {
+						token.mappingData = { ...mapping_data, verification: false };
+					}
 					tokens.push(token);
+
+					if (Array.isArray(node.metadata?.lazy_param_binding_mappings)) {
+						for (const binding_mapping of node.metadata.lazy_param_binding_mappings) {
+							const source_node = binding_mapping.source;
+							const generated_node = binding_mapping.generated;
+							if (!source_node?.loc || !generated_node?.loc) continue;
+
+							const mapping = get_mapping_from_node(
+								generated_node,
+								src_to_gen_map,
+								gen_line_offsets,
+								mapping_data_verify_only,
+							);
+							const source_start = /** @type {number} */ (source_node.start);
+							const source_end = /** @type {number} */ (source_node.end);
+							mapping.sourceOffsets = [source_start];
+							mapping.lengths = [source_end - source_start];
+							mappings.push(mapping);
+						}
+					}
 				}
 				return; // Leaf node, don't traverse further
 			} else if (node.type === 'JSXIdentifier') {
@@ -767,6 +853,10 @@ export function convert_source_map_to_mappings(
 					const node_fn = /** @type (typeof node) & AST.NodeWithLocation */ (node);
 					const is_component = node_fn.metadata?.is_component;
 					const source_func_keyword = is_component ? 'component' : 'function';
+					const function_hover = create_function_hover_replacement(
+						/** @type {AST.Parameter[]} */ (node.params),
+						is_component ? replace_label_to_component : undefined,
+					);
 					let start_col = node_fn.loc.start.column;
 					let start = node_fn.start;
 					const async_keyword = 'async';
@@ -782,7 +872,7 @@ export function convert_source_map_to_mappings(
 						mapping.lengths = [source_func_keyword.length];
 						mapping.generatedOffsets = [generated_keyword_start];
 						mapping.generatedLengths = ['function'.length];
-						mapping.data.customData.hover = replace_label_to_component;
+						if (function_hover) mapping.data.customData.hover = function_hover;
 						mappings.push(mapping);
 					} else {
 						if (node_fn.async) {
@@ -814,7 +904,7 @@ export function convert_source_map_to_mappings(
 									column: start_col + source_func_keyword.length,
 								},
 							},
-							metadata: is_component ? { hover: replace_label_to_component } : {},
+							metadata: function_hover ? { hover: function_hover } : {},
 						});
 					}
 				}
@@ -826,11 +916,24 @@ export function convert_source_map_to_mappings(
 					/** @type {AST.FunctionDeclaration | AST.FunctionExpression} */ (node).id &&
 					!is_method
 				) {
-					visit(
-						/** @type {AST.Node} */ (
-							/** @type {AST.FunctionDeclaration | AST.FunctionExpression} */ (node).id
-						),
+					const id = /** @type {AST.Identifier} */ (
+						/** @type {AST.FunctionDeclaration | AST.FunctionExpression} */ (node).id
+					);
+					const function_hover = create_function_hover_replacement(
+						/** @type {AST.Parameter[]} */ (node.params),
+						node.metadata?.is_component ? replace_label_to_component : undefined,
 					);
+					if (function_hover && id.loc) {
+						tokens.push({
+							source: id.metadata?.source_name ?? id.name,
+							generated: id.name,
+							loc: id.loc,
+							metadata: { hover: function_hover },
+							sourceLength: id.metadata?.source_length,
+						});
+					} else {
+						visit(/** @type {AST.Node} */ (id));
+					}
 				}
 
 				if (node.typeParameters) {
@@ -839,6 +942,13 @@ export function convert_source_map_to_mappings(
 
 				if (node.params) {
 					for (const param of node.params) {
+						if (
+							param.type === 'Identifier' &&
+							param.metadata?.source_length != null &&
+							LAZY_PARAM_IDENTIFIER_REGEX.test(param.name)
+						) {
+							param.metadata.lazy_param_is_component = node.metadata?.is_component === true;
+						}
 						visit(param);
 						if (param.typeAnnotation) {
 							visit(param.typeAnnotation);
@@ -2067,7 +2177,7 @@ export function convert_source_map_to_mappings(
 			token.loc.start.column,
 			src_line_offsets,
 		);
-		const source_length = source_text.length;
+		const source_length = token.sourceLength ?? source_text.length;
 		const gen_length = gen_text.length;
 		let gen_line_col;
 		try {

package/src/utils/ast.js

@@ -20,6 +20,67 @@
 
 import * as b from './builders.js';
 
+/**
+ * @param {AST.Node} node
+ * @returns {boolean}
+ */
+export function is_function_node(node) {
+	return (
+		node.type === 'FunctionExpression' ||
+		node.type === 'ArrowFunctionExpression' ||
+		node.type === 'FunctionDeclaration'
+	);
+}
+
+/**
+ * @param {AST.Node} node
+ * @returns {boolean}
+ */
+export function is_class_node(node) {
+	return node.type === 'ClassExpression' || node.type === 'ClassDeclaration';
+}
+
+/**
+ * @param {AST.Node} node
+ * @returns {boolean}
+ */
+export function is_component_node(node) {
+	return node.type === 'Component';
+}
+
+/**
+ * Returns the closest component in an ancestry path. By default, function and
+ * class boundaries stop the search so callers only match direct component
+ * body/control-flow nodes.
+ *
+ * @param {AST.Node[]} path
+ * @param {boolean} [includes_functions=false]
+ * @returns {AST.Component | undefined}
+ */
+export function get_component_from_path(path, includes_functions = false) {
+	for (let i = path.length - 1; i >= 0; i -= 1) {
+		const node = path[i];
+
+		if (!includes_functions && (is_function_node(node) || is_class_node(node))) {
+			return;
+		}
+
+		if (is_component_node(node)) {
+			return /** @type {AST.Component} */ (node);
+		}
+	}
+}
+
+/**
+ * @param {AST.Node[] | { path: AST.Node[] }} context_or_path
+ * @param {boolean} [includes_functions=false]
+ * @returns {AST.Component | undefined}
+ */
+export function is_inside_component(context_or_path, includes_functions = false) {
+	const path = Array.isArray(context_or_path) ? context_or_path : context_or_path.path;
+	return get_component_from_path(path, includes_functions);
+}
+
 /**
  * Gets the left-most identifier of a member expression or identifier.
  * @param {AST.MemberExpression | AST.Identifier} expression

package/types/index.d.ts

@@ -37,6 +37,11 @@ export interface CompileOptions {
 	dev?: boolean;
 	hmr?: boolean;
 	compat_kinds?: string[];
+	/**
+	 * When true, non-fatal errors are collected on the result's `errors`
+	 * array instead of being thrown. Defaults to false (strict mode: throws).
+	 */
+	loose?: boolean;
 }
 
 export type NameSpace = 'html' | 'svg' | 'mathml';
@@ -45,6 +50,7 @@ interface BaseNodeMetaData {
 	path: AST.Node[];
 	has_template?: boolean;
 	source_name?: string | '#server' | '#style';
+	source_length?: number;
 	is_capitalized?: boolean;
 	commentContainerId?: number;
 	parenthesized?: boolean;
@@ -56,6 +62,12 @@ interface BaseNodeMetaData {
 	lone_return?: boolean;
 	forceMapping?: boolean;
 	lazy_id?: string;
+	disable_verification?: boolean;
+	lazy_param_is_component?: boolean;
+	lazy_param_binding_mappings?: Array<{
+		source: AST.Identifier;
+		generated: AST.Identifier | AST.Literal;
+	}>;
 }
 
 interface FunctionMetaData extends BaseNodeMetaData {
@@ -1558,6 +1570,11 @@ export interface CompileResult {
 	};
 	/** The generated CSS */
 	css: string;
+	/**
+	 * Non-fatal errors collected during compilation. Populated only when the
+	 * caller passes `loose: true`; empty otherwise.
+	 */
+	errors: CompileError[];
 }
 
 /**