@tsrx/core 0.1.4 → 0.1.7

package/src/transform/scoping.js

@@ -6,6 +6,7 @@
  */
 
 import { walk } from 'zimmerframe';
+import * as b from '../utils/builders.js';
 
 /**
  * Mark every selector inside the stylesheet as "used" so `renderStylesheets`
@@ -183,7 +184,7 @@ export function add_hash_class(element, hash) {
 	if (!existing) {
 		attrs.push({
 			type: 'Attribute',
-			name: { type: 'Identifier', name: 'class' },
+			name: b.id('class'),
 			value: { type: 'Literal', value: hash, raw: JSON.stringify(hash) },
 		});
 		return;
@@ -203,22 +204,7 @@ export function add_hash_class(element, hash) {
 
 	// Dynamic expression. Concatenate at runtime via template literal.
 	const expression = value.type === 'JSXExpressionContainer' ? value.expression : value;
-	existing.value = {
-		type: 'TemplateLiteral',
-		expressions: [expression],
-		quasis: [
-			{
-				type: 'TemplateElement',
-				value: { raw: '', cooked: '' },
-				tail: false,
-			},
-			{
-				type: 'TemplateElement',
-				value: { raw: ` ${hash}`, cooked: ` ${hash}` },
-				tail: true,
-			},
-		],
-	};
+	existing.value = b.template([b.quasi('', false), b.quasi(` ${hash}`, true)], [expression]);
 }
 
 /**
@@ -237,13 +223,9 @@ function add_hash_class_to_jsx_element(element, hash, jsx_class_attr_name) {
 	);
 
 	if (!existing) {
-		attrs.push({
-			type: 'JSXAttribute',
-			name: { type: 'JSXIdentifier', name: jsx_class_attr_name, metadata: { path: [] } },
-			value: { type: 'Literal', value: hash, raw: JSON.stringify(hash) },
-			shorthand: false,
-			metadata: { path: [] },
-		});
+		const hash_literal = b.literal(hash);
+		/** @type {any} */ (hash_literal).raw = JSON.stringify(hash);
+		attrs.push(b.jsx_attribute(b.jsx_id(jsx_class_attr_name), hash_literal));
 		return;
 	}
 
@@ -268,25 +250,7 @@ function add_hash_class_to_jsx_element(element, hash, jsx_class_attr_name) {
 	}
 
 	const expression = value.type === 'JSXExpressionContainer' ? value.expression : value;
-	existing.value = {
-		type: 'JSXExpressionContainer',
-		expression: {
-			type: 'TemplateLiteral',
-			expressions: [expression],
-			quasis: [
-				{
-					type: 'TemplateElement',
-					value: { raw: '', cooked: '' },
-					tail: false,
-				},
-				{
-					type: 'TemplateElement',
-					value: { raw: ` ${hash}`, cooked: ` ${hash}` },
-					tail: true,
-				},
-			],
-			metadata: { path: [] },
-		},
-		metadata: { path: [] },
-	};
+	existing.value = b.jsx_expression_container(
+		b.template([b.quasi('', false), b.quasi(` ${hash}`, true)], [expression]),
+	);
 }

package/src/transform/segments.js

@@ -10,6 +10,7 @@
 	VolarMappingsResult,
 	PostProcessingChanges,
 	LineOffsets,
+	CompileError,
 } from '../../types/index';
 @import { CodeMapping as VolarCodeMapping } from '@volar/language-core';
  */
