svelte 5.46.0 → 5.46.3

package/package.json

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

package/src/compiler/phases/1-parse/read/script.js

@@ -6,6 +6,7 @@ import { regex_not_newline_characters } from '../../patterns.js';
 import * as e from '../../../errors.js';
 import * as w from '../../../warnings.js';
 import { is_text_attribute } from '../../../utils/ast.js';
+import { locator } from '../../../state.js';
 
 const regex_closing_script_tag = /<\/script\s*>/;
 const regex_starts_with_closing_script_tag = /^<\/script\s*>/;
@@ -39,9 +40,15 @@ export function read_script(parser, start, attributes) {
 		parser.acorn_error(err);
 	}
 
-	// TODO is this necessary?
 	ast.start = script_start;
 
+	if (ast.loc) {
+		// Acorn always uses `0` as the start of a `Program`, but for sourcemap purposes
+		// we need it to be the start of the `<script>` contents
+		({ line: ast.loc.start.line, column: ast.loc.start.column } = locator(start));
+		({ line: ast.loc.end.line, column: ast.loc.end.column } = locator(parser.index));
+	}
+
 	/** @type {'default' | 'module'} */
 	let context = 'default';
 

package/src/compiler/phases/2-analyze/index.js

@@ -657,7 +657,8 @@ export function analyze_component(root, source, options) {
 									if (
 										binding &&
 										binding.kind === 'normal' &&
-										binding.declaration_kind !== 'import'
+										binding.declaration_kind !== 'import' &&
+										binding.declaration_kind !== 'function'
 									) {
 										binding.kind = 'state';
 										binding.mutated = true;

package/src/compiler/phases/2-analyze/visitors/EachBlock.js

@@ -54,7 +54,9 @@ export function EachBlock(node, context) {
 
 		// collect transitive dependencies...
 		for (const binding of node.metadata.expression.dependencies) {
-			collect_transitive_dependencies(binding, node.metadata.transitive_deps);
+			if (binding.declaration_kind !== 'function') {
+				collect_transitive_dependencies(binding, node.metadata.transitive_deps);
+			}
 		}
 
 		// ...and ensure they are marked as state, so they can be turned

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

@@ -519,14 +519,9 @@ export function client_component(analysis, options) {
 
 	if (options.hmr) {
 		const id = b.id(analysis.name);
-		const HMR = b.id('$.HMR');
-
-		const existing = b.member(id, HMR, true);
-		const incoming = b.member(b.id('module.default'), HMR, true);
 
 		const accept_fn_body = [
-			b.stmt(b.assignment('=', b.member(incoming, 'source'), b.member(existing, 'source'))),
-			b.stmt(b.call('$.set', b.member(existing, 'source'), b.member(incoming, 'original')))
+			b.stmt(b.call(b.member(b.member(id, b.id('$.HMR'), true), 'update'), b.id('module.default')))
 		];
 
 		if (analysis.css.hash) {
@@ -535,8 +530,7 @@ export function client_component(analysis, options) {
 		}
 
 		const hmr = b.block([
-			b.stmt(b.assignment('=', id, b.call('$.hmr', id, b.thunk(b.member(existing, 'source'))))),
-
+			b.stmt(b.assignment('=', id, b.call('$.hmr', id))),
 			b.stmt(b.call('import.meta.hot.accept', b.arrow([b.id('module')], b.block(accept_fn_body))))
 		]);
 

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

@@ -336,7 +336,9 @@ export function RegularElement(node, context) {
 		trimmed.every(
 			(node) =>
 				node.type === 'Text' ||
-				(!node.metadata.expression.has_state && !node.metadata.expression.has_await)
+				(!node.metadata.expression.has_state &&
+					!node.metadata.expression.has_await &&
+					!node.metadata.expression.has_blockers())
 		) &&
 		trimmed.some((node) => node.type === 'ExpressionTag');
 

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

@@ -209,11 +209,11 @@ export function VariableDeclaration(node, context) {
 						let call = b.call(
 							'$.async_derived',
 							b.thunk(expression, true),
+							dev && b.literal(declarator.id.name),
 							location ? b.literal(location) : undefined
 						);
 
 						call = should_save ? save(call) : b.await(call);
-						if (dev) call = b.call('$.tag', call, b.literal(declarator.id.name));
 
 						declarations.push(b.declarator(declarator.id, call));
 					} else {
@@ -244,17 +244,16 @@ export function VariableDeclaration(node, context) {
 							call = b.call(
 								'$.async_derived',
 								b.thunk(expression, true),
+								dev &&
+									b.literal(
+										`[$derived ${declarator.id.type === 'ArrayPattern' ? 'iterable' : 'object'}]`
+									),
 								location ? b.literal(location) : undefined
 							);
 
 							call = should_save ? save(call) : b.await(call);
 						}
 
-						if (dev) {
-							const label = `[$derived ${declarator.id.type === 'ArrayPattern' ? 'iterable' : 'object'}]`;
-							call = b.call('$.tag', call, b.literal(label));
-						}
-
 						declarations.push(b.declarator(id, call));
 					}
 

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

@@ -134,7 +134,7 @@ export function build_template_chunk(
 
 			const evaluated = state.scope.evaluate(value);
 
-			has_await ||= node.metadata.expression.has_await;
+			has_await ||= node.metadata.expression.has_await || node.metadata.expression.has_blockers();
 			has_state ||= has_await || (node.metadata.expression.has_state && !evaluated.is_known);
 
 			if (values.length === 1) {

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

@@ -86,7 +86,14 @@ export function transform_body(instance_body, runner, transform) {
 			}
 
 			if (s.node.type === 'ExpressionStatement') {
-				const expression = /** @type {ESTree.Expression} */ (transform(s.node.expression));
+				// the expression may be a $inspect call, which will be transformed into an empty statement
+				const expression = /** @type {ESTree.Expression | ESTree.EmptyStatement} */ (
+					transform(s.node.expression)
+				);
+
+				if (expression.type === 'EmptyStatement') {
+					return null;
+				}
 
 				return expression.type === 'AwaitExpression'
 					? b.thunk(expression, true)

package/src/internal/client/dev/hmr.js

@@ -1,23 +1,25 @@
-/** @import { Source, Effect, TemplateNode } from '#client' */
+/** @import { Effect, TemplateNode } from '#client' */
 import { FILENAME, HMR } from '../../../constants.js';
 import { EFFECT_TRANSPARENT } from '#client/constants';
 import { hydrate_node, hydrating } from '../dom/hydration.js';
 import { block, branch, destroy_effect } from '../reactivity/effects.js';
-import { source } from '../reactivity/sources.js';
+import { set, source } from '../reactivity/sources.js';
 import { set_should_intro } from '../render.js';
 import { get } from '../runtime.js';
 
 /**
  * @template {(anchor: Comment, props: any) => any} Component
- * @param {Component} original
- * @param {() => Source<Component>} get_source
+ * @param {Component} fn
  */
-export function hmr(original, get_source) {
+export function hmr(fn) {
+	const current = source(fn);
+
 	/**
 	 * @param {TemplateNode} anchor
 	 * @param {any} props
 	 */
 	function wrapper(anchor, props) {
+		let component = {};
 		let instance = {};
 
 		/** @type {Effect} */
@@ -26,8 +28,9 @@ export function hmr(original, get_source) {
 		let ran = false;
 
 		block(() => {
-			const source = get_source();
-			const component = get(source);
+			if (component === (component = get(current))) {
+				return;
+			}
 
 			if (effect) {
 				// @ts-ignore
@@ -62,16 +65,24 @@ export function hmr(original, get_source) {
 	}
 
 	// @ts-expect-error
-	wrapper[FILENAME] = original[FILENAME];
+	wrapper[FILENAME] = fn[FILENAME];
 
 	// @ts-ignore
 	wrapper[HMR] = {
-		// When we accept an update, we set the original source to the new component
-		original,
-		// The `get_source` parameter reads `wrapper[HMR].source`, but in the `accept`
-		// function we always replace it with `previous[HMR].source`, which in practice
-		// means we only ever update the original
-		source: source(original)
+		fn,
+		current,
+		update: (/** @type {any} */ incoming) => {
+			// This logic ensures that the first version of the component is the one
+			// whose update function and therefore block effect is preserved across updates.
+			// If we don't do this dance and instead just use `incoming` as the new component
+			// and then update, we'll create an ever-growing stack of block effects.
+
+			// Trigger the original block effect
+			set(wrapper[HMR].current, incoming[HMR].fn);
+
+			// Replace the incoming source with the original one
+			incoming[HMR].current = wrapper[HMR].current;
+		}
 	};
 
 	return wrapper;

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

@@ -21,7 +21,7 @@ import { get_boundary } from './boundary.js';
 export function async(node, blockers = [], expressions = [], fn) {
 	var boundary = get_boundary();
 	var batch = /** @type {Batch} */ (current_batch);
-	var blocking = !boundary.is_pending();
+	var blocking = boundary.is_rendered();
 
 	boundary.update_pending_count(1);
 	batch.increment(blocking);

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

@@ -2,8 +2,10 @@
 import {
 	BOUNDARY_EFFECT,
 	COMMENT_NODE,
+	DIRTY,
 	EFFECT_PRESERVED,
-	EFFECT_TRANSPARENT
+	EFFECT_TRANSPARENT,
+	MAYBE_DIRTY
 } from '#client/constants';
 import { HYDRATION_START_ELSE } from '../../../../constants.js';
 import { component_context, set_component_context } from '../../context.js';
@@ -34,11 +36,13 @@ import { queue_micro_task } from '../task.js';
 import * as e from '../../errors.js';
 import * as w from '../../warnings.js';
 import { DEV } from 'esm-env';
-import { Batch } from '../../reactivity/batch.js';
+import { Batch, schedule_effect } from '../../reactivity/batch.js';
 import { internal_set, source } from '../../reactivity/sources.js';
 import { tag } from '../../dev/tracing.js';
 import { createSubscriber } from '../../../../reactivity/create-subscriber.js';
 import { create_text } from '../operations.js';
+import { defer_effect } from '../../reactivity/utils.js';
+import { set_signal_status } from '../../reactivity/status.js';
 
 /**
  * @typedef {{
@@ -64,7 +68,7 @@ export class Boundary {
 	/** @type {Boundary | null} */
 	parent;
 
-	#pending = false;
+	is_pending = false;
 
 	/** @type {TemplateNode} */
 	#anchor;
@@ -101,6 +105,12 @@ export class Boundary {
 
 	#is_creating_fallback = false;
 
+	/** @type {Set<Effect>} */
+	#dirty_effects = new Set();
+
+	/** @type {Set<Effect>} */
+	#maybe_dirty_effects = new Set();
+
 	/**
 	 * A source containing the number of pending async deriveds/expressions.
 	 * Only created if `$effect.pending()` is used inside the boundary,
@@ -134,7 +144,7 @@ export class Boundary {
 
 		this.parent = /** @type {Effect} */ (active_effect).b;
 
-		this.#pending = !!this.#props.pending;
+		this.is_pending = !!this.#props.pending;
 
 		this.#effect = block(() => {
 			/** @type {Effect} */ (active_effect).b = this;
@@ -151,6 +161,10 @@ export class Boundary {
 					this.#hydrate_pending_content();
 				} else {
 					this.#hydrate_resolved_content();
+
+					if (this.#pending_count === 0) {
+						this.is_pending = false;
+					}
 				}
 			} else {
 				var anchor = this.#get_anchor();
@@ -164,7 +178,7 @@ export class Boundary {
 				if (this.#pending_count > 0) {
 					this.#show_pending_snippet();
 				} else {
-					this.#pending = false;
+					this.is_pending = false;
 				}
 			}
 
@@ -184,10 +198,6 @@ export class Boundary {
 		} catch (error) {
 			this.error(error);
 		}
-
-		// Since server rendered resolved content, we never show pending state
-		// Even if client-side async operations are still running, the content is already displayed
-		this.#pending = false;
 	}
 
 	#hydrate_pending_content() {
@@ -212,7 +222,7 @@ export class Boundary {
 					this.#pending_effect = null;
 				});
 
-				this.#pending = false;
+				this.is_pending = false;
 			}
 		});
 	}
@@ -220,7 +230,7 @@ export class Boundary {
 	#get_anchor() {
 		var anchor = this.#anchor;
 
-		if (this.#pending) {
+		if (this.is_pending) {
 			this.#pending_anchor = create_text();
 			this.#anchor.before(this.#pending_anchor);
 
@@ -231,11 +241,19 @@ export class Boundary {
 	}
 
 	/**
-	 * Returns `true` if the effect exists inside a boundary whose pending snippet is shown
+	 * Defer an effect inside a pending boundary until the boundary resolves
+	 * @param {Effect} effect
+	 */
+	defer_effect(effect) {
+		defer_effect(effect, this.#dirty_effects, this.#maybe_dirty_effects);
+	}
+
+	/**
+	 * Returns `false` if the effect exists inside a boundary whose pending snippet is shown
 	 * @returns {boolean}
 	 */
-	is_pending() {
-		return this.#pending || (!!this.parent && this.parent.is_pending());
+	is_rendered() {
+		return !this.is_pending && (!this.parent || this.parent.is_rendered());
 	}
 
 	has_pending_snippet() {
@@ -298,7 +316,24 @@ export class Boundary {
 		this.#pending_count += d;
 
 		if (this.#pending_count === 0) {
-			this.#pending = false;
+			this.is_pending = false;
+
+			// any effects that were encountered and deferred during traversal
+			// should be rescheduled — after the next traversal (which will happen
+			// immediately, due to the same update that brought us here)
+			// the effects will be flushed
+			for (const e of this.#dirty_effects) {
+				set_signal_status(e, DIRTY);
+				schedule_effect(e);
+			}
+
+			for (const e of this.#maybe_dirty_effects) {
+				set_signal_status(e, MAYBE_DIRTY);
+				schedule_effect(e);
+			}
+
+			this.#dirty_effects.clear();
+			this.#maybe_dirty_effects.clear();
 
 			if (this.#pending_effect) {
 				pause_effect(this.#pending_effect, () => {
@@ -394,7 +429,7 @@ export class Boundary {
 
 			// we intentionally do not try to find the nearest pending boundary. If this boundary has one, we'll render it on reset
 			// but it would be really weird to show the parent's boundary on a child reset.
-			this.#pending = this.has_pending_snippet();
+			this.is_pending = this.has_pending_snippet();
 
 			this.#main_effect = this.#run(() => {
 				this.#is_creating_fallback = false;
@@ -404,7 +439,7 @@ export class Boundary {
 			if (this.#pending_count > 0) {
 				this.#show_pending_snippet();
 			} else {
-				this.#pending = false;
+				this.is_pending = false;
 			}
 		};
 

package/src/internal/client/index.js

@@ -98,7 +98,6 @@ export {
 	with_script
 } from './dom/template.js';
 export {
-	async_body,
 	for_await_track_reactivity_loss,
 	run,
 	save,

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

@@ -25,7 +25,6 @@ import {
 	set_from_async_derived
 } from './deriveds.js';
 import { aborted } from './effects.js';
-import { hydrate_next, hydrating, set_hydrate_node, skip_nodes } from '../dom/hydration.js';
 
 /**
  * @param {Array<Promise<void>>} blockers
@@ -211,51 +210,6 @@ export function unset_context() {
 	}
 }
 
-/**
- * @param {TemplateNode} anchor
- * @param {(target: TemplateNode) => Promise<void>} fn
- */
-export async function async_body(anchor, fn) {
-	var boundary = get_boundary();
-	var batch = /** @type {Batch} */ (current_batch);
-	var blocking = !boundary.is_pending();
-
-	boundary.update_pending_count(1);
-	batch.increment(blocking);
-
-	var active = /** @type {Effect} */ (active_effect);
-
-	var was_hydrating = hydrating;
-	var next_hydrate_node = undefined;
-
-	if (was_hydrating) {
-		hydrate_next();
-		next_hydrate_node = skip_nodes(false);
-	}
-
-	try {
-		var promise = fn(anchor);
-	} finally {
-		if (next_hydrate_node) {
-			set_hydrate_node(next_hydrate_node);
-			hydrate_next();
-		}
-	}
-
-	try {
-		await promise;
-	} catch (error) {
-		if (!aborted(active)) {
-			invoke_error_boundary(error, active);
-		}
-	} finally {
-		boundary.update_pending_count(-1);
-		batch.decrement(blocking);
-
-		unset_context();
-	}
-}
-
 /**
  * @param {Array<() => void | Promise<void>>} thunks
  */
@@ -264,7 +218,7 @@ export function run(thunks) {
 
 	var boundary = get_boundary();
 	var batch = /** @type {Batch} */ (current_batch);
-	var blocking = !boundary.is_pending();
+	var blocking = boundary.is_rendered();
 
 	boundary.update_pending_count(1);
 	batch.increment(blocking);
@@ -298,17 +252,13 @@ export function run(thunks) {
 					throw STALE_REACTION;
 				}
 
-				try {
-					restore();
-					return fn();
-				} finally {
-					// TODO do we need it here as well as below?
-					unset_context();
-				}
+				restore();
+				return fn();
 			})
 			.catch(handle_error)
 			.finally(() => {
 				unset_context();
+				current_batch?.deactivate();
 			});
 
 		promises.push(promise);