@tsrx/core 0.1.20 → 0.1.22

package/types/index.d.ts

@@ -59,7 +59,6 @@ export interface CompileOptions {
 	minify_css?: boolean;
 	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).
@@ -83,6 +82,19 @@ interface BaseNodeMetaData {
 	is_capitalized?: boolean;
 	commentContainerId?: number;
 	parenthesized?: boolean;
+	native_tsrx?: boolean;
+	native_tsrx_template_block?: boolean;
+	templateMode?: 'script' | 'template';
+	script_only?: boolean;
+	tsrxDirective?: 'if' | 'for' | 'switch' | 'try';
+	ts_name?: string;
+	delegated?: any;
+	returned_tsrx_return?: AST.ReturnStatement;
+	styleScopeHash?: string;
+	css?: {
+		scopedClasses: Map<string, { start: number; end: number; selector: any }>;
+		hash: string;
+	};
 	elementLeadingComments?: AST.Comment[];
 	returns?: AST.ReturnStatement[];
 	has_return?: boolean;
@@ -93,6 +105,7 @@ interface BaseNodeMetaData {
 	regular_js?: boolean;
 	returned_tsrx_child?: boolean;
 	forceMapping?: boolean;
+	generated_loop_skip_if?: boolean;
 	lazy_id?: string;
 	disable_verification?: boolean;
 	lazy_param_binding_mappings?: Array<{
@@ -171,6 +184,8 @@ declare module 'estree' {
 		metadata: BaseNodeMetaData & {
 			hook_split_block?: boolean;
 			native_return_block?: boolean;
+			native_tsrx_template_block?: boolean;
+			allows_native_return?: boolean;
 		};
 	}
 
@@ -236,26 +251,175 @@ declare module 'estree' {
 
 	// Include TypeScript node types and TSRX-specific nodes in NodeMap
 	interface NodeMap {
+		Element: Element;
 		TsrxFragment: TsrxFragment;
-		TsxCompat: TsxCompat;
+		Text: Text;
+		TSRXJSXElement: TSRXJSXElement;
 		TSRXExpression: TSRXExpression;
-		Element: Element;
-		Text: TextNode;
 		Attribute: Attribute;
 		SpreadAttribute: SpreadAttribute;
+		JSXCodeBlock: JSXCodeBlock;
+		JSXStyleElement: JSXStyleElement;
+		JSXIfExpression: JSXIfExpression;
+		JSXForExpression: JSXForExpression;
+		JSXSwitchExpression: JSXSwitchExpression;
+		JSXTryExpression: JSXTryExpression;
 		ParenthesizedExpression: ParenthesizedExpression;
-		ScriptContent: ScriptContent;
 	}
 
 	interface ExpressionMap {
+		Element: Element;
 		TsrxFragment: TsrxFragment;
-		Text: TextNode;
+		Text: Text;
+		TSRXExpression: TSRXExpression;
+		JSXCodeBlock: JSXCodeBlock;
+		JSXStyleElement: JSXStyleElement;
+		JSXIfExpression: JSXIfExpression;
+		JSXForExpression: JSXForExpression;
+		JSXSwitchExpression: JSXSwitchExpression;
+		JSXTryExpression: JSXTryExpression;
 		JSXEmptyExpression: ESTreeJSX.JSXEmptyExpression;
 		ParenthesizedExpression: ParenthesizedExpression;
 		TSAsExpression: TSAsExpression;
 	}
 
-	// Missing estree type
+	// Ripple-normalized template node shapes. The core parser emits JSX-shaped
+	// TSRX nodes; @tsrx/ripple creates these during its normalization pass.
+	interface Attribute extends AST.BaseNode {
+		type: 'Attribute';
+		name: AST.Identifier;
+		value: any;
+		shorthand?: boolean;
+		metadata: BaseNodeMetaData;
+	}
+
+	interface SpreadAttribute extends AST.BaseNode {
+		type: 'SpreadAttribute';
+		argument: AST.Expression;
+		metadata: BaseNodeMetaData;
+	}
+
+	interface Element extends AST.BaseExpression {
+		type: 'Element';
+		id: AST.Identifier | AST.MemberExpression | AST.Literal;
+		attributes: Array<Attribute | SpreadAttribute>;
+		children: AST.Node[];
+		openingElement: ESTreeJSX.JSXOpeningElement;
+		closingElement: ESTreeJSX.JSXClosingElement | null;
+		selfClosing?: boolean;
+		unclosed?: boolean;
+		css?: string;
+		metadata: BaseNodeMetaData;
+		start: number;
+		end: number;
+	}
+
+	interface TsrxFragment extends AST.BaseExpression {
+		type: 'TsrxFragment';
+		children: AST.Node[];
+		openingElement?: ESTreeJSX.JSXOpeningFragment;
+		closingElement?: ESTreeJSX.JSXClosingFragment | null;
+		selfClosing?: boolean;
+		attributes?: Array<Attribute | SpreadAttribute>;
+		metadata: BaseNodeMetaData;
+		start: number;
+		end: number;
+	}
+
+	interface Text extends AST.BaseExpression {
+		type: 'Text';
+		expression: AST.Expression;
+		metadata: BaseNodeMetaData;
+	}
+
+	interface TSRXExpression extends AST.BaseExpression {
+		type: 'TSRXExpression';
+		expression: AST.Expression;
+		metadata: BaseNodeMetaData;
+	}
+
+	type TSRXJSXChild =
+		| ESTreeJSX.JSXText
+		| ESTreeJSX.JSXExpressionContainer
+		| ESTreeJSX.JSXSpreadChild
+		| TSRXJSXElement
+		| TSRXJSXFragment
+		| AST.JSXCodeBlock;
+
+	interface TSRXJSXElement
+		extends Omit<ESTreeJSX.JSXElement, 'children'>, AST.NodeWithMaybeComments {
+		children: TSRXJSXChild[];
+		metadata: BaseNodeMetaData & {
+			ts_name?: string;
+		};
+	}
+
+	interface TSRXJSXFragment
+		extends Omit<ESTreeJSX.JSXFragment, 'children'>, AST.NodeWithMaybeComments {
+		children: TSRXJSXChild[];
+	}
+
+	interface JSXCodeBlock extends AST.BaseExpression {
+		type: 'JSXCodeBlock';
+		body: AST.Statement[];
+		render: AST.Node | null;
+		metadata: BaseNodeMetaData;
+		innerComments?: AST.Comment[] | undefined;
+	}
+
+	interface JSXStyleElement extends AST.BaseExpression {
+		type: 'JSXStyleElement';
+		openingElement: ESTreeJSX.JSXOpeningElement;
+		closingElement: ESTreeJSX.JSXClosingElement | null;
+		children: AST.CSS.StyleSheet[];
+		css?: string;
+		metadata: BaseNodeMetaData;
+		unclosed?: boolean;
+	}
+
+	interface JSXIfExpression extends AST.BaseExpression {
+		type: 'JSXIfExpression';
+		statementType: 'IfStatement';
+		test: AST.Expression;
+		consequent: AST.Statement;
+		alternate: AST.Statement | null;
+		metadata: BaseNodeMetaData;
+	}
+
+	interface JSXForExpression extends AST.BaseExpression {
+		type: 'JSXForExpression';
+		statementType: 'ForStatement' | 'ForInStatement' | 'ForOfStatement';
+		body: AST.Statement;
+		init?: AST.VariableDeclaration | AST.Expression | null;
+		test?: AST.Expression | null;
+		update?: AST.Expression | null;
+		left?: AST.VariableDeclaration | AST.Pattern;
+		right?: AST.Expression;
+		await?: boolean;
+		index?: AST.Identifier | null;
+		key?: AST.Expression | null;
+		empty?: AST.BlockStatement | null;
+		metadata: BaseNodeMetaData;
+	}
+
+	interface JSXSwitchExpression extends AST.BaseExpression {
+		type: 'JSXSwitchExpression';
+		statementType: 'SwitchStatement';
+		discriminant: AST.Expression;
+		cases: AST.SwitchCase[];
+		metadata: BaseNodeMetaData;
+	}
+
+	interface JSXTryExpression extends AST.BaseExpression {
+		type: 'JSXTryExpression';
+		statementType: 'TryStatement';
+		block: AST.BlockStatement;
+		handler: AST.CatchClause | null;
+		finalizer: AST.BlockStatement | null;
+		pending?: AST.BlockStatement | null;
+		metadata: BaseNodeMetaData;
+	}
+
 	interface ParenthesizedExpression extends AST.BaseNode {
 		type: 'ParenthesizedExpression';
 		expression: AST.Expression;
@@ -293,6 +457,7 @@ declare module 'estree' {
 	interface ForOfStatement {
 		index?: AST.Identifier | null;
 		key?: AST.Expression | null;
+		empty?: AST.BlockStatement | null;
 	}
 
 	interface ImportDeclaration {
@@ -344,99 +509,7 @@ declare module 'estree' {
 		trailingComments?: AST.Comment[] | undefined;
 	}
 
-	interface TsrxFragment extends AST.BaseExpression {
-		type: 'TsrxFragment';
-		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;
-		attributes: Array<any>;
-		children: ESTreeJSX.JSXElement['children'];
-		selfClosing?: boolean;
-		unclosed?: boolean;
-		openingElement: ESTreeJSX.JSXOpeningElement;
-		closingElement: ESTreeJSX.JSXClosingElement;
-	}
-
-	export interface TSRXExpression extends AST.BaseExpression {
-		type: 'TSRXExpression';
-		expression: AST.Expression;
-		loc?: AST.SourceLocation;
-	}
-
-	interface Element extends AST.BaseNode {
-		type: 'Element';
-		// MemberExpression for namespaced or dynamic elements
-		id: AST.Identifier | AST.MemberExpression;
-		attributes: TSRXAttribute[];
-		children: AST.Node[];
-		selfClosing?: boolean;
-		unclosed?: boolean;
-		loc: SourceLocation;
-		metadata: BaseNodeMetaData & {
-			ts_name?: string;
-			// for <style> tag
-			styleScopeHash?: string;
-			// for elements with scoped style classes
-			css?: {
-				scopedClasses: Map<
-					string,
-					{
-						start: number;
-						end: number;
-						selector: CSS.ClassSelector;
-					}
-				>;
-				hash: string;
-			};
-		};
-		openingElement: ESTreeJSX.JSXOpeningElement;
-		closingElement: ESTreeJSX.JSXClosingElement;
-		// for <style> tags
-		css?: string;
-		innerComments?: Comment[];
-	}
-
-	export interface TextNode extends AST.BaseExpression {
-		type: 'Text';
-		expression: AST.Expression;
-		raw?: string;
-		loc?: AST.SourceLocation;
-	}
-
-	interface ScriptContent extends Omit<AST.Element, 'type'> {
-		type: 'ScriptContent';
-		content: string;
-	}
-
-	/**
-	 * TSRX attribute nodes
-	 */
-	interface Attribute extends AST.BaseNode {
-		type: 'Attribute';
-		name: AST.Identifier;
-		value: AST.Expression | null;
-		loc?: AST.SourceLocation;
-		shorthand?: boolean;
-		metadata: BaseNodeMetaData & {
-			delegated?: boolean;
-		};
-	}
-
-	interface SpreadAttribute extends AST.BaseNode {
-		type: 'SpreadAttribute';
-		argument: AST.Expression;
-		loc?: AST.SourceLocation;
-	}
-
-	export type TSRXDeclaration = AST.Declaration | AST.TSDeclareFunction;
+	type TSRXDeclaration = AST.Declaration | AST.TSDeclareFunction;
 
 	interface TSRXExportNamedDeclaration extends Omit<AST.ExportNamedDeclaration, 'declaration'> {
 		declaration?: TSRXDeclaration | null | undefined;
@@ -446,11 +519,9 @@ declare module 'estree' {
 		body: (Program['body'][number] | FunctionExpression)[];
 	}
 
-	export type TSRXAttribute = AST.Attribute | AST.SpreadAttribute;
-
-	export type TSRXStatement = AST.Statement | TSESTree.Statement;
+	type TSRXStatement = AST.Statement | TSESTree.Statement;
 
-	export type NodeWithChildren = AST.Element | AST.TsrxFragment | AST.TsxCompat;
+	type NodeWithChildren = TSRXJSXElement | TSRXJSXFragment | JSXStyleElement;
 
 	export namespace CSS {
 		export interface BaseNode extends AST.NodeWithMaybeComments {
@@ -1132,8 +1203,7 @@ export interface ParseOptions {
 /**
  * Analyze options
  */
-export interface AnalyzeOptions
-	extends ParseOptions, Pick<CompileOptions, 'mode' | 'compat_kinds'> {
+export interface AnalyzeOptions extends ParseOptions, Pick<CompileOptions, 'mode'> {
 	errors?: CompileError[];
 	to_ts?: boolean;
 }
@@ -1211,7 +1281,7 @@ export interface Binding {
 		| AST.ClassDeclaration
 		| AST.ImportDeclaration
 		| AST.TSModuleDeclaration
-		| AST.TsrxFragment;
+		| ESTreeJSX.JSXFragment;
 	/** Whether this binding has been reassigned */
 	reassigned: boolean;
 	/** Whether this binding has been mutated (property access) */
@@ -1311,7 +1381,7 @@ export interface ScopeInterface {
 			| AST.ClassDeclaration
 			| AST.ImportDeclaration
 			| AST.TSModuleDeclaration
-			| AST.TsrxFragment,
+			| ESTreeJSX.JSXFragment,
 	): Binding;
 	/** Get binding by name */
 	get(name: string): Binding | null;
@@ -1356,10 +1426,9 @@ export interface AnalysisState extends BaseState {
 			filename: string;
 		};
 	};
-	elements?: AST.Element[];
+	elements?: Array<ESTreeJSX.JSXElement | AST.Element>;
 	function_depth?: number;
 	collect?: boolean;
-	configured_compat_kinds?: Set<string>;
 	metadata: BaseStateMetaData & {
 		styleClasses?: StyleClasses;
 	};

package/types/jsx-platform.d.ts

@@ -197,7 +197,7 @@ export interface JsxPlatformHooks {
 	renderForOf?: (node: any, loopParams: any[], bodyStatements: any[], ctx: any) => any | null;
 	/**
 	 * Optionally replace the default React-style pending lowering for
-	 * `try { ... } pending { ... }`. The default emits
+	 * `@try { ... } @pending { ... }`. The default emits
 	 * `<Suspense fallback={fallbackContent}>tryContent</Suspense>`.
 	 * Vue Vapor uses this to provide `default` and `fallback` slots via
 	 * `v-slots`.
@@ -241,11 +241,11 @@ export interface JsxPlatformHooks {
 	 */
 	createErrorBoundaryContent?: (tryContent: any, ctx: any, node: any) => any | null;
 	/**
-	 * Lower a Ripple `Element` node to a JSXElement. Default is the
+	 * Customize lowering for a native JSX element. Default is the
 	 * factory's `to_jsx_element`. The hook receives the walker-transformed
 	 * node (`inner`, with children already lowered) plus the element's
 	 * raw pre-walk children — Solid uses the latter to detect a lone
-	 * `Text` child it can hoist to a `textContent` attribute before the
+	 * `JSXText` child it can hoist to a `textContent` attribute before the
 	 * generic text→JSXExpressionContainer transform runs.
 	 */
 	transformElement?: (inner: any, ctx: any, rawChildren: any[]) => any;
@@ -314,12 +314,12 @@ export interface JsxPlatform {
 		 */
 		fragment?: string;
 		/**
-		 * Module to import `Suspense` from when a `try { ... } pending { ... }`
+		 * Module to import `Suspense` from when an `@try { ... } @pending { ... }`
 		 * block appears. React: `'react'`. Preact: `'preact/compat'`.
 		 */
 		suspense: string;
 		/**
-		 * Module to import `TsrxErrorBoundary` from when a `try { ... } catch (...)`
+		 * Module to import `TsrxErrorBoundary` from when an `@try { ... } @catch (...)`
 		 * block appears. Usually `'@tsrx/<platform>/error-boundary'`.
 		 */
 		errorBoundary: string;
@@ -357,11 +357,6 @@ export interface JsxPlatform {
 		 * not rewrite authored attributes.
 		 */
 		classAttrName?: 'class' | 'className';
-		/**
-		 * Accepted values of `kind` in `<tsx:kind>` compat blocks. React accepts
-		 * only `'react'`. Preact accepts both `'preact'` and `'react'`.
-		 */
-		acceptedTsxKinds: readonly string[];
 		/**
 		 * How to collapse multiple `ref` attributes on the same element into
 		 * one. React's and Preact's runtimes treat duplicate `ref` props as
@@ -408,7 +403,7 @@ export interface JsxPlatform {
 		scanUseServerDirectiveForAwaitWithCustomValidator?: boolean;
 		/**
 		 * Optional branded compiler error for targets that cannot lower
-		 * `try { ... } pending { ... }` in component template context.
+		 * `@try { ... } @pending { ... }` in component template context.
 		 *
 		 * When provided, the shared try-block lowering rejects any `pending`
 		 * block with this message instead of emitting a React-style

package/types/parse.d.ts

@@ -422,6 +422,11 @@ export namespace Parse {
 		tokContexts: AcornTypeScriptTokContexts;
 	}
 
+	export interface AcornTypeScriptFunctionBodyConfig {
+		isFunctionDeclaration?: boolean | number;
+		isClassMethod?: boolean;
+	}
+
 	interface Scope {
 		flags: number;
 		var: string[];
@@ -489,6 +494,8 @@ export namespace Parse {
 		inAsync: boolean;
 		/** Whether we're inside a function */
 		inFunction: boolean;
+		/** Whether @sveltejs/acorn-typescript is currently parsing a TypeScript type */
+		inType: boolean;
 		/** Stack of label names for break/continue statements */
 		labels: Array<{ kind: string | null; name?: string; statementStart?: number }>;
 		/** Current scope flags stack */
@@ -600,6 +607,12 @@ export namespace Parse {
 		 */
 		getTokenFromCode(code: number): void;
 
+		/**
+		 * Get token from character code while in a TypeScript type context
+		 * Added by @sveltejs/acorn-typescript
+		 */
+		getTokenFromCodeInType(code: number): void;
+
 		/**
 		 * Get current position as Position object
 		 * @returns { line: number, column: number, index: number }
@@ -1116,6 +1129,16 @@ export namespace Parse {
 
 		tsCheckTypeAnnotationForReadOnly(node: AST.TSTypeOperator): void;
 
+		/**
+		 * Run a parser callback with @sveltejs/acorn-typescript's type-context flag enabled
+		 */
+		tsInType<T>(cb: () => T): T;
+
+		/**
+		 * Parse a TypeScript return type or type predicate annotation
+		 */
+		tsParseTypeOrTypePredicateAnnotation(returnToken: TokenType): AST.TSTypeAnnotation;
+
 		tsParseTypeArguments(): AST.Node;
 
 		tsTryParseTypeAnnotation(): AST.TSTypeAnnotation;
@@ -1172,9 +1195,7 @@ export namespace Parse {
 		 */
 		parseTopLevel(node: AST.Program): AST.Program;
 
-		parseElement(): AST.Element | AST.TsrxFragment | AST.TsxCompat;
-
-		parseDoubleQuotedTextChild(): AST.TextNode;
+		parseElement(): ESTreeJSX.JSXElement | ESTreeJSX.JSXFragment | AST.JSXStyleElement;
 
 		parseTemplateBody(
 			body: (AST.Statement | AST.Node | ESTreeJSX.JSXText | ESTreeJSX.JSXElement['children'])[],
@@ -1192,10 +1213,11 @@ export namespace Parse {
 			topLevel?: boolean,
 			exports?: AST.ExportSpecifier,
 		):
-			| AST.TSRXExpression
-			| AST.TextNode
-			| ESTreeJSX.JSXEmptyExpression
 			| ESTreeJSX.JSXExpressionContainer
+			| ESTreeJSX.JSXElement
+			| ESTreeJSX.JSXFragment
+			| AST.JSXStyleElement
+			| ESTreeJSX.JSXText
 			| AST.ExpressionStatement
 			| ReturnType<Parser['parseElement']>
 			| AST.Statement;
@@ -1351,11 +1373,15 @@ export namespace Parse {
 		 * Parse function body
 		 */
 		parseFunctionBody(
-			node: AST.Node,
+			node: AST.FunctionDeclaration | AST.FunctionExpression | AST.ArrowFunctionExpression,
 			isArrowFunction: boolean,
 			isMethod: boolean,
 			forInit?: ForInit,
-		): void;
+			tsConfig?: AcornTypeScriptFunctionBodyConfig,
+		): AST.Node;
+
+		/** Check function parameters for duplicate names and invalid bindings */
+		checkParams(node: AST.Node, allowDuplicates: boolean): void;
 
 		/** Initialize function node properties */
 		initFunction(node: AST.Node): void;
@@ -1627,7 +1653,7 @@ export namespace Parse {
 		 * Parse JSX attribute (name="value" or {spread})
 		 * @returns JSXAttribute or JSXSpreadAttribute
 		 */
-		jsx_parseAttribute(): AST.TSRXAttribute | ESTreeJSX.JSXAttribute | ESTreeJSX.JSXSpreadAttribute;
+		jsx_parseAttribute(): ESTreeJSX.JSXAttribute | ESTreeJSX.JSXSpreadAttribute;
 
 		/**
 		 * Parse JSX opening element at position
@@ -1670,7 +1696,7 @@ export namespace Parse {
 		 * Parse complete JSX element
 		 * @returns JSXElement or JSXFragment
 		 */
-		jsx_parseElement(): ESTreeJSX.JSXElement;
+		jsx_parseElement(): ESTreeJSX.JSXElement | AST.JSXStyleElement;
 
 		// ============================================================
 		// Try-Parse for Recovery

package/types/runtime/ref.d.ts

@@ -6,6 +6,7 @@ export type MergeableVueRef<T> = { value: T | null };
 export type RefProp<T = unknown> = (node: T | null) => void | (() => void);
 export type RefValue<T = Element> =
 	| ((node: T) => void | (() => void))
+	| readonly RefValue<T>[]
 	| { current: T | null }
 	| { value: T | null }
 	| T