ripple 0.2.189 → 0.2.191

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

@@ -16,7 +16,7 @@ interface BaseNodeMetaData {
 	scoped?: boolean;
 	path: AST.Node[];
 	has_template?: boolean;
-	original_name?: string;
+	source_name?: string | '#Map' | '#Set' | '#server' | '#style';
 	is_capitalized?: boolean;
 	has_await?: boolean;
 	commentContainerId?: number;
@@ -78,11 +78,7 @@ declare module 'estree' {
 		implements?: AST.TSClassImplements[];
 	}
 
-	interface Identifier extends TrackedNode {
-		metadata: BaseNode['metadata'] & {
-			tracked_shorthand?: '#Map' | '#Set';
-		};
-	}
+	interface Identifier extends TrackedNode {}
 
 	interface MemberExpression extends AST.TrackedNode {}
 
@@ -98,7 +94,9 @@ declare module 'estree' {
 		Element: Element;
 		Text: TextNode;
 		ServerBlock: ServerBlock;
+		ServerBlockStatement: ServerBlockStatement;
 		ServerIdentifier: ServerIdentifier;
+		StyleIdentifier: StyleIdentifier;
 		TrackedExpression: TrackedExpression;
 		Attribute: Attribute;
 		RefAttribute: RefAttribute;
@@ -112,6 +110,8 @@ declare module 'estree' {
 		TrackedMapExpression: TrackedMapExpression;
 		TrackedSetExpression: TrackedSetExpression;
 		TrackedExpression: TrackedExpression;
+		StyleIdentifier: StyleIdentifier;
+		ServerIdentifier: ServerIdentifier;
 		Text: TextNode;
 	}
 
@@ -143,15 +143,17 @@ declare module 'estree' {
 		type: 'ServerIdentifier';
 	}
 
+	interface StyleIdentifier extends AST.BaseNode {
+		type: 'StyleIdentifier';
+	}
+
 	interface ImportDeclaration {
 		importKind: TSESTree.ImportDeclaration['importKind'];
 	}
 	interface ImportSpecifier {
 		importKind: TSESTree.ImportSpecifier['importKind'];
 	}
-	interface ExportNamedDeclaration
-		// doesn't seem we're using parent and assertions, removing to avoid builders errors
-		extends Omit<TSESTree.ExportNamedDeclaration, 'exportKind' | 'parent' | 'assertions'> {
+	interface ExportNamedDeclaration {
 		exportKind: TSESTree.ExportNamedDeclaration['exportKind'];
 	}
 
@@ -200,6 +202,9 @@ declare module 'estree' {
 		css: CSS.StyleSheet | null;
 		metadata: BaseNodeMetaData & {
 			inherited_css?: boolean;
+			topScopedClasses?: TopScopedClasses;
+			styleClasses?: StyleClasses;
+			styleIdentifierPresent?: boolean;
 		};
 		default: boolean;
 	}
@@ -240,14 +245,6 @@ declare module 'estree' {
 						selector: CSS.ClassSelector;
 					}
 				>;
-				topScopedClasses: Map<
-					string,
-					{
-						start: number;
-						end: number;
-						selector: CSS.ClassSelector;
-					}
-				>;
 				hash: string;
 			};
 		};
@@ -271,9 +268,13 @@ declare module 'estree' {
 		loc?: AST.SourceLocation;
 	}
 
+	interface ServerBlockStatement extends Omit<BlockStatement, 'body'> {
+		body: (AST.Statement | AST.ExportNamedDeclaration)[];
+	}
+
 	interface ServerBlock extends AST.BaseNode {
 		type: 'ServerBlock';
-		body: BlockStatement;
+		body: ServerBlockStatement;
 		metadata: BaseNodeMetaData & {
 			exports: string[];
 		};
@@ -530,6 +531,10 @@ declare module 'estree-jsx' {
 		shorthand: boolean;
 	}
 
+	interface JSXIdentifier {
+		tracked?: boolean;
+	}
+
 	interface JSXEmptyExpression {
 		loc: AST.SourceLocation;
 		innerComments?: AST.Comment[];
@@ -964,6 +969,9 @@ export interface AnalysisResult {
 	scopes: Map<AST.Node, ScopeInterface>;
 	scope: ScopeInterface;
 	component_metadata: Array<{ id: string; async: boolean }>;
+	metadata: {
+		serverIdentifierPresent: boolean;
+	};
 }
 
 /**
@@ -1111,6 +1119,8 @@ export interface BaseState {
 	/** For utils */
 	scope: ScopeInterface;
 	scopes: Map<AST.Node | AST.Node[], ScopeInterface>;
+	serverIdentifierPresent: boolean;
+	inside_server_block: boolean;
 	inside_head?: boolean;
 
 	/** Common For All */
@@ -1129,20 +1139,21 @@ export interface AnalysisState extends BaseState {
 	};
 	elements?: AST.Element[];
 	function_depth?: number;
-	inside_server_block?: boolean;
 	loose?: boolean;
-	metadata: BaseStateMetaData;
+	metadata: BaseStateMetaData & {
+		styleClasses?: StyleClasses;
+	};
 }
 
 export interface TransformServerState extends BaseState {
-	imports: Set<string>;
+	imports: Set<string | AST.ImportDeclaration>;
 	init: Array<AST.Statement> | null;
 	stylesheets: AST.CSS.StyleSheet[];
 	component_metadata: AnalysisResult['component_metadata'];
-	inside_server_block: boolean;
 	filename: string;
 	metadata: BaseStateMetaData;
 	namespace: NameSpace;
+	server_block_locals: AST.VariableDeclaration[];
 }
 
 type UpdateList = Array<{
@@ -1159,7 +1170,8 @@ export interface TransformClientState extends BaseState {
 	final: Array<AST.Statement> | null;
 	flush_node: ((is_controlled?: boolean) => AST.Identifier) | null;
 	hoisted: Array<AST.Statement>;
-	imports: Set<string>;
+	imports: Set<string | AST.ImportDeclaration>;
+	server_block_locals: AST.VariableDeclaration[];
 	init: Array<AST.Statement> | null;
 	metadata: BaseStateMetaData;
 	namespace: NameSpace;
@@ -1206,3 +1218,14 @@ export type VisitorClientContext = TransformClientContext & { root?: boolean };
 export interface DelegatedEventResult {
 	function?: AST.FunctionExpression | AST.FunctionDeclaration | AST.ArrowFunctionExpression;
 }
+
+export type TopScopedClasses = Map<
+	string,
+	{
+		start: number;
+		end: number;
+		selector: AST.CSS.ClassSelector;
+	}
+>;
+
+export type StyleClasses = Map<string, AST.MemberExpression['property']>;

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

@@ -499,6 +499,10 @@ export namespace Parse {
 		potentialArrowAt: number;
 		/** Potential arrow in for-await position */
 		potentialArrowInForAwait: boolean;
+		/** Previous token type */
+		preToken: TokenType | null;
+		/** Previous token value */
+		preValue: string | number | RegExp | bigint | null;
 		/** Private name stack for class private fields validation */
 		privateNameStack: Array<{ declared: Record<string, string>; used: Array<AST.Node> }>;
 		/** Undefined exports for module validation */
@@ -920,6 +924,7 @@ export namespace Parse {
 			forNew?: boolean,
 		):
 			| AST.ServerIdentifier
+			| AST.StyleIdentifier
 			| AST.TrackedExpression
 			| AST.TrackedMapExpression
 			| AST.TrackedSetExpression

package/src/compiler/utils.js

@@ -227,7 +227,7 @@ export function is_top_level_await(context) {
  * Returns true if context is inside a Component node
  * @param {CommonContext} context
  * @param {boolean} [includes_functions=false]
- * @returns {boolean}
+ * @returns {AST.Component | undefined}
  */
 export function is_inside_component(context, includes_functions = false) {
 	for (let i = context.path.length - 1; i >= 0; i -= 1) {
@@ -240,13 +240,13 @@ export function is_inside_component(context, includes_functions = false) {
 				type === 'ArrowFunctionExpression' ||
 				type === 'FunctionDeclaration')
 		) {
-			return false;
+			return;
 		}
 		if (context_node.type === 'Component') {
-			return true;
+			return context_node;
 		}
 	}
-	return false;
+	return;
 }
 
 /**

package/src/utils/builders.js

@@ -396,16 +396,17 @@ export function object_pattern(properties) {
  * @param {AST.Expression } key
  * @param {Value} value
  * @param {boolean} computed
+ * @param {boolean} shorthand
  * @returns {AST.Property}
  */
-export function prop(kind, key, value, computed = false) {
+export function prop(kind, key, value, computed = false, shorthand = false) {
 	return {
 		type: 'Property',
 		kind,
 		key,
 		value,
 		method: false,
-		shorthand: false,
+		shorthand,
 		computed,
 		metadata: { path: [] },
 	};

package/tests/client/compiler/compiler.basic.test.ripple

@@ -1,5 +1,5 @@
 import { parse, compile, compile_to_volar_mappings } from 'ripple/compiler';
-import { obfuscate_imported } from 'ripple/compiler/internal/import/utils';
+import { obfuscate_identifier } from 'ripple/compiler/internal/identifier/utils';
 import type * as AST from 'estree';
 
 function count_occurrences(string: string, subString: string): number {
@@ -285,15 +285,15 @@ component App() {
 `;
 			const result = compile_to_volar_mappings(source, 'test.ripple').code;
 
-			expect(count_occurrences(result, obfuscate_imported('TrackedArray'))).toBe(2);
+			expect(count_occurrences(result, obfuscate_identifier('TrackedArray'))).toBe(2);
 			expect(count_occurrences(result, 'TA')).toBe(1);
-			expect(count_occurrences(result, obfuscate_imported('TrackedObject'))).toBe(2);
+			expect(count_occurrences(result, obfuscate_identifier('TrackedObject'))).toBe(2);
 			expect(count_occurrences(result, 'TO')).toBe(1);
-			expect(count_occurrences(result, obfuscate_imported('TrackedSet'))).toBe(2);
+			expect(count_occurrences(result, obfuscate_identifier('TrackedSet'))).toBe(2);
 			expect(count_occurrences(result, 'TS')).toBe(1);
-			expect(count_occurrences(result, obfuscate_imported('TrackedMap'))).toBe(2);
+			expect(count_occurrences(result, obfuscate_identifier('TrackedMap'))).toBe(2);
 			expect(count_occurrences(result, 'TM')).toBe(1);
-			expect(count_occurrences(result, obfuscate_imported('createRefKey'))).toBe(2);
+			expect(count_occurrences(result, obfuscate_identifier('createRefKey'))).toBe(2);
 			expect(count_occurrences(result, 'crk')).toBe(1);
 		},
 	);
@@ -311,11 +311,11 @@ component App() {
 `;
 		const result = compile_to_volar_mappings(source, 'test.ripple').code;
 
-		expect(count_occurrences(result, obfuscate_imported('TrackedArray'))).toBe(2);
-		expect(count_occurrences(result, obfuscate_imported('TrackedObject'))).toBe(2);
-		expect(count_occurrences(result, obfuscate_imported('TrackedSet'))).toBe(2);
-		expect(count_occurrences(result, obfuscate_imported('TrackedMap'))).toBe(2);
-		expect(count_occurrences(result, obfuscate_imported('createRefKey'))).toBe(2);
+		expect(count_occurrences(result, obfuscate_identifier('TrackedArray'))).toBe(2);
+		expect(count_occurrences(result, obfuscate_identifier('TrackedObject'))).toBe(2);
+		expect(count_occurrences(result, obfuscate_identifier('TrackedSet'))).toBe(2);
+		expect(count_occurrences(result, obfuscate_identifier('TrackedMap'))).toBe(2);
+		expect(count_occurrences(result, obfuscate_identifier('createRefKey'))).toBe(2);
 	});
 
 	it('should not error on having js below markup in the same scope', () => {

package/types/index.d.ts

@@ -209,10 +209,10 @@ export type TrackedObjectDeep<T> = T extends
 								? { [K in keyof T]: TrackedObjectDeep<T[K]> | Tracked<TrackedObjectDeep<T[K]>> }
 								: T | Tracked<T>;
 
-export type TrackedObject<T extends object> = T & {};
+export interface TrackedObject<T extends Object> extends Object {}
 
 export interface TrackedObjectConstructor {
-	new <T extends object>(obj: T): TrackedObject<T>;
+	new <T extends Object>(obj: T): TrackedObject<T>;
 }
 
 export const TrackedObject: TrackedObjectConstructor;

package/src/compiler/import-utils.js

@@ -1,51 +0,0 @@
-export const IMPORT_OBFUSCATION_PREFIX = '_$_';
-
-/**
- * @param {string} name
- * @returns {string}
- */
-export function obfuscate_imported(name) {
-	let start = 0;
-	if (name[0] === name[0].toUpperCase()) {
-		start = 1;
-	}
-	const index = find_next_uppercase(name, start);
-
-	const first_part = name.slice(0, index);
-	const second_part = name.slice(index);
-
-	return IMPORT_OBFUSCATION_PREFIX + (second_part ? second_part + '__' + first_part : first_part);
-}
-
-/**
- * @param {string} name
- * @returns {boolean}
- */
-export function is_imported_obfuscated(name) {
-	return name.startsWith(IMPORT_OBFUSCATION_PREFIX);
-}
-
-/**
- * @param {string} name
- * @returns {string}
- */
-export function deobfuscate_imported(name) {
-	name = name.replace(IMPORT_OBFUSCATION_PREFIX, '');
-	const parts = name.split('__');
-	return (parts[1] ? parts[1] : '') + parts[0];
-}
-
-/**
- * Finds the next uppercase character or returns name.length
- * @param {string} name
- * @param {number} start
- * @returns {number}
- */
-function find_next_uppercase(name, start) {
-	for (let i = start; i < name.length; i++) {
-		if (name[i] === name[i].toUpperCase()) {
-			return i;
-		}
-	}
-	return name.length;
-}