@tsrx/core 0.1.60 → 0.1.62

package/README.md

@@ -5,9 +5,10 @@ infrastructure that powers TypeScript UI frameworks.
 
 `@tsrx/core` is framework-agnostic. It provides the parser, AST definitions, scope
 analysis, and code-generation utilities needed to target _any_ framework runtime
-using Ripple's syntax. Framework-specific packages (such as
-[`@tsrx/ripple`](../tsrx-ripple)) build on top of `@tsrx/core` to produce the
-runtime output for Ripple.
+using TSRX syntax. Framework-specific packages—such as
+[`@tsrx/react`](../tsrx-react), [`@tsrx/solid`](../tsrx-solid), and the external
+[`@tsrx/ripple`](https://github.com/Ripple-TS/ripple)—build on `@tsrx/core` to
+produce target-runtime output.
 
 ## What is TSRX?
 

package/package.json

@@ -3,11 +3,11 @@
   "description": "Core compiler infrastructure for TSRX syntax",
   "license": "MIT",
   "author": "Dominic Gannaway",
-  "version": "0.1.60",
+  "version": "0.1.62",
   "type": "module",
   "repository": {
     "type": "git",
-    "url": "git+https://github.com/Ripple-TS/ripple.git",
+    "url": "git+https://github.com/tsrx-org/tsrx.git",
     "directory": "packages/tsrx"
   },
   "exports": {
@@ -79,7 +79,7 @@
     "is-reference": "^3.0.3",
     "magic-string": "^0.30.18",
     "zimmerframe": "^1.1.2",
-    "@tsrx/runtime": "0.1.1"
+    "@tsrx/runtime": "0.1.2"
   },
   "devDependencies": {
     "@types/node": "^24.3.0",

package/src/constants.js

@@ -4,7 +4,7 @@ export const IS_CONTROLLED = 1 << 2;
 export const IS_INDEXED = 1 << 3;
 // A control-flow block that is its component's sole root: renders before the
 // parent `__anchor` (sibling semantics, no `<!>` wrapper). Must match the value
-// in ripple's runtime constants.
+// in a target runtime's constants.
 export const ROOT_CONTROLLED = 1 << 4;
 export const TEMPLATE_SVG_NAMESPACE = 1 << 5;
 export const TEMPLATE_MATHML_NAMESPACE = 1 << 6;

package/src/errors.js

@@ -57,12 +57,7 @@ export function error(message, filename, node, errors, comments, code) {
  */
 function is_error_suppress_comment(comment) {
 	const text = comment.value.trim();
-	return (
-		text.startsWith('@tsrx-ignore') ||
-		text.startsWith('@tsrx-expect-error') ||
-		text.startsWith('@ripple-ignore') ||
-		text.startsWith('@ripple-expect-error')
-	);
+	return text.startsWith('@tsrx-ignore') || text.startsWith('@tsrx-expect-error');
 }
 
 /**

package/src/parse/index.js

@@ -809,6 +809,10 @@ export function get_comment_handlers(source, comments, index = 0) {
 								const hasBlankLine = /\n\s*\n/.test(slice);
 								const nodeEndLine = node.loc?.end?.line ?? null;
 								const commentStartLine = comments[0].loc?.start?.line ?? null;
+								const commentOnSameLine =
+									nodeEndLine !== null &&
+									commentStartLine !== null &&
+									nodeEndLine === commentStartLine;
 								const isImmediateNextLine =
 									nodeEndLine !== null &&
 									commentStartLine !== null &&
@@ -853,10 +857,7 @@ export function get_comment_handlers(source, comments, index = 0) {
 									// For function parameters, only attach as trailing comment if it's on the same line
 									// Comments on next line after comma should be leading comments of next parameter
 									if (isParam) {
-										// Check if comment is on same line as the node
-										const nodeEndLine = source.slice(0, node.end).split('\n').length;
-										const commentStartLine = source.slice(0, comments[0].start).split('\n').length;
-										if (nodeEndLine === commentStartLine) {
+										if (commentOnSameLine) {
 											node.trailingComments = [
 												/** @type {AST.CommentWithLocation} */ (comments.shift()),
 											];
@@ -868,11 +869,6 @@ export function get_comment_handlers(source, comments, index = 0) {
 										// Only attach as trailing if:
 										// 1. It's on the same line as this node, OR
 										// 2. This is the last item in the array (no next sibling to attach to)
-										const commentOnSameLine =
-											nodeEndLine !== null &&
-											commentStartLine !== null &&
-											nodeEndLine === commentStartLine;
-
 										if (commentOnSameLine || is_last_in_array) {
 											node.trailingComments = [
 												/** @type {AST.CommentWithLocation} */ (comments.shift()),

package/src/plugin.js

@@ -246,7 +246,7 @@ function looks_like_generic_arrow(input, pos) {
 }
 
 /**
- * Acorn parser plugin for Ripple syntax extensions.
+ * Acorn parser plugin for TSRX syntax extensions.
  * Adds support for: native TSRX templates, &[]/&{} lazy destructuring,
  * submodule imports, TSRX directives, and enhanced JSX handling.
  *
@@ -358,7 +358,7 @@ export function TSRXPlugin(config) {
 			constructor(options, input) {
 				super(options, input);
 				this.context ??= [b_stat];
-				const tsrx_options = options?.tsrxOptions ?? options?.rippleOptions;
+				const tsrx_options = options?.tsrxOptions;
 				this.#collect = tsrx_options?.collect === true || tsrx_options?.loose === true;
 				this.#loose = tsrx_options?.loose === true;
 				this.#errors = tsrx_options?.errors;
@@ -2222,7 +2222,7 @@ export function TSRXPlugin(config) {
 			 * is exposed twice: verbatim on `content`, and as a single `JSXText` child so
 			 * generic element paths (factory targets, static hoisting, printers) emit the
 			 * body without knowing about raw-text elements. Consumers that handle
-			 * `content` directly (the Ripple transforms, the prettier plugin) must skip
+			 * `content` directly (target transforms, the Prettier plugin) must skip
 			 * the children instead of emitting both.
 			 *
 			 * @param {ESTreeJSX.TSRXJSXOpeningElement & AST.NodeWithLocation} open
@@ -2956,7 +2956,7 @@ export function TSRXPlugin(config) {
 			}
 
 			/**
-			 * Get token from character code - handles Ripple-specific tokens
+			 * Get token from character code - handles TSRX-specific tokens
 			 * @type {Parse.Parser['getTokenFromCode']}
 			 */
 			getTokenFromCode(code) {

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

@@ -391,14 +391,17 @@ export function flatten_switch_consequent(consequent) {
 export function clone_ast_node(node, with_locations = true) {
 	if (!node || typeof node !== 'object') return node;
 	if (Array.isArray(node)) {
-		return /** @type {T} */ (node.map((child) => clone_ast_node(child, with_locations)));
+		const clone = new Array(node.length);
+		for (let i = 0; i < node.length; i++) {
+			clone[i] = clone_ast_node(node[i], with_locations);
+		}
+		return /** @type {T} */ (clone);
 	}
-	const clone = { ...node };
+	const clone = /** @type {T} */ (with_locations ? { ...node } : {});
 	const clone_record = /** @type {Record<string, unknown>} */ (clone);
 
 	for (const key of Object.keys(node)) {
 		if (!with_locations && (key === 'loc' || key === 'start' || key === 'end')) {
-			delete clone_record[key];
 			continue;
 		}
 		if (key === 'metadata') {

package/src/transform/jsx/helpers.js

@@ -41,7 +41,7 @@ export function is_empty_jsx_fragment(node) {
 }
 
 /**
- * Match Ripple's transform path metadata shape: every node seen by the walker
+ * Maintain TSRX transform path metadata: every node seen by the walker
  * carries its current ancestor path for downstream CSS pruning and mapping
  * helpers.
  *

package/src/transform/jsx/index.js

@@ -268,7 +268,7 @@ function wrap_in_native_tsrx_fragment(node) {
 }
 
 /**
- * An AUTHORED `<> … </>` fragment (not a compiler-generated wrapper, nor a Ripple
+ * An AUTHORED `<> … </>` fragment (not a compiler-generated wrapper, nor a TSRX
  * code-block-chain wrapper). These are kept verbatim in the output instead of
  * being unwrapped to their single child.
  * @param {AST.Node | null | undefined} node
@@ -2362,7 +2362,7 @@ function prepare_tsrx_fragment_styles(node, transform_context) {
 		const region_hash = sheet.hash;
 		sheet.hash = css.hash;
 		// `prune_css` inside marks the matching selectors as used/scoped; selectors
-		// that match no element render commented out, like the Ripple target.
+		// that match no element render commented out, matching target behavior.
 		apply_css_definition_metadata(
 			node,
 			sheet,

package/src/transform/segments.js

@@ -517,6 +517,11 @@ export function convert_source_map_to_mappings(
 	function set_bracket_computed_mapping(node, mappings) {
 		if (has_location(node.key)) {
 			const key = node.key;
+			const start_key = `${key.loc.start.line}:${key.loc.start.column - 1}`;
+			const end_key = `${key.loc.end.line}:${key.loc.end.column + 1}`;
+			if (!src_to_gen_map.get(start_key)?.length || !src_to_gen_map.get(end_key)?.length) {
+				return;
+			}
 			mappings.push(
 				get_mapping_from_node(
 					/** @type {AST.NodeWithLocation} */ ({
@@ -625,7 +630,7 @@ export function convert_source_map_to_mappings(
 				if (node.name && node.loc) {
 					/** @type {MappingToken} */
 					let token;
-					// Check if this identifier was changed in metadata (e.g., #Map -> RippleMap)
+					// Check if this identifier was changed in metadata (for example, #Map -> ReactiveMap)
 					// Or if it was capitalized during transformation
 					if (node.metadata?.source_name) {
 						token = {
@@ -933,7 +938,7 @@ export function convert_source_map_to_mappings(
 				// text itself — and get_mapping_from_node just takes the first, so its generated length
 				// spans the wrong region and the editor can't map a completion's edit back to source
 				// (it then drops the item). The token resolves to the position whose generated text
-				// matches the node's value, giving a well-formed same-length mapping. Ripple keeps text
+				// matches the node's value, giving a well-formed same-length mapping. TSRX keeps text
 				// verbatim in to_ts, so `source` and `generated` are identical. Other text stays unmapped.
 				if (node.loc && typeof node.value === 'string' && node.value.trimStart().startsWith('@')) {
 					tokens.push({
@@ -1299,14 +1304,14 @@ export function convert_source_map_to_mappings(
 				);
 				return;
 			} else if (node.type === 'ForOfStatement' || node.type === 'ForInStatement') {
-				// Visit in source order: left, right, index (Ripple-specific), body
+				// Visit in source order: left, right, TSRX index extension, body
 				if (node.left) {
 					visit(node.left);
 				}
 				if (node.right) {
 					visit(node.right);
 				}
-				// Ripple-specific: index variable
+				// TSRX index extension: index variable
 				if (/** @type {AST.ForOfStatement} */ (node).index) {
 					visit(/** @type {AST.Node} */ (/** @type {AST.ForOfStatement} */ (node).index));
 				}

package/types/index.d.ts

@@ -352,7 +352,7 @@ declare module 'estree' {
 		lazy?: boolean;
 	}
 
-	// Ripple analysis may mark a whole member expression as tracked metadata.
+	// Target analysis may mark a whole member expression as tracked metadata.
 	interface MemberExpression {
 		tracked?: boolean;
 	}
@@ -425,7 +425,7 @@ declare module 'estree' {
 		 * `#parseScriptElement` (analogous to {@link JSXStyleElement.css}). Present only
 		 * on `<script>` elements that have a body. The parser also mirrors the body as
 		 * a single `JSXText` child so generic element consumers emit it; consumers that
-		 * handle `content` directly (the Ripple transforms, the prettier plugin, the
+		 * handle `content` directly (target transforms, the Prettier plugin, the
 		 * type-only editor output) skip the children instead of emitting both.
 		 */
 		content?: string;
@@ -1630,7 +1630,7 @@ export interface Binding {
 	/** Additional metadata for this binding */
 	metadata: {
 		pattern?: AST.Identifier;
-		is_ripple_object?: boolean;
+		is_tsrx_object?: boolean;
 		is_template_value?: boolean;
 		lazy_array_source?: string;
 		lazy_array_index?: number;
@@ -2232,7 +2232,7 @@ export type RuntimeImportMode = 'compiler' | 'direct';
 
 /**
  * Common base options accepted by every TSRX target's `compile` entry point.
- * Targets that need extra knobs (e.g. ripple's `mode`/`dev`/`hmr`, preact's
+ * Targets that need extra knobs (for example Ripple's `mode`/`dev`/`hmr`, Preact's
  * `suspenseSource`) intersect their own option type with this base when
  * declaring their `compile` export.
  */
@@ -2256,7 +2256,7 @@ export interface BaseCompileOptions {
  * @template TOptions Per-target options accepted as the third argument.
  *   Defaults to {@link BaseCompileOptions}.
  * @template TResult Per-target result type. Must extend {@link CompileResult};
- *   targets may add fields (e.g. ripple's deprecated `js` back-compat field)
+ *   targets may add fields (for example Ripple's deprecated `js` compatibility field)
  *   via intersection.
  */
 export type CompileFn<

package/types/jsx-platform.d.ts

@@ -158,7 +158,7 @@ export interface JsxTransformOptions {
 export interface JsxPlatformHooks {
 	/**
 	 * Per-statement control-flow rewrites. Each hook receives the original
-	 * Ripple statement (with children already walked) and returns a JSX
+	 * TSRX statement (with children already walked) and returns a JSX
 	 * child (or an expression container wrapping one).
 	 */
 	controlFlow?: {
@@ -205,7 +205,7 @@ export interface JsxPlatformHooks {
 	 */
 	injectImports?: (program: AST.Program, ctx: JsxTransformContext, suspenseSource: string) => void;
 	/**
-	 * Transform a Ripple element's parser-native JSX attributes. The result
+	 * Transform a TSRX element's parser-native JSX attributes. The result
 	 * is passed through the shared multi-`ref` merge. Platforms that own a
 	 * `transformElement` hook (e.g. Solid) run their own attribute pass inside
 	 * that hook.
@@ -343,7 +343,7 @@ export interface JsxPlatformHooks {
 
 /**
  * A JSX platform descriptor is the parameter to `createJsxTransform`. It
- * declares how to render a Ripple AST as valid TSX for the target platform
+ * declares how to render a TSRX AST as valid TSX for the target platform
  * (React, Preact, Solid). The shared transformer in `@tsrx/core` reads this
  * descriptor at each platform-specific decision point instead of branching
  * on the platform name.
@@ -432,7 +432,7 @@ export interface JsxPlatform {
 
 	jsx: {
 		/**
-		 * Rewrite Ripple's `class` attribute to `className` for legacy targets
+		 * Rewrite TSRX's `class` attribute to `className` for targets
 		 * that require it. First-party targets keep authored `class`.
 		 */
 		rewriteClassAttr: boolean;
@@ -527,7 +527,7 @@ export interface JsxPlatform {
 
 /**
  * Build a `transform()` function for a specific JSX platform. The returned
- * function takes a parsed Ripple AST and produces a TSX module plus source
+ * function takes a parsed TSRX AST and produces a TSX module plus source
  * map and optional CSS.
  */
 export function createJsxTransform(

package/types/parse.d.ts

@@ -193,12 +193,6 @@ export namespace Parse {
 			errors: CoreCompiler.CompileError[] | undefined;
 			filename: string | undefined;
 		};
-		rippleOptions?: {
-			collect: boolean;
-			loose: boolean;
-			errors: CoreCompiler.CompileError[] | undefined;
-			filename: string | undefined;
-		};
 		// The type has "latest" but it's converted to 1e8 at runtime
 		// and if (ecmaVersion >= 2015) { ecmaVersion -= 2009 }
 		// so we're making it always a number to reflect the runtime values
@@ -1666,7 +1660,7 @@ export namespace Parse {
 		/**
 		 * Check if a local export refers to a defined variable.
 		 * Acorn's default implementation only checks the top-level module scope,
-		 * but Ripple overrides this to check all scopes (for submodules).
+		 * but TSRX overrides this to check all scopes (for submodules).
 		 * @param id The identifier being exported
 		 */
 		checkLocalExport(id: AST.Identifier): void;