@tschk/moonshine-vue 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.
@@ -0,0 +1,1704 @@
1
+ import { captureWatchErrorHandler, invokeWatch } from "./error-context";
2
+ /** Native composition helpers, not Vue's component or compiler runtime. */
3
+ import {
4
+ batch,
5
+ createComputed,
6
+ createRoot,
7
+ createSignal,
8
+ getOwner,
9
+ onCleanup,
10
+ runWithOwner,
11
+ untrack,
12
+ type Owner,
13
+ } from "@tschk/moonshine-dom/reactive";
14
+ import { createMemo } from "@tschk/moonshine";
15
+ import {
16
+ collectDeps,
17
+ isTracking,
18
+ trackDependency,
19
+ type Trackable,
20
+ } from "@tschk/moonshine/tracking";
21
+ import { createTrackedSet } from "./set";
22
+ import {
23
+ getComponentContext,
24
+ peekComponentContext,
25
+ withComponentConsumer,
26
+ type ComponentContext,
27
+ } from "@tschk/moonshine-dom/component";
28
+ import { createEmitter } from "./events";
29
+ export { useId } from "./context";
30
+ import {
31
+ createMutable,
32
+ unwrap as unwrapStore,
33
+ } from "@tschk/moonshine-dom/store";
34
+
35
+ const refs = new WeakSet<object>();
36
+ const readonlyRefs = new WeakSet<object>();
37
+ const refTriggers = new WeakMap<Ref<any>, () => void>();
38
+ const refTriggerVersions = new WeakMap<Ref<any>, number>();
39
+ declare const refBrand: unique symbol;
40
+ export class Ref<T, S = T> {
41
+ declare readonly [refBrand]: true;
42
+ private readonly read: () => T;
43
+ private readonly write?: (value: any) => void;
44
+ constructor(read: () => T, write?: (value: S) => void) {
45
+ this.read = read;
46
+ this.write = write;
47
+ refs.add(this);
48
+ if (!write) readonlyRefs.add(this);
49
+ }
50
+ get value(): T {
51
+ return this.read();
52
+ }
53
+ set value(value: S) {
54
+ if (!this.write) throw new TypeError("Native ref is readonly");
55
+ this.write(value);
56
+ }
57
+ }
58
+ export function isRef(value: unknown): value is Ref<any, any> {
59
+ return typeof value === "object" && value !== null && refs.has(value);
60
+ }
61
+ export type MaybeRef<T = any> = T | Ref<T> | Readonly<Ref<T>>;
62
+ export type MaybeRefOrGetter<T = any> = MaybeRef<T> | (() => T);
63
+ function plain(value: unknown): value is Record<PropertyKey, unknown> {
64
+ if (value === null || typeof value !== "object") return false;
65
+ const proto = Object.getPrototypeOf(value);
66
+ return Array.isArray(value) || proto === Object.prototype || proto === null;
67
+ }
68
+ const proxies = new WeakMap<object, object>();
69
+ const shallowReactiveMap = new WeakMap<object, object>();
70
+ const readonlyMap = new WeakMap<object, object>();
71
+ const shallowReadonlyMap = new WeakMap<object, object>();
72
+ const targets = new WeakMap<object, object>();
73
+ const reactiveProxies = new WeakSet<object>();
74
+ const readonlyProxies = new WeakSet<object>();
75
+ const shallowProxies = new WeakSet<object>();
76
+ const rawMarked = new WeakSet<object>();
77
+
78
+ export function markRaw<T extends object>(value: T): T {
79
+ if (
80
+ value !== null &&
81
+ (typeof value === "object" || typeof value === "function")
82
+ ) {
83
+ rawMarked.add(value);
84
+ }
85
+ return value;
86
+ }
87
+ export function toRaw<T>(observed: T): T {
88
+ if (observed === null || typeof observed !== "object") return observed;
89
+ const target = targets.get(observed);
90
+ return target ? toRaw(target as T) : observed;
91
+ }
92
+ export function isReactive(value: unknown): value is object {
93
+ if (value === null || typeof value !== "object") return false;
94
+ if (readonlyProxies.has(value)) {
95
+ const target = targets.get(value);
96
+ return target ? isReactive(target) : false;
97
+ }
98
+ return reactiveProxies.has(value);
99
+ }
100
+ export function isReadonly(value: unknown): boolean {
101
+ return (
102
+ value !== null &&
103
+ typeof value === "object" &&
104
+ (readonlyProxies.has(value) || readonlyRefs.has(value))
105
+ );
106
+ }
107
+ export function isShallow(value: unknown): boolean {
108
+ return (
109
+ value !== null && typeof value === "object" && shallowProxies.has(value)
110
+ );
111
+ }
112
+ export function isProxy(value: unknown): boolean {
113
+ return (
114
+ value !== null &&
115
+ typeof value === "object" &&
116
+ (reactiveProxies.has(value) || readonlyProxies.has(value))
117
+ );
118
+ }
119
+ const arrayIndex = (key: PropertyKey) =>
120
+ typeof key === "string" &&
121
+ /^(0|[1-9]\d*)$/.test(key) &&
122
+ Number(key) < 4294967295;
123
+ export type Unwrap<T> =
124
+ T extends Readonly<Ref<infer V>>
125
+ ? V
126
+ : T extends Set<infer V>
127
+ ? Set<V extends Readonly<Ref<any>> ? V : Unwrap<V>>
128
+ : T extends ReadonlySet<infer V>
129
+ ? ReadonlySet<V extends Readonly<Ref<any>> ? V : Unwrap<V>>
130
+ : T extends Function | Date | Map<unknown, unknown> | Node | Window
131
+ ? T
132
+ : T extends readonly unknown[]
133
+ ? {
134
+ [K in keyof T]: T[K] extends Readonly<Ref<any>>
135
+ ? T[K]
136
+ : Unwrap<T[K]>;
137
+ }
138
+ : T extends object
139
+ ? { [K in keyof T]: Unwrap<T[K]> }
140
+ : T;
141
+ export type DeepReadonly<T> = T extends
142
+ ((...args: any[]) => any) | Date | RegExp | Node | Window
143
+ ? T
144
+ : T extends Readonly<Ref<infer V>>
145
+ ? Readonly<Ref<DeepReadonly<Unwrap<V>>>>
146
+ : T extends Set<infer V> | ReadonlySet<infer V>
147
+ ? ReadonlySet<DeepReadonly<V>>
148
+ : T extends Map<infer K, infer V> | ReadonlyMap<infer K, infer V>
149
+ ? ReadonlyMap<DeepReadonly<K>, DeepReadonly<V>>
150
+ : T extends readonly unknown[]
151
+ ? { readonly [K in keyof T]: DeepReadonly<T[K]> }
152
+ : T extends object
153
+ ? { readonly [K in keyof T]: DeepReadonly<Unwrap<T[K]>> }
154
+ : T;
155
+ function rawValue<T>(value: T): T {
156
+ return toRaw(value);
157
+ }
158
+ function wrapValue<T>(value: T): T {
159
+ if (value === null || typeof value !== "object") return value;
160
+ const raw: object = unwrapStore(value);
161
+ if (rawMarked.has(value) || rawMarked.has(raw)) return raw as T;
162
+ return plain(raw) || raw instanceof Set ? (reactive(value) as T) : value;
163
+ }
164
+ function wrapReadonly<T>(value: T): T {
165
+ if (value === null || typeof value !== "object") return value;
166
+ const raw: object = toRaw(value);
167
+ if (rawMarked.has(value) || rawMarked.has(raw)) return value;
168
+ return plain(raw) || raw instanceof Set ? (readonly(value) as T) : value;
169
+ }
170
+ export function reactive<T extends object>(value: T): Unwrap<T> {
171
+ if (readonlyProxies.has(value)) return value as Unwrap<T>;
172
+ const existing = proxies.get(value);
173
+ if (existing) return existing as Unwrap<T>;
174
+ const rawTarget = unwrapStore(value);
175
+ if (rawMarked.has(value) || rawMarked.has(rawTarget))
176
+ return rawTarget as Unwrap<T>;
177
+ const cachedRaw = proxies.get(rawTarget);
178
+ if (cachedRaw) return cachedRaw as Unwrap<T>;
179
+ if (rawTarget instanceof Set) {
180
+ if (!Object.isExtensible(rawTarget)) return rawTarget as Unwrap<T>;
181
+ const proxy = createTrackedSet(rawTarget, wrapValue, rawValue);
182
+ reactiveProxies.add(proxy);
183
+ targets.set(proxy, rawTarget);
184
+ proxies.set(rawTarget, proxy);
185
+ proxies.set(proxy, proxy);
186
+ return proxy as Unwrap<T>;
187
+ }
188
+ if (!plain(rawTarget))
189
+ throw new TypeError(
190
+ "Native reactive requires a plain object, array or Set",
191
+ );
192
+ if (!Object.isExtensible(rawTarget)) return rawTarget as Unwrap<T>;
193
+ const mutable = createMutable(rawTarget, { equals: Object.is });
194
+ const cached = proxies.get(mutable);
195
+ if (cached) return cached as Unwrap<T>;
196
+ const proxy = new Proxy(mutable, {
197
+ get(target, key, receiver) {
198
+ const next = Reflect.get(target, key, receiver);
199
+ if (isRef(next))
200
+ return Array.isArray(target) && arrayIndex(key) ? next : next.value;
201
+ return wrapValue(next);
202
+ },
203
+ set(target, key, next) {
204
+ if (typeof next === "object" && next !== null) next = toRaw(next);
205
+ return batch(() =>
206
+ untrack(() => {
207
+ const previous = Reflect.get(target, key);
208
+ if (
209
+ !(Array.isArray(target) && arrayIndex(key)) &&
210
+ isRef(previous) &&
211
+ !isRef(next)
212
+ )
213
+ previous.value = next;
214
+ else Reflect.set(target, key, next);
215
+ return true;
216
+ }),
217
+ );
218
+ },
219
+ });
220
+ reactiveProxies.add(proxy);
221
+ targets.set(proxy, rawTarget);
222
+ proxies.set(rawTarget, proxy);
223
+ proxies.set(mutable, proxy);
224
+ proxies.set(proxy, proxy);
225
+ return proxy as Unwrap<T>;
226
+ }
227
+
228
+ type ShallowCell = ReturnType<typeof createSignal<number>>;
229
+ type ShallowState = {
230
+ reads: Map<PropertyKey, ShallowCell>;
231
+ has: Map<PropertyKey, ShallowCell>;
232
+ keys?: ShallowCell;
233
+ };
234
+ const shallowStates = new WeakMap<object, ShallowState>();
235
+ const shallowArrayMutations = new Set([
236
+ "push",
237
+ "pop",
238
+ "shift",
239
+ "unshift",
240
+ "splice",
241
+ "sort",
242
+ "reverse",
243
+ "fill",
244
+ "copyWithin",
245
+ ]);
246
+ function getShallowState(target: object): ShallowState {
247
+ let node = shallowStates.get(target);
248
+ if (!node) {
249
+ node = { reads: new Map(), has: new Map() };
250
+ shallowStates.set(target, node);
251
+ }
252
+ return node;
253
+ }
254
+ function trackShallow(
255
+ map: Map<PropertyKey, ShallowCell>,
256
+ key: PropertyKey,
257
+ ): void {
258
+ if (!isTracking()) return;
259
+ let cell = map.get(key);
260
+ if (!cell) map.set(key, (cell = createSignal(0, { equals: false })));
261
+ cell[0]();
262
+ }
263
+ function notifyShallow(cell: ShallowCell | undefined): void {
264
+ cell?.[1]((version) => version + 1);
265
+ }
266
+
267
+ export function shallowReactive<T extends object>(value: T): T {
268
+ if (readonlyProxies.has(value)) return value;
269
+ if (shallowProxies.has(value) && reactiveProxies.has(value)) return value;
270
+ const rawTarget = toRaw(value);
271
+ if (
272
+ rawMarked.has(value) ||
273
+ rawMarked.has(rawTarget) ||
274
+ !Object.isExtensible(rawTarget)
275
+ )
276
+ return rawTarget;
277
+ const existing = shallowReactiveMap.get(rawTarget);
278
+ if (existing) return existing as T;
279
+ if (rawTarget instanceof Set) {
280
+ const proxy = createTrackedSet(rawTarget, (v) => v, rawValue);
281
+ reactiveProxies.add(proxy);
282
+ shallowProxies.add(proxy);
283
+ targets.set(proxy, rawTarget);
284
+ shallowReactiveMap.set(rawTarget, proxy);
285
+ shallowReactiveMap.set(proxy, proxy);
286
+ return proxy as unknown as T;
287
+ }
288
+ if (!plain(rawTarget))
289
+ throw new TypeError(
290
+ "Native shallowReactive requires a plain object, array or Set",
291
+ );
292
+ const methods = new Map<PropertyKey, Function>();
293
+ const proxy = new Proxy(rawTarget, {
294
+ get(target, key, receiver) {
295
+ const descriptor = Object.getOwnPropertyDescriptor(target, key);
296
+ if (
297
+ !descriptor?.get &&
298
+ (Object.hasOwn(target, key) ||
299
+ typeof (target as Record<PropertyKey, unknown>)[key] !== "function")
300
+ ) {
301
+ trackShallow(getShallowState(target).reads, key);
302
+ }
303
+ const result = Reflect.get(target, key, receiver);
304
+ if (
305
+ Array.isArray(target) &&
306
+ typeof key === "string" &&
307
+ shallowArrayMutations.has(key) &&
308
+ result === Reflect.get(Array.prototype, key)
309
+ ) {
310
+ let method = methods.get(key);
311
+ if (!method) {
312
+ method = function (this: unknown, ...args: unknown[]) {
313
+ return batch(() =>
314
+ untrack(() => Reflect.apply(result as Function, this, args)),
315
+ );
316
+ };
317
+ methods.set(key, method);
318
+ }
319
+ return method;
320
+ }
321
+ return result;
322
+ },
323
+ has(target, key) {
324
+ trackShallow(getShallowState(target).has, key);
325
+ return Reflect.has(target, key);
326
+ },
327
+ ownKeys(target) {
328
+ if (isTracking()) {
329
+ const node = getShallowState(target);
330
+ if (Array.isArray(target)) trackShallow(node.reads, "length");
331
+ else (node.keys ??= createSignal(0, { equals: false }))[0]();
332
+ }
333
+ return Reflect.ownKeys(target);
334
+ },
335
+ set(target, key, next, receiver) {
336
+ return batch(() =>
337
+ untrack(() => {
338
+ const isArray = Array.isArray(target);
339
+ const prevLength = isArray ? target.length : 0;
340
+ const hadKey = Object.hasOwn(target, key);
341
+ const previous = (target as Record<PropertyKey, unknown>)[key];
342
+ const ok = Reflect.set(target, key, next, receiver);
343
+ if (!ok) return false;
344
+ const node = shallowStates.get(target);
345
+ if (!node) return true;
346
+ if (!hadKey) {
347
+ notifyShallow(node.reads.get(key));
348
+ notifyShallow(node.has.get(key));
349
+ notifyShallow(node.keys);
350
+ if (isArray && target.length !== prevLength) {
351
+ notifyShallow(node.reads.get("length"));
352
+ }
353
+ } else if (!Object.is(previous, next)) {
354
+ notifyShallow(node.reads.get(key));
355
+ if (isArray) {
356
+ if (key === "length" && target.length < prevLength) {
357
+ for (let i = target.length; i < prevLength; i++) {
358
+ const idxKey = String(i);
359
+ notifyShallow(node.reads.get(idxKey));
360
+ notifyShallow(node.has.get(idxKey));
361
+ }
362
+ notifyShallow(node.keys);
363
+ } else if (key !== "length" && target.length !== prevLength) {
364
+ notifyShallow(node.reads.get("length"));
365
+ }
366
+ }
367
+ }
368
+ return true;
369
+ }),
370
+ );
371
+ },
372
+ deleteProperty(target, key) {
373
+ return batch(() =>
374
+ untrack(() => {
375
+ const hadKey = Object.hasOwn(target, key);
376
+ const ok = Reflect.deleteProperty(target, key);
377
+ if (ok && hadKey) {
378
+ const node = shallowStates.get(target);
379
+ if (node) {
380
+ notifyShallow(node.reads.get(key));
381
+ notifyShallow(node.has.get(key));
382
+ notifyShallow(node.keys);
383
+ }
384
+ }
385
+ return ok;
386
+ }),
387
+ );
388
+ },
389
+ });
390
+ reactiveProxies.add(proxy);
391
+ shallowProxies.add(proxy);
392
+ targets.set(proxy, rawTarget);
393
+ shallowReactiveMap.set(rawTarget, proxy);
394
+ shallowReactiveMap.set(proxy, proxy);
395
+ return proxy as T;
396
+ }
397
+
398
+ const readonlySetStates = new WeakMap<
399
+ object,
400
+ { target: Set<unknown>; deep: boolean }
401
+ >();
402
+ function readonlySetState(value: object) {
403
+ const found = readonlySetStates.get(value);
404
+ if (!found) throw new TypeError("Set method requires a native readonly Set");
405
+ return found;
406
+ }
407
+ function readonlySetIterator(
408
+ receiver: Set<unknown>,
409
+ entries: boolean,
410
+ ): SetIterator<any> {
411
+ const s = readonlySetState(receiver);
412
+ return (function* () {
413
+ for (const value of s.target) {
414
+ const wrapped = s.deep ? wrapReadonly(value) : value;
415
+ yield entries ? [wrapped, wrapped] : wrapped;
416
+ }
417
+ return undefined;
418
+ })();
419
+ }
420
+ const readonlySetMethods = {
421
+ get size() {
422
+ return readonlySetState(this).target.size;
423
+ },
424
+ has(this: Set<unknown>, key: unknown) {
425
+ const { target } = readonlySetState(this);
426
+ const raw = toRaw(key);
427
+ return target.has(key) || target.has(raw);
428
+ },
429
+ add() {
430
+ throw new TypeError("Cannot mutate a readonly Set");
431
+ },
432
+ delete() {
433
+ throw new TypeError("Cannot mutate a readonly Set");
434
+ },
435
+ clear() {
436
+ throw new TypeError("Cannot mutate a readonly Set");
437
+ },
438
+ keys(this: Set<unknown>) {
439
+ return readonlySetIterator(this, false);
440
+ },
441
+ values(this: Set<unknown>) {
442
+ return readonlySetIterator(this, false);
443
+ },
444
+ entries(this: Set<unknown>) {
445
+ return readonlySetIterator(this, true);
446
+ },
447
+ [Symbol.iterator](this: Set<unknown>) {
448
+ return readonlySetIterator(this, false);
449
+ },
450
+ forEach(
451
+ this: Set<unknown>,
452
+ callback: (value: unknown, key: unknown, set: Set<unknown>) => void,
453
+ thisArg?: unknown,
454
+ ) {
455
+ if (typeof callback !== "function")
456
+ throw new TypeError("Set callback must be a function");
457
+ const s = readonlySetState(this);
458
+ s.target.forEach((value) => {
459
+ const wrapped = s.deep ? wrapReadonly(value) : value;
460
+ callback.call(thisArg, wrapped, wrapped, this);
461
+ });
462
+ },
463
+ };
464
+ function createReadonlySet(target: Set<unknown>, deep: boolean): Set<unknown> {
465
+ const proxy = new Proxy(target, {
466
+ get(source, key, receiver) {
467
+ return Object.hasOwn(readonlySetMethods, key) && key in source
468
+ ? Reflect.get(readonlySetMethods, key, receiver)
469
+ : Reflect.get(source, key, receiver);
470
+ },
471
+ });
472
+ readonlySetStates.set(proxy, { target, deep });
473
+ return proxy;
474
+ }
475
+
476
+ function createReadonly<T extends object>(value: T, shallow: boolean): any {
477
+ if (isRef(value)) {
478
+ if (readonlyRefs.has(value) && (!shallow || shallowProxies.has(value))) {
479
+ return value;
480
+ }
481
+ const cache = shallow ? shallowReadonlyMap : readonlyMap;
482
+ const cachedRef = cache.get(value);
483
+ if (cachedRef) return cachedRef;
484
+ const roRef = new Ref(() =>
485
+ shallow ? value.value : wrapReadonly(value.value),
486
+ );
487
+ if (shallow) shallowProxies.add(roRef);
488
+ targets.set(roRef, value);
489
+ cache.set(value, roRef);
490
+ return roRef;
491
+ }
492
+ if (!shallow && readonlyProxies.has(value) && !shallowProxies.has(value)) {
493
+ return value;
494
+ }
495
+ if (shallow && readonlyProxies.has(value) && shallowProxies.has(value)) {
496
+ return value;
497
+ }
498
+ const underlying = readonlyProxies.has(value)
499
+ ? ((targets.get(value) as T) ?? value)
500
+ : value;
501
+ const rawCandidate = toRaw(underlying);
502
+ if (
503
+ rawMarked.has(value) ||
504
+ rawMarked.has(underlying) ||
505
+ rawMarked.has(rawCandidate) ||
506
+ !Object.isExtensible(rawCandidate)
507
+ ) {
508
+ return value;
509
+ }
510
+ const cache = shallow ? shallowReadonlyMap : readonlyMap;
511
+ const existing = cache.get(underlying);
512
+ if (existing) return existing;
513
+ if (rawCandidate instanceof Set) {
514
+ const proxy = createReadonlySet(
515
+ underlying as unknown as Set<unknown>,
516
+ !shallow,
517
+ );
518
+ readonlyProxies.add(proxy);
519
+ if (shallow) shallowProxies.add(proxy);
520
+ targets.set(proxy, underlying);
521
+ cache.set(underlying, proxy);
522
+ cache.set(proxy, proxy);
523
+ return proxy;
524
+ }
525
+ if (!plain(rawCandidate))
526
+ throw new TypeError(
527
+ "Native readonly requires a plain object, array or Set",
528
+ );
529
+ const proxy = new Proxy(underlying, {
530
+ get(target, key, receiver) {
531
+ const next = Reflect.get(target, key, receiver);
532
+ if (shallow) return next;
533
+ if (isRef(next)) {
534
+ return Array.isArray(target) && arrayIndex(key)
535
+ ? readonly(next)
536
+ : wrapReadonly(next.value);
537
+ }
538
+ return wrapReadonly(next);
539
+ },
540
+ set(_target, key) {
541
+ throw new TypeError(
542
+ `Cannot assign to read only property '${String(key)}'`,
543
+ );
544
+ },
545
+ deleteProperty(_target, key) {
546
+ throw new TypeError(
547
+ `Cannot delete property '${String(key)}' of a readonly object`,
548
+ );
549
+ },
550
+ defineProperty(_target, key) {
551
+ throw new TypeError(
552
+ `Cannot define property '${String(key)}' on a readonly object`,
553
+ );
554
+ },
555
+ });
556
+ readonlyProxies.add(proxy);
557
+ if (shallow) shallowProxies.add(proxy);
558
+ targets.set(proxy, underlying);
559
+ cache.set(underlying, proxy);
560
+ cache.set(proxy, proxy);
561
+ return proxy;
562
+ }
563
+
564
+ export function readonly<T extends object>(value: T): DeepReadonly<T> {
565
+ return createReadonly(value, false);
566
+ }
567
+ export function shallowReadonly<T extends object>(value: T): Readonly<T> {
568
+ return createReadonly(value, true);
569
+ }
570
+
571
+ export function ref<T>(value: Ref<T>): Ref<T>;
572
+ export function ref<T>(value: T): Ref<Unwrap<T>>;
573
+ export function ref<T = any>(): Ref<T | undefined>;
574
+ export function ref<T>(value?: T | Ref<T>): Ref<any> {
575
+ if (isRef(value)) return value;
576
+ const convert = wrapValue<T>;
577
+ let forceTrigger = false;
578
+ const [read, write] = createSignal(convert(value as T), {
579
+ equals: (prev, next) => !forceTrigger && Object.is(prev, next),
580
+ });
581
+ const refObject = new Ref(read, (next) => write(() => convert(next)));
582
+ refTriggers.set(refObject, () => {
583
+ forceTrigger = true;
584
+ try {
585
+ refTriggerVersions.set(
586
+ refObject,
587
+ (refTriggerVersions.get(refObject) ?? 0) + 1,
588
+ );
589
+ write((current) => current);
590
+ } finally {
591
+ forceTrigger = false;
592
+ }
593
+ });
594
+ return refObject;
595
+ }
596
+ /** Keep external snapshots intact; only replacing .value or triggerRef notifies this ref. */
597
+ export function shallowRef<T extends Readonly<Ref<any>>>(value: T): T;
598
+ export function shallowRef<T>(value: T): Ref<T>;
599
+ export function shallowRef<T = any>(): Ref<T | undefined>;
600
+ export function shallowRef(value?: unknown): Ref<any> {
601
+ if (isRef(value)) return value;
602
+ let forceTrigger = false;
603
+ const [read, write] = createSignal<unknown>(value, {
604
+ equals: (prev, next) => !forceTrigger && Object.is(prev, next),
605
+ });
606
+ const refObject = new Ref(read, (next) => write(() => next));
607
+ shallowProxies.add(refObject);
608
+ refTriggers.set(refObject, () => {
609
+ forceTrigger = true;
610
+ try {
611
+ refTriggerVersions.set(
612
+ refObject,
613
+ (refTriggerVersions.get(refObject) ?? 0) + 1,
614
+ );
615
+ write((current: unknown) => current);
616
+ } finally {
617
+ forceTrigger = false;
618
+ }
619
+ });
620
+ return refObject;
621
+ }
622
+ export function triggerRef(target: Readonly<Ref<any>>): void {
623
+ if (!isRef(target)) throw new TypeError("triggerRef requires a native ref");
624
+ refTriggers.get(target)?.();
625
+ }
626
+ export type CustomRefFactory<T> = (
627
+ track: () => void,
628
+ trigger: () => void,
629
+ ) => {
630
+ get: () => T;
631
+ set: (value: T) => void;
632
+ };
633
+ export function customRef<T>(factory: CustomRefFactory<T>): Ref<T> {
634
+ if (typeof factory !== "function")
635
+ throw new TypeError("customRef requires a factory function");
636
+ const [readVersion, writeVersion] = createSignal(0, { equals: false });
637
+ let refObject!: Ref<T>;
638
+ const track = () => {
639
+ readVersion();
640
+ };
641
+ const trigger = () => {
642
+ refTriggerVersions.set(
643
+ refObject,
644
+ (refTriggerVersions.get(refObject) ?? 0) + 1,
645
+ );
646
+ writeVersion((v) => v + 1);
647
+ };
648
+ const { get, set } = factory(track, trigger);
649
+ if (typeof get !== "function" || typeof set !== "function")
650
+ throw new TypeError("customRef factory must return get and set functions");
651
+ refObject = new Ref(
652
+ () => get(),
653
+ (value) => set(value),
654
+ );
655
+ refTriggers.set(refObject, trigger);
656
+ return refObject;
657
+ }
658
+ /** Unwrap native refs without invoking ordinary function values. */
659
+ export function unref<T>(value: T): T extends Readonly<Ref<infer V>> ? V : T;
660
+ export function unref(value: unknown): unknown {
661
+ return isRef(value) ? value.value : value;
662
+ }
663
+ /** Normalize values, refs, and zero-arg getters to their underlying value. */
664
+ export function toValue<T>(source: MaybeRefOrGetter<T>): T;
665
+ export function toValue(source: unknown): unknown {
666
+ return typeof source === "function" ? source() : unref(source);
667
+ }
668
+ export type ToRef<T> = [T] extends [Readonly<Ref<any>>] ? T : Ref<T>;
669
+ export function toRef<T extends Readonly<Ref<any>>>(value: T): T;
670
+ export function toRef<T>(getter: () => T): Readonly<Ref<T>>;
671
+ export function toRef<T>(value: T): Ref<Unwrap<T>>;
672
+ export function toRef(): Ref<undefined>;
673
+ export function toRef<T extends object, K extends keyof T>(
674
+ object: T,
675
+ key: K,
676
+ ): ToRef<T[K]>;
677
+ export function toRef<T extends object, K extends keyof T>(
678
+ object: T,
679
+ key: K,
680
+ defaultValue: T[K],
681
+ ): ToRef<Exclude<T[K], undefined>>;
682
+ export function toRef(
683
+ source?: unknown,
684
+ key?: PropertyKey,
685
+ defaultValue?: unknown,
686
+ ): Ref<any> {
687
+ if (isRef(source)) return source;
688
+ if (typeof source === "function") return new Ref(() => source());
689
+ if (source !== null && typeof source === "object" && arguments.length > 1) {
690
+ const object = source as Record<PropertyKey, unknown>;
691
+ const current = object[key!];
692
+ if (isRef(current)) return current;
693
+ return new Ref(
694
+ () => {
695
+ const value = object[key!];
696
+ return value === undefined ? defaultValue : value;
697
+ },
698
+ (value) => {
699
+ object[key!] = value;
700
+ },
701
+ );
702
+ }
703
+ return ref(source);
704
+ }
705
+ /** Link the currently enumerable string properties, preserving array holes. */
706
+ export type ToRefs<T = any> = { [K in keyof T]: ToRef<T[K]> };
707
+ export function toRefs<T extends object>(object: T): ToRefs<T> {
708
+ const result =
709
+ // Preserve sparse holes; Array.from would materialize undefined entries.
710
+ // eslint-disable-next-line unicorn/no-new-array
711
+ (Array.isArray(object) ? new Array(object.length) : {}) as ToRefs<T>;
712
+ for (const key in object) {
713
+ Object.defineProperty(result, key, {
714
+ value: toRef(object, key),
715
+ enumerable: true,
716
+ configurable: true,
717
+ writable: true,
718
+ });
719
+ }
720
+ return result;
721
+ }
722
+ export function computed<T>(
723
+ getter: (previous: T | undefined) => T,
724
+ ): Readonly<Ref<T>>;
725
+ export function computed<T>(options: {
726
+ get: (previous: T | undefined) => T;
727
+ set: (value: T) => void;
728
+ }): Ref<T>;
729
+ export function computed<T>(
730
+ input:
731
+ | ((previous: T | undefined) => T)
732
+ | { get: (previous: T | undefined) => T; set: (value: T) => void },
733
+ ): Ref<T> {
734
+ const getter = typeof input === "function" ? input : input.get;
735
+ let previous: T | undefined;
736
+ const read = createMemo(() => {
737
+ const next = getter(previous);
738
+ previous = next;
739
+ return next;
740
+ });
741
+ return new Ref(
742
+ read,
743
+ typeof input === "function"
744
+ ? undefined
745
+ : (value) => batch(() => untrack(() => input.set(value))),
746
+ );
747
+ }
748
+ export type WatchSource<T = unknown> = Readonly<Ref<T>> | (() => T);
749
+ export type WatchOptions = {
750
+ flush: "sync";
751
+ immediate?: boolean;
752
+ deep?: boolean | number;
753
+ once?: boolean;
754
+ };
755
+ export type WatchStopHandle = () => void;
756
+ export interface WatchHandle extends WatchStopHandle {
757
+ pause: () => void;
758
+ resume: () => void;
759
+ stop: () => void;
760
+ }
761
+ export type WatchCallback<V = any, OV = any> = (
762
+ value: V,
763
+ previous: OV,
764
+ onCleanup: (fn: () => void) => void,
765
+ ) => void;
766
+ type MapWatchSources<T> = {
767
+ -readonly [K in keyof T]: T[K] extends WatchSource<infer V>
768
+ ? V
769
+ : T[K] extends object
770
+ ? T[K]
771
+ : never;
772
+ };
773
+
774
+ let activeWatcherCleanup: ((fn: () => void) => void) | undefined;
775
+
776
+ export function onWatcherCleanup(
777
+ cleanupFn: () => void,
778
+ failSilently = false,
779
+ ): void {
780
+ if (typeof cleanupFn !== "function")
781
+ throw new TypeError("Watcher cleanup must be a function");
782
+ if (activeWatcherCleanup) {
783
+ activeWatcherCleanup(cleanupFn);
784
+ } else if (!failSilently) {
785
+ throw new Error("onWatcherCleanup requires an active watcher");
786
+ }
787
+ }
788
+
789
+ type DepSnapshot = Array<{ node: Trackable; version: number }>;
790
+ function captureDeps(fn: () => void): DepSnapshot {
791
+ const nodes = collectDeps(fn, undefined, true);
792
+ return nodes.map((node) => ({ node, version: node.version }));
793
+ }
794
+ function depsChanged(prev: DepSnapshot, next: DepSnapshot): boolean {
795
+ if (prev.length !== next.length) return true;
796
+ for (let i = 0; i < next.length; i++) {
797
+ if (
798
+ prev[i]!.node !== next[i]!.node ||
799
+ prev[i]!.version !== next[i]!.version
800
+ )
801
+ return true;
802
+ }
803
+ return false;
804
+ }
805
+ function traverse(
806
+ value: unknown,
807
+ depth = Infinity,
808
+ seen = new Set<unknown>(),
809
+ ): unknown {
810
+ if (
811
+ depth <= 0 ||
812
+ value === null ||
813
+ typeof value !== "object" ||
814
+ rawMarked.has(value) ||
815
+ rawMarked.has(toRaw(value))
816
+ )
817
+ return value;
818
+ if (seen.has(value)) return value;
819
+ seen.add(value);
820
+ depth--;
821
+ if (isRef(value)) {
822
+ const inner = value.value;
823
+ if (depth > 0) traverse(inner, depth, seen);
824
+ } else if (Array.isArray(value)) {
825
+ for (let i = 0; i < value.length; i++) {
826
+ traverse(value[i], depth, seen);
827
+ }
828
+ } else if (value instanceof Set || value instanceof Map) {
829
+ value.forEach((entry) => {
830
+ traverse(entry, depth, seen);
831
+ });
832
+ } else if (plain(value)) {
833
+ for (const key in value) {
834
+ traverse(value[key], depth, seen);
835
+ }
836
+ for (const symbol of Object.getOwnPropertySymbols(value)) {
837
+ if (Object.prototype.propertyIsEnumerable.call(value, symbol)) {
838
+ traverse(value[symbol], depth, seen);
839
+ }
840
+ }
841
+ }
842
+ return value;
843
+ }
844
+ function createWatchHandle(
845
+ stop: () => void,
846
+ pause: () => void,
847
+ resume: () => void,
848
+ ): WatchHandle {
849
+ const handle = (() => {
850
+ stop();
851
+ }) as WatchHandle;
852
+ handle.stop = stop;
853
+ handle.pause = pause;
854
+ handle.resume = resume;
855
+ return handle;
856
+ }
857
+
858
+ export function watch<T>(
859
+ source: WatchSource<T>,
860
+ callback: WatchCallback<T, T | undefined>,
861
+ options: WatchOptions,
862
+ ): WatchHandle;
863
+ export function watch<T extends readonly unknown[]>(
864
+ source: { [K in keyof T]: WatchSource<T[K]> },
865
+ callback: WatchCallback<T, T | undefined>,
866
+ options: WatchOptions,
867
+ ): WatchHandle;
868
+ export function watch<T extends readonly (WatchSource<unknown> | object)[]>(
869
+ source: readonly [...T],
870
+ callback: WatchCallback<MapWatchSources<T>, MapWatchSources<T> | undefined>,
871
+ options: WatchOptions,
872
+ ): WatchHandle;
873
+ export function watch<T extends object>(
874
+ source: T,
875
+ callback: WatchCallback<T, T | undefined>,
876
+ options: WatchOptions,
877
+ ): WatchHandle;
878
+ export function watch(
879
+ source: WatchSource<any> | object | readonly (WatchSource<any> | object)[],
880
+ callback: WatchCallback<any, any>,
881
+ options: WatchOptions,
882
+ ): WatchHandle {
883
+ if (
884
+ !options ||
885
+ options.flush !== "sync" ||
886
+ Object.keys(options).some(
887
+ (key) =>
888
+ key !== "flush" &&
889
+ key !== "immediate" &&
890
+ key !== "deep" &&
891
+ key !== "once",
892
+ ) ||
893
+ (options.immediate !== undefined &&
894
+ typeof options.immediate !== "boolean") ||
895
+ (options.once !== undefined && typeof options.once !== "boolean") ||
896
+ (options.deep !== undefined &&
897
+ typeof options.deep !== "boolean" &&
898
+ (typeof options.deep !== "number" || Number.isNaN(options.deep)))
899
+ )
900
+ throw new TypeError(
901
+ "Native watch supports only flush:'sync', immediate, deep, and once",
902
+ );
903
+ const sources = Array.isArray(source) ? source : [source];
904
+ if (
905
+ sources.some(
906
+ (item) => !isRef(item) && !isReactive(item) && typeof item !== "function",
907
+ )
908
+ )
909
+ throw new TypeError(
910
+ "Native watch requires refs, reactive objects, or getters",
911
+ );
912
+ const outer = getOwner();
913
+ if (outer?.disposed)
914
+ throw new Error("Cannot watch from a disposed native owner");
915
+ const reportError = captureWatchErrorHandler();
916
+ const depths = sources.map((item) => {
917
+ if (typeof options.deep === "number")
918
+ return options.deep <= 0 ? 0 : options.deep;
919
+ if (options.deep === true) return Infinity;
920
+ if (options.deep === false) return isReactive(item) ? 1 : 0;
921
+ return isReactive(item) ? (isShallow(item) ? 1 : Infinity) : 0;
922
+ });
923
+ let stop!: () => void;
924
+ let pause!: () => void;
925
+ let resume!: () => void;
926
+ createRoot((dispose) => {
927
+ stop = dispose;
928
+ let previous: any[] | undefined;
929
+ let previousVersions: number[] | undefined;
930
+ let previousDepSnapshots: Array<DepSnapshot | undefined> | undefined;
931
+ let reading = false;
932
+ let active = true;
933
+ let paused = false;
934
+ let dirtyWhilePaused = false;
935
+ let lastDeps: Array<Parameters<typeof trackDependency>[0]> = [];
936
+ const [readResume, writeResume] = createSignal(0, { equals: false });
937
+ const cleanups: Array<() => void> = [];
938
+ pause = () => {
939
+ if (active) paused = true;
940
+ };
941
+ resume = () => {
942
+ if (!active || !paused) return;
943
+ paused = false;
944
+ if (dirtyWhilePaused) {
945
+ dirtyWhilePaused = false;
946
+ writeResume((v) => v + 1);
947
+ }
948
+ };
949
+ const clean = () => {
950
+ let failed = false;
951
+ let failure: unknown;
952
+ const prevCleanup = activeWatcherCleanup;
953
+ activeWatcherCleanup = undefined;
954
+ try {
955
+ for (const fn of cleanups.splice(0)) {
956
+ try {
957
+ untrack(() =>
958
+ reportError
959
+ ? invokeWatch(reportError, "watch cleanup", fn)
960
+ : fn(),
961
+ );
962
+ } catch (error) {
963
+ if (!failed) failure = error;
964
+ failed = true;
965
+ }
966
+ }
967
+ } finally {
968
+ activeWatcherCleanup = prevCleanup;
969
+ }
970
+ if (failed) throw failure;
971
+ };
972
+ onCleanup(() => {
973
+ active = false;
974
+ paused = false;
975
+ dirtyWhilePaused = false;
976
+ clean();
977
+ });
978
+ createComputed(() => {
979
+ readResume();
980
+ // Getter reporting may write its source; callback feedback remains reentrant.
981
+ if ((reportError && reading) || !active) return;
982
+ if (paused) {
983
+ dirtyWhilePaused = true;
984
+ for (const dep of lastDeps) {
985
+ dep.validate?.();
986
+ trackDependency(dep);
987
+ }
988
+ return;
989
+ }
990
+ let values!: any[];
991
+ const depSnapshots: Array<DepSnapshot | undefined> = [];
992
+ const prevCleanup = activeWatcherCleanup;
993
+ activeWatcherCleanup = undefined;
994
+ reading = true;
995
+ try {
996
+ lastDeps = collectDeps(
997
+ () => {
998
+ values = sources.map((item, i) => {
999
+ const depth = depths[i]!;
1000
+ let value: any;
1001
+ if (depth > 0) {
1002
+ depSnapshots[i] = captureDeps(() => {
1003
+ value = isRef(item)
1004
+ ? item.value
1005
+ : typeof item === "function"
1006
+ ? reportError
1007
+ ? invokeWatch(reportError, "watch getter", item)
1008
+ : item()
1009
+ : item;
1010
+ traverse(value, depth);
1011
+ });
1012
+ } else {
1013
+ value = isRef(item)
1014
+ ? item.value
1015
+ : typeof item === "function"
1016
+ ? reportError
1017
+ ? invokeWatch(reportError, "watch getter", item)
1018
+ : item()
1019
+ : item;
1020
+ }
1021
+ return value;
1022
+ });
1023
+ },
1024
+ undefined,
1025
+ true,
1026
+ ) as Array<Parameters<typeof trackDependency>[0]>;
1027
+ } finally {
1028
+ reading = false;
1029
+ activeWatcherCleanup = prevCleanup;
1030
+ }
1031
+ const versions = sources.map((item) =>
1032
+ isRef(item) ? (refTriggerVersions.get(item) ?? 0) : 0,
1033
+ );
1034
+ if (
1035
+ previous &&
1036
+ values.every(
1037
+ (value, i) =>
1038
+ Object.is(value, previous![i]) &&
1039
+ versions[i] === previousVersions![i] &&
1040
+ (depths[i] === 0 ||
1041
+ !depsChanged(previousDepSnapshots![i]!, depSnapshots[i]!)),
1042
+ )
1043
+ )
1044
+ return;
1045
+ const old = previous;
1046
+ previous = values;
1047
+ previousVersions = versions;
1048
+ previousDepSnapshots = depSnapshots;
1049
+ if (!old && !options.immediate) return;
1050
+ untrack(() => {
1051
+ clean();
1052
+ if (!active) return;
1053
+ const registerCleanup = (fn: () => void) => {
1054
+ if (typeof fn !== "function")
1055
+ throw new TypeError("Watcher cleanup must be a function");
1056
+ if (active) cleanups.push(fn);
1057
+ else if (reportError) invokeWatch(reportError, "watch cleanup", fn);
1058
+ else fn();
1059
+ };
1060
+ const invoke = () => {
1061
+ const previousCleanup = activeWatcherCleanup;
1062
+ activeWatcherCleanup = registerCleanup;
1063
+ try {
1064
+ return callback(
1065
+ Array.isArray(source) ? values : values[0],
1066
+ Array.isArray(source) ? old : old?.[0],
1067
+ registerCleanup,
1068
+ );
1069
+ } finally {
1070
+ activeWatcherCleanup = previousCleanup;
1071
+ }
1072
+ };
1073
+ try {
1074
+ if (reportError) invokeWatch(reportError, "watch callback", invoke);
1075
+ else invoke();
1076
+ } catch (error) {
1077
+ if (options.once && active) {
1078
+ try {
1079
+ stop();
1080
+ } catch {
1081
+ /* Preserve callback failure when once-stop cleanup also throws. */
1082
+ }
1083
+ }
1084
+ throw error;
1085
+ }
1086
+ if (options.once && active) stop();
1087
+ });
1088
+ });
1089
+ });
1090
+ if (outer) onCleanup(stop);
1091
+ return createWatchHandle(stop, pause, resume);
1092
+ }
1093
+
1094
+ /** Synchronously track an owned effect; no component render scheduler is implied. */
1095
+ export function watchSyncEffect(
1096
+ effect: (onCleanup: (fn: () => void) => void) => void,
1097
+ ): WatchHandle {
1098
+ if (typeof effect !== "function")
1099
+ throw new TypeError("Watcher effect must be a function");
1100
+ const outer = getOwner();
1101
+ if (outer?.disposed)
1102
+ throw new Error("Cannot watch from a disposed native owner");
1103
+ const reportError = captureWatchErrorHandler();
1104
+ let stop!: () => void;
1105
+ let pause!: () => void;
1106
+ let resume!: () => void;
1107
+ createRoot((dispose) => {
1108
+ stop = dispose;
1109
+ let active = true;
1110
+ let running = false;
1111
+ let paused = false;
1112
+ let dirtyWhilePaused = false;
1113
+ let lastDeps: Array<Parameters<typeof trackDependency>[0]> = [];
1114
+ const [readResume, writeResume] = createSignal(0, { equals: false });
1115
+ const cleanups: Array<() => void> = [];
1116
+ pause = () => {
1117
+ if (active) paused = true;
1118
+ };
1119
+ resume = () => {
1120
+ if (!active || !paused) return;
1121
+ paused = false;
1122
+ if (dirtyWhilePaused) {
1123
+ dirtyWhilePaused = false;
1124
+ writeResume((v) => v + 1);
1125
+ }
1126
+ };
1127
+ const clean = () => {
1128
+ let failed = false;
1129
+ let failure: unknown;
1130
+ const prevCleanup = activeWatcherCleanup;
1131
+ activeWatcherCleanup = undefined;
1132
+ try {
1133
+ for (const fn of cleanups.splice(0)) {
1134
+ try {
1135
+ untrack(() =>
1136
+ reportError
1137
+ ? invokeWatch(reportError, "watch cleanup", fn)
1138
+ : fn(),
1139
+ );
1140
+ } catch (error) {
1141
+ if (!failed) failure = error;
1142
+ failed = true;
1143
+ }
1144
+ }
1145
+ } finally {
1146
+ activeWatcherCleanup = prevCleanup;
1147
+ }
1148
+ if (failed) throw failure;
1149
+ };
1150
+ onCleanup(() => {
1151
+ active = false;
1152
+ paused = false;
1153
+ dirtyWhilePaused = false;
1154
+ clean();
1155
+ });
1156
+ createComputed(() => {
1157
+ readResume();
1158
+ if (running || !active) return;
1159
+ if (paused) {
1160
+ dirtyWhilePaused = true;
1161
+ for (const dep of lastDeps) {
1162
+ dep.validate?.();
1163
+ trackDependency(dep);
1164
+ }
1165
+ return;
1166
+ }
1167
+ running = true;
1168
+ try {
1169
+ untrack(clean);
1170
+ if (!active) return;
1171
+ const registerCleanup = (fn: () => void) => {
1172
+ if (typeof fn !== "function")
1173
+ throw new TypeError("Watcher cleanup must be a function");
1174
+ if (active) cleanups.push(fn);
1175
+ };
1176
+ const invoke = () => {
1177
+ const previousCleanup = activeWatcherCleanup;
1178
+ activeWatcherCleanup = registerCleanup;
1179
+ try {
1180
+ return effect(registerCleanup);
1181
+ } finally {
1182
+ activeWatcherCleanup = previousCleanup;
1183
+ }
1184
+ };
1185
+ lastDeps = collectDeps(
1186
+ () => {
1187
+ if (reportError) invokeWatch(reportError, "watch effect", invoke);
1188
+ else invoke();
1189
+ },
1190
+ undefined,
1191
+ true,
1192
+ ) as Array<Parameters<typeof trackDependency>[0]>;
1193
+ } catch (error) {
1194
+ try {
1195
+ untrack(clean);
1196
+ } catch {
1197
+ /* Preserve the effect failure. */
1198
+ }
1199
+ throw error;
1200
+ } finally {
1201
+ running = false;
1202
+ }
1203
+ });
1204
+ });
1205
+ if (outer) onCleanup(stop);
1206
+ return createWatchHandle(stop, pause, resume);
1207
+ }
1208
+
1209
+ let activeEffectScope: EffectScope | undefined;
1210
+ const componentScopes = new WeakMap<ComponentContext, EffectScope>();
1211
+ const scopeCleanups = new WeakMap<EffectScope, Array<() => void>>();
1212
+
1213
+ function runEffectScope<T>(
1214
+ scope: EffectScope,
1215
+ scopeOwner: Owner,
1216
+ fn: () => T,
1217
+ ): T {
1218
+ const prev = activeEffectScope;
1219
+ activeEffectScope = scope;
1220
+ try {
1221
+ return runWithOwner(scopeOwner, fn);
1222
+ } finally {
1223
+ activeEffectScope = prev;
1224
+ }
1225
+ }
1226
+
1227
+ export class EffectScope {
1228
+ private isActive = true;
1229
+ private readonly owner: Owner;
1230
+ private readonly disposeOwner: () => void;
1231
+ private readonly scopes: Set<EffectScope> = new Set();
1232
+ private readonly parent?: EffectScope;
1233
+
1234
+ constructor(detached = false) {
1235
+ let disposeOwner!: () => void;
1236
+ let scopeOwner!: Owner;
1237
+ createRoot((dispose) => {
1238
+ disposeOwner = dispose;
1239
+ scopeOwner = getOwner()!;
1240
+ });
1241
+ this.disposeOwner = disposeOwner;
1242
+ this.owner = scopeOwner;
1243
+ scopeCleanups.set(this, []);
1244
+ if (!detached) {
1245
+ const parent = getCurrentScope();
1246
+ if (parent && parent.active) {
1247
+ this.parent = parent;
1248
+ parent.scopes.add(this);
1249
+ } else {
1250
+ const outer = getOwner();
1251
+ if (outer && !outer.disposed) {
1252
+ onCleanup(() => this.stop(true));
1253
+ }
1254
+ }
1255
+ }
1256
+ }
1257
+
1258
+ get active(): boolean {
1259
+ return this.isActive;
1260
+ }
1261
+
1262
+ run<T>(fn: () => T): T | undefined {
1263
+ if (!this.isActive) return undefined;
1264
+ return runEffectScope(this, this.owner, fn);
1265
+ }
1266
+
1267
+ stop(fromParent = false): void {
1268
+ if (!this.isActive) return;
1269
+ this.isActive = false;
1270
+ let failed = false;
1271
+ let failure: unknown;
1272
+ try {
1273
+ this.disposeOwner();
1274
+ } catch (error) {
1275
+ failed = true;
1276
+ failure = error;
1277
+ }
1278
+ for (const child of Array.from(this.scopes)) {
1279
+ this.scopes.delete(child);
1280
+ try {
1281
+ child.stop(true);
1282
+ } catch (error) {
1283
+ if (!failed) failure = error;
1284
+ failed = true;
1285
+ }
1286
+ }
1287
+ const cleanups = scopeCleanups.get(this);
1288
+ if (cleanups) {
1289
+ for (const cleanup of cleanups.splice(0)) {
1290
+ try {
1291
+ untrack(cleanup);
1292
+ } catch (error) {
1293
+ if (!failed) failure = error;
1294
+ failed = true;
1295
+ }
1296
+ }
1297
+ }
1298
+ if (!fromParent && this.parent) {
1299
+ this.parent.scopes.delete(this);
1300
+ }
1301
+ if (failed) throw failure;
1302
+ }
1303
+ }
1304
+
1305
+ export function effectScope(detached?: boolean): EffectScope {
1306
+ return new EffectScope(detached);
1307
+ }
1308
+
1309
+ export function getCurrentScope(): EffectScope | undefined {
1310
+ if (activeEffectScope) {
1311
+ return activeEffectScope.active ? activeEffectScope : undefined;
1312
+ }
1313
+ const frame = peekComponentContext();
1314
+ if (frame?.active && !frame.owner.disposed) {
1315
+ let scope = componentScopes.get(frame);
1316
+ if (!scope) {
1317
+ scope = new EffectScope(true);
1318
+ componentScopes.set(frame, scope);
1319
+ runWithOwner(frame.owner, () => {
1320
+ onCleanup(() => scope!.stop(true));
1321
+ });
1322
+ }
1323
+ return scope.active ? scope : undefined;
1324
+ }
1325
+ return undefined;
1326
+ }
1327
+
1328
+ export function onScopeDispose(fn: () => void, failSilently = false): void {
1329
+ if (typeof fn !== "function")
1330
+ throw new TypeError("onScopeDispose callback must be a function");
1331
+ const scope = getCurrentScope();
1332
+ if (scope) {
1333
+ scopeCleanups.get(scope)?.push(fn);
1334
+ } else if (!failSilently) {
1335
+ throw new Error("onScopeDispose requires an active effectScope");
1336
+ }
1337
+ }
1338
+
1339
+ export type TemplateRef<T = unknown> = Readonly<Ref<T | null>>;
1340
+
1341
+ const templateRefBindings = new WeakMap<
1342
+ Ref<any>,
1343
+ {
1344
+ get: () => any;
1345
+ set: (value: any) => void;
1346
+ }
1347
+ >();
1348
+ const componentTemplateRefKeys = new WeakMap<ComponentContext, Set<string>>();
1349
+
1350
+ /** Internal binder lookup for readonly useTemplateRef instances. */
1351
+ export function getTemplateRefBinding<T>(target: Readonly<Ref<T | null>>):
1352
+ | {
1353
+ get: () => T | null | undefined;
1354
+ set: (value: T | null) => void;
1355
+ }
1356
+ | undefined {
1357
+ return templateRefBindings.get(target as Ref<any>);
1358
+ }
1359
+
1360
+ /** Native component template ref; readonly to user code, bound by template ref wave. */
1361
+ export function useTemplateRef<T = unknown, K extends string = string>(
1362
+ key: K,
1363
+ ): TemplateRef<T> {
1364
+ const frame = getComponentContext();
1365
+ if (typeof key !== "string" || key.length === 0)
1366
+ throw new TypeError("Template ref key must be a non-empty string");
1367
+ let keys = componentTemplateRefKeys.get(frame);
1368
+ if (!keys) {
1369
+ keys = new Set();
1370
+ componentTemplateRefKeys.set(frame, keys);
1371
+ }
1372
+ if (keys.has(key))
1373
+ throw new Error(`useTemplateRef(${JSON.stringify(key)}) already exists`);
1374
+ keys.add(key);
1375
+ if (frame.mode === "ssr") return new Ref<T | null>(() => null);
1376
+ const [read, write] = createSignal<T | null>(null, { equals: Object.is });
1377
+ const refObject = new Ref<T | null>(read);
1378
+ templateRefBindings.set(refObject, { get: read, set: write });
1379
+ return refObject;
1380
+ }
1381
+
1382
+ export interface DefineModelOptions<T = any, G = T, S = T> {
1383
+ default?: any;
1384
+ required?: boolean;
1385
+ get?: (v: T) => G;
1386
+ set?: (v: S) => any;
1387
+ }
1388
+
1389
+ export type ModelRef<T, M extends PropertyKey = string, G = T, S = T> = Ref<
1390
+ G,
1391
+ S
1392
+ > &
1393
+ [ModelRef<T, M, G, S>, Record<M, true | undefined>];
1394
+
1395
+ const camelizeModelKey = (key: string) =>
1396
+ key.replace(/-(\w)/g, (_, letter: string) => letter.toUpperCase());
1397
+ const hyphenateModelKey = (key: string) =>
1398
+ key.replace(/\B([A-Z])/g, "-$1").toLowerCase();
1399
+ const emptyModelModifiers: Record<PropertyKey, true | undefined> =
1400
+ /* @__PURE__ */ Object.freeze({});
1401
+ const unsetModelValue = /* @__PURE__ */ Symbol("moonshine.vue.model.unset");
1402
+ const hasListenerOn = (target: object, key: string) =>
1403
+ key in target && Reflect.get(target, key, target) != null;
1404
+
1405
+ export function createModel<V, M extends PropertyKey = string, G = V, S = V>(
1406
+ props: Record<string, any>,
1407
+ name: string,
1408
+ options?: DefineModelOptions<V, G, S>,
1409
+ booleanCast?: boolean,
1410
+ soleFunction = false,
1411
+ ): ModelRef<V, M, G, S> {
1412
+ const frame = getComponentContext();
1413
+ if (props === null || typeof props !== "object" || Array.isArray(props)) {
1414
+ throw new TypeError("useModel requires a props object");
1415
+ }
1416
+ if (typeof name !== "string" || name.length === 0) {
1417
+ throw new TypeError("useModel requires a non-empty string prop name");
1418
+ }
1419
+ if (
1420
+ options !== undefined &&
1421
+ (options === null || typeof options !== "object" || Array.isArray(options))
1422
+ ) {
1423
+ throw new TypeError("useModel options must be an object");
1424
+ }
1425
+ if (options?.get !== undefined && typeof options.get !== "function") {
1426
+ throw new TypeError("useModel get option must be a function");
1427
+ }
1428
+ if (options?.set !== undefined && typeof options.set !== "function") {
1429
+ throw new TypeError("useModel set option must be a function");
1430
+ }
1431
+ const raw = (
1432
+ frame.props !== null &&
1433
+ typeof frame.props === "object" &&
1434
+ !Array.isArray(frame.props)
1435
+ ? frame.props
1436
+ : props
1437
+ ) as Record<string, unknown>;
1438
+ const emit = createEmitter<Record<string, readonly unknown[]>>(raw);
1439
+ const camelName = camelizeModelKey(name);
1440
+ const hyphenName = hyphenateModelKey(camelName);
1441
+ const rawUpdateEvent = "update:" + name;
1442
+ const camelUpdateKey = "onUpdate:" + camelName;
1443
+ const rawUpdateKey = "onUpdate:" + name;
1444
+ const hyphenUpdateKey = "onUpdate:" + hyphenName;
1445
+
1446
+ const hasUpdateListener = () =>
1447
+ hasListenerOn(raw, camelUpdateKey) ||
1448
+ hasListenerOn(raw, rawUpdateKey) ||
1449
+ hasListenerOn(raw, hyphenUpdateKey) ||
1450
+ hasListenerOn(raw, camelUpdateKey + "Once") ||
1451
+ hasListenerOn(raw, rawUpdateKey + "Once") ||
1452
+ hasListenerOn(raw, hyphenUpdateKey + "Once") ||
1453
+ (props !== raw &&
1454
+ (hasListenerOn(props, camelUpdateKey) ||
1455
+ hasListenerOn(props, rawUpdateKey) ||
1456
+ hasListenerOn(props, hyphenUpdateKey)));
1457
+
1458
+ const hasDefaultOption = options !== undefined && "default" in options;
1459
+ let hasCachedDefault = false;
1460
+ let cachedDefault: unknown;
1461
+ const resolveDefault = () => {
1462
+ if (!hasDefaultOption) return undefined;
1463
+ const def = options!.default;
1464
+ if (!soleFunction && typeof def === "function") {
1465
+ if (!hasCachedDefault) {
1466
+ cachedDefault = withComponentConsumer(frame, () =>
1467
+ untrack(() => (def as () => unknown)()),
1468
+ );
1469
+ hasCachedDefault = true;
1470
+ }
1471
+ return cachedDefault;
1472
+ }
1473
+ return def;
1474
+ };
1475
+
1476
+ let prevRawOnly: unknown = unsetModelValue;
1477
+ const readIncomingProp = (): {
1478
+ hasProp: boolean;
1479
+ rawValue: unknown;
1480
+ resolved: V;
1481
+ } => {
1482
+ let hasProp = false;
1483
+ let propValue: unknown;
1484
+ if (name in raw) {
1485
+ hasProp = true;
1486
+ propValue = Reflect.get(raw, name, raw);
1487
+ } else if (camelName in raw) {
1488
+ hasProp = true;
1489
+ propValue = Reflect.get(raw, camelName, raw);
1490
+ } else if (hyphenName in raw) {
1491
+ hasProp = true;
1492
+ propValue = Reflect.get(raw, hyphenName, raw);
1493
+ }
1494
+ const rawOnly = propValue;
1495
+ if (props !== raw) {
1496
+ const fromProps =
1497
+ name in props
1498
+ ? Reflect.get(props, name, props)
1499
+ : Reflect.get(props, camelName, props);
1500
+ if (!hasProp && fromProps !== undefined) {
1501
+ hasProp = true;
1502
+ propValue = fromProps;
1503
+ } else if (
1504
+ hasProp &&
1505
+ propValue === undefined &&
1506
+ fromProps !== undefined &&
1507
+ (prevRawOnly === unsetModelValue || !Object.is(fromProps, prevRawOnly))
1508
+ ) {
1509
+ propValue = fromProps;
1510
+ }
1511
+ }
1512
+ if (rawOnly !== undefined) prevRawOnly = rawOnly;
1513
+ let resolved = propValue;
1514
+ if (resolved === undefined && hasDefaultOption) {
1515
+ resolved = resolveDefault();
1516
+ }
1517
+ if (booleanCast !== undefined) {
1518
+ if (!hasProp && !hasDefaultOption) {
1519
+ resolved = false;
1520
+ } else if (booleanCast && (resolved === "" || resolved === hyphenName)) {
1521
+ resolved = true;
1522
+ }
1523
+ }
1524
+ return { hasProp, rawValue: propValue, resolved: resolved as V };
1525
+ };
1526
+
1527
+ let forceTrigger = false;
1528
+ let writing = false;
1529
+ const initial = untrack(readIncomingProp);
1530
+ const [readLocal, writeLocal] = createSignal<V>(initial.resolved, {
1531
+ equals: (prev, next) => !forceTrigger && Object.is(prev, next),
1532
+ });
1533
+ let prevHasProp = initial.hasProp;
1534
+ let prevRawValue = initial.rawValue;
1535
+ let prevSetValue: unknown = unsetModelValue;
1536
+ let localWrittenInSSR = false;
1537
+
1538
+ if (frame.mode === "dom") {
1539
+ let initialized = false;
1540
+ createComputed(() => {
1541
+ const next = readIncomingProp();
1542
+ if (!initialized) {
1543
+ initialized = true;
1544
+ prevHasProp = next.hasProp;
1545
+ prevRawValue = next.rawValue;
1546
+ untrack(() => writeLocal(() => next.resolved));
1547
+ return;
1548
+ }
1549
+ if (
1550
+ next.hasProp !== prevHasProp ||
1551
+ !Object.is(next.rawValue, prevRawValue)
1552
+ ) {
1553
+ prevHasProp = next.hasProp;
1554
+ prevRawValue = next.rawValue;
1555
+ if (!writing) prevSetValue = unsetModelValue;
1556
+ untrack(() => writeLocal(() => next.resolved));
1557
+ }
1558
+ });
1559
+ }
1560
+
1561
+ const getter = options?.get;
1562
+ const setter = options?.set;
1563
+ let modelRef!: ModelRef<V, M, G, S>;
1564
+
1565
+ const read = (): G => {
1566
+ const value =
1567
+ frame.mode === "ssr" && !localWrittenInSSR
1568
+ ? readIncomingProp().resolved
1569
+ : readLocal();
1570
+ return getter ? getter(value) : (value as unknown as G);
1571
+ };
1572
+
1573
+ const write = (next: S): void => {
1574
+ const currentLocal =
1575
+ frame.mode === "ssr" && !localWrittenInSSR
1576
+ ? untrack(readIncomingProp).resolved
1577
+ : untrack(readLocal);
1578
+ const emittedValue = (setter ? setter(next) : next) as unknown as V;
1579
+ if (
1580
+ Object.is(emittedValue, currentLocal) &&
1581
+ Object.is(next, emittedValue) &&
1582
+ (prevSetValue === unsetModelValue || Object.is(next, prevSetValue))
1583
+ ) {
1584
+ return;
1585
+ }
1586
+ prevSetValue = next;
1587
+ localWrittenInSSR = true;
1588
+ refTriggerVersions.set(
1589
+ modelRef,
1590
+ (refTriggerVersions.get(modelRef) ?? 0) + 1,
1591
+ );
1592
+ writing = true;
1593
+ try {
1594
+ if (!Object.is(next, emittedValue)) {
1595
+ forceTrigger = true;
1596
+ }
1597
+ try {
1598
+ writeLocal(() => emittedValue);
1599
+ } finally {
1600
+ forceTrigger = false;
1601
+ }
1602
+ emit(rawUpdateEvent, emittedValue);
1603
+ const post = untrack(readIncomingProp);
1604
+ if (post.hasProp && hasUpdateListener()) {
1605
+ prevHasProp = post.hasProp;
1606
+ prevRawValue = post.rawValue;
1607
+ writeLocal(() => post.resolved);
1608
+ }
1609
+ } finally {
1610
+ writing = false;
1611
+ }
1612
+ };
1613
+
1614
+ const resolveModifiers = (): Record<PropertyKey, true | undefined> => {
1615
+ const mod =
1616
+ (camelName === "modelValue"
1617
+ ? (Reflect.get(raw, "modelModifiers", raw) ??
1618
+ Reflect.get(raw, "modelValueModifiers", raw) ??
1619
+ Reflect.get(raw, "model-valueModifiers", raw))
1620
+ : undefined) ??
1621
+ Reflect.get(raw, name + "Modifiers", raw) ??
1622
+ Reflect.get(raw, camelName + "Modifiers", raw) ??
1623
+ Reflect.get(raw, hyphenName + "Modifiers", raw) ??
1624
+ (props !== raw
1625
+ ? ((camelName === "modelValue"
1626
+ ? (Reflect.get(props, "modelModifiers", props) ??
1627
+ Reflect.get(props, "modelValueModifiers", props))
1628
+ : undefined) ??
1629
+ Reflect.get(props, name + "Modifiers", props) ??
1630
+ Reflect.get(props, camelName + "Modifiers", props))
1631
+ : undefined);
1632
+ if (!mod || typeof mod !== "object") return emptyModelModifiers;
1633
+ const normalized: Record<PropertyKey, true | undefined> = {};
1634
+ for (const key of Reflect.ownKeys(mod)) {
1635
+ if (Reflect.get(mod, key, mod)) {
1636
+ normalized[key] = true;
1637
+ }
1638
+ }
1639
+ return Object.freeze(normalized);
1640
+ };
1641
+ const modifiers = resolveModifiers() as Record<M, true | undefined>;
1642
+
1643
+ modelRef = new Ref<G, S>(read, write) as ModelRef<V, M, G, S>;
1644
+ refTriggers.set(modelRef, () => {
1645
+ forceTrigger = true;
1646
+ try {
1647
+ refTriggerVersions.set(
1648
+ modelRef,
1649
+ (refTriggerVersions.get(modelRef) ?? 0) + 1,
1650
+ );
1651
+ writeLocal((current) => current);
1652
+ } finally {
1653
+ forceTrigger = false;
1654
+ }
1655
+ });
1656
+ Object.defineProperty(modelRef, Symbol.iterator, {
1657
+ value: function* () {
1658
+ yield modelRef;
1659
+ yield modifiers;
1660
+ },
1661
+ writable: false,
1662
+ enumerable: false,
1663
+ configurable: true,
1664
+ });
1665
+ return modelRef;
1666
+ }
1667
+
1668
+ export function useModel<
1669
+ T extends Record<string, any>,
1670
+ K extends keyof T & string,
1671
+ M extends PropertyKey = string,
1672
+ G = Exclude<T[K], undefined>,
1673
+ S = Exclude<T[K], undefined>,
1674
+ >(
1675
+ props: T,
1676
+ name: K,
1677
+ options: DefineModelOptions<Exclude<T[K], undefined>, G, S> & {
1678
+ default: Exclude<T[K], undefined> | (() => Exclude<T[K], undefined>);
1679
+ },
1680
+ ): ModelRef<Exclude<T[K], undefined>, M, G, S>;
1681
+ export function useModel<
1682
+ T extends Record<string, any>,
1683
+ K extends keyof T & string,
1684
+ M extends PropertyKey = string,
1685
+ G = T[K],
1686
+ S = T[K],
1687
+ >(
1688
+ props: T,
1689
+ name: K,
1690
+ options?: DefineModelOptions<T[K], G, S>,
1691
+ ): ModelRef<T[K], M, G, S>;
1692
+ export function useModel<
1693
+ T extends Record<string, any>,
1694
+ K extends keyof T & string,
1695
+ M extends PropertyKey = string,
1696
+ G = T[K],
1697
+ S = T[K],
1698
+ >(
1699
+ props: T,
1700
+ name: K,
1701
+ options?: DefineModelOptions<T[K], G, S>,
1702
+ ): ModelRef<T[K], M, G, S> {
1703
+ return createModel<T[K], M, G, S>(props, name, options);
1704
+ }