@@ -343,6 +344,7 @@ function extract_classes(node, src_to_gen_map, gen_line_offsets, src_line_offset
  * @param {RawSourceMap} source_map - Esrap source map for accurate position lookup
  * @param {PostProcessingChanges } post_processing_changes - Optional post-processing changes
  * @param {number[]} line_offsets - Pre-computed line offsets array for generated code
+ * @param {CompileError[]} [errors]
  * @returns {Omit<VolarMappingsResult, 'errors'>}
  */
 export function convert_source_map_to_mappings(
@@ -353,6 +355,7 @@ export function convert_source_map_to_mappings(
 	source_map,
 	post_processing_changes,
 	line_offsets,
+	errors = [],
 ) {
 	/** @type {CodeMapping[]} */
 	const mappings = [];
@@ -361,11 +364,12 @@ export function convert_source_map_to_mappings(
 	const src_line_offsets = build_line_offsets(source);
 	const gen_line_offsets = build_line_offsets(generated_code);
 
-	const [src_to_gen_map] = build_src_to_gen_map(
+	const [src_to_gen_map, , source_line_generated_map] = build_src_to_gen_map(
 		source_map,
 		post_processing_changes,
 		line_offsets,
 		generated_code,
+		errors.length > 0,
 	);
 
 	/** @type {Token[]} */
@@ -2250,6 +2254,15 @@ export function convert_source_map_to_mappings(
 		});
 	}
 
+	add_diagnostic_mappings(
+		mappings,
+		errors,
+		generated_code,
+		src_to_gen_map,
+		source_line_generated_map,
+		gen_line_offsets,
+	);
+
 	// Sort mappings by start position, but prioritize narrower ranges that are fully contained
 	// within wider ones. This ensures that specific tokens (like identifiers) take precedence
 	// over broader ranges (like `if` consequent blocks) during language server lookups.
@@ -2351,7 +2364,7 @@ function find_component_keyword_offset(generated_code, generated_id_start) {
  * 	source: string,
  * 	generated_code: string,
  * 	source_map: RawSourceMap,
- * 	errors?: import('../../types/index').CompileError[],
+ * 	errors?: CompileError[],
  * 	post_processing_changes?: PostProcessingChanges,
  * 	line_offsets?: LineOffsets,
  * }} params
@@ -2367,20 +2380,160 @@ export function create_volar_mappings_result({
 	post_processing_changes,
 	line_offsets,
 }) {
+	const result = convert_source_map_to_mappings(
+		ast,
+		ast_from_source,
+		source,
+		generated_code,
+		source_map,
+		/** @type {PostProcessingChanges} */ (post_processing_changes),
+		line_offsets ?? build_line_offsets(generated_code),
+		errors,
+	);
+
 	return {
-		...convert_source_map_to_mappings(
-			ast,
-			ast_from_source,
-			source,
-			generated_code,
-			source_map,
-			/** @type {PostProcessingChanges} */ (post_processing_changes),
-			line_offsets ?? build_line_offsets(generated_code),
-		),
+		...result,
 		errors,
 	};
 }
 
+/**
+ * Parser diagnostics can point at source-only tokens that are intentionally
+ * omitted or rewritten away in generated TSX. Add a narrow mapping so the
+ * language-server diagnostic plugin can translate those exact source ranges.
+ *
+ * @param {CodeMapping[]} mappings
+ * @param {CompileError[]} errors
+ * @param {string} generated_code
+ * @param {Map<string, Array<{ line: number, column: number }>>} src_to_gen_map
+ * @param {Map<number, Array<{ column: number, position: { line: number, column: number } }>> | null} source_line_generated_map
+ * @param {LineOffsets} gen_line_offsets
+ */
+function add_diagnostic_mappings(
+	mappings,
+	errors,
+	generated_code,
+	src_to_gen_map,
+	source_line_generated_map,
+	gen_line_offsets,
+) {
+	if (errors.length === 0 || !source_line_generated_map) {
+		return;
+	}
+
+	/** @type {CodeMapping[]} */
+	const diagnostic_mappings = [];
+
+	for (const error of errors) {
+		const start = error.pos;
+		if (start === undefined) continue;
+		if (has_exact_source_map_position(error, src_to_gen_map)) continue;
+
+		const end = error.end && error.end > start ? error.end : start + 1;
+		const length = end - start;
+		const generated_start = get_nearest_generated_offset_from_source_line_map(
+			error,
+			source_line_generated_map,
+			gen_line_offsets,
+			generated_code,
+		);
+		if (generated_start === null) continue;
+
+		diagnostic_mappings.push({
+			sourceOffsets: [start],
+			generatedOffsets: [generated_start],
+			lengths: [length],
+			generatedLengths: [
+				generated_code.length === 0
+					? 0
+					: Math.max(1, Math.min(length, generated_code.length - generated_start)),
+			],
+			data: {
+				...mapping_data_verify_only,
+				customData: {},
+			},
+		});
+	}
+
+	mappings.unshift(...diagnostic_mappings);
+}
+
+/**
+ * @param {CompileError} error
+ * @param {Map<string, Array<{ line: number, column: number }>>} src_to_gen_map
+ */
+function has_exact_source_map_position(error, src_to_gen_map) {
+	const loc = error.loc?.start;
+	return !!loc && src_to_gen_map.has(`${loc.line}:${loc.column}`);
+}
+
+/**
+ * @param {CompileError} error
+ * @param {Map<number, Array<{ column: number, position: { line: number, column: number } }>>} source_line_generated_map
+ * @param {LineOffsets} gen_line_offsets
+ * @param {string} generated_code
+ */
+function get_nearest_generated_offset_from_source_line_map(
+	error,
+	source_line_generated_map,
+	gen_line_offsets,
+	generated_code,
+) {
+	const loc = error.loc?.start;
+	if (!loc || generated_code.length === 0) {
+		return null;
+	}
+
+	const position = get_nearest_source_line_generated_position(
+		source_line_generated_map,
+		loc.line,
+		loc.column,
+	);
+	if (!position) {
+		return null;
+	}
+
+	const generated_offset =
+		loc_to_offset(position.line, position.column, gen_line_offsets) +
+		('sourceColumn' in position ? loc.column - position.sourceColumn : 0);
+	return Math.max(0, Math.min(generated_offset, generated_code.length - 1));
+}
+
+/**
+ * @param {Map<number, Array<{ column: number, position: { line: number, column: number } }>>} source_line_generated_map
+ * @param {number} line
+ * @param {number} column
+ * @returns {{ line: number, column: number, sourceColumn: number } | null}
+ */
+function get_nearest_source_line_generated_position(source_line_generated_map, line, column) {
+	const line_positions = source_line_generated_map.get(line);
+	if (!line_positions?.length) {
+		return null;
+	}
+	line_positions.sort((a, b) => a.column - b.column);
+
+	let low = 0;
+	let high = line_positions.length - 1;
+	let best = -1;
+	while (low <= high) {
+		const mid = (low + high) >> 1;
+		if (line_positions[mid].column <= column) {
+			best = mid;
+			low = mid + 1;
+		} else {
+			high = mid - 1;
+		}
+	}
+
+	if (best === -1) {
+		return null;
+	}
+
+	const entry = line_positions[best];
+	const position = entry.position;
+	return { line: position.line, column: position.column, sourceColumn: entry.column };
+}
+
 /**
  * Remove byte-for-byte duplicate mappings. Framework compilers that extract
  * shared helpers or replay JSX can emit identical mapping entries for the

package/src/utils/ast.js

@@ -32,6 +32,19 @@ export function is_function_node(node) {
 	);
 }
 
+/**
+ * @param {AST.Node} node
+ * @returns {boolean}
+ */
+export function is_function_or_component_node(node) {
+	return (
+		node.type === 'FunctionDeclaration' ||
+		node.type === 'FunctionExpression' ||
+		node.type === 'ArrowFunctionExpression' ||
+		node.type === 'Component'
+	);
+}
+
 /**
  * @param {AST.Node} node
  * @returns {boolean}

package/src/utils/builders.js

@@ -57,10 +57,12 @@ export function assignment_pattern(left, right) {
 /**
  * @param {Array<AST.Pattern>} params
  * @param {AST.BlockStatement | AST.Expression} body
+ * @param {boolean} [async]
+ * @param {AST.TSTypeParameterDeclaration} [type_parameters]
  * @param {AST.NodeWithLocation} [loc_info]
  * @returns {AST.ArrowFunctionExpression}
  */
-export function arrow(params, body, async = false, loc_info) {
+export function arrow(params, body, async = false, type_parameters, loc_info) {
 	const node = /** @type {AST.ArrowFunctionExpression} */ ({
 		type: 'ArrowFunctionExpression',
 		params,
@@ -68,6 +70,7 @@ export function arrow(params, body, async = false, loc_info) {
 		expression: body.type !== 'BlockStatement',
 		generator: false,
 		async,
+		typeParameters: type_parameters,
 		metadata: { path: [] },
 	});
 
@@ -296,12 +299,16 @@ export function export_builder(
  * @param {AST.Identifier} id
  * @param {AST.Pattern[]} params
  * @param {AST.BlockStatement} body
+ * @param {boolean} [async]
+ * @param {AST.TSTypeParameterDeclaration} [type_parameters]
+ * @param
  * @returns {AST.FunctionDeclaration}
  */
-export function function_declaration(id, params, body, async = false) {
+export function function_declaration(id, params, body, async = false, type_parameters) {
 	return {
 		type: 'FunctionDeclaration',
 		id,
+		typeParameters: type_parameters,
 		params,
 		body,
 		generator: false,
@@ -370,11 +377,12 @@ export function init(name, value) {
 
 /**
  * @param {boolean | string | number | bigint | false | RegExp | null | undefined} value
+ * @param {string} [raw]
  * @param {AST.NodeWithLocation} [loc_info]
  * @returns {AST.Literal}
  */
-export function literal(value, loc_info) {
-	const node = /** @type {AST.Literal} */ ({ type: 'Literal', value, metadata: { path: [] } });
+export function literal(value, raw, loc_info) {
+	const node = /** @type {AST.Literal} */ ({ type: 'Literal', value, raw, metadata: { path: [] } });
 
 	return set_location(node, loc_info);
 }
@@ -940,16 +948,18 @@ export function method(kind, key, params, body, computed = false, is_static = fa
  * @param {AST.Pattern[]} params
  * @param {AST.BlockStatement} body
  * @param {boolean} async
+ * @param {AST.TSTypeParameterDeclaration} [type_parameters]
  * @param {AST.NodeWithLocation} [loc_info]
  * @returns {AST.FunctionExpression}
  */
-function function_builder(id, params, body, async = false, loc_info) {
+function function_builder(id, params, body, async = false, type_parameters, loc_info) {
 	/** @type {AST.FunctionExpression} */
 	const node = {
 		type: 'FunctionExpression',
 		id,
 		params,
 		body,
+		typeParameters: type_parameters,
 		generator: false,
 		async,
 		metadata: { path: [] },
@@ -990,7 +1000,7 @@ export function import_all(as, source, attributes = [], importKind = 'value') {
 }
 
 /**
- * @param {Array<[string, string, AST.ImportDeclaration['importKind']]>} parts
+ * @param {Array<[string, string] | [string, string, AST.ImportDeclaration['importKind']]>} parts
  * @param {string} source
  * @param {Array<AST.ImportAttribute>} attributes
  * @param {AST.ImportDeclaration['importKind']} importKind
@@ -1001,13 +1011,41 @@ export function imports(parts, source, attributes = [], importKind = 'value') {
 		type: 'ImportDeclaration',
 		source: literal(source),
 		attributes,
-		specifiers: parts.map((p) => ({
-			type: 'ImportSpecifier',
-			imported: id(p[0]),
-			local: id(p[1]),
-			importKind: p.length > 2 ? p[2] : 'value',
-			metadata: { path: [] },
-		})),
+		specifiers: parts.map((p) => import_specifier(p[0], p[1], p.length > 2 ? p[2] : 'value')),
+		importKind,
+		metadata: { path: [] },
+	};
+}
+
+/**
+ * @param {string | AST.Identifier} imported
+ * @param {string | AST.Identifier} [local]
+ * @param {AST.ImportDeclaration['importKind']} [importKind]
+ * @returns {AST.ImportSpecifier}
+ */
+export function import_specifier(imported, local = imported, importKind = 'value') {
+	return {
+		type: 'ImportSpecifier',
+		imported: typeof imported === 'string' ? id(imported) : imported,
+		local: typeof local === 'string' ? id(local) : local,
+		importKind,
+		metadata: { path: [] },
+	};
+}
+
+/**
+ * @param {Array<AST.ImportSpecifier | AST.ImportDefaultSpecifier | AST.ImportNamespaceSpecifier>} specifiers
+ * @param {string} source
+ * @param {Array<AST.ImportAttribute>} [attributes]
+ * @param {AST.ImportDeclaration['importKind']} [importKind]
+ * @returns {AST.ImportDeclaration}
+ */
+export function import_declaration(specifiers, source, attributes = [], importKind = 'value') {
+	return {
+		type: 'ImportDeclaration',
+		source: literal(source),
+		specifiers,
+		attributes,
 		importKind,
 		metadata: { path: [] },
 	};

package/src/utils/dom.js

@@ -0,0 +1,158 @@
+const VOID_ELEMENT_NAMES = [
+	'area',
+	'base',
+	'br',
+	'col',
+	'command',
+	'embed',
+	'hr',
+	'img',
+	'input',
+	'keygen',
+	'link',
+	'meta',
+	'param',
+	'source',
+	'track',
+	'wbr',
+];
+
+/**
+ * Returns true if name is a void element
+ * @param {string} name
+ * @returns {boolean}
+ */
+export function is_void_element(name) {
+	return VOID_ELEMENT_NAMES.includes(name) || name.toLowerCase() === '!doctype';
+}
+
+const RESERVED_WORDS = [
+	'arguments',
+	'await',
+	'break',
+	'case',
+	'catch',
+	'class',
+	'const',
+	'continue',
+	'debugger',
+	'default',
+	'delete',
+	'do',
+	'else',
+	'enum',
+	'eval',
+	'export',
+	'extends',
+	'false',
+	'finally',
+	'for',
+	'function',
+	'if',
+	'implements',
+	'import',
+	'in',
+	'instanceof',
+	'interface',
+	'let',
+	'new',
+	'null',
+	'package',
+	'private',
+	'protected',
+	'public',
+	'return',
+	'static',
+	'super',
+	'switch',
+	'this',
+	'throw',
+	'true',
+	'try',
+	'typeof',
+	'var',
+	'void',
+	'while',
+	'with',
+	'yield',
+];
+
+/**
+ * Returns true if word is a reserved JS keyword
+ * @param {string} word
+ * @returns {boolean}
+ */
+export function is_reserved(word) {
+	return RESERVED_WORDS.includes(word);
+}
+
+/**
+ * Attributes that are boolean, i.e. they are present or not present.
+ */
+const DOM_BOOLEAN_ATTRIBUTES = [
+	'allowfullscreen',
+	'async',
+	'autofocus',
+	'autoplay',
+	'checked',
+	'controls',
+	'default',
+	'disabled',
+	'formnovalidate',
+	'hidden',
+	'indeterminate',
+	'inert',
+	'ismap',
+	'loop',
+	'multiple',
+	'muted',
+	'nomodule',
+	'novalidate',
+	'open',
+	'playsinline',
+	'readonly',
+	'required',
+	'reversed',
+	'seamless',
+	'selected',
+	'webkitdirectory',
+	'defer',
+	'disablepictureinpicture',
+	'disableremoteplayback',
+];
+
+/**
+ * Returns true if name is a boolean DOM attribute
+ * @param {string} name
+ * @returns {boolean}
+ */
+export function is_boolean_attribute(name) {
+	return DOM_BOOLEAN_ATTRIBUTES.includes(name);
+}
+
+const DOM_PROPERTIES = [
+	...DOM_BOOLEAN_ATTRIBUTES,
+	'formNoValidate',
+	'isMap',
+	'noModule',
+	'playsInline',
+	'readOnly',
+	'value',
+	'volume',
+	'defaultValue',
+	'defaultChecked',
+	'srcObject',
+	'noValidate',
+	'allowFullscreen',
+	'disablePictureInPicture',
+	'disableRemotePlayback',
+];
+
+/**
+ * Returns true if name is a DOM property
+ * @param {string} name
+ * @returns {boolean}
+ */
+export function is_dom_property(name) {
+	return DOM_PROPERTIES.includes(name);
+}