🚀. Socket Launch Week Day 2:Introducing Manifest Alerts.Learn more →
Sign In

svelte

Package Overview
Dependencies
Maintainers
3
Versions
1083
Alerts
File Explorer

Advanced tools

License
Socket logo

Install Socket

Detect and block malicious and high-risk dependencies

Install

svelte - npm Package Compare versions

Comparing version
5.55.5
 to
5.55.6
+1
-1
package.json

@@ -5,3 +5,3 @@ {

"license": "MIT",
"version": "5.55.5",
"version": "5.55.6",
"type": "module",

@@ -8,0 +8,0 @@ "types": "./types/index.d.ts",

+15
-0
src/compiler/phases/1-parse/read/style.js

@@ -527,2 +527,17 @@ /** @import { AST } from '#compiler' */

return value.trim();
} else if (
char === '/' &&
!in_url &&
!quote_mark &&
parser.template[parser.index + 1] === '*'
) {
parser.index += 2;
while (parser.index < parser.template.length) {
if (parser.template[parser.index] === '*' && parser.template[parser.index + 1] === '/') {
parser.index += 2;
break;
}
parser.index++;
}
continue;
}

@@ -529,0 +544,0 @@ 

+10
-4
src/compiler/phases/3-transform/client/visitors/DebugTag.js

@@ -11,2 +11,6 @@ /** @import { Expression} from 'estree' */

export function DebugTag(node, context) {
const blockers = node.identifiers
.map((identifier) => context.state.scope.get(identifier.name)?.blocker)
.filter((blocker) => blocker != null);
const object = b.object(

@@ -24,7 +28,9 @@ node.identifiers.map((identifier) => {

const call = b.call('console.log', object);
const args = [b.thunk(b.block([b.stmt(b.call('console.log', object)), b.debugger]))];
context.state.init.push(
b.stmt(b.call('$.template_effect', b.thunk(b.block([b.stmt(call), b.debugger]))))
);
if (blockers.length > 0) {
args.push(b.array([]), b.array([]), b.array(blockers));
}
context.state.init.push(b.stmt(b.call('$.template_effect', ...args)));
}
+5
-1
src/compiler/phases/3-transform/server/visitors/Component.js

@@ -12,3 +12,7 @@ /** @import { Expression } from 'estree' */

export function Component(node, context) {
build_inline_component(node, /** @type {Expression} */ (context.visit(b.id(node.name))), context);
build_inline_component(
node,
/** @type {Expression} */ (context.visit(b.member_id(node.name))),
context
);
}
+21
-10
src/compiler/phases/3-transform/server/visitors/DebugTag.js

@@ -5,2 +5,3 @@ /** @import { Expression } from 'estree' */

import * as b from '#compiler/builders';
import { create_child_block } from './shared/utils.js';

@@ -12,15 +13,25 @@ /**

export function DebugTag(node, context) {
const blockers = node.identifiers
.map((identifier) => context.state.scope.get(identifier.name)?.blocker)
.filter((blocker) => blocker != null);
context.state.template.push(
b.stmt(
b.call(
'console.log',
b.object(
node.identifiers.map((identifier) =>
b.prop('init', identifier, /** @type {Expression} */ (context.visit(identifier)))
...create_child_block(
[
b.stmt(
b.call(
'console.log',
b.object(
node.identifiers.map((identifier) =>
b.prop('init', identifier, /** @type {Expression} */ (context.visit(identifier)))
)
)
)
)
)
),
b.debugger
),
b.debugger
],
b.array(blockers),
false
)
);
}
+2
-2
src/compiler/phase...ansform/server/visitors/shared/utils.js

@@ -15,3 +15,3 @@ /** @import { Expression, Identifier, Node, Statement, BlockStatement, ArrayExpression } from 'estree' */

import { regex_whitespaces_strict } from '../../../../patterns.js';
import { has_await_expression } from '../../../../../utils/ast.js';
import { has_await_expression, save } from '../../../../../utils/ast.js';
import { ExpressionMetadata } from '../../../../nodes.js';

@@ -364,3 +364,3 @@

b.array_pattern(this.expressions.map((_, i) => b.id(`$$${i}`))),
b.await(b.call('Promise.all', promises))
save(b.call('Promise.all', promises))
);

@@ -367,0 +367,0 @@ }

+2
-0
src/internal/client/dev/inspect.js

@@ -23,2 +23,4 @@ import { UNINITIALIZED } from '../../../constants.js';

