@tsrx/core 0.1.58 → 0.1.60

package/package.json

@@ -3,7 +3,7 @@
   "description": "Core compiler infrastructure for TSRX syntax",
   "license": "MIT",
   "author": "Dominic Gannaway",
-  "version": "0.1.58",
+  "version": "0.1.60",
   "type": "module",
   "repository": {
     "type": "git",
@@ -78,12 +78,14 @@
     "esrap": "^2.3.2",
     "is-reference": "^3.0.3",
     "magic-string": "^0.30.18",
-    "zimmerframe": "^1.1.2"
+    "zimmerframe": "^1.1.2",
+    "@tsrx/runtime": "0.1.1"
   },
   "devDependencies": {
     "@types/node": "^24.3.0",
     "@typescript-eslint/types": "^8.40.0",
     "@volar/language-core": "~2.4.28",
+    "@volar/source-map": "~2.4.28",
     "typescript": "^5.9.3",
     "vite": "^8.1.5",
     "vscode-languageserver-types": "^3.17.5"

package/src/analyze/prune.js

@@ -15,6 +15,8 @@ const BACKWARD = 1;
 // since the code is synchronous, this is safe
 /** @type {string} */
 let css_hash;
+/** @type {string} */
+let css_region_hash;
 /** @type {StyleClasses} */
 let style_identifier_classes;
 /** @type {TopScopedClasses} */
@@ -300,6 +302,7 @@ function apply_selector(relative_selectors, rule, element, direction) {
 								start: selector.start,
 								end: selector.end,
 								selector: selector,
+								regionHash: css_region_hash,
 							});
 						}
 					}
@@ -1107,10 +1110,12 @@ function rule_has_animation(rule) {
  * @param {AST.TSRXElementNode} element
  * @param {StyleClasses} styleClasses
  * @param {TopScopedClasses} topScopedClasses
+ * @param {string} [regionHash]
  * @return {void}
  */
-export function prune_css(css, element, styleClasses, topScopedClasses) {
+export function prune_css(css, element, styleClasses, topScopedClasses, regionHash = css.hash) {
 	css_hash = css.hash;
+	css_region_hash = regionHash;
 	style_identifier_classes = styleClasses;
 	top_scoped_classes = topScopedClasses;
 
@@ -1152,6 +1157,7 @@ export function prune_css(css, element, styleClasses, topScopedClasses) {
 							start: class_selector.start,
 							end: class_selector.end,
 							selector: class_selector,
+							regionHash: css_region_hash,
 						});
 					}
 				}

package/src/comment-utils.js

@@ -29,6 +29,14 @@ export function is_triple_slash_directive(comment) {
 	return /^\/\s*<(reference|amd-module|amd-dependency)/.test(value);
 }
 
