@tschk/moonshine-svelte 0.0.0-stage → 0.4.49

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.
package/package.json CHANGED
@@ -1,6 +1,59 @@
1
1
  {
2
2
  "name": "@tschk/moonshine-svelte",
3
- "version": "0.0.0-stage",
4
- "stub": true,
5
- "description": "Temporary package placeholder for staged publishing"
6
- }
3
+ "version": "0.4.49",
4
+ "description": "Independent Svelte store and native lifecycle APIs with Moonshine signal bridges",
5
+ "license": "ISC",
6
+ "type": "module",
7
+ "main": "./src/index.ts",
8
+ "types": "./src/index.ts",
9
+ "exports": {
10
+ ".": "./src/index.ts",
11
+ "./svelte": "./src/svelte.ts",
12
+ "./store": "./src/store.ts",
13
+ "./runes": "./src/runes.ts",
14
+ "./binding": "./src/binding.ts",
15
+ "./class": "./src/class.ts",
16
+ "./ssr": "./src/ssr.ts",
17
+ "./pre": "./src/pre.ts",
18
+ "./directives": "./src/directives.ts",
19
+ "./await": "./src/await.ts",
20
+ "./store-binding": "./src/store-binding.ts",
21
+ "./raw-snippet": "./src/raw-snippet.ts",
22
+ "./raw-snippet-dom": "./src/raw-snippet-dom.ts",
23
+ "./raw-snippet-ssr": "./src/raw-snippet-ssr.ts",
24
+ "./each": "./src/each.ts",
25
+ "./mount": "./src/mount.ts",
26
+ "./server-mount": "./src/server-mount.ts",
27
+ "./const": "./src/const-derived.ts"
28
+ },
29
+ "dependencies": {
30
+ "@tschk/moonshine": "^0.4.48",
31
+ "@tschk/moonshine-dom": "^0.4.48"
32
+ },
33
+ "devDependencies": {
34
+ "typescript": "7.0.2"
35
+ },
36
+ "peerDependencies": {
37
+ "@tschk/moonshine-framework": "^0.4.48"
38
+ },
39
+ "peerDependenciesMeta": {
40
+ "@tschk/moonshine-framework": {
41
+ "optional": true
42
+ }
43
+ },
44
+ "files": [
45
+ "src",
46
+ "README.md"
47
+ ],
48
+ "keywords": [
49
+ "moonshine",
50
+ "svelte",
51
+ "adapter"
52
+ ],
53
+ "scripts": {
54
+ "format": "bunx prettier --check .",
55
+ "lint": "bunx oxlint .",
56
+ "typecheck": "bunx tsc --noEmit",
57
+ "test": "bun test"
58
+ }
59
+ }
package/src/await.ts ADDED
@@ -0,0 +1,123 @@
1
+ /** Independent await-block control; no async SSR, hydration, or transitions. */
2
+ import {
3
+ createComponentScope,
4
+ createRenderEffect,
5
+ createSignal,
6
+ getOwner,
7
+ getRenderScheduler,
8
+ onCleanup,
9
+ runWithOwner,
10
+ untrack,
11
+ type Accessor,
12
+ } from "@tschk/moonshine-dom/reactive";
13
+ import { mapArray } from "@tschk/moonshine-dom/control";
14
+ import { isSSRRendering } from "@tschk/moonshine-dom/ssr-owner";
15
+ import { peekComponentContext } from "@tschk/moonshine-dom/component";
16
+ import { flushRuneWork } from "./pre";
17
+ /** Compiler-facing awaited source type; erased from runtime output. */
18
+ export type AwaitValue<Read extends () => unknown> = Awaited<ReturnType<Read>>;
19
+ export type AwaitInput<T> = T | PromiseLike<T>;
20
+ export type AwaitBranches<T, R> = {
21
+ pending?: () => R;
22
+ then?: (value: Accessor<T>) => R;
23
+ catch?: (error: Accessor<unknown>) => R;
24
+ };
25
+ function promise(value: unknown): value is PromiseLike<unknown> {
26
+ return (
27
+ value != null &&
28
+ (typeof value === "object" || typeof value === "function") &&
29
+ typeof (value as PromiseLike<unknown>).then === "function"
30
+ );
31
+ }
32
+ export function awaitBlock<T, R>(
33
+ read: () => T | PromiseLike<T>,
34
+ branches: AwaitBranches<T, R>,
35
+ schedule?: (read: () => (R | undefined)[]) => Accessor<(R | undefined)[]>,
36
+ ): Accessor<(R | undefined)[]> {
37
+ if (isSSRRendering() || peekComponentContext()?.mode === "ssr") {
38
+ const input = read();
39
+ let child: R | undefined;
40
+ if (promise(input)) {
41
+ input.then(null, () => {});
42
+ child = branches.pending?.();
43
+ } else child = branches.then?.(() => input);
44
+ const result = child === undefined ? [] : [child];
45
+ return () => result;
46
+ }
47
+ const outer = getOwner();
48
+ if (!outer || outer.disposed || !getRenderScheduler())
49
+ throw Error("Await blocks require a live owner and withRuneScheduler");
50
+ return createComponentScope(() => {
51
+ const owner = getOwner()!;
52
+ let starting = true;
53
+ let generation = 0,
54
+ disposed = false;
55
+ const [state, setState] = createSignal<
56
+ "pending" | "then" | "catch" | undefined
57
+ >(undefined);
58
+ const [value, setValue] = createSignal<T | undefined>(undefined),
59
+ [error, setError] = createSignal<unknown>(undefined);
60
+ onCleanup(() => {
61
+ disposed = true;
62
+ generation++;
63
+ });
64
+ function alive(token: number) {
65
+ return !disposed && !owner.disposed && generation === token;
66
+ }
67
+ createRenderEffect(() => {
68
+ const token = ++generation;
69
+ const input = read();
70
+ if (!promise(input)) {
71
+ setValue(() => input);
72
+ setState("then");
73
+ return;
74
+ }
75
+ let settled = false;
76
+ const publish = (kind: "then" | "catch", next: unknown) => {
77
+ if (!alive(token)) return;
78
+ settled = true;
79
+ try {
80
+ runWithOwner(owner, () =>
81
+ untrack(() => {
82
+ if (kind === "then") setValue(() => next as T);
83
+ else setError(() => next);
84
+ setState(kind);
85
+ if (!starting) flushRuneWork();
86
+ }),
87
+ );
88
+ } catch (failure) {
89
+ queueMicrotask(() => {
90
+ throw failure;
91
+ });
92
+ }
93
+ };
94
+ input.then(
95
+ (next) => publish("then", next),
96
+ (reason) => publish("catch", reason),
97
+ );
98
+ queueMicrotask(() => {
99
+ if (!settled && alive(token))
100
+ runWithOwner(owner, () => {
101
+ setState("pending");
102
+ flushRuneWork();
103
+ });
104
+ });
105
+ });
106
+ const view = mapArray(
107
+ () => {
108
+ const current = state();
109
+ return current === undefined ? [] : [current];
110
+ },
111
+ (kind) => {
112
+ if (kind === "pending") return branches.pending?.();
113
+ if (kind === "then") return branches.then?.(value as Accessor<T>);
114
+ if (!branches.catch) throw untrack(error);
115
+ return branches.catch(error);
116
+ },
117
+ undefined,
118
+ schedule,
119
+ );
120
+ starting = false;
121
+ return view;
122
+ });
123
+ }
package/src/binding.ts ADDED
@@ -0,0 +1,116 @@
1
+ /** Native binding helpers with Svelte state-proxy identity comparison. */
2
+ import {
3
+ bindSelectValue as nativeBindSelectValue,
4
+ bindValue as nativeBindValue,
5
+ type InputValue,
6
+ createInputGroup as nativeCreateInputGroup,
7
+ } from "@tschk/moonshine-dom/binding";
8
+ import { stateEquals } from "./state";
9
+ import {
10
+ createComponentScope,
11
+ getOwner,
12
+ getRenderScheduler,
13
+ } from "@tschk/moonshine-dom/reactive";
14
+ import {
15
+ bindOwnedReference,
16
+ type ComponentReference,
17
+ type OwnedReference,
18
+ } from "@tschk/moonshine-dom/component-instance";
19
+ import { captureRuneReferenceCleanup } from "./pre";
20
+ export {
21
+ bindChecked,
22
+ bindFiles,
23
+ bindOpen,
24
+ setOptionValue,
25
+ setInputValue,
26
+ type InputValue,
27
+ } from "@tschk/moonshine-dom/binding";
28
+
29
+ export function bindSelectValue(
30
+ select: HTMLSelectElement,
31
+ read: () => unknown,
32
+ write: (value: unknown) => void,
33
+ ): void {
34
+ nativeBindSelectValue(select, read, write, stateEquals);
35
+ }
36
+
37
+ export function createInputGroup(
38
+ kind: "radio" | "checkbox" | "mixed",
39
+ read: () => unknown,
40
+ write: (value: unknown) => void,
41
+ ): { bind(input: HTMLInputElement, watch?: () => unknown): void } {
42
+ return nativeCreateInputGroup(kind, read, write, stateEquals);
43
+ }
44
+
45
+ /** Svelte numeric bindings write null for an empty number/range input. */
46
+ export function bindValue(
47
+ element: HTMLInputElement | HTMLTextAreaElement,
48
+ read: () => InputValue,
49
+ write: (value: string | number | null) => void,
50
+ ): void {
51
+ nativeBindValue(element, read, (value, reset) => {
52
+ write(
53
+ value === undefined
54
+ ? reset && element.defaultValue !== ""
55
+ ? Number(element.defaultValue)
56
+ : null
57
+ : value,
58
+ );
59
+ });
60
+ }
61
+
62
+ /** Compiler-owned element references publish before this element's actions. */
63
+ export function bindThis<
64
+ T extends Element,
65
+ Parts extends readonly unknown[] = [],
66
+ >(element: T, reference: ComponentReference<T, Parts, unknown>): void {
67
+ const owner = getOwner();
68
+ if (!owner || owner.disposed || owner.disposing)
69
+ throw new Error("Element references require a live native owner");
70
+ if (
71
+ !(element instanceof Element) ||
72
+ !reference ||
73
+ typeof reference.get !== "function" ||
74
+ typeof reference.set !== "function"
75
+ )
76
+ throw new TypeError(
77
+ "Element references require an element and getter/setter functions",
78
+ );
79
+ if (reference.cleanup !== undefined && reference.cleanup !== "commit")
80
+ throw new TypeError(
81
+ "Element reference cleanup must be commit when provided",
82
+ );
83
+ if (reference.publication !== undefined && reference.publication !== "post")
84
+ throw new TypeError(
85
+ "Element reference publication must be post when provided",
86
+ );
87
+ const scheduler = getRenderScheduler();
88
+ if (!scheduler)
89
+ throw new Error("Element references require an opt-in render scheduler");
90
+ const enqueueClear = captureRuneReferenceCleanup();
91
+ createComponentScope(() =>
92
+ scheduler.branch(() => {
93
+ const scope = getOwner()!;
94
+ const posts = getRenderScheduler()!;
95
+ let published = false;
96
+ let firstPublication: (() => void) | undefined;
97
+ bindOwnedReference(
98
+ scope,
99
+ element,
100
+ // Tuple callbacks enter the checked internal path protocol here.
101
+ reference as unknown as OwnedReference<T>,
102
+ (publish) => {
103
+ if (published) publish();
104
+ else
105
+ posts.post(
106
+ (firstPublication ??= () => {
107
+ published = true;
108
+ publish();
109
+ }),
110
+ );
111
+ },
112
+ { cleanup: "commit", previousCheck: "after-set", enqueueClear },
113
+ )();
114
+ }),
115
+ );
116
+ }
package/src/class.ts ADDED
@@ -0,0 +1,78 @@
1
+ /** Normalize source class expressions; ordinary native h attributes stay unchanged. */
2
+ export function classValue(value: unknown): string | undefined {
3
+ if (value === null || value === undefined) return undefined;
4
+ if (typeof value !== "object") return `${value}` || undefined;
5
+ const tokens: string[] = [];
6
+ function append(entry: unknown): void {
7
+ if (!entry) return;
8
+ if (typeof entry === "string" || typeof entry === "number") {
9
+ tokens.push(`${entry}`);
10
+ } else if (Array.isArray(entry)) {
11
+ const length = entry.length;
12
+ for (let index = 0; index < length; index++) append(entry[index]);
13
+ } else if (typeof entry === "object") {
14
+ // Enumerable inherited class flags are part of Svelte's class expression API.
15
+ for (const key in entry)
16
+ if ((entry as Record<string, unknown>)[key]) tokens.push(key);
17
+ }
18
+ }
19
+ append(value);
20
+ return tokens.join(" ") || undefined;
21
+ }
22
+
23
+ function isClassWhitespace(code: number): boolean {
24
+ return (
25
+ code === 0x20 ||
26
+ (code >= 0x09 && code <= 0x0d) ||
27
+ code === 0xa0 ||
28
+ code === 0xfeff
29
+ );
30
+ }
31
+
32
+ /** Host-free class directive application over a classValue-normalized base. */
33
+ export function classDirectives(
34
+ value: unknown,
35
+ hash: string | null | undefined,
36
+ directives: Readonly<Record<string, unknown>>,
37
+ ): string | undefined {
38
+ const names = Object.keys(directives);
39
+ for (const name of names) {
40
+ let blank = true;
41
+ for (let index = 0; index < name.length; index++) {
42
+ if (!isClassWhitespace(name.charCodeAt(index))) {
43
+ blank = false;
44
+ break;
45
+ }
46
+ }
47
+ if (blank) {
48
+ throw new TypeError(
49
+ `Class directive name must contain a non-whitespace character: ${JSON.stringify(name)}`,
50
+ );
51
+ }
52
+ }
53
+ let result = classValue(value) ?? "";
54
+ if (hash) result = result ? `${result} ${hash}` : hash;
55
+ for (const name of names) {
56
+ if (directives[name]) {
57
+ result = result ? `${result} ${name}` : name;
58
+ continue;
59
+ }
60
+ const width = name.length;
61
+ let from = 0;
62
+ while (result.length > 0) {
63
+ const start = result.indexOf(name, from);
64
+ if (start < 0) break;
65
+ const end = start + width;
66
+ if (
67
+ (start === 0 || isClassWhitespace(result.charCodeAt(start - 1))) &&
68
+ (end === result.length || isClassWhitespace(result.charCodeAt(end)))
69
+ ) {
70
+ // The delimiter after the removed token is consumed with it.
71
+ result = result.slice(0, start) + result.slice(end + 1);
72
+ } else {
73
+ from = end;
74
+ }
75
+ }
76
+ }
77
+ return result || undefined;
78
+ }
@@ -0,0 +1,47 @@
1
+ /** Compiler-owned const evaluation with per-evaluation cleanup and consumer context. */
2
+ import { createDerived } from "./derived";
3
+ import { getRuneConsumer } from "./pre";
4
+ import { isHistoryReading } from "./history";
5
+ import {
6
+ withComponentConsumer,
7
+ withComponentCleanupConsumer,
8
+ } from "@tschk/moonshine-dom/component";
9
+ import {
10
+ createRoot,
11
+ getOwner,
12
+ onCleanup,
13
+ runWithOwner,
14
+ type Owner,
15
+ } from "@tschk/moonshine-dom/reactive";
16
+ export function createConstDerived<T>(fn: () => T): { readonly value: T } {
17
+ const frame = getRuneConsumer();
18
+ const parent = getOwner();
19
+ if (!parent || parent.disposed || !frame || frame.owner.disposed)
20
+ throw Error("Const requires a live consumer");
21
+ let stop: (() => void) | undefined;
22
+ const release = () => {
23
+ const previous = stop;
24
+ stop = undefined;
25
+ previous?.();
26
+ };
27
+ onCleanup(release);
28
+ return createDerived(() => {
29
+ if (isHistoryReading()) return withComponentCleanupConsumer(frame, fn);
30
+ release();
31
+ let evaluation!: Owner;
32
+ createRoot((dispose) => {
33
+ stop = dispose;
34
+ evaluation = getOwner()!;
35
+ });
36
+ try {
37
+ return runWithOwner(evaluation, () => withComponentConsumer(frame, fn));
38
+ } catch (error) {
39
+ try {
40
+ release();
41
+ } catch {
42
+ /* Preserve the computation failure after disposing owned work. */
43
+ }
44
+ throw error;
45
+ }
46
+ });
47
+ }
package/src/derived.ts ADDED
@@ -0,0 +1,276 @@
1
+ /** Lazy native derived values with writable optimistic overrides. */
2
+ import { createMemo, createSignal, untrack } from "@tschk/moonshine";
3
+ import {
4
+ collectDeps,
5
+ subscribeInvalidation,
6
+ trackDependency,
7
+ hasValueDemand,
8
+ type Trackable,
9
+ } from "@tschk/moonshine/tracking";
10
+ import {
11
+ getOwner,
12
+ onCleanup,
13
+ runWithOwner,
14
+ } from "@tschk/moonshine-dom/reactive";
15
+
16
+ import {
17
+ collectHistoryReads,
18
+ hasHistory,
19
+ historicalValue,
20
+ isHistoryReading,
21
+ readHistory,
22
+ recordHistory,
23
+ trackHistoryRead,
24
+ withHistoryCleanup,
25
+ withHistoryMutation,
26
+ type HistoryRead,
27
+ } from "./history";
28
+
29
+ export function createDerived<T>(fn: () => T): {
30
+ get value(): T;
31
+ set value(value: T);
32
+ } {
33
+ const owner = getOwner();
34
+ if (owner?.disposed)
35
+ throw new Error("Cannot create a derived value in a disposed owner");
36
+ const invalidation = createSignal(0);
37
+ const token = {};
38
+ let reads: HistoryRead[] = [];
39
+ let baseValue!: T;
40
+ type Snapshot = { value: T } | undefined;
41
+ function snapshot(): Snapshot {
42
+ return overridden
43
+ ? { value: override }
44
+ : returned
45
+ ? { value: last }
46
+ : undefined;
47
+ }
48
+ let initialized = false,
49
+ overridden = false,
50
+ disposed = false,
51
+ returned = false,
52
+ overrideInvalidated = false;
53
+ let inputRevision = 0;
54
+ let memoDependency: Trackable | undefined;
55
+ let overrideVersions = new Map<Trackable, number>();
56
+ let override!: T, last!: T;
57
+ let subscriptions = new Map<Trackable, () => void>();
58
+ function invalidate(): void {
59
+ if (disposed) return;
60
+ // Invalidating a committed override restores the previous computed inputs.
61
+ // A same-flush assignment already recorded its earlier value, which wins.
62
+ if (overridden) recordHistory(token, "override", undefined, undefined);
63
+ overrideInvalidated = true;
64
+ inputRevision++;
65
+ }
66
+ // Preserve the kernel dependency graph for pull validation and diamond updates.
67
+ // Side observers mark input changes without turning observation into value demand.
68
+ // Only a changed base computation resets an optimistic override.
69
+ const base = createMemo(() => {
70
+ let next!: T,
71
+ failed = false,
72
+ failure: unknown;
73
+ const versions = new Map<Trackable, number>();
74
+ const dependencies = collectDeps(
75
+ () => {
76
+ try {
77
+ const collected = collectHistoryReads(() => runWithOwner(owner, fn));
78
+ next = collected.value;
79
+ reads = collected.reads;
80
+ } catch (error) {
81
+ failed = true;
82
+ failure = error;
83
+ }
84
+ },
85
+ (dependency) => versions.set(dependency, dependency.version),
86
+ true,
87
+ );
88
+ const nextSubscriptions = new Map<Trackable, () => void>();
89
+ try {
90
+ untrack(() => {
91
+ for (const dependency of dependencies)
92
+ nextSubscriptions.set(
93
+ dependency,
94
+ subscriptions.get(dependency) ??
95
+ subscribeInvalidation(dependency, {
96
+ demand: false,
97
+ invalidate,
98
+ notify() {
99
+ if (!disposed) invalidation.set((previous) => previous + 1);
100
+ },
101
+ }),
102
+ );
103
+ for (const [dependency, unsubscribe] of subscriptions)
104
+ if (!nextSubscriptions.has(dependency)) unsubscribe();
105
+ });
106
+ } catch (error) {
107
+ for (const [dependency, unsubscribe] of nextSubscriptions)
108
+ if (!subscriptions.has(dependency)) unsubscribe();
109
+ if (!failed) failure = error;
110
+ failed = true;
111
+ }
112
+ subscriptions = nextSubscriptions;
113
+ if (failed) throw failure;
114
+ if (
115
+ dependencies.some(
116
+ (dependency) => dependency.version !== versions.get(dependency),
117
+ )
118
+ )
119
+ throw new Error("Derived computations must not write their dependencies");
120
+ // Pull validation can run before this dependency's queued notification.
121
+ // Reset here too so optimistic siblings cannot expose a stale override.
122
+ if (initialized) {
123
+ if (hasHistory(reads))
124
+ recordHistory(token, "override", undefined, undefined);
125
+ overridden = false;
126
+ }
127
+ initialized = true;
128
+ baseValue = next;
129
+ return next;
130
+ });
131
+ let baseDependency: Parameters<typeof trackDependency>[0] | undefined;
132
+ const baseView: Parameters<typeof trackDependency>[0] = {
133
+ get version() {
134
+ return inputRevision;
135
+ },
136
+ validate() {},
137
+ subscribe: (
138
+ ...args: Parameters<Parameters<typeof trackDependency>[0]["subscribe"]>
139
+ ) => baseDependency!.subscribe(...args),
140
+ };
141
+ const memo = createMemo(() => {
142
+ invalidation();
143
+ let computed!: T;
144
+ if (overridden && initialized && !overrideInvalidated && baseDependency) {
145
+ computed = override;
146
+ } else if (baseDependency) computed = untrack(base);
147
+ else {
148
+ const dependencies = collectDeps(() => {
149
+ computed = base();
150
+ });
151
+ baseDependency = dependencies[0] as Parameters<typeof trackDependency>[0];
152
+ }
153
+ trackDependency(baseView);
154
+ overrideInvalidated = false;
155
+ last = overridden ? override : computed;
156
+ returned = true;
157
+ return last;
158
+ });
159
+ if (owner)
160
+ onCleanup(() => {
161
+ disposed = true;
162
+ for (const unsubscribe of subscriptions.values()) untrack(unsubscribe);
163
+ subscriptions.clear();
164
+ });
165
+ let frozenFailure = false,
166
+ frozenError: unknown;
167
+ return {
168
+ get value() {
169
+ trackHistoryRead(token, "override");
170
+ for (const read of reads) trackHistoryRead(read.target, read.key);
171
+ if (isHistoryReading())
172
+ return historicalValue(token, () =>
173
+ untrack(() => {
174
+ let recorded = true;
175
+ const previous = readHistory<Snapshot>(token, "override", () => {
176
+ recorded = false;
177
+ return undefined;
178
+ });
179
+ if (previous) return previous.value;
180
+ if (initialized && !hasHistory(reads))
181
+ return !recorded && overridden ? override : baseValue;
182
+ return runWithOwner(owner, () => withHistoryCleanup(fn));
183
+ }),
184
+ );
185
+ if (disposed) {
186
+ if (frozenFailure) throw frozenError;
187
+ if (returned) return last;
188
+ if (overridden) return override;
189
+ // A never-read value may finish once after its owner has stopped, without
190
+ // reconnecting the disposed memo or retaining dependency subscriptions.
191
+ frozenFailure = true;
192
+ frozenError = new Error(
193
+ "Derived value read during its disposed evaluation",
194
+ );
195
+ const versions = new Map<Trackable, number>();
196
+ let next!: T;
197
+ try {
198
+ const dependencies = untrack(() =>
199
+ collectDeps(
200
+ () => {
201
+ next = runWithOwner(owner, fn);
202
+ },
203
+ (dependency) => versions.set(dependency, dependency.version),
204
+ ),
205
+ );
206
+ if (
207
+ dependencies.some(
208
+ (dependency) => dependency.version !== versions.get(dependency),
209
+ )
210
+ )
211
+ throw new Error(
212
+ "Derived computations must not write their dependencies",
213
+ );
214
+ frozenFailure = false;
215
+ last = baseValue = next;
216
+ returned = initialized = true;
217
+ return next;
218
+ } catch (error) {
219
+ frozenFailure = true;
220
+ frozenError = error;
221
+ throw error;
222
+ }
223
+ }
224
+ if (
225
+ overridden &&
226
+ initialized &&
227
+ memoDependency &&
228
+ !hasValueDemand(memoDependency)
229
+ ) {
230
+ let changed = false;
231
+ untrack(() => {
232
+ for (const [dependency, version] of overrideVersions) {
233
+ dependency.validate?.();
234
+ if (dependency.version !== version) changed = true;
235
+ }
236
+ });
237
+ if (changed && !overrideInvalidated) {
238
+ overrideInvalidated = true;
239
+ inputRevision++;
240
+ invalidation.set((previous) => previous + 1);
241
+ }
242
+ }
243
+ if (!memoDependency) {
244
+ let value!: T;
245
+ collectDeps(
246
+ () => {
247
+ value = memo();
248
+ },
249
+ (dependency) => {
250
+ memoDependency = dependency;
251
+ },
252
+ true,
253
+ );
254
+ return value;
255
+ }
256
+ return memo();
257
+ },
258
+ set value(value: T) {
259
+ if (disposed) throw new Error("Cannot override a disposed derived value");
260
+ withHistoryMutation(() => {
261
+ if (!initialized) untrack(base);
262
+ recordHistory(token, "override", snapshot(), { value });
263
+ overrideVersions = new Map(
264
+ [...subscriptions.keys()].map((dependency) => [
265
+ dependency,
266
+ dependency.version,
267
+ ]),
268
+ );
269
+ overrideInvalidated = false;
270
+ override = value;
271
+ overridden = true;
272
+ invalidation.set((previous) => previous + 1);
273
+ });
274
+ },
275
+ };
276
+ }