svelte 5.48.0 → 5.48.2

package/package.json

@@ -2,7 +2,7 @@
   "name": "svelte",
   "description": "Cybernetically enhanced web apps",
   "license": "MIT",
-  "version": "5.48.0",
+  "version": "5.48.2",
   "type": "module",
   "types": "./types/index.d.ts",
   "engines": {

package/src/compiler/errors.js

@@ -977,12 +977,12 @@ export function const_tag_invalid_expression(node) {
 }
 
 /**
- * `{@const}` must be the immediate child of `{#snippet}`, `{#if}`, `{:else if}`, `{:else}`, `{#each}`, `{:then}`, `{:catch}`, `<svelte:fragment>`, `<svelte:boundary` or `<Component>`
+ * `{@const}` must be the immediate child of `{#snippet}`, `{#if}`, `{:else if}`, `{:else}`, `{#each}`, `{:then}`, `{:catch}`, `<svelte:fragment>`, `<svelte:boundary>` or `<Component>`
  * @param {null | number | NodeLike} node
  * @returns {never}
  */
 export function const_tag_invalid_placement(node) {
-	e(node, 'const_tag_invalid_placement', `\`{@const}\` must be the immediate child of \`{#snippet}\`, \`{#if}\`, \`{:else if}\`, \`{:else}\`, \`{#each}\`, \`{:then}\`, \`{:catch}\`, \`<svelte:fragment>\`, \`<svelte:boundary\` or \`<Component>\`\nhttps://svelte.dev/e/const_tag_invalid_placement`);
+	e(node, 'const_tag_invalid_placement', `\`{@const}\` must be the immediate child of \`{#snippet}\`, \`{#if}\`, \`{:else if}\`, \`{:else}\`, \`{#each}\`, \`{:then}\`, \`{:catch}\`, \`<svelte:fragment>\`, \`<svelte:boundary>\` or \`<Component>\`\nhttps://svelte.dev/e/const_tag_invalid_placement`);
 }
 
 /**

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

@@ -170,6 +170,7 @@ export function client_component(analysis, options) {
 		// these are set inside the `Fragment` visitor, and cannot be used until then
 		init: /** @type {any} */ (null),
 		consts: /** @type {any} */ (null),
+		snippets: /** @type {any} */ (null),
 		let_directives: /** @type {any} */ (null),
 		update: /** @type {any} */ (null),
 		after_update: /** @type {any} */ (null),

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

@@ -1,4 +1,4 @@
-/** @import { Pattern } from 'estree' */
+/** @import { Expression, Identifier, Pattern } from 'estree' */
 /** @import { AST } from '#compiler' */
 /** @import { ComponentContext } from '../types' */
 /** @import { ExpressionMetadata } from '../../../nodes.js' */
@@ -88,8 +88,8 @@ export function ConstTag(node, context) {
 
 /**
  * @param {ComponentContext['state']} state
- * @param {import('estree').Identifier} id
- * @param {import('estree').Expression} expression
+ * @param {Identifier} id
+ * @param {Expression} expression
  * @param {ExpressionMetadata} metadata
  * @param {import('#compiler').Binding[]} bindings
  */
@@ -99,7 +99,9 @@ function add_const_declaration(state, id, expression, metadata, bindings) {
 	const after = dev ? [b.stmt(b.call('$.get', id))] : [];
 
 	const has_await = metadata.has_await;
-	const blockers = [...metadata.dependencies].map((dep) => dep.blocker).filter((b) => b !== null);
+	const blockers = [...metadata.dependencies]
+		.map((dep) => dep.blocker)
+		.filter((b) => b !== null && b.object !== state.async_consts?.id);
 
 	if (has_await || state.async_consts || blockers.length > 0) {
 		const run = (state.async_consts ??= {
@@ -112,7 +114,11 @@ function add_const_declaration(state, id, expression, metadata, bindings) {
 		const assignment = b.assignment('=', id, expression);
 		const body = after.length === 0 ? assignment : b.block([b.stmt(assignment), ...after]);
 
-		if (blockers.length > 0) run.thunks.push(b.thunk(b.call('Promise.all', b.array(blockers))));
+		if (blockers.length === 1) {
+			run.thunks.push(b.thunk(b.member(/** @type {Expression} */ (blockers[0]), 'promise')));
+		} else if (blockers.length > 0) {
+			run.thunks.push(b.thunk(b.call('$.wait', b.array(blockers))));
+		}
 
 		run.thunks.push(b.thunk(body, has_await));
 

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

@@ -1,13 +1,13 @@
 /** @import { Expression, Statement } from 'estree' */
 /** @import { AST } from '#compiler' */
 /** @import { ComponentClientTransformState, ComponentContext } from '../types' */
-import { TEMPLATE_FRAGMENT, TEMPLATE_USE_IMPORT_NODE } from '../../../../../constants.js';
 import * as b from '#compiler/builders';
+import { TEMPLATE_FRAGMENT, TEMPLATE_USE_IMPORT_NODE } from '../../../../../constants.js';
 import { clean_nodes, infer_namespace } from '../../utils.js';
 import { transform_template } from '../transform-template/index.js';
+import { Template } from '../transform-template/template.js';
 import { process_children } from './shared/fragment.js';
 import { build_render_statement, Memoizer } from './shared/utils.js';
-import { Template } from '../transform-template/template.js';
 
 /**
  * @param {AST.Fragment} node
@@ -60,6 +60,7 @@ export function Fragment(node, context) {
 	const state = {
 		...context.state,
 		init: [],
+		snippets: [],
 		consts: [],
 		let_directives: [],
 		update: [],
@@ -150,7 +151,7 @@ export function Fragment(node, context) {
 		}
 	}
 
-	body.push(...state.let_directives, ...state.consts);
+	body.push(...state.snippets, ...state.let_directives, ...state.consts);
 
 	if (state.async_consts && state.async_consts.thunks.length > 0) {
 		body.push(b.var(state.async_consts.id, b.call('$.run', b.array(state.async_consts.thunks))));

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

@@ -329,7 +329,7 @@ export function RegularElement(node, context) {
 	);
 
 	/** @type {typeof state} */
-	const child_state = { ...state, init: [], update: [], after_update: [] };
+	const child_state = { ...state, init: [], update: [], after_update: [], snippets: [] };
 
 	for (const node of hoisted) {
 		context.visit(node, child_state);
@@ -441,6 +441,7 @@ export function RegularElement(node, context) {
 		// Wrap children in `{...}` to avoid declaration conflicts
 		context.state.init.push(
 			b.block([
+				...child_state.snippets,
 				...child_state.init,
 				...element_state.init,
 				child_state.update.length > 0 ? build_render_statement(child_state) : b.empty,

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

@@ -89,6 +89,6 @@ export function SnippetBlock(node, context) {
 			context.state.instance_level_snippets.push(declaration);
 		}
 	} else {
-		context.state.init.push(declaration);
+		context.state.snippets.push(declaration);
 	}
 }

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

@@ -77,7 +77,7 @@ export function SvelteBoundary(node, context) {
 				/** @type {Statement[]} */
 				const statements = [];
 
-				context.visit(child, { ...context.state, init: statements });
+				context.visit(child, { ...context.state, snippets: statements });
 
 				const snippet = /** @type {VariableDeclaration} */ (statements[0]);
 

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

@@ -333,7 +333,7 @@ export function build_component(node, component_name, loc, context) {
 			// can be used as props without creating conflicts
 			context.visit(child, {
 				...context.state,
-				init: snippet_declarations
+				snippets: snippet_declarations
 			});
 
 			push_prop(b.prop('init', child.expression, child.expression));

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

@@ -15,7 +15,7 @@ export function ConstTag(node, context) {
 	const has_await = node.metadata.expression.has_await;
 	const blockers = [...node.metadata.expression.dependencies]
 		.map((dep) => dep.blocker)
-		.filter((b) => b !== null);
+		.filter((b) => b !== null && b.object !== context.state.async_consts?.id);
 
 	if (has_await || context.state.async_consts || blockers.length > 0) {
 		const run = (context.state.async_consts ??= {
@@ -30,7 +30,9 @@ export function ConstTag(node, context) {
 			context.state.init.push(b.let(identifier.name));
 		}
 
-		if (blockers.length > 0) {
+		if (blockers.length === 1) {
+			run.thunks.push(b.thunk(/** @type {Expression} */ (blockers[0])));
+		} else if (blockers.length > 0) {
 			run.thunks.push(b.thunk(b.call('Promise.all', b.array(blockers))));
 		}
 

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

@@ -2,7 +2,7 @@
 /** @import { AST } from '#compiler' */
 /** @import { ComponentContext } from '../types.js' */
 import * as b from '#compiler/builders';
-import { create_push } from './shared/utils.js';
+import { block_close, block_open, create_push } from './shared/utils.js';
 
 /**
  * @param {AST.HtmlTag} node
@@ -12,5 +12,15 @@ export function HtmlTag(node, context) {
 	const expression = /** @type {Expression} */ (context.visit(node.expression));
 	const call = b.call('$.html', expression);
 
+	const has_await = node.metadata.expression.has_await;
+
+	if (has_await) {
+		context.state.template.push(block_open);
+	}
+
 	context.state.template.push(create_push(call, node.metadata.expression, true));
+
+	if (has_await) {
+		context.state.template.push(block_close);
+	}
 }

package/src/compiler/phases/3-transform/shared/transform-async.js

@@ -49,22 +49,25 @@ export function transform_body(instance_body, runner, transform) {
 	if (instance_body.async.length > 0) {
 		const thunks = instance_body.async.map((s) => {
 			if (s.node.type === 'VariableDeclarator') {
-				const visited = /** @type {ESTree.VariableDeclaration} */ (
+				const visited = /** @type {ESTree.VariableDeclaration | ESTree.EmptyStatement} */ (
 					transform(b.var(s.node.id, s.node.init))
 				);
 
-				const statements = visited.declarations.map((node) => {
-					if (
-						node.id.type === 'Identifier' &&
-						(node.id.name.startsWith('$$d') || node.id.name.startsWith('$$array'))
-					) {
-						// this is an intermediate declaration created in VariableDeclaration.js;
-						// subsequent statements depend on it
-						return b.var(node.id, node.init);
-					}
+				const statements =
+					visited.type === 'VariableDeclaration'
+						? visited.declarations.map((node) => {
+								if (
+									node.id.type === 'Identifier' &&
+									(node.id.name.startsWith('$$d') || node.id.name.startsWith('$$array'))
+								) {
+									// this is an intermediate declaration created in VariableDeclaration.js;
+									// subsequent statements depend on it
+									return b.var(node.id, node.init);
+								}
 
-					return b.stmt(b.assignment('=', node.id, node.init ?? b.void0));
-				});
+								return b.stmt(b.assignment('=', node.id, node.init ?? b.void0));
+							})
+						: [];
 
 				if (statements.length === 1) {
 					const statement = /** @type {ESTree.ExpressionStatement} */ (statements[0]);

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

@@ -1,4 +1,4 @@
-/** @import { TemplateNode, Value } from '#client' */
+/** @import { Blocker, TemplateNode, Value } from '#client' */
 import { flatten } from '../../reactivity/async.js';
 import { Batch, current_batch } from '../../reactivity/batch.js';
 import { get } from '../../runtime.js';
@@ -14,11 +14,16 @@ import { get_boundary } from './boundary.js';
 
 /**
  * @param {TemplateNode} node
- * @param {Array<Promise<void>>} blockers
+ * @param {Blocker[]} blockers
  * @param {Array<() => Promise<any>>} expressions
  * @param {(anchor: TemplateNode, ...deriveds: Value[]) => void} fn
  */
 export function async(node, blockers = [], expressions = [], fn) {
+	if (expressions.length === 0 && blockers.every((b) => b.settled)) {
+		fn(node);
+		return;
+	}
+
 	var boundary = get_boundary();
 	var batch = /** @type {Batch} */ (current_batch);
 	var blocking = boundary.is_rendered();

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

@@ -102,6 +102,7 @@ export class Boundary {
 
 	#local_pending_count = 0;
 	#pending_count = 0;
+	#pending_count_update_queued = false;
 
 	#is_creating_fallback = false;
 
@@ -202,12 +203,11 @@ export class Boundary {
 
 	#hydrate_pending_content() {
 		const pending = this.#props.pending;
-		if (!pending) {
-			return;
-		}
+		if (!pending) return;
+
 		this.#pending_effect = branch(() => pending(this.#anchor));
 
-		Batch.enqueue(() => {
+		queue_micro_task(() => {
 			var anchor = this.#get_anchor();
 
 			this.#main_effect = this.#run(() => {
@@ -359,9 +359,15 @@ export class Boundary {
 
 		this.#local_pending_count += d;
 
-		if (this.#effect_pending) {
-			internal_set(this.#effect_pending, this.#local_pending_count);
-		}
+		if (!this.#effect_pending || this.#pending_count_update_queued) return;
+		this.#pending_count_update_queued = true;
+
+		queue_micro_task(() => {
+			this.#pending_count_update_queued = false;
+			if (this.#effect_pending) {
+				internal_set(this.#effect_pending, this.#local_pending_count);
+			}
+		});
 	}
 
 	get_effect_pending() {

package/src/internal/client/dom/elements/attributes.js

@@ -1,4 +1,4 @@
-/** @import { Effect } from '#client' */
+/** @import { Blocker, Effect } from '#client' */
 import { DEV } from 'esm-env';
 import { hydrating, set_hydrating } from '../hydration.js';
 import { get_descriptors, get_prototype_of } from '../../../shared/utils.js';
@@ -483,7 +483,7 @@ function set_attributes(
  * @param {(...expressions: any) => Record<string | symbol, any>} fn
  * @param {Array<() => any>} sync
  * @param {Array<() => Promise<any>>} async
- * @param {Array<Promise<void>>} blockers
+ * @param {Blocker[]} blockers
  * @param {string} [css_hash]
  * @param {boolean} [should_remove_defaults]
  * @param {boolean} [skip_warning]

package/src/internal/client/index.js

@@ -103,7 +103,8 @@ export {
 	run,
 	save,
 	track_reactivity_loss,
-	run_after_blockers
+	run_after_blockers,
+	wait
 } from './reactivity/async.js';
 export { eager, flushSync as flush } from './reactivity/batch.js';
 export {

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

@@ -1,4 +1,4 @@
-/** @import { Effect, TemplateNode, Value } from '#client' */
+/** @import { Blocker, Effect, Value } from '#client' */
 import { DESTROYED, STALE_REACTION } from '#client/constants';
 import { DEV } from 'esm-env';
 import {
@@ -27,7 +27,7 @@ import {
 import { aborted } from './effects.js';
 
 /**
- * @param {Array<Promise<void>>} blockers
+ * @param {Blocker[]} blockers
  * @param {Array<() => any>} sync
  * @param {Array<() => Promise<any>>} async
  * @param {(values: Value[]) => any} fn
@@ -35,7 +35,10 @@ import { aborted } from './effects.js';
 export function flatten(blockers, sync, async, fn) {
 	const d = is_runes() ? derived : derived_safe_equal;
 
-	if (async.length === 0 && blockers.length === 0) {
+	// Filter out already-settled blockers - no need to wait for them
+	var pending = blockers.filter((b) => !b.settled);
+
+	if (async.length === 0 && pending.length === 0) {
 		fn(sync.map(d));
 		return;
 	}
@@ -44,47 +47,52 @@ export function flatten(blockers, sync, async, fn) {
 	var parent = /** @type {Effect} */ (active_effect);
 
 	var restore = capture();
+	var blocker_promise =
+		pending.length === 1
+			? pending[0].promise
+			: pending.length > 1
+				? Promise.all(pending.map((b) => b.promise))
+				: null;
+
+	/** @param {Value[]} values */
+	function finish(values) {
+		restore();
 
-	function run() {
-		Promise.all(async.map((expression) => async_derived(expression)))
-			.then((result) => {
-				restore();
+		try {
+			fn(values);
+		} catch (error) {
+			if ((parent.f & DESTROYED) === 0) {
+				invoke_error_boundary(error, parent);
+			}
+		}
 
-				try {
-					fn([...sync.map(d), ...result]);
-				} catch (error) {
-					// ignore errors in blocks that have already been destroyed
-					if ((parent.f & DESTROYED) === 0) {
-						invoke_error_boundary(error, parent);
-					}
-				}
+		batch?.deactivate();
+		unset_context();
+	}
 
-				batch?.deactivate();
-				unset_context();
-			})
-			.catch((error) => {
-				invoke_error_boundary(error, parent);
-			});
+	// Fast path: blockers but no async expressions
+	if (async.length === 0) {
+		/** @type {Promise<any>} */ (blocker_promise).then(() => finish(sync.map(d)));
+		return;
 	}
 
-	if (blockers.length > 0) {
-		Promise.all(blockers).then(() => {
-			restore();
+	// Full path: has async expressions
+	function run() {
+		restore();
+		Promise.all(async.map((expression) => async_derived(expression)))
+			.then((result) => finish([...sync.map(d), ...result]))
+			.catch((error) => invoke_error_boundary(error, parent));
+	}
 
-			try {
-				return run();
-			} finally {
-				batch?.deactivate();
-				unset_context();
-			}
-		});
+	if (blocker_promise) {
+		blocker_promise.then(run);
 	} else {
 		run();
 	}
 }
 
 /**
- * @param {Array<Promise<void>>} blockers
+ * @param {Blocker[]} blockers
  * @param {(values: Value[]) => any} fn
  */
 export function run_after_blockers(blockers, fn) {
@@ -239,7 +247,13 @@ export function run(thunks) {
 
 	var promise = Promise.resolve(thunks[0]()).catch(handle_error);
 
-	var promises = [promise];
+	/** @type {Blocker} */
+	var blocker = { promise, settled: false };
+	var blockers = [blocker];
+
+	promise.finally(() => {
+		blocker.settled = true;
+	});
 
 	for (const fn of thunks.slice(1)) {
 		promise = promise
@@ -255,13 +269,17 @@ export function run(thunks) {
 				restore();
 				return fn();
 			})
-			.catch(handle_error)
-			.finally(() => {
-				unset_context();
-				current_batch?.deactivate();
-			});
+			.catch(handle_error);
+
+		const blocker = { promise, settled: false };
+		blockers.push(blocker);
 
-		promises.push(promise);
+		promise.finally(() => {
+			blocker.settled = true;
+
+			unset_context();
+			current_batch?.deactivate();
+		});
 	}
 
 	promise
@@ -273,5 +291,12 @@ export function run(thunks) {
 			batch.decrement(blocking);
 		});
 
-	return promises;
+	return blockers;
+}
+
+/**
+ * @param {Blocker[]} blockers
+ */
+export function wait(blockers) {
+	return Promise.all(blockers.map((b) => b.promise));
 }

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

@@ -27,8 +27,6 @@ import {
 	get,
 	increment_write_version,
 	is_dirty,
-	is_updating_effect,
-	set_is_updating_effect,
 	update_effect
 } from '../runtime.js';
 import * as e from '../errors.js';
@@ -140,6 +138,8 @@ export class Batch {
 
 	is_fork = false;
 
+	#decrement_queued = false;
+
 	is_deferred() {
 		return this.is_fork || this.#blocking_pending > 0;
 	}
@@ -151,8 +151,6 @@ export class Batch {
 	process(root_effects) {
 		queued_root_effects = [];
 
-		previous_batch = null;
-
 		this.apply();
 
 		/** @type {Effect[]} */
@@ -170,14 +168,18 @@ export class Batch {
 			// log_inconsistent_branches(root);
 		}
 
-		if (!this.is_fork) {
-			this.#resolve();
-		}
-
 		if (this.is_deferred()) {
 			this.#defer_effects(render_effects);
 			this.#defer_effects(effects);
 		} else {
+			// append/remove branches
+			for (const fn of this.#commit_callbacks) fn();
+			this.#commit_callbacks.clear();
+
+			if (this.#pending === 0) {
+				this.#commit();
+			}
+
 			// If sources are written to, then work needs to happen in a separate batch, else prior sources would be mixed with
 			// newly updated sources, which could lead to infinite loops when effects run over and over again.
 			previous_batch = this;
@@ -330,18 +332,6 @@ export class Batch {
 		this.#discard_callbacks.clear();
 	}
 
-	#resolve() {
-		if (this.#blocking_pending === 0) {
-			// append/remove branches
-			for (const fn of this.#commit_callbacks) fn();
-			this.#commit_callbacks.clear();
-		}
-
-		if (this.#pending === 0) {
-			this.#commit();
-		}
-	}
-
 	#commit() {
 		// If there are other pending batches, they now need to be 'rebased' —
 		// in other words, we re-run block/async effects with the newly
@@ -438,7 +428,22 @@ export class Batch {
 		this.#pending -= 1;
 		if (blocking) this.#blocking_pending -= 1;
 
-		this.revive();
+		if (this.#decrement_queued) return;
+		this.#decrement_queued = true;
+
+		queue_micro_task(() => {
+			this.#decrement_queued = false;
+
+			if (!this.is_deferred()) {
+				// we only reschedule previously-deferred effects if we expect
+				// to be able to run them after processing the batch
+				this.revive();
+			} else if (queued_root_effects.length > 0) {
+				// if other effects are scheduled, process the batch _without_
+				// rescheduling the previously-deferred effects
+				this.flush();
+			}
+		});
 	}
 
 	revive() {
@@ -476,7 +481,7 @@ export class Batch {
 			batches.add(current_batch);
 
 			if (!is_flushing_sync) {
-				Batch.enqueue(() => {
+				queue_micro_task(() => {
 					if (current_batch !== batch) {
 						// a flushSync happened in the meantime
 						return;
@@ -490,11 +495,6 @@ export class Batch {
 		return current_batch;
 	}
 
-	/** @param {() => void} task */
-	static enqueue(task) {
-		queue_micro_task(task);
-	}
-
 	apply() {
 		if (!async_mode_flag || (!this.is_fork && batches.size === 1)) return;
 
@@ -561,14 +561,12 @@ export function flushSync(fn) {
 }
 
 function flush_effects() {
-	var was_updating_effect = is_updating_effect;
 	is_flushing = true;
 
 	var source_stacks = DEV ? new Set() : null;
 
 	try {
 		var flush_count = 0;
-		set_is_updating_effect(true);
 
 		while (queued_root_effects.length > 0) {
 			var batch = Batch.ensure();
@@ -612,7 +610,6 @@ function flush_effects() {
 		}
 	} finally {
 		is_flushing = false;
-		set_is_updating_effect(was_updating_effect);
 
 		last_scheduled_effect = null;
 

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

@@ -1,4 +1,4 @@
-/** @import { ComponentContext, ComponentContextLegacy, Derived, Effect, TemplateNode, TransitionManager } from '#client' */
+/** @import { Blocker, ComponentContext, ComponentContextLegacy, Derived, Effect, TemplateNode, TransitionManager } from '#client' */
 import {
 	is_dirty,
 	active_effect,
@@ -361,7 +361,7 @@ export function render_effect(fn, flags = 0) {
  * @param {(...expressions: any) => void | (() => void)} fn
  * @param {Array<() => any>} sync
  * @param {Array<() => Promise<any>>} async
- * @param {Array<Promise<void>>} blockers
+ * @param {Blocker[]} blockers
  */
 export function template_effect(fn, sync = [], async = [], blockers = []) {
 	flatten(blockers, sync, async, (values) => {
@@ -374,7 +374,7 @@ export function template_effect(fn, sync = [], async = [], blockers = []) {
  * @param {(...expressions: any) => void | (() => void)} fn
  * @param {Array<() => any>} sync
  * @param {Array<() => Promise<any>>} async
- * @param {Array<Promise<void>>} blockers
+ * @param {Blocker[]} blockers
  */
 export function deferred_template_effect(fn, sync = [], async = [], blockers = []) {
 	var batch = /** @type {Batch} */ (current_batch);