eager_effect(() => {
error = UNINITIALIZED;
try {

@@ -25,0 +27,0 @@ var value = get_value();

+1
-5
src/internal/client/dom/blocks/async.js
/** @import { Blocker, TemplateNode, Value } from '#client' */
import { flatten, increment_pending } from '../../reactivity/async.js';
import { flatten } from '../../reactivity/async.js';
import { get } from '../../runtime.js';

@@ -45,4 +45,2 @@ import {

const decrement_pending = increment_pending();
if (was_hydrating) {

@@ -68,6 +66,4 @@ var previous_hydrate_node = hydrate_node;

}
decrement_pending();
}
});
}
+4
-5
src/internal/client/dom/blocks/boundary.js

@@ -38,3 +38,3 @@ /** @import { Effect, Source, TemplateNode, } from '#client' */

import { DEV } from 'esm-env';
import { Batch, current_batch, previous_batch, schedule_effect } from '../../reactivity/batch.js';
import { Batch, current_batch } from '../../reactivity/batch.js';
import { internal_set, source } from '../../reactivity/sources.js';

@@ -45,9 +45,8 @@ import { tag } from '../../dev/tracing.js';

import { defer_effect } from '../../reactivity/utils.js';
import { set_signal_status } from '../../reactivity/status.js';
/**
* @typedef {{
* onerror?: (error: unknown, reset: () => void) => void;
* failed?: (anchor: Node, error: () => unknown, reset: () => () => void) => void;
* pending?: (anchor: Node) => void;
* onerror?: ((error: unknown, reset: () => void) => void) | null;
* failed?: ((anchor: Node, error: () => unknown, reset: () => () => void) => void) | null;
* pending?: ((anchor: Node) => void) | null;
* }} BoundaryProps

@@ -54,0 +53,0 @@ */

+6
-5
src/internal/client/dom/blocks/svelte-head.js
/** @import { TemplateNode } from '#client' */
import { hydrate_node, hydrating, set_hydrate_node, set_hydrating } from '../hydration.js';
import { create_text, get_first_child, get_next_sibling } from '../operations.js';
import { block } from '../../reactivity/effects.js';
import { COMMENT_NODE, EFFECT_PRESERVED, HEAD_EFFECT } from '#client/constants';
import { block, branch } from '../../reactivity/effects.js';
import { COMMENT_NODE, HEAD_EFFECT } from '#client/constants';

@@ -52,5 +52,6 @@ /**

try {
// normally a branch is the child of a block and would have the EFFECT_PRESERVED flag,
// but since head blocks don't necessarily only have direct branch children we add it on the block itself
block(() => render_fn(anchor), HEAD_EFFECT | EFFECT_PRESERVED);
block(() => {
var e = branch(() => render_fn(anchor));
e.f |= HEAD_EFFECT;
});
} finally {

@@ -57,0 +58,0 @@ if (was_hydrating) {

+1
-1
src/internal/client/dom/elements/attributes.js

@@ -587,3 +587,3 @@ /** @import { Blocker, Effect } from '#client' */

