svelte 5.43.8 → 5.43.9

package/src/compiler/phases/3-transform/client/visitors/SvelteBoundary.js

@@ -48,7 +48,11 @@ export function SvelteBoundary(node, context) {
 		if (child.type === 'ConstTag') {
 			has_const = true;
 			if (!context.state.options.experimental.async) {
-				context.visit(child, { ...context.state, consts: const_tags });
+				context.visit(child, {
+					...context.state,
+					consts: const_tags,
+					scope: context.state.scopes.get(node.fragment) ?? context.state.scope
+				});
 			}
 		}
 	}
@@ -101,7 +105,13 @@ export function SvelteBoundary(node, context) {
 		nodes.push(child);
 	}
 
-	const block = /** @type {BlockStatement} */ (context.visit({ ...node.fragment, nodes }));
+	const block = /** @type {BlockStatement} */ (
+		context.visit(
+			{ ...node.fragment, nodes },
+			// Since we're creating a new fragment the reference in scopes can't match, so we gotta attach the right scope manually
+			{ ...context.state, scope: context.state.scopes.get(node.fragment) ?? context.state.scope }
+		)
+	);
 
 	if (!context.state.options.experimental.async) {
 		block.body.unshift(...const_tags);

package/src/compiler/phases/3-transform/client/visitors/shared/fragment.js

@@ -105,7 +105,7 @@ export function process_children(nodes, initial, is_element, context) {
 				is_element &&
 				// In case it's wrapped in async the async logic will want to skip sibling nodes up until the end, hence we cannot make this controlled
 				// TODO switch this around and instead optimize for elements with a single block child and not require extra comments (neither for async nor normally)
-				!(node.body.metadata.has_await || node.metadata.expression.is_async())
+				!node.metadata.expression.is_async()
 			) {
 				node.metadata.is_controlled = true;
 			} else {

package/src/compiler/phases/3-transform/server/visitors/ConstTag.js

@@ -2,6 +2,7 @@
 /** @import { AST } from '#compiler' */
 /** @import { ComponentContext } from '../types.js' */
 import * as b from '#compiler/builders';
+import { extract_identifiers } from '../../../../utils/ast.js';
 
 /**
  * @param {AST.ConstTag} node
@@ -11,6 +12,29 @@ export function ConstTag(node, context) {
 	const declaration = node.declaration.declarations[0];
 	const id = /** @type {Pattern} */ (context.visit(declaration.id));
 	const init = /** @type {Expression} */ (context.visit(declaration.init));
+	const has_await = node.metadata.expression.has_await;
 
-	context.state.init.push(b.const(id, init));
+	if (has_await || context.state.async_consts) {
+		const run = (context.state.async_consts ??= {
+			id: b.id(context.state.scope.generate('promises')),
+			thunks: []
+		});
+
+		const identifiers = extract_identifiers(declaration.id);
+		const bindings = context.state.scope.get_bindings(declaration);
+
+		for (const identifier of identifiers) {
+			context.state.init.push(b.let(identifier.name));
+		}
+
+		const assignment = b.assignment('=', id, init);
+		run.thunks.push(b.thunk(b.block([b.stmt(assignment)]), has_await));
+
+		const blocker = b.member(run.id, b.literal(run.thunks.length - 1), true);
+		for (const binding of bindings) {
+			binding.blocker = blocker;
+		}
+	} else {
+		context.state.init.push(b.const(id, init));
+	}
 }

package/src/compiler/phases/3-transform/server/visitors/EachBlock.js

@@ -34,11 +34,7 @@ export function EachBlock(node, context) {
 
 	const new_body = /** @type {BlockStatement} */ (context.visit(node.body)).body;
 
-	if (node.body)
-		each.push(
-			// TODO get rid of fragment.has_await
-			...(node.body.metadata.has_await ? [create_async_block(b.block(new_body))] : new_body)
-		);
+	if (node.body) each.push(...new_body);
 
 	const for_loop = b.for(
 		b.declaration('let', [
@@ -61,7 +57,7 @@ export function EachBlock(node, context) {
 			b.if(
 				b.binary('!==', b.member(array_id, 'length'), b.literal(0)),
 				b.block([open, for_loop]),
-				node.fallback.metadata.has_await ? create_async_block(fallback) : fallback
+				fallback
 			)
 		);
 	} else {

package/src/compiler/phases/3-transform/server/visitors/Fragment.js

@@ -28,7 +28,8 @@ export function Fragment(node, context) {
 		init: [],
 		template: [],
 		namespace,
-		skip_hydration_boundaries: is_standalone
+		skip_hydration_boundaries: is_standalone,
+		async_consts: undefined
 	};
 
 	for (const node of hoisted) {
@@ -42,5 +43,11 @@ export function Fragment(node, context) {
 
 	process_children(trimmed, { ...context, state });
 
+	if (state.async_consts && state.async_consts.thunks.length > 0) {
+		state.init.push(
+			b.var(state.async_consts.id, b.call('$$renderer.run', b.array(state.async_consts.thunks)))
+		);
+	}
+
 	return b.block([...state.init, ...build_template(state.template)]);
 }

package/src/compiler/phases/3-transform/server/visitors/IfBlock.js

@@ -25,11 +25,7 @@ export function IfBlock(node, context) {
 
 	const is_async = node.metadata.expression.is_async();
 
-	const has_await =
-		node.metadata.expression.has_await ||
-		// TODO get rid of this stuff
-		node.consequent.metadata.has_await ||
-		node.alternate?.metadata.has_await;
+	const has_await = node.metadata.expression.has_await;
 
 	if (is_async || has_await) {
 		statement = create_async_block(

package/src/compiler/phases/3-transform/server/visitors/SnippetBlock.js

@@ -3,7 +3,6 @@
 /** @import { ComponentContext } from '../types.js' */
 import { dev } from '../../../../state.js';
 import * as b from '#compiler/builders';
-import { create_async_block } from './shared/utils.js';
 
 /**
  * @param {AST.SnippetBlock} node
@@ -16,10 +15,6 @@ export function SnippetBlock(node, context) {
 		/** @type {BlockStatement} */ (context.visit(node.body))
 	);
 
-	if (node.body.metadata.has_await) {
-		fn.body = b.block([create_async_block(fn.body)]);
-	}
-
 	// @ts-expect-error - TODO remove this hack once $$render_inner for legacy bindings is gone
 	fn.___snippet = true;
 

package/src/compiler/phases/3-transform/server/visitors/SvelteBoundary.js

@@ -7,8 +7,7 @@ import {
 	block_open,
 	block_open_else,
 	build_attribute_value,
-	build_template,
-	create_async_block
+	build_template
 } from './shared/utils.js';
 
 /**
@@ -43,14 +42,11 @@ export function SvelteBoundary(node, context) {
 			);
 			const pending = b.call(callee, b.id('$$renderer'));
 			const block = /** @type {BlockStatement} */ (context.visit(node.fragment));
-			const statement = node.fragment.metadata.has_await
-				? create_async_block(b.block([block]))
-				: block;
 			context.state.template.push(
 				b.if(
 					callee,
 					b.block(build_template([block_open_else, b.stmt(pending), block_close])),
-					b.block(build_template([block_open, statement, block_close]))
+					b.block(build_template([block_open, block, block_close]))
 				)
 			);
 		} else {
@@ -70,9 +66,6 @@ export function SvelteBoundary(node, context) {
 		}
 	} else {
 		const block = /** @type {BlockStatement} */ (context.visit(node.fragment));
-		const statement = node.fragment.metadata.has_await
-			? create_async_block(b.block([block]))
-			: block;
-		context.state.template.push(block_open, statement, block_close);
+		context.state.template.push(block_open, block, block_close);
 	}
 }

package/src/compiler/phases/3-transform/server/visitors/shared/component.js

@@ -244,12 +244,7 @@ export function build_inline_component(node, expression, context) {
 			params.push(pattern);
 		}
 
-		const slot_fn = b.arrow(
-			params,
-			node.fragment.metadata.has_await
-				? b.block([create_async_block(b.block(block.body))])
-				: b.block(block.body)
-		);
+		const slot_fn = b.arrow(params, b.block(block.body));
 
 		if (slot_name === 'default' && !has_children_prop) {
 			if (

package/src/compiler/phases/nodes.js

@@ -112,6 +112,10 @@ export class ExpressionMetadata {
 		return b.array([...this.#get_blockers()]);
 	}
 
+	has_blockers() {
+		return this.#get_blockers().size > 0;
+	}
+
 	is_async() {
 		return this.has_await || this.#get_blockers().size > 0;
 	}

package/src/compiler/phases/scope.js

@@ -1,4 +1,4 @@
-/** @import { ArrowFunctionExpression, BinaryOperator, ClassDeclaration, Expression, FunctionDeclaration, FunctionExpression, Identifier, ImportDeclaration, MemberExpression, LogicalOperator, Node, Pattern, UnaryOperator, VariableDeclarator, Super } from 'estree' */
+/** @import { BinaryOperator, ClassDeclaration, Expression, FunctionDeclaration, Identifier, ImportDeclaration, MemberExpression, LogicalOperator, Node, Pattern, UnaryOperator, VariableDeclarator, Super, SimpleLiteral, FunctionExpression, ArrowFunctionExpression } from 'estree' */
 /** @import { Context, Visitor } from 'zimmerframe' */
 /** @import { AST, BindingKind, DeclarationKind } from '#compiler' */
 import is_reference from 'is-reference';
@@ -108,7 +108,10 @@ export class Binding {
 	/** @type {Array<{ node: Identifier; path: AST.SvelteNode[] }>} */
 	references = [];
 
-	/** @type {Array<{ value: Expression; scope: Scope }>} */
+	/**
+	 * (Re)assignments of this binding. Includes declarations such as `function x() {}`.
+	 * @type {Array<{ value: Expression; scope: Scope }>}
+	 */
 	assignments = [];
 
 	/**
@@ -135,9 +138,10 @@ export class Binding {
 	/**
 	 * Instance-level declarations may follow (or contain) a top-level `await`. In these cases,
 	 * any reads that occur in the template must wait for the corresponding promise to resolve
-	 * otherwise the initial value will not have been assigned
+	 * otherwise the initial value will not have been assigned.
+	 * It is a member expression of the form `$$blockers[n]`.
 	 * TODO the blocker is set during transform which feels a bit grubby
-	 * @type {Expression | null}
+	 * @type {MemberExpression & { object: Identifier, property: SimpleLiteral & { value: number } } | null}
 	 */
 	blocker = null;
 

package/src/compiler/utils/builders.js

@@ -181,7 +181,7 @@ export function logical(operator, left, right) {
 }
 
 /**
- * @param {'const' | 'let' | 'var'} kind
+ * @param {ESTree.VariableDeclaration['kind']} kind
  * @param {ESTree.VariableDeclarator[]} declarations
  * @returns {ESTree.VariableDeclaration}
  */

package/src/internal/client/dom/blocks/each.js

@@ -244,7 +244,9 @@ export function each(node, flags, get_collection, get_key, render_fn, fallback_f
 					item.i = i;
 				}
 
-				batch.skipped_effects.delete(item.e);
+				if (defer) {
+					batch.skipped_effects.delete(item.e);
+				}
 			} else {
 				item = create_item(
 					first_run ? anchor : null,
@@ -298,14 +300,14 @@ export function each(node, flags, get_collection, get_key, render_fn, fallback_f
 			set_hydrate_node(skip_nodes());
 		}
 
-		for (const [key, item] of state.items) {
-			if (!keys.has(key)) {
-				batch.skipped_effects.add(item.e);
-			}
-		}
-
 		if (!first_run) {
 			if (defer) {
+				for (const [key, item] of state.items) {
+					if (!keys.has(key)) {
+						batch.skipped_effects.add(item.e);
+					}
+				}
+
 				batch.oncommit(commit);
 				batch.ondiscard(() => {
 					// TODO presumably we need to do something here?

package/src/internal/client/reactivity/deriveds.js

@@ -11,7 +11,8 @@ import {
 	STALE_REACTION,
 	ASYNC,
 	WAS_MARKED,
-	CONNECTED
+	CONNECTED,
+	DESTROYED
 } from '#client/constants';
 import {
 	active_reaction,
@@ -296,7 +297,9 @@ function get_derived_parent_effect(derived) {
 	var parent = derived.parent;
 	while (parent !== null) {
 		if ((parent.f & DERIVED) === 0) {
-			return /** @type {Effect} */ (parent);
+			// The original parent effect might've been destroyed but the derived
+			// is used elsewhere now - do not return the destroyed effect in that case
+			return (parent.f & DESTROYED) === 0 ? /** @type {Effect} */ (parent) : null;
 		}
 		parent = parent.parent;
 	}

package/src/internal/client/reactivity/sources.js

@@ -14,7 +14,9 @@ import {
 	is_dirty,
 	untracking,
 	is_destroying_effect,
-	push_reaction_value
+	push_reaction_value,
+	set_is_updating_effect,
+	is_updating_effect
 } from '../runtime.js';
 import { equals, safe_equals } from './equality.js';
 import {
@@ -246,19 +248,25 @@ export function internal_set(source, value) {
 
 export function flush_eager_effects() {
 	eager_effects_deferred = false;
+	var prev_is_updating_effect = is_updating_effect;
+	set_is_updating_effect(true);
 
 	const inspects = Array.from(eager_effects);
 
-	for (const effect of inspects) {
-		// Mark clean inspect-effects as maybe dirty and then check their dirtiness
-		// instead of just updating the effects - this way we avoid overfiring.
-		if ((effect.f & CLEAN) !== 0) {
-			set_signal_status(effect, MAYBE_DIRTY);
-		}
+	try {
+		for (const effect of inspects) {
+			// Mark clean inspect-effects as maybe dirty and then check their dirtiness
+			// instead of just updating the effects - this way we avoid overfiring.
+			if ((effect.f & CLEAN) !== 0) {
+				set_signal_status(effect, MAYBE_DIRTY);
+			}
 
-		if (is_dirty(effect)) {
-			update_effect(effect);
+			if (is_dirty(effect)) {
+				update_effect(effect);
+			}
 		}
+	} finally {
+		set_is_updating_effect(prev_is_updating_effect);
 	}
 
 	eager_effects.clear();

package/src/version.js

@@ -4,5 +4,5 @@
  * The current version, as set in package.json.
  * @type {string}
  */
-export const VERSION = '5.43.8';
+export const VERSION = '5.43.9';
 export const PUBLIC_VERSION = '5';