@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.
package/src/render.ts ADDED
@@ -0,0 +1,365 @@
1
+ /** Compiler-private optional Vue defaults component scheduling. */
2
+ import { collectDeps, type Trackable } from "@tschk/moonshine/tracking";
3
+ import {
4
+ createComponentScope,
5
+ createRoot,
6
+ createSignal,
7
+ getOwner,
8
+ getRenderScheduler,
9
+ onCleanup,
10
+ runWithOwner,
11
+ untrack,
12
+ type Owner,
13
+ } from "@tschk/moonshine-dom/reactive";
14
+ import {
15
+ renderSchedulerKey,
16
+ type RenderScheduler,
17
+ } from "@tschk/moonshine-dom/render-scheduler";
18
+ import { isSSRRendering } from "@tschk/moonshine-dom/ssr-owner";
19
+ const groupKey = /* @__PURE__ */ Symbol("moonshine.vue.render-group");
20
+ type Order = {
21
+ parent?: Order;
22
+ next: number;
23
+ index: number;
24
+ read?: () => number;
25
+ };
26
+ type Job = {
27
+ owner: Owner;
28
+ order: Order;
29
+ phase: "pre" | "structural" | "render";
30
+ run: () => void;
31
+ pass: number;
32
+ };
33
+ type Group = {
34
+ order?: Order;
35
+ id: number;
36
+ owner: Owner;
37
+ jobs: Set<Job>;
38
+ posts: Set<() => void>;
39
+ blocked: boolean;
40
+ preparing: number;
41
+ pass: number;
42
+ };
43
+ let running: Group | undefined;
44
+ let nextId = 0,
45
+ flushing = false,
46
+ scheduled = false;
47
+ const pending = /* @__PURE__ */ new Set<Group>();
48
+ export function currentGroup(): Group | undefined {
49
+ return getOwner()?.context?.get(groupKey) as Group | undefined;
50
+ }
51
+ const alive = (g: Group) => !g.owner.disposed;
52
+ function enqueue(g: Group) {
53
+ if (!alive(g) || g.blocked) return;
54
+ pending.add(g);
55
+ if (!scheduled && !flushing) {
56
+ scheduled = true;
57
+ queueMicrotask(flush);
58
+ }
59
+ }
60
+ function compare(a: Order, b: Order) {
61
+ const path = (n: Order) => {
62
+ const p: Order[] = [];
63
+ for (let v: Order | undefined = n; v; v = v.parent) p.unshift(v);
64
+ return p;
65
+ };
66
+ const x = path(a),
67
+ y = path(b);
68
+ let i = 0;
69
+ while (x[i] && x[i] === y[i]) i++;
70
+ if (!x[i] || !y[i]) return x.length - y.length;
71
+ return untrack(
72
+ () => (x[i]!.read?.() ?? x[i]!.index) - (y[i]!.read?.() ?? y[i]!.index),
73
+ );
74
+ }
75
+ function drain(callbacks: Iterable<() => void>) {
76
+ let failed = false,
77
+ error: unknown;
78
+ for (const cb of callbacks)
79
+ try {
80
+ cb();
81
+ } catch (e) {
82
+ if (!failed) error = e;
83
+ failed = true;
84
+ }
85
+ if (failed) throw error;
86
+ }
87
+ function flush() {
88
+ if (flushing) return;
89
+ scheduled = false;
90
+ flushing = true;
91
+ let failed = false,
92
+ error: unknown;
93
+ const counts = new Map<Group, number>();
94
+ const postCounts = new Map<Group, number>();
95
+ try {
96
+ do {
97
+ while (pending.size) {
98
+ // oxlint-disable-next-line unicorn/no-array-sort -- sort an already fresh snapshot.
99
+ const g = [...pending].sort(
100
+ (a, b) => compare(a.order!, b.order!) || a.id - b.id,
101
+ )[0]!;
102
+ pending.delete(g);
103
+ if (!alive(g) || g.blocked || g.preparing) continue;
104
+ const count = (counts.get(g) ?? 0) + 1;
105
+ counts.set(g, count);
106
+ try {
107
+ if (count > 1000) throw Error("Vue render update limit exceeded");
108
+ running = g;
109
+ g.pass++;
110
+ const ran = new Set<Job>();
111
+ while (true) {
112
+ const jobs = [...g.jobs]
113
+ .filter(
114
+ (j) => !j.owner.disposed && !ran.has(j) && j.pass !== g.pass,
115
+ )
116
+ // oxlint-disable-next-line unicorn/no-array-sort -- sort an already fresh filtered snapshot.
117
+ .sort(
118
+ (a, b) =>
119
+ (a.phase === "pre" ? 0 : a.phase === "structural" ? 1 : 2) -
120
+ (b.phase === "pre"
121
+ ? 0
122
+ : b.phase === "structural"
123
+ ? 1
124
+ : 2) || compare(a.order, b.order),
125
+ );
126
+ const job = jobs[0];
127
+ if (!job || !alive(g) || g.blocked) break;
128
+ ran.add(job);
129
+ job.pass = g.pass;
130
+ job.run();
131
+ }
132
+ } catch (e) {
133
+ if (!failed) error = e;
134
+ failed = true;
135
+ } finally {
136
+ running = undefined;
137
+ }
138
+ }
139
+ // Child groups post before their live ancestors; callback registration order within group.
140
+ // oxlint-disable-next-line unicorn/no-array-sort -- sort an already fresh snapshot.
141
+ const posts = [...postGroups].sort((a, b) => {
142
+ const ancestor = (x: Order, y: Order) => {
143
+ for (let v: Order | undefined = y; v; v = v.parent)
144
+ if (v === x) return true;
145
+ return false;
146
+ };
147
+ return ancestor(a.order!, b.order!)
148
+ ? 1
149
+ : ancestor(b.order!, a.order!)
150
+ ? -1
151
+ : compare(a.order!, b.order!) || a.id - b.id;
152
+ });
153
+ postGroups.clear();
154
+ for (const g of posts) {
155
+ const callbacks = [...g.posts];
156
+ g.posts.clear();
157
+ try {
158
+ const count = (postCounts.get(g) ?? 0) + 1;
159
+ postCounts.set(g, count);
160
+ if (count > 1000) throw Error("Vue post update limit exceeded");
161
+ drain(callbacks);
162
+ } catch (e) {
163
+ if (!failed) error = e;
164
+ failed = true;
165
+ }
166
+ }
167
+ } while (pending.size || postGroups.size);
168
+ } finally {
169
+ flushing = false;
170
+ if (pending.size || postGroups.size) {
171
+ scheduled = true;
172
+ queueMicrotask(flush);
173
+ }
174
+ }
175
+ if (failed) throw error;
176
+ }
177
+ const postGroups = /* @__PURE__ */ new Set<Group>();
178
+ export function prepareProps<T>(group: Group | undefined, fn: () => T): T {
179
+ if (!group) return fn();
180
+ group.preparing++;
181
+ let success = false;
182
+ try {
183
+ const value = fn();
184
+ success = true;
185
+ return value;
186
+ } finally {
187
+ group.preparing--;
188
+ if (alive(group)) {
189
+ group.blocked = !success;
190
+ if (success) enqueue(group);
191
+ else pending.delete(group);
192
+ }
193
+ }
194
+ }
195
+ function install<T>(
196
+ fn: () => T,
197
+ parent?: Order,
198
+ existing?: Group,
199
+ read?: () => number,
200
+ ): T {
201
+ const owner = getOwner();
202
+ if (!owner || owner.disposed)
203
+ throw Error("Vue scheduler requires live owner");
204
+ const group = existing ?? {
205
+ id: nextId++,
206
+ owner,
207
+ jobs: new Set<Job>(),
208
+ posts: new Set<() => void>(),
209
+ blocked: false,
210
+ preparing: 0,
211
+ pass: 0,
212
+ };
213
+ const order: Order = {
214
+ parent,
215
+ next: 0,
216
+ index: parent ? parent.next++ : 0,
217
+ read,
218
+ };
219
+ if (!existing) group.order = order;
220
+ const before = owner.context;
221
+ owner.context = new Map(before);
222
+ owner.context.set(groupKey, group);
223
+ owner.context.set(renderSchedulerKey, carrier(group, order));
224
+ if (!existing)
225
+ onCleanup(() => {
226
+ pending.delete(group);
227
+ postGroups.delete(group);
228
+ group.posts.clear();
229
+ });
230
+ return fn();
231
+ }
232
+ type VueCarrier = RenderScheduler & { [groupKey]: Group };
233
+ function carrier(group: Group, parent: Order): VueCarrier {
234
+ return {
235
+ [groupKey]: group,
236
+ effect(fn, initial) {
237
+ let previous = initial;
238
+ registerJob(group, parent, "render", () => {
239
+ previous = fn(previous);
240
+ });
241
+ },
242
+ memo: ((fn: any, initial: any, options: any) => {
243
+ const [read, write] = createSignal(initial, options);
244
+ registerJob(group, parent, "structural", () =>
245
+ write(() => fn(untrack(read))),
246
+ );
247
+ return read;
248
+ }) as RenderScheduler["memo"],
249
+ component(fn) {
250
+ return install(fn, parent);
251
+ },
252
+ branch(fn, order) {
253
+ return install(fn, parent, group, order);
254
+ },
255
+ reorder() {
256
+ if (running !== group) enqueue(group);
257
+ },
258
+ pre(fn) {
259
+ registerJob(group, parent, "pre", () => {
260
+ const stop = fn();
261
+ if (typeof stop === "function") onCleanup(stop);
262
+ });
263
+ },
264
+ post(fn) {
265
+ group.posts.add(fn);
266
+ postGroups.add(group);
267
+ if (!scheduled && !flushing) {
268
+ scheduled = true;
269
+ queueMicrotask(flush);
270
+ }
271
+ },
272
+ };
273
+ }
274
+ function registerJob(
275
+ group: Group,
276
+ parent: Order,
277
+ phase: Job["phase"],
278
+ fn: () => void,
279
+ ) {
280
+ const owner = createComponentScope(() => getOwner()!);
281
+ const order: Order = { parent, next: 0, index: parent.next++ };
282
+ let stopRun: (() => void) | undefined;
283
+ let subscriptions = new Map<Trackable, () => void>();
284
+ const value: Job = { owner, order, phase, run, pass: group.pass };
285
+ group.jobs.add(value);
286
+ function close() {
287
+ group.jobs.delete(value);
288
+ const old = stopRun;
289
+ stopRun = undefined;
290
+ const callbacks = [...subscriptions.values(), ...(old ? [old] : [])];
291
+ subscriptions.clear();
292
+ drain(callbacks);
293
+ }
294
+ function run() {
295
+ if (owner.disposed || !alive(group)) return;
296
+ const old = stopRun;
297
+ stopRun = undefined;
298
+ old?.();
299
+ if (owner.disposed) return;
300
+ let found: Trackable[] = [];
301
+ const versions = new Map<Trackable, number>();
302
+ runWithOwner(owner, () =>
303
+ createRoot((stop) => {
304
+ const scope = getOwner()!;
305
+ stopRun = stop;
306
+ scope.context = new Map(scope.context);
307
+ scope.context.set(renderSchedulerKey, carrier(group, order));
308
+ createComponentScope(() => {
309
+ found = collectDeps(fn, (dep) => versions.set(dep, dep.version));
310
+ });
311
+ if (!owner.disposed) {
312
+ scope.parent = owner;
313
+ owner.children.add(scope);
314
+ }
315
+ }),
316
+ );
317
+ if (owner.disposed) {
318
+ close();
319
+ return;
320
+ }
321
+ const next = new Map<Trackable, () => void>();
322
+ try {
323
+ for (const dep of found)
324
+ next.set(
325
+ dep,
326
+ subscriptions.get(dep) ??
327
+ dep.subscribe(() => {
328
+ if (running !== group || value.pass === group.pass)
329
+ enqueue(group);
330
+ }),
331
+ );
332
+ } catch (e) {
333
+ try {
334
+ drain(next.values());
335
+ close();
336
+ } catch {}
337
+ throw e;
338
+ }
339
+ const removed = [...subscriptions]
340
+ .filter(([dep]) => !next.has(dep))
341
+ .map(([, stop]) => stop);
342
+ subscriptions = next;
343
+ drain(removed);
344
+ if (found.some((dep) => versions.get(dep) !== dep.version)) enqueue(group);
345
+ }
346
+ runWithOwner(owner, () => onCleanup(close));
347
+ try {
348
+ run();
349
+ } catch (e) {
350
+ try {
351
+ close();
352
+ } catch {}
353
+ throw e;
354
+ }
355
+ }
356
+ export function withVueScheduler<T>(fn: () => T): T {
357
+ if (isSSRRendering()) return fn();
358
+ const group = currentGroup();
359
+ const current = getRenderScheduler() as VueCarrier | undefined;
360
+ if (group && current?.[groupKey] === group && alive(group)) {
361
+ if (getOwner()?.disposed) throw Error("Vue scheduler requires live owner");
362
+ return fn();
363
+ }
364
+ return install(fn);
365
+ }
@@ -0,0 +1,24 @@
1
+ /** Compiler-facing option selection; source SSR differs from mounted select policy. */
2
+ import { h, type SSRChild } from "@tschk/moonshine-dom/ssr";
3
+ import { equalModelValue } from "./model-equality";
4
+
5
+ export function createServerModelOption(
6
+ props: Record<string, unknown>,
7
+ children: SSRChild,
8
+ read: () => unknown,
9
+ ): SSRChild {
10
+ const attributes: Record<string, unknown> = Object.create(null);
11
+ for (const key of Object.keys(props))
12
+ if (key !== "value") attributes[key] = () => props[key];
13
+ const value = "value" in props ? props.value : null;
14
+ if (value != null && ["string", "number", "boolean"].includes(typeof value))
15
+ attributes.value = value;
16
+ const model = read();
17
+ if (
18
+ Array.isArray(model)
19
+ ? model.some((entry) => equalModelValue(entry, value))
20
+ : equalModelValue(model, value)
21
+ )
22
+ attributes.selected = true;
23
+ return h("option", attributes, children);
24
+ }
package/src/select.ts ADDED
@@ -0,0 +1,159 @@
1
+ /** Opt-in Vue source select policy; independent of Svelte default/reset adoption. */
2
+ import { h, type DOMChild } from "@tschk/moonshine-dom/dom";
3
+ import {
4
+ createRenderEffect,
5
+ getOwner,
6
+ getRenderScheduler,
7
+ onCleanup,
8
+ untrack,
9
+ } from "@tschk/moonshine-dom/reactive";
10
+ import { equalModelValue } from "./model-equality";
11
+
12
+ const values = new WeakMap<HTMLOptionElement, unknown>();
13
+ const refresh = new WeakMap<HTMLSelectElement, () => void>();
14
+ const valueOf = (option: HTMLOptionElement): unknown =>
15
+ values.has(option) ? values.get(option) : option.value;
16
+
17
+ /** Bind after options; the returned refresh also supports factories building children. */
18
+ export function bindSelectModel(
19
+ select: HTMLSelectElement,
20
+ read: () => unknown,
21
+ write: (value: unknown) => void,
22
+ number = false,
23
+ ): () => void {
24
+ const owner = getOwner();
25
+ if (!owner || owner.disposed)
26
+ throw new Error("Select models require a live native owner");
27
+ if (!(select instanceof HTMLSelectElement))
28
+ throw new TypeError("Select models require a select element");
29
+ if (typeof read !== "function" || typeof write !== "function")
30
+ throw new TypeError("Select models require getter/setter functions");
31
+ if (refresh.has(select))
32
+ throw new Error("Select already has a model binding");
33
+ let active = true;
34
+ let assigning = false;
35
+ const apply = () => {
36
+ const model = read();
37
+ if (!active) return;
38
+ if (select.multiple) {
39
+ if (!Array.isArray(model) && !(model instanceof Set)) return;
40
+ for (const option of select.options) {
41
+ const value = valueOf(option);
42
+ const selected =
43
+ model instanceof Set
44
+ ? model.has(value)
45
+ : model.some((entry) => equalModelValue(entry, value));
46
+ if (!assigning) option.selected = selected;
47
+ }
48
+ } else {
49
+ let found = false;
50
+ for (const option of select.options) {
51
+ const matches = !found && equalModelValue(model, valueOf(option));
52
+ if (!assigning) option.selected = matches;
53
+ if (matches) found = true;
54
+ }
55
+ if (!found && !assigning) select.selectedIndex = -1;
56
+ }
57
+ };
58
+ const change = () =>
59
+ untrack(() => {
60
+ const selected = Array.from(select.options)
61
+ .filter((option) => option.selected)
62
+ .map((option) => {
63
+ const value = valueOf(option);
64
+ if (!number || typeof value !== "string") return value;
65
+ const parsed = Number.parseFloat(value);
66
+ return Number.isNaN(parsed) ? value : parsed;
67
+ });
68
+ const model = read();
69
+ assigning = true;
70
+ try {
71
+ write(
72
+ select.multiple
73
+ ? model instanceof Set
74
+ ? new Set(selected)
75
+ : selected
76
+ : selected[0],
77
+ );
78
+ } finally {
79
+ queueMicrotask(() => {
80
+ assigning = false;
81
+ });
82
+ }
83
+ });
84
+ select.addEventListener("change", change);
85
+ const observer = new MutationObserver(() => {
86
+ if (active) untrack(apply);
87
+ });
88
+ refresh.set(select, apply);
89
+ onCleanup(() => {
90
+ active = false;
91
+ observer.disconnect();
92
+ refresh.delete(select);
93
+ select.removeEventListener("change", change);
94
+ });
95
+ createRenderEffect(apply);
96
+ observer.observe(select, {
97
+ childList: true,
98
+ subtree: true,
99
+ characterData: true,
100
+ attributes: true,
101
+ attributeFilter: ["value", "selected", "multiple"],
102
+ });
103
+ return () => untrack(apply);
104
+ }
105
+
106
+ /** Compiler-facing typed option; omitted values retain the DOM text fallback. */
107
+ export function createModelOption(
108
+ props: Record<string, unknown>,
109
+ children: DOMChild,
110
+ ): HTMLOptionElement {
111
+ const attributes: Record<string, unknown> = Object.create(null);
112
+ for (const key of Object.keys(props))
113
+ if (key !== "ref")
114
+ attributes[key] = key.startsWith("on") ? props[key] : () => props[key];
115
+ if ("ref" in props)
116
+ attributes.ref = (option: HTMLOptionElement) => {
117
+ if (typeof props.ref === "function")
118
+ (props.ref as (node: HTMLOptionElement) => void)(option);
119
+ };
120
+ const option = h("option", attributes, children);
121
+ if ("value" in props)
122
+ createRenderEffect(() => {
123
+ values.set(option, props.value);
124
+ const select = option.closest("select");
125
+ if (select) untrack(() => refresh.get(select)?.());
126
+ });
127
+ return option;
128
+ }
129
+
130
+ /** Register the model before user handlers, then synchronously select built options. */
131
+ export function createSelectModel(
132
+ props: Record<string, unknown>,
133
+ read: () => unknown,
134
+ write: (value: unknown) => void,
135
+ children: DOMChild,
136
+ number = false,
137
+ ): HTMLSelectElement {
138
+ const attributes: Record<string, unknown> = Object.create(null);
139
+ for (const key of Object.keys(props))
140
+ if (!key.startsWith("on") && key !== "ref")
141
+ attributes[key] = () => props[key];
142
+ let apply!: () => void;
143
+ attributes.ref = (select: HTMLSelectElement) => {
144
+ apply = bindSelectModel(select, read, write, number);
145
+ };
146
+ for (const key of Object.keys(props))
147
+ if (key.startsWith("on")) attributes[key] = props[key];
148
+ const select = h("select", attributes, children);
149
+ apply();
150
+ if (typeof props.ref === "function")
151
+ (props.ref as (node: HTMLSelectElement) => void)(select);
152
+ return select;
153
+ }
154
+
155
+ /** Compiler helper elements share the authored component's update group. */
156
+ export function captureSelectScope(): <T>(fn: () => T) => T {
157
+ const scheduler = getRenderScheduler();
158
+ return (fn) => (scheduler ? scheduler.branch(fn) : fn());
159
+ }
package/src/set.ts ADDED
@@ -0,0 +1,145 @@
1
+ /** Independent Set instrumentation on the native graph. */
2
+ import { isTracking } from "@tschk/moonshine/tracking";
3
+ import { batch, createSignal } from "@tschk/moonshine-dom/reactive";
4
+
5
+ type Cell = ReturnType<typeof createSignal<number>>;
6
+ type State = {
7
+ target: Set<unknown>;
8
+ wrap: (value: unknown) => unknown;
9
+ raw: (value: unknown) => unknown;
10
+ keys: Map<unknown, Cell>;
11
+ objects: WeakMap<object, Cell>;
12
+ iteration?: Cell;
13
+ cleared?: Cell;
14
+ };
15
+ const states = new WeakMap<object, State>();
16
+ function state(value: object): State {
17
+ const found = states.get(value);
18
+ if (!found) throw new TypeError("Set method requires a native reactive Set");
19
+ return found;
20
+ }
21
+ const objectKey = (key: unknown): key is object =>
22
+ (typeof key === "object" && key !== null) || typeof key === "function";
23
+ function cell(s: State, key: unknown, create = false): Cell | undefined {
24
+ let found = objectKey(key) ? s.objects.get(key) : s.keys.get(key);
25
+ if (!found && create) {
26
+ found = createSignal(0);
27
+ if (objectKey(key)) s.objects.set(key, found);
28
+ else s.keys.set(key, found);
29
+ }
30
+ return found;
31
+ }
32
+ function trackKey(s: State, key: unknown): void {
33
+ if (!isTracking()) return;
34
+ (s.cleared ??= createSignal(0))[0]();
35
+ cell(s, key, true)![0]();
36
+ }
37
+ function trackIteration(s: State): void {
38
+ if (isTracking()) (s.iteration ??= createSignal(0))[0]();
39
+ }
40
+ function bump(signal: Cell | undefined): void {
41
+ signal?.[1]((version) => version + 1);
42
+ }
43
+ function changed(s: State, key: unknown): void {
44
+ batch(() => {
45
+ bump(cell(s, key));
46
+ bump(s.iteration);
47
+ });
48
+ }
49
+ function iterator(receiver: Set<unknown>, entries: boolean): SetIterator<any> {
50
+ const s = state(receiver);
51
+ trackIteration(s);
52
+ return (function* () {
53
+ for (const value of s.target) {
54
+ const wrapped = s.wrap(value);
55
+ yield entries ? [wrapped, wrapped] : wrapped;
56
+ }
57
+ return undefined;
58
+ })();
59
+ }
60
+ const methods = {
61
+ get size() {
62
+ const s = state(this);
63
+ trackIteration(s);
64
+ return s.target.size;
65
+ },
66
+ has(this: Set<unknown>, key: unknown) {
67
+ const s = state(this),
68
+ raw = s.raw(key);
69
+ trackKey(s, key);
70
+ if (!Object.is(key, raw)) trackKey(s, raw);
71
+ return s.target.has(key) || s.target.has(raw);
72
+ },
73
+ add(this: Set<unknown>, value: unknown) {
74
+ const s = state(this),
75
+ key = s.raw(value);
76
+ if (!s.target.has(key)) {
77
+ s.target.add(key);
78
+ changed(s, key);
79
+ }
80
+ return this;
81
+ },
82
+ delete(this: Set<unknown>, value: unknown) {
83
+ const s = state(this),
84
+ key = s.target.has(value) ? value : s.raw(value);
85
+ const deleted = s.target.delete(key);
86
+ if (deleted) changed(s, key);
87
+ return deleted;
88
+ },
89
+ clear(this: Set<unknown>) {
90
+ const s = state(this);
91
+ if (!s.target.size) return;
92
+ s.target.clear();
93
+ batch(() => {
94
+ bump(s.cleared);
95
+ bump(s.iteration);
96
+ });
97
+ },
98
+ keys(this: Set<unknown>) {
99
+ return iterator(this, false);
100
+ },
101
+ values(this: Set<unknown>) {
102
+ return iterator(this, false);
103
+ },
104
+ entries(this: Set<unknown>) {
105
+ return iterator(this, true);
106
+ },
107
+ [Symbol.iterator](this: Set<unknown>) {
108
+ return iterator(this, false);
109
+ },
110
+ forEach(
111
+ this: Set<unknown>,
112
+ callback: (value: unknown, key: unknown, set: Set<unknown>) => void,
113
+ thisArg?: unknown,
114
+ ) {
115
+ if (typeof callback !== "function")
116
+ throw new TypeError("Set callback must be a function");
117
+ const s = state(this);
118
+ trackIteration(s);
119
+ s.target.forEach((value) => {
120
+ const wrapped = s.wrap(value);
121
+ callback.call(thisArg, wrapped, wrapped, this);
122
+ });
123
+ },
124
+ };
125
+ export function createTrackedSet(
126
+ target: Set<unknown>,
127
+ wrap: State["wrap"],
128
+ raw: State["raw"],
129
+ ): Set<unknown> {
130
+ const proxy = new Proxy(target, {
131
+ get(source, key, receiver) {
132
+ return Object.hasOwn(methods, key) && key in source
133
+ ? Reflect.get(methods, key, receiver)
134
+ : Reflect.get(source, key, receiver);
135
+ },
136
+ });
137
+ states.set(proxy, {
138
+ target,
139
+ wrap,
140
+ raw,
141
+ keys: new Map(),
142
+ objects: new WeakMap(),
143
+ });
144
+ return proxy;
145
+ }
package/src/shims.d.ts ADDED
@@ -0,0 +1,17 @@
1
+ declare module "vue" {
2
+ export const ref: unknown;
3
+ export const computed: unknown;
4
+ export const watch: unknown;
5
+ export const reactive: unknown;
6
+ export const onMounted: unknown;
7
+ export const onUnmounted: unknown;
8
+ export const defineComponent: unknown;
9
+ export const h: unknown;
10
+ export const createApp: unknown;
11
+ }
12
+
13
+ declare module "vue/compiler-sfc" {
14
+ export const parse: unknown;
15
+ export const compileScript: unknown;
16
+ export const compileTemplate: unknown;
17
+ }