ripple 0.3.11 → 0.3.13

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

@@ -34,16 +34,10 @@ import {
 	RippleSet as _$_Set__Ripple,
 	RippleArray as _$_Array__Ripple,
 	RippleObject as _$_Object__Ripple,
-	Context as _$_Context__Ripple,
 	RippleURL as _$_URL__Ripple,
 	RippleURLSearchParams as _$_URLSearchParams__Ripple,
 	RippleDate as _$_Date__Ripple,
-	MediaQuery as _$_MediaQuery__,
 	createRefKey as _$_RefKey__create,
-	track as _$_track__,
-	effect as _$_effect__,
-	untrack as _$_untrack__,
-	ripple_namespace as _$__u0023_ripple,
 } from 'ripple';
 
 export {
@@ -51,14 +45,8 @@ export {
 	_$_Set__Ripple,
 	_$_Array__Ripple,
 	_$_Object__Ripple,
-	_$_Context__Ripple,
 	_$_URL__Ripple,
 	_$_URLSearchParams__Ripple,
 	_$_Date__Ripple,
-	_$_MediaQuery__,
 	_$_RefKey__create,
-	_$_track__,
-	_$_effect__,
-	_$_untrack__,
-	_$__u0023_ripple,
 };

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

@@ -15,11 +15,9 @@ interface BaseNodeMetaData {
 	has_template?: boolean;
 	source_name?: string | '#server' | '#style';
 	is_capitalized?: boolean;
-	has_await?: boolean;
 	commentContainerId?: number;
 	parenthesized?: boolean;
 	elementLeadingComments?: AST.Comment[];
-	inside_component_top_level?: boolean;
 	returns?: AST.ReturnStatement[];
 	has_return?: boolean;
 	has_throw?: boolean;
@@ -57,6 +55,10 @@ interface FunctionLikeTS {
 
 // Ripple augmentation for ESTree function nodes
 declare module 'estree' {
+	interface Program {
+		innerComments?: Comment[] | undefined;
+	}
+
 	interface FunctionDeclaration extends FunctionLikeTS {
 		metadata: FunctionMetaData;
 	}
@@ -193,6 +195,10 @@ declare module 'estree' {
 		pending?: AST.BlockStatement | null;
 	}
 
+	interface CatchClause {
+		resetParam?: AST.Pattern | null;
+	}
+
 	interface ForOfStatement {
 		index?: AST.Identifier | null;
 		key?: AST.Expression | null;
@@ -1086,7 +1092,7 @@ export interface AnalysisResult {
 	ast: AST.Program;
 	scopes: Map<AST.Node, ScopeInterface>;
 	scope: ScopeInterface;
-	component_metadata: Array<{ id: string; async: boolean }>;
+	component_metadata: Array<{ id: string }>;
 	metadata: {
 		serverIdentifierPresent: boolean;
 	};
@@ -1255,7 +1261,6 @@ export interface ScopeInterface {
 
 interface BaseStateMetaData {
 	tracking?: boolean | null;
-	await?: boolean;
 }
 
 export interface BaseState {
@@ -1306,6 +1311,8 @@ export interface TransformServerState extends BaseState {
 	dev?: boolean;
 	return_flags?: Map<AST.ReturnStatement, { name: string; tracked: boolean }>;
 	template_child?: boolean;
+	skip_regular_blocks?: boolean;
+	in_regular_block?: boolean;
 }
 
 type UpdateList = Array<
@@ -1319,7 +1326,7 @@ type UpdateList = Array<
 		},
 		'initial' | 'identity' | 'expression'
 	>
-> & { async?: boolean };
+>;
 
 export interface TransformClientState extends BaseState {
 	events: Set<string>;

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

@@ -1112,6 +1112,8 @@ export namespace Parse {
 
 		tsParseTypeArguments(): AST.Node;
 
+		tsTryParseTypeAnnotation(): AST.TSTypeAnnotation;
+
 		/**
 		 * Get property kind from name
 		 * @param prop Property node

package/src/compiler/utils.js

@@ -163,19 +163,22 @@ const DOM_PROPERTIES = [
 	'disableRemotePlayback',
 ];
 
-/** @type {Record<string, string>} */
+// Omits track, trackSplit and trackAsync are they're handled separately
+/** @type {Record<string, {name: string, requiresBlock?: boolean}>} */
 const RIPPLE_IMPORT_CALL_NAME = {
-	RippleURL: 'ripple_url',
-	RippleURLSearchParams: 'ripple_url_search_params',
-	RippleDate: 'ripple_date',
-	RippleMap: 'ripple_map',
-	RippleSet: 'ripple_set',
-	MediaQuery: 'media_query',
-	Context: 'context',
-	effect: 'effect',
-	untrack: 'untrack',
-	RippleArray: 'ripple_array',
-	RippleObject: 'ripple_object',
+	RippleArray: { name: 'ripple_array', requiresBlock: true },
+	RippleObject: { name: 'ripple_object', requiresBlock: true },
+	RippleURL: { name: 'ripple_url', requiresBlock: true },
+	RippleURLSearchParams: { name: 'ripple_url_search_params', requiresBlock: true },
+	RippleDate: { name: 'ripple_date', requiresBlock: true },
+	RippleMap: { name: 'ripple_map', requiresBlock: true },
+	RippleSet: { name: 'ripple_set', requiresBlock: true },
+	MediaQuery: { name: 'media_query', requiresBlock: true },
+	Context: { name: 'context' },
+	effect: { name: 'effect' },
+	untrack: { name: 'untrack' },
+	trackPending: { name: 'is_tracked_pending' },
+	peek: { name: 'peek_tracked' },
 };
 
 /**
@@ -209,31 +212,6 @@ export function is_delegated_event(event_name, handler, context) {
 	return true;
 }
 
-/**
- * Returns true if context is inside a top-level await: inside component or module
- * @param {CommonContext} context
- * @returns {boolean}
- */
-export function is_top_level_await(context) {
-	for (let i = context.path.length - 1; i >= 0; i -= 1) {
-		const context_node = context.path[i];
-		const type = context_node.type;
-
-		if (context_node.type === 'Component') {
-			return true;
-		}
-
-		if (
-			type === 'FunctionExpression' ||
-			type === 'ArrowFunctionExpression' ||
-			type === 'FunctionDeclaration'
-		) {
-			return false;
-		}
-	}
-	return true;
-}
-
 /**
  * Returns true if context is inside a Component node
  * @param {CommonContext} context
@@ -292,25 +270,25 @@ export function is_component_level_function(context) {
  * Returns the matched Ripple tracking call name
  * @param {AST.Expression | AST.Super} callee
  * @param {CommonContext} context
- * @returns {'track' | null}
+ * @returns {'track' | 'trackAsync' | null}
  */
 export function is_ripple_track_call(callee, context) {
 	// Super expressions cannot be Ripple track calls
 	if (callee.type === 'Super') return null;
 
-	if (callee.type === 'Identifier' && callee.name === 'track') {
-		return is_ripple_import(callee, context) ? 'track' : null;
+	if (callee.type === 'Identifier' && (callee.name === 'track' || callee.name === 'trackAsync')) {
+		return is_ripple_import(callee, context) ? callee.name : null;
 	}
 
 	if (
 		callee.type === 'MemberExpression' &&
 		callee.object.type === 'Identifier' &&
 		callee.property.type === 'Identifier' &&
-		callee.property.name === 'track' &&
+		(callee.property.name === 'track' || callee.property.name === 'trackAsync') &&
 		!callee.computed &&
 		is_ripple_import(callee, context)
 	) {
-		return 'track';
+		return callee.property.name;
 	}
 
 	return null;
@@ -1076,7 +1054,7 @@ export function flatten_switch_consequent(consequent) {
  * @returns {string | null}
  */
 export function get_ripple_namespace_call_name(name) {
-	return name == null ? null : (RIPPLE_IMPORT_CALL_NAME[name] ?? null);
+	return name == null ? null : (RIPPLE_IMPORT_CALL_NAME[name]?.name ?? null);
 }
 
 /**
@@ -1085,7 +1063,24 @@ export function get_ripple_namespace_call_name(name) {
  * @returns {boolean}
  */
 export function ripple_import_requires_block(name) {
-	return name !== 'effect' && name !== 'untrack' && name !== 'Context';
+	return name == null ? false : (RIPPLE_IMPORT_CALL_NAME[name]?.requiresBlock ?? false);
+}
+
+/**
+ * @param {AST.ClassDeclaration | AST.ClassExpression} node
+ * @param {CommonContext} context
+ * @returns {void}
+ */
+export function strip_class_typescript_syntax(node, context) {
+	delete node.typeParameters;
+	delete node.superTypeParameters;
+	delete node.implements;
+
+	if (node.superClass?.type === 'TSInstantiationExpression') {
+		node.superClass = /** @type {AST.Expression} */ (context.visit(node.superClass.expression));
+	} else if (node.superClass && 'typeArguments' in node.superClass) {
+		delete node.superClass.typeArguments;
+	}
 }
 
 /**

package/src/helpers.d.ts

@@ -7,3 +7,5 @@ export type RequiredPresent<T, K extends keyof T> = Omit<T, K> & Required<Pick<T
 export type Nullable<T> = T | null;
 
 export type Nullish<T> = T | null | undefined;
+
+export type NestedArray<T> = (T | NestedArray<T>)[];

package/src/runtime/index-client.js

@@ -21,6 +21,12 @@ import { COMMENT_NODE, HYDRATION_START } from '../constants.js';
 
 // Re-export JSX runtime functions for jsxImportSource: "ripple"
 export { jsx, jsxs, Fragment } from '../jsx-runtime.js';
+export {
+	UNINITIALIZED,
+	DERIVED_UPDATED,
+	SUSPENSE_PENDING,
+	SUSPENSE_REJECTED,
+} from './internal/client/constants.js';
 
 /**
  * @returns {CompatOptions | undefined}
@@ -112,7 +118,15 @@ export function hydrate(component, options) {
 
 export { Context } from './internal/client/context.js';
 
-export { flush_sync as flushSync, track, untrack, tick } from './internal/client/runtime.js';
+export {
+	flush_sync as flushSync,
+	track,
+	track_async as trackAsync,
+	untrack,
+	tick,
+	is_tracked_pending as trackPending,
+	peek_tracked as peek,
+} from './internal/client/runtime.js';
 
 export { RippleArray } from './array.js';
 
@@ -159,15 +173,3 @@ export {
 	bindOffsetWidth,
 	bindOffsetHeight,
 } from './internal/client/bindings.js';
-
-import { RippleMap } from './map.js';
-import { RippleSet } from './set.js';
-import { RippleArray } from './array.js';
-import { RippleObject } from './object.js';
-import { Context } from './internal/client/context.js';
-import { RippleURL } from './url.js';
-import { RippleURLSearchParams } from './url-search-params.js';
-import { RippleDate } from './date.js';
-import { MediaQuery } from './media-query.js';
-import { track, untrack, ref_prop as createRefKey } from './internal/client/runtime.js';
-import { user_effect as effect } from './internal/client/blocks.js';

package/src/runtime/index-server.js

@@ -1,10 +1,21 @@
-import { get, set, untrack, track } from './internal/server/index.js';
+import { output_push, noop } from './internal/server/index.js';
 
 export { Context } from './internal/server/context.js';
-
-export { get, set, untrack, track };
-
-function noop() {}
+export {
+	get,
+	set,
+	untrack,
+	track,
+	track_async as trackAsync,
+	is_tracked_pending as trackPending,
+	peek_tracked as peek,
+} from './internal/server/index.js';
+export {
+	UNINITIALIZED,
+	DERIVED_UPDATED,
+	SUSPENSE_PENDING,
+	SUSPENSE_REJECTED,
+} from './internal/client/constants.js';
 
 export const effect = noop;
 export const createRefKey = noop;
@@ -61,13 +72,9 @@ export const bindOffsetHeight = noop;
  * Portal component noop for server-side rendering.
  * Portals are client-only and do not render on the server.
  * However, we need to output a marker comment so hydration can work correctly.
- * @param {any} output
- * @param {any} __
  */
-export function Portal(output, __) {
+export function Portal() {
 	// Portals are client-only, but we need to output a marker for hydration
 	// Output an empty HTML comment as a placeholder
-	if (output && typeof output.push === 'function') {
-		output.push('<!--portal-->');
-	}
+	output_push('<!--portal-->');
 }

package/src/runtime/internal/client/blocks.js

@@ -8,10 +8,12 @@ import {
 	DESTROYED,
 	EFFECT_BLOCK,
 	PAUSED,
+	PRE_EFFECT_BLOCK,
 	RENDER_BLOCK,
 	ROOT_BLOCK,
 	TRY_BLOCK,
 	HEAD_BLOCK,
+	DIRECT_CHILD_BLOCK,
 } from './constants.js';
 import { next_sibling } from './operations.js';
 import { apply_element_spread } from './render.js';
@@ -20,13 +22,11 @@ import {
 	active_component,
 	active_reaction,
 	create_component_ctx,
-	handle_error,
 	is_block_dirty,
 	run_block,
 	run_teardown,
 	schedule_update,
 } from './runtime.js';
-import { suspend } from './try.js';
 
 /**
  * @param {Function} fn
@@ -60,6 +60,14 @@ export function effect(fn) {
 	return block(EFFECT_BLOCK, fn);
 }
 
+/**
+ * Creates a pre-effect block that runs eagerly before render blocks in the flush cycle.
+ * @param {Function} fn
+ */
+export function pre_effect(fn) {
+	return block(PRE_EFFECT_BLOCK, fn);
+}
+
 /**
  * @param {Function} fn
  * @param {any} [state]
@@ -87,27 +95,6 @@ export function branch(fn, flags = 0, state = null) {
 	return block(BRANCH_BLOCK | flags, fn, state);
 }
 
-/**
- * @param {() => any} fn
- */
-export function async(fn) {
-	return block(BRANCH_BLOCK, async () => {
-		var current_block = active_block;
-		const unsuspend = suspend();
-		try {
-			await fn();
-			// An extra microtask tick ensures `suspend()` → `pending` is visible for at
-			// least one full microtask cycle.  This matters during SSR hydration: the
-			// test (or any awaiter) gets to observe the pending state before `unsuspend`
-			// swaps back to the resolved content.
-			await Promise.resolve();
-			unsuspend();
-		} catch (error) {
-			handle_error(error, /** @type {Block} */ (current_block));
-		}
-	});
-}
-
 /**
  * @param {Element} element
  * @param {() => (element: Element) => (void | (() => void))} get_fn
@@ -176,6 +163,15 @@ export function create_try_block(fn, state) {
 	return block(TRY_BLOCK, fn, state);
 }
 
+/**
+ * @param {() => void} fn
+ * @param {number} [flags]
+ * @param {any} [state]
+ */
+export function boundary_fn_running_block(fn, flags = 0, state = null) {
+	return branch(fn, DIRECT_CHILD_BLOCK | flags, state);
+}
+
 /**
  * @param {Block} block
  * @param {Block} parent_block

package/src/runtime/internal/client/constants.js

@@ -9,18 +9,21 @@ export var SWITCH_BLOCK = 1 << 8;
 export var COMPOSITE_BLOCK = 1 << 9;
 export var ASYNC_BLOCK = 1 << 10;
 export var HEAD_BLOCK = 1 << 11;
-export var CONTAINS_UPDATE = 1 << 12;
-export var CONTAINS_TEARDOWN = 1 << 13;
-export var BLOCK_HAS_RUN = 1 << 14;
-export var TRACKED = 1 << 15;
-export var DERIVED = 1 << 16;
-export var DEFERRED = 1 << 17;
-export var PAUSED = 1 << 18;
-export var DESTROYED = 1 << 19;
+export var PRE_EFFECT_BLOCK = 1 << 12;
+export var DIRECT_CHILD_BLOCK = 1 << 13;
+export var CONTAINS_UPDATE = 1 << 14;
+export var CONTAINS_TEARDOWN = 1 << 15;
+export var BLOCK_HAS_RUN = 1 << 16;
+export var TRACKED = 1 << 17;
+export var DERIVED = 1 << 18;
+export var DEFERRED = 1 << 19;
+export var PAUSED = 1 << 20;
+export var DESTROYED = 1 << 21;
 
 export var CONTROL_FLOW_BLOCK = FOR_BLOCK | IF_BLOCK | SWITCH_BLOCK | TRY_BLOCK | COMPOSITE_BLOCK;
 
-export var UNINITIALIZED = Symbol();
+/** @type {unique symbol} */
+export const UNINITIALIZED = Symbol('uninitialized');
 /** @type {unique symbol} */
 export const TRACKED_ARRAY = Symbol();
 /** @type {unique symbol} */
@@ -38,3 +41,11 @@ export const NAMESPACE_URI = {
 	svg: 'http://www.w3.org/2000/svg',
 	mathml: 'http://www.w3.org/1998/Math/MathML',
 };
+/** @type {unique symbol} */
+export const DERIVED_UPDATED = Symbol('derived_updated');
+/** @type {unique symbol} */
+export const SUSPENSE_PENDING = Symbol('suspense_pending');
+/** @type {unique symbol} */
+export const SUSPENSE_REJECTED = Symbol('suspense_rejected');
+/** @type {unique symbol} */
+export const ASYNC_DERIVED_READ_THROWN = Symbol('async_derived_read_thrown');

package/src/runtime/internal/client/index.js

@@ -20,15 +20,22 @@ export {
 export {
 	render,
 	render_spread,
-	async,
 	ref,
 	branch,
 	destroy_block,
 	move_block,
 	root,
 	user_effect as effect,
+	resume_block,
+	is_destroyed,
 } from './blocks.js';
 
+export {
+	UNINITIALIZED,
+	DERIVED_UPDATED,
+	SUSPENSE_PENDING,
+	SUSPENSE_REJECTED,
+} from './constants.js';
 export { event, render_event, delegate } from './events.js';
 
 export {
@@ -40,7 +47,6 @@ export {
 	get_tracked,
 	get_derived,
 	set,
-	async_computed,
 	tracked,
 	spread_props,
 	computed_property,
@@ -52,6 +58,9 @@ export {
 	update_property,
 	update_pre_property,
 	track,
+	track_async,
+	is_tracked_pending,
+	peek_tracked,
 	push_component,
 	pop_component,
 	untrack,
@@ -59,12 +68,13 @@ export {
 	fallback,
 	exclude_from_object,
 	derived,
-	maybe_tracked,
 	tick,
 	proxy_props,
 	with_block,
 	with_ns,
 	handle_error,
+	queue_post_block_flush_callback,
+	schedule_update,
 } from './runtime.js';
 
 export { composite } from './composite.js';
@@ -73,7 +83,7 @@ export { for_block as for, for_block_keyed as for_keyed } from './for.js';
 
 export { if_block as if } from './if.js';
 
-export { try_block as try, aborted, suspend } from './try.js';
+export { try_block as try, get_pending_boundary } from './try.js';
 
 export { switch_block as switch } from './switch.js';