+/**
+ * @param {AST.CommentWithLocation} comment
+ * @returns {boolean}
+ */
+export function is_jsdoc_comment(comment) {
+	return comment.type === 'Block' && comment.value.startsWith('*');
+}
+
 /**
  * Check if a comment is a JSDoc comment with TypeScript annotations
  * Examples: block comments containing `@type`, `@typedef`, `@param`, `@returns`, etc.
@@ -36,10 +44,7 @@ export function is_triple_slash_directive(comment) {
  * @returns {boolean}
  */
 export function is_jsdoc_ts_annotation(comment) {
-	if (comment.type !== 'Block') return false;
-
-	// JSDoc comments start with /** which means the value starts with * after /* is stripped
-	if (!comment.value.startsWith('*')) return false;
+	if (!is_jsdoc_comment(comment)) return false;
 
 	// Check if it contains TypeScript-relevant tags
 	const tsAnnotations = [
@@ -84,6 +89,36 @@ export function should_preserve_comment(comment) {
 	);
 }
 
+/**
+ * Declaration generators also consume documentation and custom `// @...`
+ * annotations from JSX-backed virtual TypeScript. Keep this broader policy
+ * separate from the legacy to_ts printer's semantic-comment policy.
+ * @param {AST.CommentWithLocation} comment
+ * @returns {boolean}
+ */
+export function should_preserve_jsx_tooling_comment(comment) {
+	return (
+		should_preserve_comment(comment) ||
+		is_jsdoc_comment(comment) ||
+		(comment.type === 'Line' && comment.value.trimStart().startsWith('@'))
+	);
+}
+
+/**
+ * Only file-wide directives may move ahead of generated imports or hoists.
+ * In particular, @ts-ignore/@ts-expect-error and declaration JSDoc must stay
+ * with the statement they describe.
+ * @param {AST.CommentWithLocation} comment
+ * @returns {boolean}
+ */
+export function is_file_level_pragma(comment) {
+	return (
+		is_jsx_pragma(comment) ||
+		is_triple_slash_directive(comment) ||
+		(comment.type === 'Line' && /^\s*@ts-(?:no)?check\b/.test(comment.value))
+	);
+}
+
 /**
  * Format a comment for output
  * @param {AST.CommentWithLocation} comment

package/src/runtime/iterable.js

@@ -1,112 +1 @@
-/**
- * @template T
- * @template U
- * @param {Iterable<T> | Iterator<T>} iterable
- * @param {(item: T, index: number, is_last: boolean) => U} fn
- * @param {() => U | U[]} [tail]
- * @param {() => U | U[]} [empty]
- * @returns {U[]}
- */
-export function map_iterable(iterable, fn, tail, empty) {
-	if (Array.isArray(iterable)) {
-		return map_array(iterable, fn, tail, empty);
-	}
-
-	/** @type {Iterator<T>} */
-	var iterator;
-	var iterable_prop = /** @type {Iterable<T>} */ (iterable)[Symbol.iterator];
-
-	if (typeof iterable_prop === 'function') {
-		iterator = iterable_prop.call(iterable);
-	} else if (typeof (/** @type {Iterator<T>} */ (iterable).next) === 'function') {
-		iterator = Iterator.from(iterable);
-	} else {
-		throw new TypeError('The loop target has to be an Iterable');
-	}
-
-	var current = iterator.next();
-	if (current.done) {
-		if (!empty) {
-			return [];
-		}
-		var empty_value = empty();
-		if (Array.isArray(empty_value)) {
-			return empty_value;
-		}
-		return [empty_value];
-	}
-
-	var index = 0;
-	var result = [];
-	while (true) {
-		var next = iterator.next();
-		var value = fn(current.value, index++, !!next.done);
-		if (Array.isArray(value)) {
-			for (var j = 0; j < value.length; j++) {
-				result.push(value[j]);
-			}
-		} else {
-			result.push(value);
-		}
-		if (next.done) {
-			break;
-		}
-		current = next;
-	}
-	if (tail) {
-		var tail_value = tail();
-		if (Array.isArray(tail_value)) {
-			for (var j = 0; j < tail_value.length; j++) {
-				result.push(tail_value[j]);
-			}
-		} else {
-			result.push(tail_value);
-		}
-	}
-	return result;
-}
-
-/**
- * @template T
- * @template U
- * @param {Array<T>} array
- * @param {(item: T, index: number, is_last: boolean) => U} fn
- * @param {() => U | U[]} [tail]
- * @param {() => U | U[]} [empty]
- * @returns {U[]}
- */
-function map_array(array, fn, tail, empty) {
-	var length = array.length;
-	if (length === 0) {
-		if (!empty) {
-			return [];
-		}
-		var empty_value = empty();
-		if (Array.isArray(empty_value)) {
-			return empty_value;
-		}
-		return [empty_value];
-	}
-	var result = [];
-	for (var i = 0; i < length; i++) {
-		var value = fn(array[i], i, i === length - 1);
-		if (Array.isArray(value)) {
-			for (var j = 0; j < value.length; j++) {
-				result.push(value[j]);
-			}
-		} else {
-			result.push(value);
-		}
-	}
-	if (tail) {
-		var tail_value = tail();
-		if (Array.isArray(tail_value)) {
-			for (var j = 0; j < tail_value.length; j++) {
-				result.push(tail_value[j]);
-			}
-		} else {
-			result.push(tail_value);
-		}
-	}
-	return result;
-}
+export * from '@tsrx/runtime/iterable';

package/src/runtime/language-helpers.js

@@ -1,139 +1 @@
-/** @type {typeof Object.getOwnPropertyDescriptor} */
-export var get_descriptor = Object.getOwnPropertyDescriptor;
-/** @type {typeof Object.getOwnPropertyDescriptors} */
-export var get_descriptors = Object.getOwnPropertyDescriptors;
-/** @type {typeof Array.from} */
-export var array_from = Array.from;
-/** @type {typeof Array.isArray} */
-export var is_array = Array.isArray;
-/** @type {typeof Object.defineProperty} */
-export var define_property = Object.defineProperty;
-/** @type {typeof Object.getPrototypeOf} */
-export var get_prototype_of = Object.getPrototypeOf;
-/** @type {typeof Object.values} */
-export var object_values = Object.values;
-/** @type {typeof Object.entries} */
-export var object_entries = Object.entries;
-/** @type {typeof Object.keys} */
-export var object_keys = Object.keys;
-/** @type {typeof Object.getOwnPropertySymbols} */
-export var get_own_property_symbols = Object.getOwnPropertySymbols;
-/** @type {typeof structuredClone} */
-export var structured_clone = structuredClone;
-/** @type {typeof Object.prototype} */
-export var object_prototype = Object.prototype;
-/** @type {typeof Array.prototype} */
-export var array_prototype = Array.prototype;
-/** @type {typeof Object.prototype.hasOwnProperty} */
-export var has_own_property = object_prototype.hasOwnProperty;
-
-/**
- * @param {object} value
- * @param {PropertyKey} key
- * @returns {boolean}
- */
-export function has_prototype_accessor(value, key) {
-	var proto = get_prototype_of(value);
-	while (proto != null) {
-		var descriptor = get_descriptor(proto, key);
-		if (descriptor !== undefined) {
-			return typeof descriptor.get === 'function' || typeof descriptor.set === 'function';
-		}
-		proto = get_prototype_of(proto);
-	}
-	return false;
-}
-
-/**
- * Slice helper for arrays and array-like values.
- * @template T
- * @param {ArrayLike<T>} array_like
- * @param {...number} args
- * @returns {T[]}
- */
-export function array_slice(array_like, ...args) {
-	return is_array(array_like)
-		? array_like.slice(...args)
-		: array_prototype.slice.call(array_like, ...args);
-}
-
-/**
- * Converts iterables, iterators, and array-like values to an array from an index.
- * @template T
- * @param {Iterable<T> | Iterator<T> | ArrayLike<T>} iterable
- * @param {number} [index]
- * @returns {T[]}
- */
-export function iterable_array_from(iterable, index = 0) {
-	/** @type {Iterator<T>} */
-	var iterator;
-	var iterable_prop = /** @type {Iterable<T>} */ (iterable)[Symbol.iterator];
-
-	if (typeof iterable_prop === 'function') {
-		iterator = iterable_prop.call(iterable);
-	} else if (typeof (/** @type {Iterator<T>} */ (iterable).next) === 'function') {
-		iterator = Iterator.from(/** @type {Iterator<T>} */ (iterable));
-	} else {
-		return array_from(/** @type {ArrayLike<T>} */ (iterable)).slice(index);
-	}
-
-	var result = [];
-	var i = 0;
-	var current = iterator.next();
-	while (!current.done) {
-		if (i++ < index) {
-			current = iterator.next();
-			continue;
-		}
-		result.push(current.value);
-		current = iterator.next();
-	}
-	return result;
-}
-
-/**
- * Creates a shallow forwarding object without one prop. Values are exposed through
- * getters so compiler-emitted reactive prop accessors are not snapshotted.
- *
- * @template {object} [T=Record<PropertyKey, unknown>]
- * @template {PropertyKey} [K=PropertyKey]
- * @param {T | null | undefined} props
- * @param {K} exclude_prop
- * @returns {Omit<T, K>} the forwarding object; `{}` when `props` is nullish
- */
-export function exclude_prop_from_object(props, exclude_prop) {
-	/** @type {Record<PropertyKey, unknown>} */
-	const next = {};
-
-	if (props != null) {
-		const source = /** @type {Record<PropertyKey, unknown>} */ (props);
-
-		for (const prop of Reflect.ownKeys(source)) {
-			if (prop === exclude_prop) continue;
-
-			const descriptor = get_descriptor(source, prop);
-			if (!descriptor?.enumerable) continue;
-
-			/** @type {PropertyDescriptor} */
-			const forwarding_descriptor = {
-				enumerable: true,
-				configurable: true,
-				get() {
-					return source[prop];
-				},
-			};
-
-			if (descriptor.writable === true || typeof descriptor.set === 'function') {
-				forwarding_descriptor.set = (value) => {
-					source[prop] = value;
-				};
-			}
-
-			define_property(next, prop, forwarding_descriptor);
-		}
-	}
-
-	// The forwarding object is assembled key by key, which no incremental type
-	// can describe; it mirrors `props` minus `exclude_prop` by construction.
-	return /** @type {Omit<T, K>} */ (next);
-}
+export * from '@tsrx/runtime/language-helpers';

package/src/runtime/ref.js

@@ -1,319 +1 @@
-/** @import { MergeableRef, RefProp, RefValue, SpreadProps } from '../../types/runtime/ref' */
-
-import {
-	has_own_property,
-	get_descriptor,
-	has_prototype_accessor,
-	is_array,
-} from '@tsrx/core/runtime/language-helpers';
-
-const REF_VALUE = Symbol();
-
-/**
- * Merge multiple refs (function refs and ref objects) into a single
- * callback ref. Used by React, Preact, and Vue targets when an element has
- * more than one `ref` attribute.
- * This is a public method and also used by the compiler to unite any refs with
- * any of the supported syntaxes.  It does not process spreads, that is delegated to
- * `normalize_spread_props`.
- *
- * @template [T=Element]
- * @param {...MergeableRef<T>} refs
- * @returns {(node: T | null) => (() => 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 (is_ref_object(ref, 'current')) {
-				ref.current = node;
-				cleanups.push(() => {
-					ref.current = null;
-				});
-			} else if (is_ref_object(ref, 'value')) {
-				ref.value = node;
-				cleanups.push(() => {
-					ref.value = null;
-				});
-			}
-		}
-		return () => {
-			for (const cleanup of cleanups) cleanup();
-		};
-	};
-}
-
-export { is_ref_prop as isRefProp };
-
-/**
- * A ref value that is a function is a callback ref — the bare-element branch of
- * `RefValue` is never callable.
- *
- * @template T
- * @param {RefValue<T>} value
- * @returns {value is (node: T | null) => void | (() => void)}
- */
-function is_ref_callback(value) {
-	return typeof value === 'function';
-}
-
-/**
- * @param {unknown} value
- * @returns {value is RefProp<Element>}
- */
-function is_ref_prop(value) {
-	return typeof value === 'function' && REF_VALUE in value;
-}
-
-/**
- * @template [T=Element]
- * @param {RefValue<T>} ref_value
- * @param {T | null} node
- * @param {(value: T | null) => void} [set_ref_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 (is_ref_callback(item) && node !== null) {
-				cleanups.push(() => item(null));
-			}
-		}
-		if (cleanups.length > 0) {
-			return () => {
-				for (const cleanup of cleanups) cleanup();
-			};
-		}
-		return;
-	}
-
-	if (is_ref_callback(ref_value)) {
-		return ref_value(node);
-	}
-
-	if (ref_value && typeof ref_value === 'object') {
-		if (is_ref_object(ref_value, 'current')) {
-			ref_value.current = node;
-			return () => {
-				ref_value.current = null;
-			};
-		}
-
-		if (is_ref_object(ref_value, 'value')) {
-			ref_value.value = node;
-			return () => {
-				ref_value.value = null;
-			};
-		}
-	}
-
-	if (set_ref_value !== undefined) {
-		set_ref_value(node);
-	}
-}
-
-/**
- * @template [T=Element]
- * @param {() => RefValue<T>} get_ref_value
- * @param {(value: T | null) => void} [set_ref_value]
- * @returns {RefProp<T>}
- */
-export function create_ref_prop(get_ref_value, set_ref_value) {
-	/**
-	 * @param {T | null} node
-	 * @returns {void | (() => void)}
-	 */
-	function ref_prop_callback(node) {
-		const ref_value = get_ref_value();
-		const cleanup = apply_ref_value(ref_value, node, set_ref_value);
-		if (typeof cleanup === 'function' || node === null) {
-			return cleanup;
-		}
-		return () => {
-			apply_ref_value(ref_value, null, set_ref_value);
-		};
-	}
-
-	Object.defineProperty(ref_prop_callback, REF_VALUE, {
-		value: 'ref_value',
-		enumerable: false,
-	});
-
-	return ref_prop_callback;
-}
-
-/**
- * @template [T=Element]
- * @param {...RefValue<T>} refs
- * @returns {RefValue<T>} the single surviving ref, or a callback applying all
- */
-export function merge_ref_props(...refs) {
-	const filtered = refs.filter((ref) => ref != null);
-
-	if (filtered.length === 0) {
-		return undefined;
-	}
-
-	if (filtered.length === 1) {
-		return filtered[0];
-	}
-
-	/**
-	 * @param {T | null} node
-	 * @returns {void | (() => void)}
-	 */
-	function merged_ref_prop(node) {
-		/** @type {Array<() => void>} */
-		const cleanups = [];
-
-		for (const ref of filtered) {
-			const cleanup = apply_ref_value(ref, node);
-			if (typeof cleanup === 'function') {
-				cleanups.push(cleanup);
-			} else if (is_ref_callback(ref) && node !== null) {
-				cleanups.push(() => ref(null));
-			}
-		}
-
-		return () => {
-			for (const cleanup of cleanups) {
-				cleanup();
-			}
-		};
-	}
-
-	return merged_ref_prop;
-}
-
-/**
- * @param {object | null | undefined} props a props bag; `object` rather than an
- *   index signature so an interface-typed bag is accepted
- * @param {...RefValue<Element>} outer_refs
- * @returns {SpreadProps | null | undefined}
- */
-export function normalize_spread_props(props, ...outer_refs) {
-	if (props == null) {
-		return props;
-	}
-
-	const source = /** @type {SpreadProps} */ (props);
-	/** @type {Array<RefValue<Element>>} */
-	const refs = [];
-	/** @type {SpreadProps} */
-	const next = {};
-	let changed = false;
-	let existing_ref;
-
-	for (const key of Reflect.ownKeys(source)) {
-		const descriptor = get_descriptor(source, key);
-		if (!descriptor?.enumerable) {
-			continue;
-		}
-
-		const value = source[key];
-
-		if (key === 'ref') {
-			if (is_ref_prop(value)) {
-				refs.push(value);
-				changed = true;
-			} else {
-				existing_ref = /** @type {RefValue<Element>} */ (value);
-			}
-			continue;
-		}
-
-		if (is_ref_prop(value)) {
-			refs.push(value);
-			changed = true;
-			continue;
-		}
-
-		next[key] = value;
-	}
-
-	if (!changed && outer_refs.length === 0) {
-		return source;
-	}
-
-	const merged_ref = merge_ref_props(existing_ref, ...refs, ...outer_refs);
-	if (merged_ref !== undefined) {
-		next.ref = merged_ref;
-	}
-
-	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 {object | null | undefined} props
- * @param {...RefValue<Element>} outer_refs
- * @returns {SpreadProps | 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;
-}
-
-/**
- * @template {'current' | 'value'} K
- * @param {object} value
- * @param {K} key
- * @returns {value is Record<K, unknown>}
- */
-function is_ref_object(value, key) {
-	if (is_dom_node(value)) {
-		return false;
-	}
-	if (key === 'value' && '__v_isRef' in value) {
-		return true;
-	}
-	if (has_own_property.call(value, key)) {
-		return true;
-	}
-	return key === 'value' && has_prototype_accessor(value, 'value');
-}
-
-/**
- * @param {object} value
- * @returns {boolean}
- */
-function is_dom_node(value) {
-	return (
-		(typeof Node !== 'undefined' && value instanceof Node) ||
-		('nodeType' in value &&
-			typeof (/** @type {{ nodeType?: unknown }} */ (value).nodeType) === 'number' &&
-			'nodeName' in value &&
-			typeof (/** @type {{ nodeName?: unknown }} */ (value).nodeName) === 'string')
-	);
-}
+export * from '@tsrx/runtime/ref';