11194 Commits (145a5cc20491adf1f9e635caccf32c294f28aa00)

 

All Branches   

Search

Author	SHA1	Message	Date
Rich Harris	145a5cc204	shrink comment (the AI agent habit of referring to the behaviour of the code it just deleted is somewhat unhelpful)	4 months ago
Rich Harris	45b12df4ac	rename methods to make phases more explicit	4 months ago
Mathias Picker	1ea3389f04	chore: reword changeset to reflect bug-fix framing ... The refactor closes a 5-year-old correctness bug (#6733), not just a perf optimization. Update the changeset entry to match. Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com>	4 months ago
Mathias Picker	103646e0f0	perf: batch FLIP animation reads and writes ... Split the per-item `fix()` step in the keyed `{#each}` animation manager into three phases (`fix_size` reads only, `fix_position` writes only, `fix_transform` reads the post-absolute rect and applies a compensating transform). The caller in each.js runs three batched loops instead of one combined loop, which cuts forced synchronous reflows from ~2N down to ~2 per destroy batch. The visual result is unchanged: `transform = from - to` lands the element at its captured `from` position regardless of when `to` is measured. Measured ~+42% in real Chromium on a 45-item animate:flip destroy. All 6006 runtime tests still pass. Co-Authored-By: Claude Opus 4.7 (1M context) <noreply@anthropic.com>	4 months ago
Simon H	65283bc13a	fix: transfer effects when merging batches (#18254) ... An effect could be gated behind a branch. If we don't defer + transfer them upon merge, the branch would still be marked clean but the effect behind it is dirty but no longer reachable. It's not reachable via mark either because that one only concerns itself with block/async effects, and the branch gating the effect is not guaranteed to be touched by that. Fixes #18249 Little sad side-effect: Since we cannot reliably know _before_ traversal if we have no blocking pending work left (the traversal could mark an if block falsy which contains the last blocker), we gotta undo a performance optimization.	4 months ago
github-actions[bot]	b65a3f3fc5	Version Packages (#18240) ... This PR was opened by the [Changesets release](https://github.com/changesets/action) GitHub action. When you're ready to do a release, you can merge this and the packages will be published to npm automatically. If you're not ready to do a release yet, that's fine, whenever you add more changesets to main, this PR will be updated. # Releases ## svelte@5.55.9 ### Patch Changes - fix: don't unset batch when calling `{#await ...}` promise ([#18243](https://github.com/sveltejs/svelte/pull/18243)) - fix: promise-ify `{#await await ...}` expressions on the server and correctly hydrate them on the client ([#18243](https://github.com/sveltejs/svelte/pull/18243)) - fix: deduplicate dependencies that are added outside the init/update cycle ([#18243](https://github.com/sveltejs/svelte/pull/18243)) - fix: avoid false-positive batch invariant error ([#18246](https://github.com/sveltejs/svelte/pull/18246)) - fix: inline primitive constants in attribute values during SSR ([#18232](https://github.com/sveltejs/svelte/pull/18232)) Co-authored-by: github-actions[bot] <41898282+github-actions[bot]@users.noreply.github.com>	4 months ago
Simon H	ef319ed492	chore: bump acorn-typescript/esrap (#18248)	4 months ago
Simon H	d654db83ef	fix: avoid false-positive batch invariant error (#18246) ... Thanks to https://github.com/sveltejs/svelte/issues/17940#issuecomment-4480016550 I was finally able to isolate and reproduce a false-positive invariant error. I had a hunch this could happen and this shows it. Essentially, you can end up in situations where two batches are scheduled to run in the same microtask queue flush, and if the first rebases the second the invariant will throw, which is wrong. We can avoid this by checking if a decrement is queued.	4 months ago
Simon H	000c594e05	fix: `{#await await ...}` and async dependencies fixes (#18243) ... This started out as an investigation to get rid of the runtime code for `{#await ...}` that deactivated a batch prior to reading the promise function. That can result in a new batch being created if the promise invocation happens to write a source. Through that I discovered two other bugs: 1. The way we handle `{#await await ...}` was flawed around SSR/hydration: On the server it would await the expression (which it should not; `{#await await ...}` is kind of a weird special case here) and during hydration it did not produce matching nodes, leading to hydration fails. 2. When reading a dependency after an await expression which we add to the current reaction, we did not deduplicate those reads. That can lead to duplicate dependencies, which in turn can lead to bugs when `remove_reaction` later runs. Conside this: You have `deps = [count, unrelated, count]`. Now you do `remove_reactions(deps, 1)`, i.e. "remove all reactions after the first one". That means the "disconnect these from each other" logic runs for `count`, too, because it's also in the third position, but that is wrong because it is also in the first position, i.e. the connection should be kept. --------- Co-authored-by: Rich Harris <rich.harris@vercel.com>	4 months ago
Kiwi	be8ffeb2a4	docs(contributing): fix grammar in Prioritization section (#18241) ... Small typo in `CONTRIBUTING.md` — "the most important and active ones repositories" reads like a leftover from an edit. Removed the dangling "ones". ```diff -PRs to the most important and active ones repositories get reviewed more quickly +PRs to the most important and active repositories get reviewed more quickly ```	4 months ago
Mukunda Rao Katta	a63bf862c0	docs: clarify context state getter pattern (#18226) ... Closes #18022 This updates the context docs to show the getter pattern for state that may be reassigned, such as primitive state. The new example passes a function through context so children read the current value instead of capturing the initial value. This is a docs-only clarification and does not change runtime behavior. Validation: - `git diff --check` - `pnpm exec prettier --check documentation/docs/06-runtime/02-context.md` Full `pnpm test`/`pnpm lint` were not run because this only changes documentation. --------- Co-authored-by: Rich Harris <hello@rich-harris.dev>	4 months ago
Sean Kenneth Doherty	a5df6616ea	fix: avoid unnecessary stringify in server attributes (#18232) ... ### Before submitting the PR, please make sure you do the following - [x] It's really useful if your PR references an issue where it is discussed ahead of time. Fixes #10031. - [x] Prefix your PR title with `feat:`, `fix:`, `chore:`, or `docs:`. - [x] This message body should clearly illustrate what problems it solves. - [x] Ideally, include a test that fails without this PR but passes with it. - [x] If this PR changes code within `packages/svelte/src`, add a changeset (`npx changeset`). ### What this changes Server attribute template generation currently wraps each dynamic expression in `$.stringify`, even when the compiler can prove the expression is a string or a known constant. This reuses the existing scope evaluation metadata so server output can avoid `$.stringify` for proven string/constant chunks while keeping it for possibly nullish unknown values. The updated snapshot covers a mixed attribute with a known string, mutable state, `null`, numeric/undefined constants, a known string-producing `typeof`, and an unknown prop value. ### Tests and linting - [x] `pnpm test snapshot -t nullish-coallescence-omittance` - [x] `pnpm test snapshot` - [x] `pnpm --filter svelte check` - [x] `pnpm lint` - [x] `pnpm prettier --check .changeset/slow-bikes-serve.md` --------- Co-authored-by: Rich Harris <hello@rich-harris.dev>	4 months ago
github-actions[bot]	f9440dc3ed	Version Packages (#18239) ... This PR was opened by the [Changesets release](https://github.com/changesets/action) GitHub action. When you're ready to do a release, you can merge this and the packages will be published to npm automatically. If you're not ready to do a release yet, that's fine, whenever you add more changesets to main, this PR will be updated. # Releases ## svelte@5.55.8 ### Patch Changes - fix(print): handle `svelte:body` and fix keyframe percentage double-printing ([#18234](https://github.com/sveltejs/svelte/pull/18234)) - fix: execute uninitialized derived even if it's destroyed ([#18228](https://github.com/sveltejs/svelte/pull/18228)) - fix: use named symbols everywhere ([#18238](https://github.com/sveltejs/svelte/pull/18238)) - fix: don't run teardown effects when deriveds are unfreezed ([#18227](https://github.com/sveltejs/svelte/pull/18227)) - fix: unset context synchronously in `run` ([#18236](https://github.com/sveltejs/svelte/pull/18236)) Co-authored-by: github-actions[bot] <41898282+github-actions[bot]@users.noreply.github.com>	4 months ago
OfirHaf	ca3f35bf7d	fix(print): handle svelte:body and fix keyframe percentage double-printing (#18234) ... Fixes #18206 and fixes #18207 — both are printer bugs in `packages/svelte/src/compiler/print/index.js`. ## Changes ### Fix 1: `svelte:body` crashes the printer (#18206) `SvelteBody` was missing from the visitor map, causing a crash with `Error: Not implemented: SvelteBody`. Added the handler (same one-liner pattern as `SvelteDocument`, `SvelteHead`, etc.) and added `SvelteBody` to the `is_block_element` check so whitespace is handled consistently. ### Fix 2: Keyframe percent stops print as `0%%` (#18207) `Percentage.value` already includes the `%` sign (captured by `/\d+(\.\d+)?%/y`), but the printer was writing `` `${node.value}%` `` — appending a second `%`. Changed to `context.write(node.value)` to match the `Nth` printer pattern directly above it. Also updated the existing `style` snapshot which had `50%%` (the bug was silently baked in), and added dedicated test samples for both fixes.	4 months ago
Rich Harris	2bc3592eb1	fix: use named symbols everywhere (#18238) ... This isn't _really_ a fix since these should never surface to the user, but it's useful for debugging when they do, as in https://github.com/sveltejs/kit/pull/15779. Instead of seeing `Symbol()` we see e.g. `Symbol(uninitialized)` which makes it easier to understand where a bug is coming from.	4 months ago
Simon H	dc1f037fa6	fix: don't run teardown effects when deriveds are unfreezed (#18227) ... The logic was flawed - a teardown effect only has a teardown function but not `fn` property, but unfreeze thought that everything with a `teardown` needs to be unfreezed Helps with #18221 (though likely doesn't fix it completely, at least not the more general `batch.#roots`problems)	4 months ago
Simon H	1e899cba35	fix: execute uninitialized derived even if it's destroyed (#18228) ... Turns out there are a few unavoidable cases where we have to execute the derived even if we otherwise wouldn't, because of its lazy nature. Fixes #18139	4 months ago
Simon H	eb10a70cf1	fix: unset context synchronously in `run` (#18236) ... Our `run` function which executes top level awaits (and synchronous statements in-between/after) did not unset the context in time in case the function returns an async value. In that case the context was still around until the that promise resolves, which can be too late because unrelated things can be intertwined with the batch. The test shows this: Without the fix, the unrelated count incrementation would not update the view until the top level awaits in the child are done. In the test this just shows as a delayed visual update, but it also can result in stale roots as shown in https://github.com/sveltejs/svelte/issues/18221#issuecomment-4470921077	4 months ago
github-actions[bot]	4d8f99a270	Version Packages (#18220) ... This PR was opened by the [Changesets release](https://github.com/changesets/action) GitHub action. When you're ready to do a release, you can merge this and the packages will be published to npm automatically. If you're not ready to do a release yet, that's fine, whenever you add more changesets to main, this PR will be updated. # Releases ## svelte@5.55.7 ### Patch Changes - fix: prevent XSS on `hydratable` from user contents ([`a16ebc67bbcf8f708360195687e1b2719463e1a4`](a16ebc67bb)) - chore: bump devalue ([#18219](https://github.com/sveltejs/svelte/pull/18219)) - fix: disallow empty attribute names during SSR ([`547853e2406a2147ad7fb5ffeba95b01bd9642da`](547853e240)) - fix: harden regex ([`d2375e2ebcab5c88feb5652f1a9d621b8f06b259`](d2375e2ebc)) - fix: move Svelte runtime properties to symbols ([`e1cbbd96441e82c9eb8a23a2903c0d06d3cda991`](e1cbbd9644)) Co-authored-by: github-actions[bot] <41898282+github-actions[bot]@users.noreply.github.com>	4 months ago
Rich Harris	0552308817	chore: bump devalue (#18219)	4 months ago
Elliott Johnson	e1cbbd9644	Merge commit from fork ... * fix: move Svelte runtime properties to symbols Prevents DOM clobbering * shorten names --------- Co-authored-by: Simon Holthausen <simon.holthausen@vercel.com>	4 months ago
Elliott Johnson	a16ebc67bb	Merge commit from fork ... https://github.com/sveltejs/svelte/security/advisories/GHSA-f3cj-j4f6-wq85 Co-authored-by: Simon Holthausen <simon.holthausen@vercel.com>	4 months ago
Simon H	d2375e2ebc	Merge commit from fork	4 months ago
Simon H	547853e240	Merge commit from fork ... * fix: disallow empty attribute names during SSR * Update packages/svelte/tests/server-side-rendering/samples/spread-attributes-event-handler-xss/main.svelte Co-authored-by: Conduitry <git@chor.date> --------- Co-authored-by: Elliott Johnson <hello@ell.iott.dev> Co-authored-by: Conduitry <git@chor.date>	4 months ago
github-actions[bot]	55f9c85c09	Version Packages (#18158) ... This PR was opened by the [Changesets release](https://github.com/changesets/action) GitHub action. When you're ready to do a release, you can merge this and the packages will be published to npm automatically. If you're not ready to do a release yet, that's fine, whenever you add more changesets to main, this PR will be updated. # Releases ## svelte@5.55.6 ### Patch Changes - fix: leave stale promises to wait for a later resolution, instead of rejecting ([#18180](https://github.com/sveltejs/svelte/pull/18180)) - fix: keep dependencies of `$state.eager/pending` ([#18218](https://github.com/sveltejs/svelte/pull/18218)) - fix: reapply context after transforming error during SSR ([#18099](https://github.com/sveltejs/svelte/pull/18099)) - fix: don't rebase just-created batches ([#18117](https://github.com/sveltejs/svelte/pull/18117)) - chore: allow `null` for `pending` in typings ([#18201](https://github.com/sveltejs/svelte/pull/18201)) - fix: flush eager effects in production ([#18107](https://github.com/sveltejs/svelte/pull/18107)) - fix: rethrow error of failed iterable after calling `return()` ([#18169](https://github.com/sveltejs/svelte/pull/18169)) - fix: account for proxified instance when updating `bind:this` ([#18147](https://github.com/sveltejs/svelte/pull/18147)) - fix: ensure scheduled batch is flushed if not obsolete ([#18131](https://github.com/sveltejs/svelte/pull/18131)) - fix: resolve stale deriveds with latest value ([#18167](https://github.com/sveltejs/svelte/pull/18167)) - chore: remove unnecessary `increment_pending` calls ([#18183](https://github.com/sveltejs/svelte/pull/18183)) - fix: correctly compile component member expressions for SSR ([#18192](https://github.com/sveltejs/svelte/pull/18192)) - fix: reset `source.updated` stack traces after `flush` ([#18196](https://github.com/sveltejs/svelte/pull/18196)) - fix: replacing async 'blocking' strategy with 'merging' ([#18205](https://github.com/sveltejs/svelte/pull/18205)) - fix: allow `@debug` tags to reference awaited variables ([#18138](https://github.com/sveltejs/svelte/pull/18138)) - fix: re-run fallback props if dependencies update ([#18146](https://github.com/sveltejs/svelte/pull/18146)) - fix: abort running obsolete async branches ([#18118](https://github.com/sveltejs/svelte/pull/18118)) - fix: ignore comments when reading CSS values ([#18153](https://github.com/sveltejs/svelte/pull/18153)) - fix: wrap `Promise.all` in `save` during SSR ([#18178](https://github.com/sveltejs/svelte/pull/18178)) - fix: ignore false-positive errors of `$inspect` dependencies ([#18106](https://github.com/sveltejs/svelte/pull/18106)) Co-authored-by: github-actions[bot] <41898282+github-actions[bot]@users.noreply.github.com>	4 months ago
Rich Harris	a10e8e47a5	fix: keep dependencies of `$state.eager`/`pending` (alternative approach) (#18218) ... #18108, with two differences: - we use a global map - we use the parent reaction as the key, rather than traversing upwards for a branch I think this has the same outcome? ### Before submitting the PR, please make sure you do the following - [x] It's really useful if your PR references an issue where it is discussed ahead of time. In many cases, features are absent for a reason. For large changes, please create an RFC: https://github.com/sveltejs/rfcs - [x] Prefix your PR title with `feat:`, `fix:`, `chore:`, or `docs:`. - [x] This message body should clearly illustrate what problems it solves. - [x] Ideally, include a test that fails without this PR but passes with it. - [x] If this PR changes code within `packages/svelte/src`, add a changeset (`npx changeset`). ### Tests and linting - [x] Run the tests with `pnpm test` and lint the project with `pnpm lint` --------- Co-authored-by: Simon Holthausen <simon.holthausen@vercel.com> Co-authored-by: Simon H <5968653+dummdidumm@users.noreply.github.com>	4 months ago
quyentonndbs	ef4b97dfab	fix: duplicated "of" in events.js comment (#18217) ... One-line typo fix in `packages/svelte/src/internal/client/dom/elements/events.js`: "removal or moving of of the DOM" → "removal or moving of the DOM". No code/behavior change. --------- Co-authored-by: Kai Tanaka <275430420+quyentonndbs@users.noreply.github.com> Co-authored-by: Rich Harris <hello@rich-harris.dev>	4 months ago
Rich Harris	5122936edb	fix: treat batches as a linked list (#18205) ... This is another attempt to address some of the tricky edge cases that arise when async batches resolve out of order. The idea is this: Essentially, when a batch resolves: 1. we find the latest batch it shares changes with 2. if none exists (either because this is the earliest batch, or because it is independent of any earlier batches): - we commit it: effects are flushed, `oncommit` callbacks are run - we restart any async work in later batches that depends on both the committed values and the later batch's changes 3. otherwise, we don't commit the batch. instead: - we merge the changes from the later batch onto the earlier batch. in some cases this may mean restarting async work on the earlier batch, but we avoid doing so unnecessarily. - we then `#process()` the earlier batch. if it resolves, goto 1 This feels like it ought to work. There are still two failing tests, which I'm currently looking into. Notable changes: - Instead of having a `batches` set, we have a linked list. When a batch resolves, this makes it easy to find the batch that it should be merged into - The `#is_deferred` logic now takes account of skipped effects — there's no need to wait for a promise inside a falsy `if` block (this accounts for the change in the `async-inner-after-outer` test) - We no longer care about `#blockers` I would like to believe that this approach will allow us to simplify and delete some code, for example the `rebase` logic, though that remains to be seen. It also feels like some version of #18035 would be helpful. - closes #18189 - closes #18162 - fixes https://github.com/sveltejs/kit/issues/15431 ### Before submitting the PR, please make sure you do the following - [x] It's really useful if your PR references an issue where it is discussed ahead of time. In many cases, features are absent for a reason. For large changes, please create an RFC: https://github.com/sveltejs/rfcs - [x] Prefix your PR title with `feat:`, `fix:`, `chore:`, or `docs:`. - [x] This message body should clearly illustrate what problems it solves. - [x] Ideally, include a test that fails without this PR but passes with it. - [x] If this PR changes code within `packages/svelte/src`, add a changeset (`npx changeset`). ### Tests and linting - [x] Run the tests with `pnpm test` and lint the project with `pnpm lint` --------- Co-authored-by: Simon H <5968653+dummdidumm@users.noreply.github.com> Co-authored-by: Simon Holthausen <simon.holthausen@vercel.com>	4 months ago
Simon H	1688c84be9	chore: allow `null` for `pending` in typings (#18201) ... Closes #18166 We handle all falsy values at runtime already and for basically every other dom attribute also allow `null`, so no reason not to do this.	4 months ago
Rich Harris	af5b9724ab	chore: flatten `#process()` (#18190) ... Realised that we can make the logic in `#process()` a little easier to follow by early-returning if a batch is deferred (or blocked) after processing, since nothing that happens after the `if` block applies in that case	4 months ago
Rich Harris	9ffc13d7c3	fix: remove `source.updated` stack traces after `flush` (#18196) ... Noticed that we're not actually doing anything with `source_stacks` — we shadow the module-level declaration in `flush`, which means we just keep appending to it and then clearing a different (and empty) set. As a result, any source that ever gets an `updated` property never gets rid of it. This probably causes a memory leak? Anyway, this fixes it. ### Before submitting the PR, please make sure you do the following - [ ] It's really useful if your PR references an issue where it is discussed ahead of time. In many cases, features are absent for a reason. For large changes, please create an RFC: https://github.com/sveltejs/rfcs - [x] Prefix your PR title with `feat:`, `fix:`, `chore:`, or `docs:`. - [x] This message body should clearly illustrate what problems it solves. - [ ] Ideally, include a test that fails without this PR but passes with it. - [x] If this PR changes code within `packages/svelte/src`, add a changeset (`npx changeset`). ### Tests and linting - [x] Run the tests with `pnpm test` and lint the project with `pnpm lint`	4 months ago
Simon H	e00944ffd1	fix: correctly compile component member expressions for SSR (#18192) ... Fixes #18191	4 months ago
Rich Harris	9950b22869	fix: process batches created in effect and immediately flushed (#18194) ... no changeset because the bug this fixes hasn't been released	4 months ago
Simon H	fcaa8ce723	fix: reapply new batch after `#commit` (#18186) ... Fixes a regression of #18170 (not released yet therefore no changeset). `current_batch` is nulled out if the `#commit` rebases other branches, and that can lead to nullpointers down the line. No test right now but it's part of getting the failing SvelteKit test passing.	4 months ago
Rich Harris	908c9d0312	fix: leave stale promises to wait for a later resolution, instead of rejecting (#18180) ... This incorporates some of the fixes and insights from #18177, but gets rid of the `skip` logic. Instead, we differentiate between _stale_ and _obsolete_ promises. A promise is stale if it has been overtaken by a subsequent update, and was rejected with `STALE_REACTION`: ```ts async function search(query: string) { return fetch(`/search?q=${query}`, { signal: getAbortSignal() }).then((r) => r.json()); } ``` In this case, if we start typing `pot`, and then finish typing `potato`, the first promise will eventually resolve with the results for `/search?q=potato`, instead of the batch entering a weird limbo/zombie state. A promise is obsolete if it belongs to a now-destroyed effect, meaning that toggling `show` doesn't result in an accumulation of never-resolving batches: ```svelte {#if show} {await neverResolves()} {/if} ``` Fixes part of https://github.com/sveltejs/kit/issues/15431 --------- Co-authored-by: Simon Holthausen <simon.holthausen@vercel.com> Co-authored-by: Simon H <5968653+dummdidumm@users.noreply.github.com>	4 months ago
Rich Harris	4d2b6c61e0	chore: make `batch.#pending` a number rather than a map (#18184) ... there's no reason for this to be a map	4 months ago
Simon H	1c150a460f	fix: abort running obsolete async branches (#18118) ... We shouldn't continue executing async work where we know the surrounding branch is destroyed already, it can leave to noisy "derived inter" warnings or even runtime errors ("cannot stringify symbol" when running a template effect with an uninitialized source). Neither should we warn about waterfalls on an already-destroyed async effect. Fixes #18097 (though strictly speaking that particular instance is also fixed by #18117 which fixes the underlying cause for the reruns; this one is necessary in itself though, as shown by the new test) --------- Co-authored-by: Rich Harris <rich.harris@vercel.com>	4 months ago
Rich Harris	91e1ead773	chore: remove unnecessary `increment_pending` calls (#18183) ... These might have been necessary at one point, but I'm confident they're unnecessary now — `increment_pending` happens (if necessary) inside `flatten`, which is called inside `async` and `deferred_template_effect`, so there's no need to call it inside those functions as well.	4 months ago
Simon H	aeb6bd088b	fix: reapply context after transforming error during SSR (#18099) ... Don't have a test for it and no bug report but I stumbled upon this and I'm very certain not restoring context here is wrong since it means the failed snippet rendering gets the wrong context. --------- Co-authored-by: Rich Harris <rich.harris@vercel.com>	4 months ago
Simon H	5e054574db	fix: don't override new current_batch (#18170) ... This is a regression from #18117 - we moved `this.#commit()` higher up but that means that `current_batch` could be nulled out / overridden through `batch.activate/deactivate` / blocker runs inside `#commit()`. Therefore restore the previous value afterwards. No changest because #18117 is not released yet. Fixes the other part of the failing SvelteKit `query.live` test. --------- Co-authored-by: Rich Harris <rich.harris@vercel.com>	4 months ago
Simon H	d4c5a91735	fix: rethrow error of failed iterable after calling `return()` (#18169) ... The fix in #17966 wasn't quite right, because we gotta rethrow in case the iterator stopped because of an error. Fixes part of the SvelteKit `query.live` test failure. --------- Co-authored-by: vercel[bot] <35613825+vercel[bot]@users.noreply.github.com> Co-authored-by: Rich Harris <rich.harris@vercel.com>	4 months ago
Paolo Ricciuti	89b6a939fe	fix: wrap `Promise.all` in `save` during SSR (#18178) ... Closes #18168 Not sure if there's a deeper issue in play because the error it's only really there if you also add a title to the component. I think the issue is that with multiple arguments the top level `Promise.all` is not wrapped in `save` and that probably causes a race condition with `title` that sets the context back to `null` in a `finally`. One issue is that now the generated code looks like this ```js const [$$0, $$1] = (await $.save(Promise.all([ (async () => (await $.save(user()))().name)(), (async () => (await $.save(user()))().image)() ])))(); ``` which seems a bit redundant, but I'm not sure if we can get rid of the inner `save` since they are indeed awaiting something.	4 months ago
Rich Harris	dc5bd887b5	fix: resolve stale deriveds with latest value (#18167) ... While looking into #18162 I found an adjacent bug. Currently, if an async derived resolves in batch 2 before it resolves in batch 1, we reject the promise belonging to batch 1 and by extension the batch itself. This means that any other changes in batch 1 are silently discarded, incorrectly. The fix is almost comically simple: rather than rejecting the earlier promise, we just resolve it with the latest value. I have a hunch that this might also enable us to simplify the rebase logic, though I haven't investigated that in this PR. ### Before submitting the PR, please make sure you do the following - [x] It's really useful if your PR references an issue where it is discussed ahead of time. In many cases, features are absent for a reason. For large changes, please create an RFC: https://github.com/sveltejs/rfcs - [x] Prefix your PR title with `feat:`, `fix:`, `chore:`, or `docs:`. - [x] This message body should clearly illustrate what problems it solves. - [x] Ideally, include a test that fails without this PR but passes with it. - [x] If this PR changes code within `packages/svelte/src`, add a changeset (`npx changeset`). ### Tests and linting - [x] Run the tests with `pnpm test` and lint the project with `pnpm lint`	4 months ago
Rich Harris	e65025be58	docs: fix testing docs (#18163) ... extracted from https://github.com/sveltejs/svelte.dev/pull/1959	4 months ago
Simon H	572444a696	fix: ignore false-positive errors of `$inspect` dependencies (#18106) ... We had logic in place to ignore errors of `$inspect` effects that are about to destroy, but we didn't take into account that we can get these transient errors while checking for `is_dirty` in preparation for running the effect, too. Now effects are marked as dirty in case an error occurs while evaluating their dependencies, which guarantees we will see the error again but we can then handle it properly. Fixes #15741 --------- Co-authored-by: Rich Harris <rich.harris@vercel.com>	4 months ago
Simon H	90a70cb012	fix: flush eager effects in production (#18107) ... While working on #18106 I noticed that we're not adding eager effects inside `mark_reactions` when `DEV` is `false`. As a result production build could have `$state.eager` or `$state.pending` not working correctly. ~No test because I can't get Vitest to not run with `DEV` being `true`.~ added a test	4 months ago
Simon H	9521b9f3dc	fix: don't rebase just-created batches (#18117) ... It's possible to rebase just-created batches. Case A: - batch A runs effects - one of these effects writes to a source. This creates a new batch B - an effect _after_ that (still part of "flush effects of batch A") executes a derived. This creates an entry in the `current` Map in batch B - batch A commits after processing batch B (`next_batch` etc logic), batch B is pending. Due to derived being part of batchB.current batch A can wrongfully think these are connected and try to rerun/add effects etc on batch B Case B: - like case A but with an additional await inside a pending snippet Case C: - batch A with source a and b, it flushes effects - one of these effects schedules batch B with b and c scheduling an async effect - batch B is deferred - batch A commits. Due to the a/b/c partial overlap it will needlessly rerun the just scheduled async effect All these cases are wrong. We fix it like this: 1. we call `this.#commit()` _before_ running the new batches, which may stick around due to having pending work, and we don't want to rebase these. This fixes case A and C 2. we capture derived values in `previous_batch` if it exists, because it means we're currently flushing effects, and derived writes belong to that batch and not a new one that might have been scheduled already. This fixes case B Discovered this while working on #18097 --------- Co-authored-by: Rich Harris <rich.harris@vercel.com>	4 months ago
Rohan Santhosh Kumar	7719a74eef	chore: fix constructor typo in attributes comment (#18115) ... ## Summary - Fix the `constructor` typo in the attributes comment. ## Related issue - N/A ## Guideline alignment - Read `CONTRIBUTING.md` and kept this to one focused text-only file change. - No behavior, test, fixture, changeset, or generated-file changes. ## Test plan - `git diff --check` - Not run: comment-only change. Co-authored-by: Codex <codex@openai.com>	4 months ago
Eduardo Kurek	146cb5ea6c	fix: lazy props reactivity (#18146) ... Fix #18132 This PR treat lazy fallbacks on `prop()` as derived. Now a default function that uses a $state is recalculated whenever its dependents changes. This change implies that this lazy functions cannot mutate a state anymore (because it is derived), causing a `state_unsafe_mutation`error. This implies on a breaking change, but reasonable. --- ### New breaking change here - **Who does this affect**: Everyone that has updated a $state on a default lazy prop. Example: ```html <script> let myValue = $state(0); let callCount = $state(0); function getValue() { callCount++; // causes a state_unsafe_mutation error return myValue; // returning a state doesn't cause an error, and now it is tracked as a dependency } let { value = getValue() } = $props(); </script> ``` **Why make this breaking change** This encourages people to not update states on a function that fundamentaly, is readonly. When someone wants to use a default function expecting that it should be tracked, its not likely that this function will change some state. It is anti-pattern to change some state inside a getter function. But what if someone wants to do it, like in the code above? The code above doesn't make sense before this PR, the old way to calculate lazy functions is to execute it one time, and only one, so the `callCount` variable will never change. But let's assume that someone did it, how to migrate? The migration in same example is easy, since the `callCount` is executed only once, it will not be executed after the component is mounted. So the `callCount` doesn't need to be a state, the `callCount` will be in a valid state when the component is created. So here is the migrated code: ```html <script> let myValue = $state(0); let callCount = 0; function getValue() { callCount++; // doesn't causes an error return myValue; } let { value = getValue() } = $props(); </script> ``` As we can see, there is no reason for the variable `callCount` in this example (before this PR), and if someone did it, it is more likely that they used a constant instead: ```html <script> let myValue = $state(0); let callCount = 1; function getValue() { return myValue; } let { value = getValue() } = $props(); </script> ``` There is another example that causes the `state_unsafe_mutation` and how to fix (this happened on the tests that i changed): ```html <script> let log = $state([]); function fallbackExample => { log.push('fallback called'); return 1; // any value, just to show the issue with the log } let { value = fallbackExample() } = $props(); </script> ``` Here, we can see that `log` variable is a state. Before this PR, as i said, this function `fallbackExample` will be executed once. So the logs will be computed when the component is mounted. So there is no reason to make the `log` a state. The simplest way to fix this is to make it a normal variable: ```html <script> let log = []; </script> ``` But with this PR, the function might be recalculated at some point, and the `log` with a state makes sense now, so how to migrate in this case? As i said, changing a state inside a lazy prop function is not a good practice, we can think in a way to invert this dependency, and change the approach from push (imperative mutation) to pull (declarative derivation). If a developer really needs to track how many times a fallback is executed or react to its changes, they should use a $derived or an $effect that observes the same dependencies as the fallback, or simply observe the property itself: ```html <script> let { value = fallbackExample() } = $props(); let log = $state([]); $effect(() => { const message = `${value}`; untrack(() => { // we don't want to track changes on the log variable log.push(message); }); }); </script> ``` ### After all, how to migrate? 1. **If there is no state mutation inside the prop function, no need to changes**; 2. **If there is a state mutation inside the prop function, but the value muted is declared inside the same component:** remove the state from it. Before this PR the method will be executed only once, and to get the same result, you do not need the variable to be a state; **Before** ```html <script> let log = $state([]); const fallback_fn = () => { log.push('fallback_fn'); return 1; } const { myProp = fallback_fn() } = $props(); </script> ``` **After** ```html <script> let log = []; const fallback_fn = () => { log.push('fallback_fn'); return 1; } const { myProp = fallback_fn() } = $props(); </script> ``` 3. **If there is a state mutation inside the prop function, and the value is read in multiple places:** change your approach, use a effect to detect the change on the prop, and apply your mutation inside the effect; Before: ```html <script> import { setLog } from './logs.js'; // setLog apply a mutation on a state const fallback_fn = () => { setLog('fallback_fn'); return 1; } const { myProp = fallback_fn() } = $props(); </script> ``` After ```html <script> import { setLog } from './logs.js'; // setLog apply a mutation on a state const fallback_fn = () => { return 1; } const { myProp = fallback_fn() } = $props(); $effect(() => { const message = `${myProp}`; untrack(() => { setLog(message); }); }); </script> ``` ### Severity (number of people affected x effort): Low - **Affected Users:** Minimal. Mutating state inside a property initializer is a rare edge case and considered an anti-pattern (because its a side effect inside a getter). Most users use constants or pure functions for fallbacks. - **Migration Effort:** Low. As demonstrated in the examples above, the fix usually involves either removing an unnecessary $state or moving the side effect to its proper place, the $effect ### Conclusion This PR encourages users to program in a better way. Forcing a clean separation between data and their side effects. The developer can use this new feature mainly in i18n services, providing better usability and experience. Also, this PR makes the properties more predictable, since the expected behavior is that it works reactively, eliminating this bug for future developers. Even though this PR adds a breaking change, it's easily solvable, and the chance of any user facing this problem is low. **Full example to test reactivity in props** (won't work on web, you can get the PR and test localy to see it working): https://svelte.dev/playground/a6608434d8c642179f0e2b72468c74d7?version=latest *A unit test for this reactivity was created: runtime-runes/props-default-value-reactivity*. --------- Co-authored-by: Rich Harris <rich.harris@vercel.com> Co-authored-by: Rich Harris <hello@rich-harris.dev>	4 months ago
Simon H	bc82a55647	fix: ensure scheduled batch is flushed if not obsolete (#18131) ... The logic of checking that the current batch is still the generated one is flawed. If microtasks align the current batch can be a different value even if the batch still need to be flushed. This therefore switches the heuristic to what it actually should express: "has this batch run already?" Fixes #18126 (because the batch isn't running, it later runs into the invariant)	4 months ago