// Stop at Element, from there on there's only unnecessary setters we're not interested in
// Do not use contructor.name here as that's unreliable in some browser environments
// Do not use constructor.name here as that's unreliable in some browser environments
while (element_proto !== proto) {

@@ -590,0 +590,0 @@ descriptors = get_descriptors(proto);

+1
-1
src/internal/client/dom/elements/bindings/this.js

@@ -43,3 +43,3 @@ /** @import { ComponentContext, Effect } from '#client' */

untrack(() => {
if (element_or_component !== get_value(...parts)) {
if (!is_bound_this(get_value(...parts), element_or_component)) {
update(element_or_component, ...parts);

@@ -46,0 +46,0 @@ // If this is an effect rerun (cause: each block context changes), then nullify the binding at

+2
-2
src/internal/client/dom/elements/events.js

@@ -240,5 +240,5 @@ import { teardown } from '../../reactivity/effects.js';

// This started because of Chromium issue https://chromestatus.com/feature/5128696823545856,
// where removal or moving of of the DOM can cause sync `blur` events to fire, which can cause logic
// where removal or moving of the DOM can cause sync `blur` events to fire, which can cause logic
// to run inside the current `active_reaction`, which isn't what we want at all. However, on reflection,
// it's probably best that all event handled by Svelte have this behaviour, as we don't really want
// it's probably best that all events handled by Svelte have this behaviour, as we don't really want
// an event handler to run in the context of another reaction or effect.

@@ -245,0 +245,0 @@ var previous_reaction = active_reaction;

+34
-16
src/internal/client/reactivity/async.js

@@ -58,2 +58,6 @@ /** @import { Blocker, Effect, Value } from '#client' */

function finish(values) {
if ((parent.f & DESTROYED) !== 0) {
return;
}
restore();

@@ -64,5 +68,3 @@

} catch (error) {
if ((parent.f & DESTROYED) === 0) {
invoke_error_boundary(error, parent);
}
invoke_error_boundary(error, parent);
}

@@ -73,10 +75,13 @@

var decrement_pending = increment_pending();
// Fast path: blockers but no async expressions
if (async.length === 0) {
/** @type {Promise<any>} */ (blocker_promise).then(() => finish(sync.map(d)));
/** @type {Promise<any>} */ (blocker_promise)
.then(() => finish(sync.map(d)))
.finally(decrement_pending);
return;
}
var decrement_pending = increment_pending();
// Full path: has async expressions

@@ -87,3 +92,3 @@ function run() {

.catch((error) => invoke_error_boundary(error, parent))
.finally(() => decrement_pending());
.finally(decrement_pending);
}

@@ -220,4 +225,5 @@

/** Whether the completion of the iterator was "normal", meaning it wasn't ended via `break` or a similar method */
let normal_completion = false;
// eslint-disable-next-line no-useless-assignment
let invoke_return = true;
try {

@@ -227,12 +233,24 @@ while (true) {

if (done) {
normal_completion = true;
invoke_return = false;
break;
}
var prev = reactivity_loss_tracker;
yield value;
try {
yield value;
} catch (e) {
set_reactivity_loss_tracker(prev);
// If the yield throws, we need to call `return` but not return its value, instead rethrow
if (iterator.return !== undefined) {
(await track_reactivity_loss(iterator.return()))();
}
throw e;
}
set_reactivity_loss_tracker(prev);
}
} catch (error) {
invoke_return = false;
throw error;
} finally {
// If the iterator had an abrupt completion and `return` is defined on the iterator, call it and return the value
if (!normal_completion && iterator.return !== undefined) {
// If the iterator had an abrupt completion (break) and `return` is defined on the iterator, call it and return the value
if (invoke_return && iterator.return !== undefined) {
// eslint-disable-next-line no-unsafe-finally

@@ -319,3 +337,3 @@ return /** @type {TReturn} */ ((await track_reactivity_loss(iterator.return()))().value);

.then(() => Promise.resolve())
.finally(() => decrement_pending());
.finally(decrement_pending);

@@ -344,6 +362,6 @@ return blockers;

return (skip = false) => {
return () => {
boundary.update_pending_count(-1, batch);
batch.decrement(blocking, effect, skip);
batch.decrement(blocking, effect);
};
}
+294
-127
src/internal/client/reactivity/batch.js

@@ -19,3 +19,4 @@ /** @import { Fork } from 'svelte' */

MANAGED_EFFECT,
REACTION_RAN
REACTION_RAN,
DESTROYING
} from '#client/constants';

@@ -37,3 +38,3 @@ import { async_mode_flag } from '../../flags/index.js';

import { flush_eager_effects, old_values, set_eager_effects, source, update } from './sources.js';
import { eager_effect, unlink_effect } from './effects.js';
import { eager_effect, teardown, unlink_effect } from './effects.js';
import { defer_effect } from './utils.js';

@@ -46,6 +47,9 @@ import { UNINITIALIZED } from '../../../constants.js';

/** @type {Set<Batch>} */
const batches = new Set();
/** @type {Batch | null} */
let first_batch = null;
/** @type {Batch | null} */
let last_batch = null;
/** @type {Batch | null} */
export let current_batch = null;

@@ -91,4 +95,6 @@

var flush_count = 0;
var source_stacks = DEV ? new Set() : null;
/** @type {Set<Value>} */
var source_stacks = new Set();
let uid = 1;

@@ -99,2 +105,16 @@

/** True as soon as `#process` was called */
#started = false;
linked = true;
/** @type {Batch | null} */
#prev = null;
/** @type {Batch | null} */
#next = null;
/** @type {Map<Effect, ReturnType<typeof deferred<any>>>} */
async_deriveds = new Map();
/**

@@ -116,2 +136,9 @@ * The current values of any signals that are updated in this batch.

/**
* Async effects which this batch doesn't take into account anymore when calculating blockers,
* as it has a value for it already.
* @type {Set<Effect>}
*/
unblocked = new Set();
/**
* When the batch is committed (and the DOM is updated), we need to remove old branches

@@ -136,6 +163,5 @@ * and append new ones by calling the functions added inside (if/each/key/etc) blocks

/**
* Async effects that are currently in flight
* @type {Map<Effect, number>}
* The number of async effects that are currently in flight
*/
#pending = new Map();
#pending = 0;

@@ -198,28 +224,21 @@ /**

/** @type {Set<Batch>} */
#blockers = new Set();
#is_deferred() {
return this.is_fork || this.#blocking_pending.size > 0;
}
if (this.is_fork) return true;
#is_blocked() {
for (const batch of this.#blockers) {
for (const effect of batch.#blocking_pending.keys()) {
var skipped = false;
var e = effect;
for (const effect of this.#blocking_pending.keys()) {
var e = effect;
var skipped = false;
while (e.parent !== null) {
if (this.#skipped_branches.has(e)) {
skipped = true;
break;
}
e = e.parent;
while (e.parent !== null) {
if (this.#skipped_branches.has(e)) {
skipped = true;
break;
}
if (!skipped) {
return true;
}
e = e.parent;
}
if (!skipped) {
return true;
}
}

@@ -266,7 +285,17 @@

#process() {
this.#started = true;
if (flush_count++ > 1000) {
batches.delete(this);
this.#unlink();
infinite_loop_guard();
}
if (DEV) {
// track all the values that were updated during this flush,
// so that they can be reset afterwards
for (const value of this.current.keys()) {
source_stacks.add(value);
}
}
// we only reschedule previously-deferred effects if we expect

@@ -326,3 +355,4 @@ // to be able to run them after processing the batch

if (this.#is_deferred() || this.#is_blocked()) {
// if the batch has outstanding pending work, stash effects and bail
if (this.#is_deferred()) {
this.#defer_effects(render_effects);

@@ -334,25 +364,48 @@ this.#defer_effects(effects);

}
} else {
if (this.#pending.size === 0) {
batches.delete(this);
if (updates.length > 0) {
/** @type {Batch} */ (/** @type {unknown} */ (current_batch)).#process();
}
// clear effects. Those that are still needed will be rescheduled through unskipping the skipped branches.
this.#dirty_effects.clear();
this.#maybe_dirty_effects.clear();
return;
}
// append/remove branches
for (const fn of this.#commit_callbacks) fn(this);
this.#commit_callbacks.clear();
const earlier_batch = this.#find_earlier_batch();
previous_batch = this;
flush_queued_effects(render_effects);
flush_queued_effects(effects);
previous_batch = null;
this.#deferred?.resolve();
if (earlier_batch) {
earlier_batch.#merge(this);
return;
}
// clear effects. Those that are still needed will be rescheduled through unskipping the skipped branches.
this.#dirty_effects.clear();
this.#maybe_dirty_effects.clear();
// append/remove branches
for (const fn of this.#commit_callbacks) fn(this);
this.#commit_callbacks.clear();
previous_batch = this;
flush_queued_effects(render_effects);
flush_queued_effects(effects);
previous_batch = null;
this.#deferred?.resolve();
var next_batch = /** @type {Batch | null} */ (/** @type {unknown} */ (current_batch));
if (this.linked && this.#pending === 0) {
this.#unlink();
}
// Order matters here - we need to commit and THEN continue flushing new batches, not the other way around,
// else we could start flushing a new batch and then, if it has pending work, rebase it right afterwards, which is wrong.
// In sync mode flushSync can cause #commit to wrongfully think that there needs to be a rebase, so we only do it in async mode
// TODO fix the underlying cause, otherwise this will likely regress when non-async mode is removed
if (async_mode_flag && !this.linked) {
this.#commit();
// Rebases can activate other batches or null it out, therefore restore the new one here
current_batch = next_batch;
}
// Edge case: During traversal new branches might create effects that run immediately and set state,

@@ -362,3 +415,8 @@ // causing an effect and therefore a root to be scheduled again. We need to traverse the current batch

if (this.#roots.length > 0) {
const batch = (next_batch ??= this);
if (next_batch === null) {
next_batch = this;
this.#link();
}
const batch = next_batch;
batch.#roots.push(...this.#roots.filter((r) => !batch.#roots.includes(r)));

@@ -368,18 +426,4 @@ }

if (next_batch !== null) {
batches.add(next_batch);
if (DEV) {
for (const source of this.current.keys()) {
/** @type {Set<Source>} */ (source_stacks).add(source);
}
}
next_batch.#process();
}
// In sync mode flushSync can cause #commit to wrongfully think that there needs to be a rebase, so we only do it in async mode
// TODO fix the underlying cause, otherwise this will likely regress when non-async mode is removed
if (async_mode_flag && !batches.has(this)) {
this.#commit();
}
}

@@ -439,3 +483,79 @@

#find_earlier_batch() {
var batch = this.#prev;
while (batch !== null) {
if (!batch.is_fork) {
// if the batches are connected, break
for (const [value, [, is_derived]] of this.current) {
if (batch.current.has(value) && !is_derived) {
return batch;
}
}
}
batch = batch.#prev;
}
return null;
}
/**
* @param {Batch} batch
*/
#merge(batch) {
for (const [source, value] of batch.current) {
if (!this.previous.has(source) && batch.previous.has(source)) {
this.previous.set(source, batch.previous.get(source));
}
this.current.set(source, value);
}
for (const [effect, deferred] of batch.async_deriveds) {
const d = this.async_deriveds.get(effect);
if (d) deferred.promise.then(d.resolve);
}
/**
* mark all effects that depend on `batch.current`, except the
* async effects that we just resolved (TODO unless they depend
* on values in this batch that are NOT in the later batch?).
* Through this we also will populate the correct #skipped_branches,
* oncommit callbacks etc, so we don't need to merge them separately.
* @param {Value} value
*/
const mark = (value) => {
var reactions = value.reactions;
if (reactions === null) return;
for (const reaction of reactions) {
var flags = reaction.f;
if ((flags & DERIVED) !== 0) {
mark(/** @type {Derived} */ (reaction));
} else {
var effect = /** @type {Effect} */ (reaction);
if (flags & (ASYNC | BLOCK_EFFECT) && !this.async_deriveds.has(effect)) {
this.#maybe_dirty_effects.delete(effect);
set_signal_status(effect, DIRTY);
this.schedule(effect);
}
}
}
};
for (const source of this.current.keys()) {
mark(source);
}
this.oncommit(() => batch.discard());
batch.#unlink();
current_batch = this;
this.#process();
}
/**
* @param {Effect[]} effects

@@ -482,5 +602,7 @@ */

flush() {
var source_stacks = DEV ? new Set() : null;
try {
if (DEV) {
source_stacks.clear();
}
try {
is_processing = true;

@@ -503,3 +625,3 @@ current_batch = this;

if (DEV) {
for (const source of /** @type {Set<Source>} */ (source_stacks)) {
for (const source of source_stacks) {
source.updated = null;

@@ -516,3 +638,3 @@ }

batches.delete(this);
this.#unlink();
}

@@ -528,2 +650,4 @@

#commit() {
this.#unlink();
// If there are other pending batches, they now need to be 'rebased' —

@@ -533,3 +657,3 @@ // in other words, we re-run block/async effects with the newly

// recent value for a given source
for (const batch of batches) {
for (let batch = first_batch; batch !== null; batch = batch.#next) {
var is_earlier = batch.id < this.id;

@@ -557,2 +681,13 @@

if (is_earlier) {
// TODO do we need to restart these in some cases, instead of
// immediately resolving them? Likely not because of how this.apply() works.
for (const [effect, deferred] of this.async_deriveds) {
const d = batch.async_deriveds.get(effect);
if (d) deferred.promise.then(d.resolve);
}
}
if (!batch.#started) continue;
// Re-run async/block effects that depend on distinct values changed in both batches

@@ -598,15 +733,19 @@ var others = [...batch.current.keys()].filter((s) => !this.current.has(s));

var current_unequal = [...batch.current.keys()].filter((c) =>
this.current.has(c) ? /** @type {[any, boolean]} */ (this.current.get(c))[0] !== c : true
this.current.has(c)
? /** @type {[any, boolean]} */ (this.current.get(c))[0] !== c.v
: true
);
for (const effect of this.#new_effects) {
if (
(effect.f & (DESTROYED | INERT | EAGER_EFFECT)) === 0 &&
depends_on(effect, current_unequal, checked)
) {
if ((effect.f & (ASYNC | BLOCK_EFFECT)) !== 0) {
set_signal_status(effect, DIRTY);
batch.schedule(effect);
} else {
batch.#dirty_effects.add(effect);
if (current_unequal.length > 0) {
for (const effect of this.#new_effects) {
if (
(effect.f & (DESTROYED | INERT | EAGER_EFFECT)) === 0 &&
depends_on(effect, current_unequal, checked)
) {
if ((effect.f & (ASYNC | BLOCK_EFFECT)) !== 0) {
set_signal_status(effect, DIRTY);
batch.schedule(effect);
} else {
batch.#dirty_effects.add(effect);
}
}

@@ -630,13 +769,2 @@ }

}
for (const batch of batches) {
if (batch.#blockers.has(this)) {
batch.#blockers.delete(this);
if (batch.#blockers.size === 0 && !batch.#is_deferred()) {
batch.activate();
batch.#process();
}
}
}
}

@@ -649,4 +777,3 @@

increment(blocking, effect) {
let pending_count = this.#pending.get(effect) ?? 0;
this.#pending.set(effect, pending_count + 1);
this.#pending += 1;

@@ -662,13 +789,6 @@ if (blocking) {

* @param {Effect} effect
* @param {boolean} skip - whether to skip updates (because this is triggered by a stale reaction)
*/
decrement(blocking, effect, skip) {
let pending_count = this.#pending.get(effect) ?? 0;
decrement(blocking, effect) {
this.#pending -= 1;
if (pending_count === 1) {
this.#pending.delete(effect);
} else {
this.#pending.set(effect, pending_count - 1);
}
if (blocking) {

@@ -684,3 +804,3 @@ let blocking_pending_count = this.#blocking_pending.get(effect) ?? 0;

if (this.#decrement_queued || skip) return;
if (this.#decrement_queued) return;
this.#decrement_queued = true;

@@ -690,3 +810,6 @@

this.#decrement_queued = false;
this.flush();
if (this.linked) {
this.flush();
}
});

@@ -739,16 +862,10 @@ }

const batch = (current_batch = new Batch());
batch.#link();
if (!is_processing) {
batches.add(current_batch);
if (!is_flushing_sync) {
queue_micro_task(() => {
if (current_batch !== batch) {
// a flushSync happened in the meantime
return;
}
if (!is_processing && !is_flushing_sync) {
queue_micro_task(() => {
if (!batch.#started) {
batch.flush();
});
}
}
});
}

@@ -761,3 +878,3 @@ }

apply() {
if (!async_mode_flag || (!this.is_fork && batches.size === 1)) {
if (!async_mode_flag || (!this.is_fork && this.#prev === null && this.#next === null)) {
batch_values = null;

@@ -774,24 +891,29 @@ return;

// ...and undo changes belonging to other batches unless they block this one
for (const batch of batches) {
// ...and undo changes belonging to other batches unless they intersect
for (let batch = first_batch; batch !== null; batch = batch.#next) {
if (batch === this || batch.is_fork) continue;
// A batch is blocked on an earlier batch if it overlaps with the earlier batch's changes but is not a superset
// If two batches intersect, the latter batch will be merged into the earlier batch,
// and we should treat them as a single set of changes
var intersects = false;
var differs = false;
if (batch.id < this.id) {
for (const [source, [, is_derived]] of batch.current) {
// Derived values don't partake in the blocking mechanism, because a derived could
// Derived values don't partake in the intersection mechanism, because a derived could
// be triggered in one batch already but not the other one yet, causing a false-positive
if (is_derived) continue;
intersects ||= this.current.has(source);
differs ||= !this.current.has(source);
if (this.current.has(source)) {
intersects = true;
break;
}
}
}
if (intersects && differs) {
this.#blockers.add(batch);
} else {
// Since the latter batch merges into the earlier (if it resolves before the earlier one),
// we treat the earlier values as "already applied". This way we don't need to rerun async
// effects of the earlier batch in case they are merged.
// As a result you can think of batch_values as having the latest values of all intersecting
// batches up until this batch.
if (!intersects) {
for (const [source, previous] of batch.previous) {

@@ -862,2 +984,32 @@ if (!batch_values.has(source)) {

}
#link() {
if (last_batch === null) {
first_batch = last_batch = this;
} else {
last_batch.#next = this;
this.#prev = last_batch;
}
last_batch = this;
}
#unlink() {
var prev = this.#prev;
var next = this.#next;
if (prev === null) {
first_batch = next;
} else {
prev.#next = next;
}
if (next === null) {
last_batch = prev;
} else {
next.#prev = prev;
}
this.linked = false;
}
}

@@ -1116,2 +1268,5 @@

/** @type {Map<Reaction, Source<number>>} */
var version_map = new Map();
/**

@@ -1124,6 +1279,18 @@ * Implementation of `$state.eager(fn())`

export function eager(fn) {
var version = source(0);
var initial = true;
var value = /** @type {T} */ (undefined);
if (active_reaction === null) {
return fn();
}
let parent = active_reaction;
let version = version_map.get(parent) ?? source(0);
version_map.set(parent, version);
teardown(() => {
if (parent.f & DESTROYING) version_map.delete(parent);
});
get(version);

@@ -1248,3 +1415,3 @@

if (!batches.has(batch)) {
if (!batch.linked) {
e.fork_discarded();

@@ -1295,3 +1462,3 @@ }

if (!committed && batches.has(batch)) {
if (!committed && batch.linked) {
batch.discard();

@@ -1307,3 +1474,3 @@ }

export function clear() {
batches.clear();
first_batch = last_batch = null;
}
+30
-29
src/internal/client/reactivity/deriveds.js

@@ -46,3 +46,3 @@ /** @import { Derived, Effect, Reaction, Source, Value } from '#client' */

import { UNINITIALIZED } from '../../../constants.js';
import { batch_values, current_batch } from './batch.js';
import { batch_values, current_batch, previous_batch } from './batch.js';
import { increment_pending, unset_context } from './async.js';

@@ -104,2 +104,4 @@ import { deferred, includes, noop } from '../../shared/utils.js';

export const OBSOLETE = Symbol('obsolete');
/**

@@ -123,3 +125,3 @@ * @template V

if (DEV) signal.label = label;
if (DEV) signal.label = label ?? fn.toString();

@@ -129,4 +131,4 @@ // only suspend in async deriveds created on initialisation

/** @type {Map<Batch, ReturnType<typeof deferred<V>>>} */
var deferreds = new Map();
/** @type {Set<ReturnType<typeof deferred<V>>>} */
var deferreds = new Set();

@@ -148,3 +150,9 @@ async_effect(() => {

// We call `unset_context` to undo any `save` calls that happen inside `fn()`
Promise.resolve(fn()).then(d.resolve, d.reject).finally(unset_context);
Promise.resolve(fn())
.then(d.resolve, (e) => {
// if the promise was rejected by the user, via `getAbortSignal`, then
// wait for a subsequent resolution instead of flushing the batch
if (e !== STALE_REACTION) d.reject(e);
})
.finally(unset_context);
} catch (error) {

@@ -188,4 +196,3 @@ d.reject(error);

if (/** @type {Boundary} */ (parent.b).is_rendered()) {
deferreds.get(batch)?.reject(STALE_REACTION);
deferreds.delete(batch); // delete to ensure correct order in Map iteration below
batch.async_deriveds.get(effect)?.reject(OBSOLETE);
} else {

@@ -195,8 +202,8 @@ // While the boundary is still showing pending, a new run supersedes all older in-flight runs

for (const d of deferreds.values()) {
d.reject(STALE_REACTION);
d.reject(OBSOLETE);
}
deferreds.clear();
}
deferreds.set(batch, d);
deferreds.add(d);
batch.async_deriveds.set(effect, d);
}

@@ -213,12 +220,6 @@

if (decrement_pending) {
// don't trigger an update if we're only here because
// the promise was superseded before it could resolve
var skip = error === STALE_REACTION;
decrement_pending(skip);
}
decrement_pending?.();
deferreds.delete(d);
if (error === STALE_REACTION || (effect.f & DESTROYED) !== 0) {
return;
}
if (error === OBSOLETE) return;

@@ -239,9 +240,2 @@ batch.activate();

// All prior async derived runs are now stale
for (const [b, d] of deferreds) {
deferreds.delete(b);
if (b === batch) break;
d.reject(STALE_REACTION);
}
if (DEV && location !== undefined) {

@@ -251,3 +245,3 @@ recent_async_deriveds.add(signal);

setTimeout(() => {
if (recent_async_deriveds.has(signal)) {
if (recent_async_deriveds.has(signal) && (effect.f & DESTROYED) === 0) {
w.await_waterfall(/** @type {string} */ (signal.label), location);

@@ -267,4 +261,4 @@ recent_async_deriveds.delete(signal);

teardown(() => {
for (const d of deferreds.values()) {
d.reject(STALE_REACTION);
for (const d of deferreds) {
d.reject(OBSOLETE);
}

@@ -413,3 +407,10 @@ });

if (current_batch !== null) {
// We also write to previous_batch because if it exists, it is a sign that we're
// currently in the process of flushing effects. These updates to deriveds may belong
// to the previous batch, not the new one (which can already exist if an earlier
// effect wrote to a source). This can cause bugs when running batch.#commit() later,
// but not adding it to current_batch can, too, so we add it to both.
// See https://github.com/sveltejs/svelte/pull/18117 for more details.
current_batch.capture(derived, value, true);
previous_batch?.capture(derived, value, true);
} else {

@@ -416,0 +417,0 @@ derived.v = value;

+1
-9
src/internal/client/reactivity/effects.js

@@ -46,3 +46,3 @@ /** @import { Blocker, ComponentContext, ComponentContextLegacy, Derived, Effect, TemplateNode, TransitionManager } from '#client' */

import { Batch, collected_effects, current_batch } from './batch.js';
import { flatten, increment_pending } from './async.js';
import { flatten } from './async.js';
import { without_reactive_context } from '../dom/elements/bindings/shared.js';

@@ -400,12 +400,4 @@ import { set_signal_status } from './status.js';

export function deferred_template_effect(fn, sync = [], async = [], blockers = []) {
if (async.length > 0 || blockers.length > 0) {
var decrement_pending = increment_pending();
}
flatten(blockers, sync, async, (values) => {
create_effect(EFFECT, () => fn(...values.map(get)));
if (decrement_pending) {
decrement_pending();
}
});

@@ -412,0 +404,0 @@ }

+7
-1
src/internal/client/reactivity/props.js

@@ -1,2 +0,2 @@

/** @import { Effect, Source } from './types.js' */
/** @import { Derived, Effect, Source } from './types.js' */
import { DEV } from 'esm-env';

@@ -286,4 +286,10 @@ import {

var fallback_dirty = true;
var fallback_signal = /** @type {Derived<V> | undefined} */ (undefined);
var get_fallback = () => {
if (lazy && runes) {
fallback_signal ??= derived(/** @type {() => V} */ (fallback));
return get(fallback_signal);
}
if (fallback_dirty) {

@@ -290,0 +296,0 @@ fallback_dirty = false;

+19
-9
src/internal/client/reactivity/sources.js

@@ -50,3 +50,3 @@ /** @import { Derived, Effect, Source, Value } from '#client' */

/** @type {Set<any>} */
/** @type {Set<Effect>} */
export let eager_effects = new Set();

@@ -276,3 +276,14 @@

if (is_dirty(effect)) {
let dirty;
try {
dirty = is_dirty(effect);
} catch {
// Dirty-checking can evaluate derived dependencies and throw in cases where
// parent effects are about to destroy this eager effect. Run the effect so
// its own error handling can deal with transient failures.
dirty = true;
}
if (dirty) {
update_effect(effect);

@@ -343,8 +354,2 @@ }

// Inspect effects need to run immediately, so that the stack trace makes sense
if (DEV && (flags & EAGER_EFFECT) !== 0) {
eager_effects.add(reaction);
continue;
}
var not_dirty = (flags & DIRTY) === 0;

@@ -357,3 +362,8 @@

if ((flags & DERIVED) !== 0) {
if ((flags & EAGER_EFFECT) !== 0) {
// Eager effects need to run immediately:
// - for $inspect so that the stack trace makes sense
// - for $state.eager because they might be without an effect parent
eager_effects.add(/** @type {Effect} */ (reaction));
} else if ((flags & DERIVED) !== 0) {
var derived = /** @type {Derived} */ (reaction);

@@ -360,0 +370,0 @@ 

+6
-1
src/internal/server/renderer.js

@@ -718,4 +718,9 @@ /** @import { Component } from 'svelte' */

set_ssr_context(context);
let transformed = await transformError(error);
let promise = transformError(error);
set_ssr_context(null);
let transformed = await promise;
set_ssr_context(context);
// Render the failed snippet instead of the partial children content

@@ -722,0 +727,0 @@ const failed_renderer = new Renderer(item.global, item);

+1
-1
src/version.js

@@ -7,3 +7,3 @@ // generated during release, do not modify

*/
export const VERSION = '5.55.5';
export const VERSION = '5.55.6';
export const PUBLIC_VERSION = '5';
+1
-1
types/index.d.ts.map

@@ -276,4 +276,4 @@ {

],
"mappings": "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",
"mappings": "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",
"ignoreList": []
}
compiler/index.js

Sorry, the diff of this file is too big to display

elements.d.ts

Sorry, the diff of this file is too big to display

types/index.d.ts

Sorry, the diff of this file is too big to display