ripple 0.2.182 → 0.2.184

package/src/compiler/types/index.d.ts

@@ -1,30 +1,319 @@
-import type * as ESTree from 'estree';
+import type * as AST from 'estree';
+import type * as ESTreeJSX from 'estree-jsx';
+import type { TSESTree } from '@typescript-eslint/types';
+import type { NAMESPACE_URI } from '../../runtime/internal/client/constants.js';
+import type { Parse } from '#parser';
+
+export type RpcModules = Map<string, [string, string]>;
+
+declare global {
+	var rpc_modules: RpcModules | undefined;
+}
+
+export type NameSpace = keyof typeof NAMESPACE_URI;
+interface BaseNodeMetaData {
+	scoped?: boolean;
+	path: AST.Node[];
+	has_template?: boolean;
+	original_name?: string;
+	is_capitalized?: boolean;
+	has_await?: boolean;
+	commentContainerId?: number;
+	openingTagEnd?: number;
+	openingTagEndLoc?: AST.Position;
+	parenthesized?: boolean;
+	elementLeadingComments?: AST.Comment[];
+}
+
+interface FunctionMetaData extends BaseNodeMetaData {
+	was_component?: boolean;
+	tracked?: boolean;
+}
+
+// Strip parent, loc, and range from TSESTree nodes to match @sveltejs/acorn-typescript output
+// acorn-typescript uses start/end instead of range, and loc is optional
+type AcornTSNode<T> = Omit<T, 'parent' | 'loc' | 'range' | 'expression'> & {
+	start: number;
+	end: number;
+	loc?: AST.SourceLocation;
+	range?: AST.BaseNode['range'];
+	metadata: BaseNodeMetaData;
+
+	leadingComments?: AST.Comment[] | undefined;
+	trailingComments?: AST.Comment[] | undefined;
+};
+
+interface FunctionLikeTS {
+	returnType?: AST.TSTypeAnnotation;
+	typeParameters?: AST.TSTypeParameterDeclaration;
+	typeAnnotation?: AST.TSTypeAnnotation;
+}
 
 // Ripple augmentation for ESTree function nodes
 declare module 'estree' {
-	interface FunctionDeclaration {
-		metadata?: any;
+	interface FunctionDeclaration extends FunctionLikeTS {
+		metadata: FunctionMetaData;
 	}
-	interface FunctionExpression {
-		metadata?: any;
+	interface FunctionExpression extends FunctionLikeTS {
+		metadata: FunctionMetaData;
 	}
-	interface ArrowFunctionExpression {
-		metadata?: any;
+	interface ArrowFunctionExpression extends FunctionLikeTS {
+		metadata: FunctionMetaData;
 	}
-	interface Identifier {
+
+	interface Identifier extends TrackedNode {
+		metadata: BaseNode['metadata'] & {
+			tracked_shorthand?: '#Map' | '#Set';
+		};
+	}
+
+	interface MemberExpression extends TrackedNode {}
+
+	interface TrackedNode {
 		tracked?: boolean;
 	}
-	interface Component {
+
+	// Include TypeScript node types and Ripple-specific nodes in NodeMap
+	interface NodeMap {
+		Component: Component;
+		TsxCompat: TsxCompat;
+		Html: Html;
+		Element: Element;
+		Text: TextNode;
+		ServerBlock: ServerBlock;
+		ServerIdentifier: ServerIdentifier;
+		TrackedExpression: TrackedExpression;
+		Attribute: Attribute;
+		RefAttribute: RefAttribute;
+		SpreadAttribute: SpreadAttribute;
+		ParenthesizedExpression: ParenthesizedExpression;
+	}
+
+	interface ExpressionMap {
+		TrackedArrayExpression: TrackedArrayExpression;
+		TrackedObjectExpression: TrackedObjectExpression;
+		TrackedMapExpression: TrackedMapExpression;
+		TrackedSetExpression: TrackedSetExpression;
+		TrackedExpression: TrackedExpression;
+		Text: TextNode;
+	}
+
+	// Missing estree type
+	interface ParenthesizedExpression extends BaseNode {
+		type: 'ParenthesizedExpression';
+		expression: Expression;
+	}
+
+	interface Comment {
+		context?: Parse.CommentMetaData | null;
+	}
+
+	/**
+	 * Custom Comment interface with location information
+	 */
+	type CommentWithLocation = Comment & NodeWithLocation;
+
+	interface TryStatement {
+		pending?: BlockStatement | null;
+	}
+
+	interface ForOfStatement {
+		index?: Identifier | null;
+		key?: Expression | null;
+	}
+
+	interface ServerIdentifier extends BaseNode {
+		type: 'ServerIdentifier';
+	}
+
+	interface ImportDeclaration {
+		importKind: TSESTree.ImportDeclaration['importKind'];
+	}
+	interface ImportSpecifier {
+		importKind: TSESTree.ImportSpecifier['importKind'];
+	}
+	interface ExportNamedDeclaration {
+		exportKind: TSESTree.ExportNamedDeclaration['exportKind'];
+	}
+
+	interface BaseNodeWithoutComments {
+		// Adding start, end for now as always there
+		// later might change to optional
+		// And only define on certain nodes
+		// BaseNode inherits from this interface
+		start?: number;
+		end?: number;
+	}
+
+	interface BaseNode {
+		is_controlled?: boolean;
+		// This is for Pattern but it's a type alias
+		// So it's just easy to extend BaseNode even though
+		// typeAnnotation, typeArguments do not apply to all nodes
+		typeAnnotation?: TSTypeAnnotation;
+		typeArguments?: TSTypeParameterInstantiation;
+
+		// even though technically metadata starts out as undefined
+		// metadata is always populated by the `_` visitor
+		// which runs for every node before other visitors
+		// so taking a practical approach and making it required
+		// to avoid lots of typecasting or checking for undefined
+		metadata: BaseNodeMetaData;
+
+		comments?: AST.Comment[];
+	}
+
+	interface NodeWithLocation {
+		start: number;
+		end: number;
+		loc: SourceLocation;
+	}
+
+	/**
+	 * Ripple custom interfaces and types section
+	 */
+	interface Component extends BaseNode {
 		type: 'Component';
-		id: Identifier;
+		// null is for anonymous components {component: () => {}}
+		id: Identifier | null;
 		params: Pattern[];
+		body: Node[];
+		css: CSS.StyleSheet | null;
+		metadata: BaseNodeMetaData & {
+			inherited_css?: boolean;
+		};
+		default: boolean;
+	}
+
+	interface TsxCompat extends BaseNode {
+		type: 'TsxCompat';
+		kind: string;
+		attributes: Array<any>;
+		children: ESTreeJSX.JSXElement['children'];
+		selfClosing?: boolean;
+		unclosed?: boolean;
+	}
+
+	interface Html extends BaseNode {
+		type: 'Html';
+		expression: Expression;
+	}
+
+	interface Element extends BaseNode {
+		type: 'Element';
+		id: Identifier;
+		attributes: RippleAttribute[];
+		children: Node[];
+		selfClosing?: boolean;
+		unclosed?: boolean;
+		loc: AST.SourceLocation;
+		metadata: BaseNodeMetaData & {
+			ts_name?: string;
+		};
+
+		// currently only for <style> and <script> tags
+		openingElement?: ESTreeJSX.JSXOpeningElement;
+		closingElement?: ESTreeJSX.JSXClosingElement;
+
+		// for <style> tags
+		css?: string;
+
+		// for <script> tags
+		content?: string;
+
+		innerComments?: Comment[];
+	}
+
+	export interface TextNode extends AST.BaseNode {
+		type: 'Text';
+		expression: Expression;
+		loc?: SourceLocation;
+	}
+
+	interface ServerBlock extends BaseNode {
+		type: 'ServerBlock';
 		body: BlockStatement;
+		metadata: BaseNodeMetaData & {
+			exports: string[];
+		};
 	}
 
-	interface TryStatement {
-		pending?: BlockStatement | null;
+	/**
+	 * Tracked Expressions
+	 */
+	interface TrackedArrayExpression extends Omit<ArrayExpression, 'type'> {
+		type: 'TrackedArrayExpression';
+		elements: (Expression | SpreadElement | null)[];
 	}
 
+	interface TrackedExpression extends BaseNode {
+		argument: Expression;
+		type: 'TrackedExpression';
+	}
+
+	interface TrackedObjectExpression extends Omit<ObjectExpression, 'type'> {
+		type: 'TrackedObjectExpression';
+		properties: (Property | SpreadElement)[];
+	}
+
+	interface TrackedMapExpression extends BaseNode {
+		type: 'TrackedMapExpression';
+		arguments: (Expression | SpreadElement)[];
+	}
+
+	interface TrackedSetExpression extends BaseNode {
+		type: 'TrackedSetExpression';
+		arguments: (Expression | SpreadElement)[];
+	}
+
+	/**
+	 * Ripple attribute nodes
+	 */
+	interface Attribute extends BaseNode {
+		type: 'Attribute';
+		name: Identifier;
+		value: Expression | null;
+		loc?: SourceLocation;
+		shorthand?: boolean;
+		metadata: BaseNodeMetaData & {
+			delegated?: boolean;
+		};
+	}
+
+	interface RefAttribute extends BaseNode {
+		type: 'RefAttribute';
+		argument: Expression;
+		loc?: SourceLocation;
+	}
+
+	interface SpreadAttribute extends BaseNode {
+		type: 'SpreadAttribute';
+		argument: Expression;
+		loc?: SourceLocation;
+	}
+
+	/**
+	 * Ripple's extended Declaration type that includes Component
+	 * Use this instead of AST.Declaration when you need Component support
+	 */
+	export type RippleDeclaration = AST.Declaration | AST.Component | AST.TSDeclareFunction;
+
+	/**
+	 * Ripple's extended ExportNamedDeclaration with Component support
+	 */
+	interface RippleExportNamedDeclaration extends Omit<AST.ExportNamedDeclaration, 'declaration'> {
+		declaration?: RippleDeclaration | null | undefined;
+	}
+
+	/**
+	 * Ripple's extended Program with Component support
+	 */
+	interface RippleProgram extends Omit<AST.Program, 'body'> {
+		body: (AST.Program['body'][number] | Component)[];
+	}
+
+	export type RippleAttribute = Attribute | SpreadAttribute | RefAttribute;
+
 	export namespace CSS {
 		export interface BaseNode {
 			start: number;
@@ -79,6 +368,7 @@ declare module 'estree' {
 			metadata: {
 				rule: Rule | null;
 				used: boolean;
+				is_global?: boolean;
 			};
 		}
 
@@ -199,154 +489,432 @@ declare module 'estree-jsx' {
 		shorthand: boolean;
 	}
 
-	interface JSXOpeningElement {
-		loc: ESTree.SourceLocation;
+	interface JSXEmptyExpression {
+		loc: AST.SourceLocation;
+		innerComments?: Comment[];
 	}
 
-	interface JSXClosingElement {
-		loc: ESTree.SourceLocation;
+	interface JSXOpeningFragment {
+		attributes: Array<JSXAttribute | JSXSpreadAttribute>;
 	}
-}
 
-import type { Comment, Position } from 'acorn';
-import type {
-	Program,
-	Node,
-	Identifier,
-	VariableDeclarator,
-	FunctionDeclaration,
-	FunctionExpression,
-	ArrowFunctionExpression,
-	ClassDeclaration,
-	ImportDeclaration,
-	ArrayExpression,
-	ObjectExpression,
-	Expression,
-	Property,
-	SpreadElement,
-	Pattern,
-} from 'estree';
+	interface JSXElement {
+		metadata: BaseNodeMetaData & {
+			ts_name?: string;
+		};
+	}
 
-/**
- * Parse error information
- */
-export interface ParseError {
-	message: string;
-	pos: number;
-	loc: Position;
-}
+	interface JSXExpressionContainer {
+		html?: boolean;
+	}
 
-/**
- * Result of parsing operation
- */
-export interface ParseResult {
-	ast: Program;
-	errors: ParseError[];
-}
+	interface JSXMemberExpression {
+		computed?: boolean;
+	}
 
-/**
- * Comment with location information
- */
-export interface CommentWithLocation extends Comment {
-	start: number;
-	end: number;
+	interface ExpressionMap {
+		JSXIdentifier: JSXIdentifier;
+	}
 }
 
-/**
- * Tracked array expression node
- */
-export interface TrackedArrayExpression extends Omit<ArrayExpression, 'type'> {
-	type: 'TrackedArrayExpression';
-	elements: (Expression | null)[];
-}
+declare module 'estree' {
+	// Helper map for creating our own TypeNode
+	// and to be used to extend estree's NodeMap
+	interface TSNodeMap {
+		// TypeScript nodes
+		TSAnyKeyword: TSAnyKeyword;
+		TSArrayType: TSArrayType;
+		TSAsExpression: TSAsExpression;
+		TSBigIntKeyword: TSBigIntKeyword;
+		TSBooleanKeyword: TSBooleanKeyword;
+		TSCallSignatureDeclaration: TSCallSignatureDeclaration;
+		TSConditionalType: TSConditionalType;
+		TSConstructorType: TSConstructorType;
+		TSConstructSignatureDeclaration: TSConstructSignatureDeclaration;
+		TSDeclareFunction: TSDeclareFunction;
+		TSEnumDeclaration: TSEnumDeclaration;
+		TSEnumMember: TSEnumMember;
+		TSExportAssignment: TSExportAssignment;
+		TSExternalModuleReference: TSExternalModuleReference;
+		TSFunctionType: TSFunctionType;
+		TSImportEqualsDeclaration: TSImportEqualsDeclaration;
+		TSImportType: TSImportType;
+		TSIndexedAccessType: TSIndexedAccessType;
+		TSIndexSignature: TSIndexSignature;
+		TSInferType: TSInferType;
+		TSInstantiationExpression: TSInstantiationExpression;
+		TSInterfaceBody: TSInterfaceBody;
+		TSInterfaceDeclaration: TSInterfaceDeclaration;
+		TSIntersectionType: TSIntersectionType;
+		TSIntrinsicKeyword: TSIntrinsicKeyword;
+		TSLiteralType: TSLiteralType;
+		TSMappedType: TSMappedType;
+		TSMethodSignature: TSMethodSignature;
+		TSModuleBlock: TSModuleBlock;
+		TSModuleDeclaration: TSModuleDeclaration;
+		TSNamedTupleMember: TSNamedTupleMember;
+		TSNamespaceExportDeclaration: TSNamespaceExportDeclaration;
+		TSNeverKeyword: TSNeverKeyword;
+		TSNonNullExpression: TSNonNullExpression;
+		TSNullKeyword: TSNullKeyword;
+		TSNumberKeyword: TSNumberKeyword;
+		TSObjectKeyword: TSObjectKeyword;
+		TSOptionalType: TSOptionalType;
+		TSParameterProperty: TSParameterProperty;
+		TSPropertySignature: TSPropertySignature;
+		TSQualifiedName: TSQualifiedName;
+		TSRestType: TSRestType;
+		TSSatisfiesExpression: TSSatisfiesExpression;
+		TSStringKeyword: TSStringKeyword;
+		TSSymbolKeyword: TSSymbolKeyword;
+		TSThisType: TSThisType;
+		TSTupleType: TSTupleType;
+		TSTypeAliasDeclaration: TSTypeAliasDeclaration;
+		TSTypeAnnotation: TSTypeAnnotation;
+		TSTypeAssertion: TSTypeAssertion;
+		TSTypeLiteral: TSTypeLiteral;
+		TSTypeOperator: TSTypeOperator;
+		TSTypeParameter: TSTypeParameter;
+		TSTypeParameterDeclaration: TSTypeParameterDeclaration;
+		TSTypeParameterInstantiation: TSTypeParameterInstantiation;
+		TSTypePredicate: TSTypePredicate;
+		TSTypeQuery: TSTypeQuery;
+		TSTypeReference: TSTypeReference;
+		TSUndefinedKeyword: TSUndefinedKeyword;
+		TSUnionType: TSUnionType;
+		TSUnknownKeyword: TSUnknownKeyword;
+		TSVoidKeyword: TSVoidKeyword;
+		TSParenthesizedType: TSParenthesizedType;
+		TSExpressionWithTypeArguments: TSExpressionWithTypeArguments;
+	}
 
-export interface TrackedExpression extends Omit<Expression, 'type'> {
-	argument: Expression;
-	type: 'TrackedExpression';
-}
+	// Extend NodeMap to include TypeScript nodes
+	interface NodeMap extends TSNodeMap {}
 
-/**
- * Tracked object expression node
- */
-export interface TrackedObjectExpression extends Omit<ObjectExpression, 'type'> {
-	type: 'TrackedObjectExpression';
-	properties: (Property | SpreadElement)[];
-}
+	// Create our version of TypeNode with modified types to be used in replacements
+	type TypeNode = TSNodeMap[keyof TSNodeMap];
+	type EntityName = AST.Identifier | AST.ThisExpression | TSQualifiedName;
+	type Parameter =
+		| ArrayPattern
+		| AssignmentPattern
+		| Identifier
+		| ObjectPattern
+		| RestElement
+		| TSParameterProperty;
+	type TypeElement =
+		| TSCallSignatureDeclaration
+		| TSConstructSignatureDeclaration
+		| TSIndexSignature
+		| TSMethodSignature
+		| TSPropertySignature;
+	type TSPropertySignature = TSPropertySignatureComputedName | TSPropertySignatureNonComputedName;
+	type PropertyNameComputed = Expression;
+	type PropertyNameNonComputed = Identifier | NumberLiteral | StringLiteral;
 
-/**
- * Tracked Map expression node
- */
-export interface TrackedMapExpression extends Omit<Node, 'type'> {
-	type: 'TrackedMapExpression';
-	arguments: (Expression | SpreadElement)[];
-}
+	// TypeScript AST node interfaces from @sveltejs/acorn-typescript
+	// Based on TSESTree types but adapted for acorn's output format
+	interface TSAnyKeyword extends AcornTSNode<TSESTree.TSAnyKeyword> {}
+	interface TSArrayType extends Omit<AcornTSNode<TSESTree.TSArrayType>, 'elementType'> {
+		elementType: TypeNode;
+	}
+	interface TSAsExpression extends AcornTSNode<TSESTree.TSAsExpression> {
+		// Have to override it to use our Expression for required properties like metadata
+		expression: AST.Expression;
+	}
+	interface TSBigIntKeyword extends AcornTSNode<TSESTree.TSBigIntKeyword> {}
+	interface TSBooleanKeyword extends AcornTSNode<TSESTree.TSBooleanKeyword> {}
+	interface TSCallSignatureDeclaration
+		extends Omit<
+			AcornTSNode<TSESTree.TSCallSignatureDeclaration>,
+			'typeParameters' | 'typeAnnotation'
+		> {
+		parameters: Parameter[];
+		typeParameters: TSTypeParameterDeclaration | undefined;
+		typeAnnotation: TSTypeAnnotation | undefined;
+	}
+	interface TSConditionalType
+		extends Omit<
+			AcornTSNode<TSESTree.TSConditionalType>,
+			'checkType' | 'extendsType' | 'falseType' | 'trueType'
+		> {
+		checkType: TypeNode;
+		extendsType: TypeNode;
+		falseType: TypeNode;
+		trueType: TypeNode;
+	}
+	interface TSConstructorType
+		extends Omit<AcornTSNode<TSESTree.TSConstructorType>, 'typeParameters' | 'params'> {
+		typeAnnotation: TSTypeAnnotation | undefined;
+		typeParameters: TSTypeParameterDeclaration | undefined;
+		parameters: Parameter[];
+	}
+	interface TSConstructSignatureDeclaration
+		extends Omit<
+			AcornTSNode<TSESTree.TSConstructSignatureDeclaration>,
+			'typeParameters' | 'typeAnnotation'
+		> {
+		parameters: Parameter[];
+		typeParameters: TSTypeParameterDeclaration | undefined;
+		typeAnnotation: TSTypeAnnotation | undefined;
+	}
+	interface TSDeclareFunction
+		extends Omit<
+			AcornTSNode<TSESTree.TSDeclareFunction>,
+			'id' | 'params' | 'typeParameters' | 'returnType'
+		> {
+		id: AST.Identifier;
+		params: Parameter[];
+		typeParameters: TSTypeParameterDeclaration | undefined;
+		returnType: TSTypeAnnotation | undefined;
+	}
+	interface TSEnumDeclaration
+		extends Omit<AcornTSNode<TSESTree.TSEnumDeclaration>, 'id' | 'members'> {
+		id: AST.Identifier;
+		members: TSEnumMember[];
+	}
+	interface TSEnumMember extends Omit<AcornTSNode<TSESTree.TSEnumMember>, 'id' | 'initializer'> {
+		id: AST.Identifier | StringLiteral;
+		initializer: AST.Expression | undefined;
+	}
+	interface TSExportAssignment
+		extends Omit<AcornTSNode<TSESTree.TSExportAssignment>, 'expression'> {
+		expression: AST.Expression;
+	}
+	interface TSExternalModuleReference
+		extends Omit<AcornTSNode<TSESTree.TSExternalModuleReference>, 'expression'> {
+		expression: StringLiteral;
+	}
+	interface TSFunctionType
+		extends Omit<AcornTSNode<TSESTree.TSFunctionType>, 'typeParameters' | 'params'> {
+		typeAnnotation: TSTypeAnnotation | undefined;
+		typeParameters: TSTypeParameterDeclaration | undefined;
+		parameters: Parameter[];
+	}
+	interface TSImportEqualsDeclaration extends AcornTSNode<TSESTree.TSImportEqualsDeclaration> {}
+	interface TSImportType
+		extends Omit<AcornTSNode<TSESTree.TSImportType>, 'argument' | 'qualifier' | 'typeParameters'> {
+		argument: TypeNode;
+		qualifier: EntityName | null;
+		// looks like acorn-typescript has typeParameters
+		typeParameters: TSTypeParameterDeclaration | undefined | undefined;
+	}
+	interface TSIndexedAccessType
+		extends Omit<AcornTSNode<TSESTree.TSIndexedAccessType>, 'indexType' | 'objectType'> {
+		indexType: TypeNode;
+		objectType: TypeNode;
+	}
+	interface TSIndexSignature
+		extends Omit<AcornTSNode<TSESTree.TSIndexSignature>, 'parameters' | 'typeAnnotation'> {
+		parameters: Parameter[];
+		typeAnnotation: TSTypeAnnotation | undefined;
+	}
+	interface TSInferType extends Omit<AcornTSNode<TSESTree.TSInferType>, 'typeParameter'> {
+		typeParameter: TSTypeParameter;
+	}
+	interface TSInstantiationExpression extends AcornTSNode<TSESTree.TSInstantiationExpression> {
+		expression: AST.Expression;
+	}
+	interface TSInterfaceBody extends Omit<AcornTSNode<TSESTree.TSInterfaceBody>, 'body'> {
+		body: TypeElement[];
+	}
+	interface TSInterfaceDeclaration
+		extends Omit<
+			AcornTSNode<TSESTree.TSInterfaceDeclaration>,
+			'id' | 'typeParameters' | 'body' | 'extends'
+		> {
+		id: AST.Identifier;
+		typeParameters: TSTypeParameterDeclaration | undefined;
+		body: TSInterfaceBody;
+		extends: TSExpressionWithTypeArguments[];
+	}
+	interface TSIntersectionType extends Omit<AcornTSNode<TSESTree.TSIntersectionType>, 'types'> {
+		types: TypeNode[];
+	}
+	interface TSIntrinsicKeyword extends AcornTSNode<TSESTree.TSIntrinsicKeyword> {}
+	interface TSLiteralType extends Omit<AcornTSNode<TSESTree.TSLiteralType>, 'literal'> {
+		literal: AST.Literal | AST.TemplateLiteral;
+	}
+	interface TSMappedType
+		extends Omit<AcornTSNode<TSESTree.TSMappedType>, 'typeParameter' | 'typeAnnotation'> {
+		typeAnnotation: TypeNode | undefined;
+		typeParameter: TSTypeParameter;
+	}
+	interface TSMethodSignature
+		extends Omit<
+			AcornTSNode<TSESTree.TSMethodSignature>,
+			'key' | 'typeParameters' | 'params' | 'typeAnnotation'
+		> {
+		key: PropertyNameComputed | PropertyNameNonComputed;
+		typeParameters: TSTypeParameterDeclaration | undefined;
+		parameters: Parameter[];
+		// doesn't actually exist in the spec but acorn-typescript adds it
+		typeAnnotation: TSTypeAnnotation | undefined;
+	}
+	interface TSModuleBlock extends Omit<AcornTSNode<TSESTree.TSModuleBlock>, 'body'> {
+		body: AST.Statement[];
+	}
+	interface TSModuleDeclaration
+		extends Omit<AcornTSNode<TSESTree.TSModuleDeclaration>, 'body' | 'id'> {
+		body: TSModuleBlock;
+		id: AST.Identifier;
+	}
+	interface TSNamedTupleMember
+		extends Omit<AcornTSNode<TSESTree.TSNamedTupleMember>, 'elementType' | 'label'> {
+		elementType: TypeNode;
+		label: AST.Identifier;
+	}
+	interface TSNamespaceExportDeclaration
+		extends Omit<AcornTSNode<TSESTree.TSNamespaceExportDeclaration>, 'id'> {
+		id: AST.Identifier;
+	}
+	interface TSNeverKeyword extends AcornTSNode<TSESTree.TSNeverKeyword> {}
+	interface TSNonNullExpression extends AcornTSNode<TSESTree.TSNonNullExpression> {
+		expression: AST.Expression;
+	}
+	interface TSNullKeyword extends AcornTSNode<TSESTree.TSNullKeyword> {}
+	interface TSNumberKeyword extends AcornTSNode<TSESTree.TSNumberKeyword> {}
+	interface TSObjectKeyword extends AcornTSNode<TSESTree.TSObjectKeyword> {}
+	interface TSOptionalType extends Omit<AcornTSNode<TSESTree.TSOptionalType>, 'typeAnnotation'> {
+		typeAnnotation: TypeNode;
+	}
+	interface TSParameterProperty extends AcornTSNode<TSESTree.TSParameterProperty> {}
+	interface TSPropertySignatureComputedName
+		extends Omit<AcornTSNode<TSESTree.TSPropertySignatureComputedName>, 'key' | 'typeAnnotation'> {
+		key: PropertyNameComputed;
+		typeAnnotation: TSTypeAnnotation | undefined;
+	}
+	interface TSPropertySignatureNonComputedName
+		extends Omit<
+			AcornTSNode<TSESTree.TSPropertySignatureNonComputedName>,
+			'key' | 'typeAnnotation'
+		> {
+		key: PropertyNameNonComputed;
+		typeAnnotation: TSTypeAnnotation | undefined;
+	}
+	interface TSQualifiedName extends Omit<AcornTSNode<TSESTree.TSQualifiedName>, 'left' | 'right'> {
+		left: EntityName;
+		right: AST.Identifier;
+	}
+	interface TSRestType extends Omit<AcornTSNode<TSESTree.TSRestType>, 'typeAnnotation'> {
+		typeAnnotation: TypeNode;
+	}
+	interface TSSatisfiesExpression extends AcornTSNode<TSESTree.TSSatisfiesExpression> {
+		expression: AST.Expression;
+	}
+	interface TSStringKeyword extends AcornTSNode<TSESTree.TSStringKeyword> {}
+	interface TSSymbolKeyword extends AcornTSNode<TSESTree.TSSymbolKeyword> {}
+	interface TSThisType extends AcornTSNode<TSESTree.TSThisType> {}
+	interface TSTupleType extends Omit<AcornTSNode<TSESTree.TSTupleType>, 'elementTypes'> {
+		elementTypes: TypeNode[];
+	}
+	interface TSTypeAliasDeclaration
+		extends Omit<
+			AcornTSNode<TSESTree.TSTypeAliasDeclaration>,
+			'id' | 'typeParameters' | 'typeAnnotation'
+		> {
+		id: AST.Identifier;
+		typeAnnotation: TypeNode;
+		typeParameters: TSTypeParameterDeclaration | undefined;
+	}
+	interface TSTypeAnnotation
+		extends Omit<AcornTSNode<TSESTree.TSTypeAnnotation>, 'typeAnnotation'> {
+		typeAnnotation: TypeNode;
+	}
+	interface TSTypeAssertion extends AcornTSNode<TSESTree.TSTypeAssertion> {
+		expression: AST.Expression;
+	}
+	interface TSTypeLiteral extends Omit<AcornTSNode<TSESTree.TSTypeLiteral>, 'members'> {
+		members: TypeElement[];
+	}
+	interface TSTypeOperator extends Omit<AcornTSNode<TSESTree.TSTypeOperator>, 'typeAnnotation'> {
+		typeAnnotation: TypeNode | undefined;
+	}
+	interface TSTypeParameter
+		extends Omit<AcornTSNode<TSESTree.TSTypeParameter>, 'name' | 'constraint' | 'default'> {
+		constraint: TypeNode | undefined;
+		default: TypeNode | undefined;
+		name: AST.Identifier;
+	}
+	interface TSTypeParameterDeclaration
+		extends Omit<AcornTSNode<TSESTree.TSTypeParameterDeclaration>, 'params'> {
+		params: TypeNode[];
+	}
+	interface TSTypeParameterInstantiation
+		extends Omit<AcornTSNode<TSESTree.TSTypeParameterInstantiation>, 'params'> {
+		params: TypeNode[];
+	}
+	interface TSTypePredicate extends AcornTSNode<TSESTree.TSTypePredicate> {}
+	interface TSTypeQuery
+		extends Omit<AcornTSNode<TSESTree.TSTypeQuery>, 'exprName' | 'typeArguments'> {
+		exprName: EntityName | TSImportType;
+		typeArguments: TSTypeParameterInstantiation | undefined;
+	}
+	interface TSTypeReference
+		extends Omit<AcornTSNode<TSESTree.TSTypeReference>, 'typeName' | 'typeArguments'> {
+		typeArguments: TSTypeParameterInstantiation | undefined;
+		typeName: EntityName;
+	}
+	interface TSUndefinedKeyword extends AcornTSNode<TSESTree.TSUndefinedKeyword> {}
+	interface TSUnionType extends Omit<AcornTSNode<TSESTree.TSUnionType>, 'types'> {
+		types: TypeNode[];
+	}
+	// TSInterfaceHeritage doesn't exist in acorn-typescript which uses TSExpressionWithTypeArguments
+	interface TSInterfaceHeritage
+		extends Omit<AcornTSNode<TSESTree.TSInterfaceHeritage>, 'expression' | 'typeParameters'> {
+		expression: AST.Expression;
+		// acorn-typescript uses typeParameters instead of typeArguments
+		typeParameters: TSTypeParameterInstantiation | undefined;
+	}
+	// Extends TSInterfaceHeritage as it's the semantically the same as used by acorn-typescript
+	interface TSExpressionWithTypeArguments extends Omit<TSInterfaceHeritage, 'type'> {
+		type: 'TSExpressionWithTypeArguments';
+	}
 
-/**
- * Tracked Set expression node
- */
-export interface TrackedSetExpression extends Omit<Node, 'type'> {
-	type: 'TrackedSetExpression';
-	arguments: (Expression | SpreadElement)[];
-}
+	interface TSUnknownKeyword extends AcornTSNode<TSESTree.TSUnknownKeyword> {}
+	interface TSVoidKeyword extends AcornTSNode<TSESTree.TSVoidKeyword> {}
+	interface NumberLiteral extends AcornTSNode<TSESTree.NumberLiteral> {}
+	interface StringLiteral extends AcornTSNode<TSESTree.StringLiteral> {}
 
-/**
- * Ripple component node
- */
-export interface Component extends Omit<Node, 'type'> {
-	type: 'Component';
-	id: Identifier;
-	params: Pattern[];
-	body: Node[];
-	css: any;
-	start?: number;
-	end?: number;
-	loc?: any;
-}
+	// acorn-typescript specific nodes (not in @typescript-eslint/types)
+	interface TSParenthesizedType extends AST.BaseNode {
+		type: 'TSParenthesizedType';
+	}
 
-/**
- * Ripple element node
- */
-export interface Element extends Omit<Node, 'type'> {
-	type: 'Element';
-	id: Identifier;
-	attributes: Array<Attribute | SpreadAttribute>;
-	children: Node[];
-	metadata: any;
+	// Extend ExpressionMap for TypeScript expressions
+	interface ExpressionMap {
+		TSAsExpression: TSAsExpression;
+		TSInstantiationExpression: TSInstantiationExpression;
+		TSNonNullExpression: TSNonNullExpression;
+		TSSatisfiesExpression: TSSatisfiesExpression;
+		TSTypeAssertion: TSTypeAssertion;
+	}
 }
 
+import type { Comment, Position } from 'acorn';
+import type { A, M } from 'vitest/dist/chunks/environment.d.cL3nLXbE.js';
+
 /**
- * TSX compatibility node for elements with namespaces like <tsx:react>
- * Note: TsxCompat elements cannot be self-closing and must have a closing tag
+ * Parse error information
  */
-export interface TsxCompat extends Omit<Node, 'type'> {
-	type: 'TsxCompat';
-	kind: string;
-	attributes: Array<Attribute | SpreadAttribute>;
-	children: Node[];
-	metadata: any;
+export interface ParseError {
+	message: string;
+	pos: number;
+	loc: Position;
 }
 
 /**
- * Ripple attribute node
+ * Result of parsing operation
  */
-export interface Attribute {
-	type: 'Attribute';
-	name: Identifier;
-	value: Expression | null;
-	start?: number;
-	end?: number;
-	loc?: any;
+export interface ParseResult {
+	ast: AST.Program;
+	errors: ParseError[];
 }
 
-/**
- * Ripple spread attribute node
- */
-export interface SpreadAttribute {
-	type: 'SpreadAttribute';
-	argument: Expression;
-	start?: number;
-	end?: number;
-	loc?: any;
+export interface AnalysisResult {
+	ast: AST.Program;
+	scopes: Map<AST.Node, ScopeInterface>;
+	scope: ScopeInterface;
+	component_metadata: Array<{ id: string; async: boolean }>;
 }
 
 /**
@@ -374,18 +942,29 @@ export type DeclarationKind =
 /**
  * Binding kinds
  */
-export type BindingKind = 'normal' | 'for_pattern' | 'rest_prop' | 'prop' | 'prop_fallback';
+export type BindingKind =
+	| 'normal'
+	| 'for_pattern'
+	| 'rest_prop'
+	| 'prop'
+	| 'prop_fallback'
+	| 'index';
 
 /**
  * A variable binding in a scope
  */
 export interface Binding {
 	/** The identifier node that declares this binding */
-	node: Identifier;
+	node: AST.Identifier;
 	/** References to this binding */
-	references: Array<{ node: Identifier; path: Node[] }>;
+	references: Array<{ node: AST.Identifier; path: AST.Node[] }>;
 	/** Initial value/declaration */
-	initial: null | Expression | FunctionDeclaration | ClassDeclaration | ImportDeclaration;
+	initial:
+		| null
+		| AST.Expression
+		| AST.FunctionDeclaration
+		| AST.ClassDeclaration
+		| AST.ImportDeclaration;
 	/** Whether this binding has been reassigned */
 	reassigned: boolean;
 	/** Whether this binding has been mutated (property access) */
@@ -395,13 +974,23 @@ export interface Binding {
 	/** Whether this binding represents a called function */
 	is_called: boolean;
 	/** Additional metadata for this binding */
-	metadata?: any;
+	metadata: {
+		is_dynamic_component?: boolean;
+		pattern?: AST.Identifier;
+		is_tracked_object?: boolean;
+	} | null;
 	/** Kind of binding */
 	kind: BindingKind;
 	/** Declaration kind */
 	declaration_kind?: DeclarationKind;
 	/** The scope that contains this binding */
-	scope?: any;
+	scope: ScopeInterface;
+	/** Transform functions for reading, assigning, and updating this binding */
+	transform?: {
+		read: (node?: AST.Identifier) => AST.Expression;
+		assign?: (node: AST.Pattern, value: AST.Expression) => AST.AssignmentExpression;
+		update?: (node: AST.UpdateExpression) => AST.UpdateExpression;
+	};
 }
 
 /**
@@ -411,7 +1000,7 @@ export interface ScopeRoot {
 	/** Set of conflicting/reserved names */
 	conflicts: Set<string>;
 	/** Generate unique identifier name */
-	unique(preferred_name: string): Identifier;
+	unique(preferred_name: string): AST.Identifier;
 }
 
 /**
@@ -425,98 +1014,146 @@ export interface ScopeInterface {
 	/** Map of declared bindings */
 	declarations: Map<string, Binding>;
 	/** Map of declarators to their bindings */
-	declarators: Map<VariableDeclarator, Binding[]>;
+	declarators: Map<AST.VariableDeclarator, Binding[]>;
 	/** Map of references in this scope */
-	references: Map<string, Array<{ node: Identifier; path: Node[] }>>;
+	references: Map<string, Array<{ node: AST.Identifier; path: AST.Node[] }>>;
 	/** Function nesting depth */
 	function_depth: number;
 	/** Whether reactive tracing is enabled */
-	tracing: null | Expression;
+	tracing: null | AST.Expression;
+	server_block?: boolean;
 
 	/** Create child scope */
 	child(porous?: boolean): ScopeInterface;
 	/** Declare a binding */
 	declare(
-		node: Identifier,
+		node: AST.Identifier,
 		kind: BindingKind,
 		declaration_kind: DeclarationKind,
-		initial?: null | Expression | FunctionDeclaration | ClassDeclaration | ImportDeclaration,
+		initial?:
+			| null
+			| AST.Expression
+			| AST.FunctionDeclaration
+			| AST.ClassDeclaration
+			| AST.ImportDeclaration,
 	): Binding;
 	/** Get binding by name */
 	get(name: string): Binding | null;
 	/** Get bindings for a declarator */
-	get_bindings(node: VariableDeclarator): Binding[];
+	get_bindings(node: AST.VariableDeclarator): Binding[];
 	/** Find the scope that owns a name */
 	owner(name: string): ScopeInterface | null;
 	/** Add a reference */
-	reference(node: Identifier, path: Node[]): void;
+	reference(node: AST.Identifier, path: AST.Node[]): void;
 	/** Generate unique identifier name */
 	generate(preferred_name: string): string;
 }
 
 /**
- * Text node interface
+ * Compiler state object
  */
-export interface TextNode {
-	type: 'Text';
-	expression: Expression;
-	start?: number;
-	end?: number;
-	loc?: any;
-}
 
-/**
- * Union type for all Ripple AST nodes
- */
-export type RippleNode = Node | Component | Element | TextNode;
+interface BaseStateMetaData {
+	tracking?: boolean | null;
+	await?: boolean;
+}
 
-/**
- * Compiler state object
- */
-export interface CompilerState {
-	/** Current scope */
+export interface BaseState {
+	/** For utils */
 	scope: ScopeInterface;
-	/** Analysis data */
-	analysis?: {
-		/** Module analysis */
-		module?: {
-			/** Module scope */
-			scope?: {
-				/** Module references */
-				references?: Set<string>;
-			};
-		};
-		/** Exported identifiers */
-		exports?: Array<{ name: string }>;
-	};
-	/** Scopes map */
-	scopes?: Map<RippleNode, ScopeInterface>;
-	/** Whether inside head element */
+	scopes: Map<AST.Node | AST.Node[], ScopeInterface>;
 	inside_head?: boolean;
-	/** Transform metadata */
-	metadata?: {
-		spread?: boolean;
-		[key: string]: any;
+
+	/** Common For All */
+	to_ts: boolean;
+	component?: AST.Component;
+}
+
+export interface AnalysisState extends BaseState {
+	analysis: AnalysisResult & {
+		module: {
+			ast: AnalysisResult['ast'];
+			scope: AnalysisResult['scope'];
+			scopes: AnalysisResult['scopes'];
+			filename: string;
+		};
 	};
+	elements?: AST.Element[];
+	function_depth?: number;
+	inside_server_block?: boolean;
+	loose?: boolean;
+	metadata: BaseStateMetaData;
+}
+
+export interface TransformServerState extends BaseState {
+	imports: Set<string>;
+	init: Array<AST.Statement> | null;
+	stylesheets: AST.CSS.StyleSheet[];
+	component_metadata: AnalysisResult['component_metadata'];
+	inside_server_block: boolean;
+	filename: string;
+	metadata: BaseStateMetaData;
+	namespace: NameSpace;
+}
+
+type UpdateList = Array<{
+	identity?: AST.Identifier | AST.Expression;
+	initial?: AST.Expression;
+	operation: (expr?: AST.Expression, prev?: AST.Expression) => AST.ExpressionStatement;
+	expression?: AST.Expression;
+	needsPrevTracking?: boolean;
+}> & { async?: boolean };
+
+export interface TransformClientState extends BaseState {
+	events: Set<string>;
+	filename: string;
+	final: Array<AST.Statement> | null;
+	flush_node: ((is_controlled?: boolean) => AST.Identifier) | null;
+	hoisted: Array<AST.Statement>;
+	imports: Set<string>;
+	init: Array<AST.Statement> | null;
+	metadata: BaseStateMetaData;
+	namespace: NameSpace;
+	ripple_user_imports: Map<string, string>;
+	setup: Array<AST.Statement> | null;
+	stylesheets: Array<AST.CSS.StyleSheet>;
+	template: Array<string | AST.Expression> | null;
+	update: UpdateList | null;
+}
+
+/** Override zimmerframe types and provide our own */
+type NodeOf<T extends string, X> = X extends { type: T } ? X : never;
+
+type SpecializedVisitors<T extends AST.Node | AST.CSS.Node, U> = {
+	[K in T['type']]?: Visitor<NodeOf<K, T>, U, T>;
+};
+
+export type Visitor<T, U, V> = (node: T, context: Context<V, U>) => V | void;
+
+export type Visitors<T extends AST.Node | AST.CSS.Node, U> = T['type'] extends '_'
+	? never
+	: SpecializedVisitors<T, U> & { _?: Visitor<T, U, T> };
+
+export interface Context<T, U> {
+	next: (state?: U) => T | void;
+	path: T[];
+	state: U;
+	stop: () => void;
+	visit: (node: T, state?: U) => T;
 }
 
 /**
  * Transform context object
  */
-export interface TransformContext {
-	/** Compiler state */
-	state: CompilerState;
-	/** AST path */
-	path: RippleNode[];
-	/** Visit function */
-	visit: (node: any, state?: any) => any;
-	/** Transform metadata */
-	metadata?: any;
-}
+export type TransformClientContext = Context<AST.Node, TransformClientState>;
+export type TransformServerContext = Context<AST.Node, TransformServerState>;
+export type AnalysisContext = Context<AST.Node, AnalysisState>;
+export type CommonContext = TransformClientContext | TransformServerContext | AnalysisContext;
+export type VisitorClientContext = TransformClientContext & { root?: boolean };
 
 /**
  * Delegated event result
  */
 export interface DelegatedEventResult {
-	function?: FunctionExpression | FunctionDeclaration | ArrowFunctionExpression;
+	function?: AST.FunctionExpression | AST.FunctionDeclaration | AST.ArrowFunctionExpression;
 }