@vue/reactivity 3.2.40 → 3.2.42

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.
Files changed (9) hide show
  1. package/dist/reactivity.cjs.js +1222 -1219
  2. package/dist/reactivity.cjs.prod.js +1147 -1144
  3. package/dist/reactivity.d.ts +7 -4
  4. package/dist/reactivity.esm-browser.js +1278 -1271
  5. package/dist/reactivity.esm-browser.prod.js +1 -1
  6. package/dist/reactivity.esm-bundler.js +1236 -1233
  7. package/dist/reactivity.global.js +1278 -1271
  8. package/dist/reactivity.global.prod.js +1 -1
  9. package/package.json +2 -2
package/dist/reactivity.esm-browser.js CHANGED
@@ -1,1296 +1,1303 @@
1
- /**
2
- * Make a map and return a function for checking if a key
3
- * is in that map.
4
- * IMPORTANT: all calls of this function must be prefixed with
5
- * \/\*#\_\_PURE\_\_\*\/
6
- * So that rollup can tree-shake them if necessary.
7
- */
8
- function makeMap(str, expectsLowerCase) {
9
- const map = Object.create(null);
10
- const list = str.split(',');
11
- for (let i = 0; i < list.length; i++) {
12
- map[list[i]] = true;
13
- }
14
- return expectsLowerCase ? val => !!map[val.toLowerCase()] : val => !!map[val];
1
+ /**
2
+ * Make a map and return a function for checking if a key
3
+ * is in that map.
4
+ * IMPORTANT: all calls of this function must be prefixed with
5
+ * \/\*#\_\_PURE\_\_\*\/
6
+ * So that rollup can tree-shake them if necessary.
7
+ */
8
+ function makeMap(str, expectsLowerCase) {
9
+ const map = Object.create(null);
10
+ const list = str.split(',');
11
+ for (let i = 0; i < list.length; i++) {
12
+ map[list[i]] = true;
13
+ }
14
+ return expectsLowerCase ? val => !!map[val.toLowerCase()] : val => !!map[val];
15
15
  }
16
16
 
17
- Object.freeze({})
18
- ;
19
- Object.freeze([]) ;
20
- const extend = Object.assign;
21
- const hasOwnProperty = Object.prototype.hasOwnProperty;
22
- const hasOwn = (val, key) => hasOwnProperty.call(val, key);
23
- const isArray = Array.isArray;
24
- const isMap = (val) => toTypeString(val) === '[object Map]';
25
- const isFunction = (val) => typeof val === 'function';
26
- const isString = (val) => typeof val === 'string';
27
- const isSymbol = (val) => typeof val === 'symbol';
28
- const isObject = (val) => val !== null && typeof val === 'object';
29
- const objectToString = Object.prototype.toString;
30
- const toTypeString = (value) => objectToString.call(value);
31
- const toRawType = (value) => {
32
- // extract "RawType" from strings like "[object RawType]"
33
- return toTypeString(value).slice(8, -1);
34
- };
35
- const isIntegerKey = (key) => isString(key) &&
36
- key !== 'NaN' &&
37
- key[0] !== '-' &&
38
- '' + parseInt(key, 10) === key;
39
- const cacheStringFunction = (fn) => {
40
- const cache = Object.create(null);
41
- return ((str) => {
42
- const hit = cache[str];
43
- return hit || (cache[str] = fn(str));
44
- });
45
- };
46
- /**
47
- * @private
48
- */
49
- const capitalize = cacheStringFunction((str) => str.charAt(0).toUpperCase() + str.slice(1));
50
- // compare whether a value has changed, accounting for NaN.
51
- const hasChanged = (value, oldValue) => !Object.is(value, oldValue);
52
- const def = (obj, key, value) => {
53
- Object.defineProperty(obj, key, {
54
- configurable: true,
55
- enumerable: false,
56
- value
57
- });
17
+ Object.freeze({})
18
+ ;
19
+ Object.freeze([]) ;
20
+ const extend = Object.assign;
21
+ const hasOwnProperty = Object.prototype.hasOwnProperty;
22
+ const hasOwn = (val, key) => hasOwnProperty.call(val, key);
23
+ const isArray = Array.isArray;
24
+ const isMap = (val) => toTypeString(val) === '[object Map]';
25
+ const isFunction = (val) => typeof val === 'function';
26
+ const isString = (val) => typeof val === 'string';
27
+ const isSymbol = (val) => typeof val === 'symbol';
28
+ const isObject = (val) => val !== null && typeof val === 'object';
29
+ const objectToString = Object.prototype.toString;
30
+ const toTypeString = (value) => objectToString.call(value);
31
+ const toRawType = (value) => {
32
+ // extract "RawType" from strings like "[object RawType]"
33
+ return toTypeString(value).slice(8, -1);
34
+ };
35
+ const isIntegerKey = (key) => isString(key) &&
36
+ key !== 'NaN' &&
37
+ key[0] !== '-' &&
38
+ '' + parseInt(key, 10) === key;
39
+ const cacheStringFunction = (fn) => {
40
+ const cache = Object.create(null);
41
+ return ((str) => {
42
+ const hit = cache[str];
43
+ return hit || (cache[str] = fn(str));
44
+ });
45
+ };
46
+ /**
47
+ * @private
48
+ */
49
+ const capitalize = cacheStringFunction((str) => str.charAt(0).toUpperCase() + str.slice(1));
50
+ // compare whether a value has changed, accounting for NaN.
51
+ const hasChanged = (value, oldValue) => !Object.is(value, oldValue);
52
+ const def = (obj, key, value) => {
53
+ Object.defineProperty(obj, key, {
54
+ configurable: true,
55
+ enumerable: false,
56
+ value
57
+ });
58
+ };
59
+ const toNumber = (val) => {
60
+ const n = parseFloat(val);
61
+ return isNaN(n) ? val : n;
58
62
  };
59
63
 
60
- function warn(msg, ...args) {
61
- console.warn(`[Vue warn] ${msg}`, ...args);
64
+ function warn(msg, ...args) {
65
+ console.warn(`[Vue warn] ${msg}`, ...args);
62
66
  }
63
67
 
64
- let activeEffectScope;
65
- class EffectScope {
66
- constructor(detached = false) {
67
- /**
68
- * @internal
69
- */
70
- this.active = true;
71
- /**
72
- * @internal
73
- */
74
- this.effects = [];
75
- /**
76
- * @internal
77
- */
78
- this.cleanups = [];
79
- if (!detached && activeEffectScope) {
80
- this.parent = activeEffectScope;
81
- this.index =
82
- (activeEffectScope.scopes || (activeEffectScope.scopes = [])).push(this) - 1;
83
- }
84
- }
85
- run(fn) {
86
- if (this.active) {
87
- const currentEffectScope = activeEffectScope;
88
- try {
89
- activeEffectScope = this;
90
- return fn();
91
- }
92
- finally {
93
- activeEffectScope = currentEffectScope;
94
- }
95
- }
96
- else {
97
- warn(`cannot run an inactive effect scope.`);
98
- }
99
- }
100
- /**
101
- * This should only be called on non-detached scopes
102
- * @internal
103
- */
104
- on() {
105
- activeEffectScope = this;
106
- }
107
- /**
108
- * This should only be called on non-detached scopes
109
- * @internal
110
- */
111
- off() {
112
- activeEffectScope = this.parent;
113
- }
114
- stop(fromParent) {
115
- if (this.active) {
116
- let i, l;
117
- for (i = 0, l = this.effects.length; i < l; i++) {
118
- this.effects[i].stop();
119
- }
120
- for (i = 0, l = this.cleanups.length; i < l; i++) {
121
- this.cleanups[i]();
122
- }
123
- if (this.scopes) {
124
- for (i = 0, l = this.scopes.length; i < l; i++) {
125
- this.scopes[i].stop(true);
126
- }
127
- }
128
- // nested scope, dereference from parent to avoid memory leaks
129
- if (this.parent && !fromParent) {
130
- // optimized O(1) removal
131
- const last = this.parent.scopes.pop();
132
- if (last && last !== this) {
133
- this.parent.scopes[this.index] = last;
134
- last.index = this.index;
135
- }
136
- }
137
- this.active = false;
138
- }
139
- }
140
- }
141
- function effectScope(detached) {
142
- return new EffectScope(detached);
143
- }
144
- function recordEffectScope(effect, scope = activeEffectScope) {
145
- if (scope && scope.active) {
146
- scope.effects.push(effect);
147
- }
148
- }
149
- function getCurrentScope() {
150
- return activeEffectScope;
151
- }
152
- function onScopeDispose(fn) {
153
- if (activeEffectScope) {
154
- activeEffectScope.cleanups.push(fn);
155
- }
156
- else {
157
- warn(`onScopeDispose() is called when there is no active effect scope` +
158
- ` to be associated with.`);
159
- }
68
+ let activeEffectScope;
69
+ class EffectScope {
70
+ constructor(detached = false) {
71
+ this.detached = detached;
72
+ /**
73
+ * @internal
74
+ */
75
+ this.active = true;
76
+ /**
77
+ * @internal
78
+ */
79
+ this.effects = [];
80
+ /**
81
+ * @internal
82
+ */
83
+ this.cleanups = [];
84
+ this.parent = activeEffectScope;
85
+ if (!detached && activeEffectScope) {
86
+ this.index =
87
+ (activeEffectScope.scopes || (activeEffectScope.scopes = [])).push(this) - 1;
88
+ }
89
+ }
90
+ run(fn) {
91
+ if (this.active) {
92
+ const currentEffectScope = activeEffectScope;
93
+ try {
94
+ activeEffectScope = this;
95
+ return fn();
96
+ }
97
+ finally {
98
+ activeEffectScope = currentEffectScope;
99
+ }
100
+ }
101
+ else {
102
+ warn(`cannot run an inactive effect scope.`);
103
+ }
104
+ }
105
+ /**
106
+ * This should only be called on non-detached scopes
107
+ * @internal
108
+ */
109
+ on() {
110
+ activeEffectScope = this;
111
+ }
112
+ /**
113
+ * This should only be called on non-detached scopes
114
+ * @internal
115
+ */
116
+ off() {
117
+ activeEffectScope = this.parent;
118
+ }
119
+ stop(fromParent) {
120
+ if (this.active) {
121
+ let i, l;
122
+ for (i = 0, l = this.effects.length; i < l; i++) {
123
+ this.effects[i].stop();
124
+ }
125
+ for (i = 0, l = this.cleanups.length; i < l; i++) {
126
+ this.cleanups[i]();
127
+ }
128
+ if (this.scopes) {
129
+ for (i = 0, l = this.scopes.length; i < l; i++) {
130
+ this.scopes[i].stop(true);
131
+ }
132
+ }
133
+ // nested scope, dereference from parent to avoid memory leaks
134
+ if (!this.detached && this.parent && !fromParent) {
135
+ // optimized O(1) removal
136
+ const last = this.parent.scopes.pop();
137
+ if (last && last !== this) {
138
+ this.parent.scopes[this.index] = last;
139
+ last.index = this.index;
140
+ }
141
+ }
142
+ this.parent = undefined;
143
+ this.active = false;
144
+ }
145
+ }
146
+ }
147
+ function effectScope(detached) {
148
+ return new EffectScope(detached);
149
+ }
150
+ function recordEffectScope(effect, scope = activeEffectScope) {
151
+ if (scope && scope.active) {
152
+ scope.effects.push(effect);
153
+ }
154
+ }
155
+ function getCurrentScope() {
156
+ return activeEffectScope;
157
+ }
158
+ function onScopeDispose(fn) {
159
+ if (activeEffectScope) {
160
+ activeEffectScope.cleanups.push(fn);
161
+ }
162
+ else {
163
+ warn(`onScopeDispose() is called when there is no active effect scope` +
164
+ ` to be associated with.`);
165
+ }
160
166
  }
161
167
 
162
- const createDep = (effects) => {
163
- const dep = new Set(effects);
164
- dep.w = 0;
165
- dep.n = 0;
166
- return dep;
167
- };
168
- const wasTracked = (dep) => (dep.w & trackOpBit) > 0;
169
- const newTracked = (dep) => (dep.n & trackOpBit) > 0;
170
- const initDepMarkers = ({ deps }) => {
171
- if (deps.length) {
172
- for (let i = 0; i < deps.length; i++) {
173
- deps[i].w |= trackOpBit; // set was tracked
174
- }
175
- }
176
- };
177
- const finalizeDepMarkers = (effect) => {
178
- const { deps } = effect;
179
- if (deps.length) {
180
- let ptr = 0;
181
- for (let i = 0; i < deps.length; i++) {
182
- const dep = deps[i];
183
- if (wasTracked(dep) && !newTracked(dep)) {
184
- dep.delete(effect);
185
- }
186
- else {
187
- deps[ptr++] = dep;
188
- }
189
- // clear bits
190
- dep.w &= ~trackOpBit;
191
- dep.n &= ~trackOpBit;
192
- }
193
- deps.length = ptr;
194
- }
168
+ const createDep = (effects) => {
169
+ const dep = new Set(effects);
170
+ dep.w = 0;
171
+ dep.n = 0;
172
+ return dep;
173
+ };
174
+ const wasTracked = (dep) => (dep.w & trackOpBit) > 0;
175
+ const newTracked = (dep) => (dep.n & trackOpBit) > 0;
176
+ const initDepMarkers = ({ deps }) => {
177
+ if (deps.length) {
178
+ for (let i = 0; i < deps.length; i++) {
179
+ deps[i].w |= trackOpBit; // set was tracked
180
+ }
181
+ }
182
+ };
183
+ const finalizeDepMarkers = (effect) => {
184
+ const { deps } = effect;
185
+ if (deps.length) {
186
+ let ptr = 0;
187
+ for (let i = 0; i < deps.length; i++) {
188
+ const dep = deps[i];
189
+ if (wasTracked(dep) && !newTracked(dep)) {
190
+ dep.delete(effect);
191
+ }
192
+ else {
193
+ deps[ptr++] = dep;
194
+ }
195
+ // clear bits
196
+ dep.w &= ~trackOpBit;
197
+ dep.n &= ~trackOpBit;
198
+ }
199
+ deps.length = ptr;
200
+ }
195
201
  };
196
202
 
197
- const targetMap = new WeakMap();
198
- // The number of effects currently being tracked recursively.
199
- let effectTrackDepth = 0;
200
- let trackOpBit = 1;
201
- /**
202
- * The bitwise track markers support at most 30 levels of recursion.
203
- * This value is chosen to enable modern JS engines to use a SMI on all platforms.
204
- * When recursion depth is greater, fall back to using a full cleanup.
205
- */
206
- const maxMarkerBits = 30;
207
- let activeEffect;
208
- const ITERATE_KEY = Symbol('iterate' );
209
- const MAP_KEY_ITERATE_KEY = Symbol('Map key iterate' );
210
- class ReactiveEffect {
211
- constructor(fn, scheduler = null, scope) {
212
- this.fn = fn;
213
- this.scheduler = scheduler;
214
- this.active = true;
215
- this.deps = [];
216
- this.parent = undefined;
217
- recordEffectScope(this, scope);
218
- }
219
- run() {
220
- if (!this.active) {
221
- return this.fn();
222
- }
223
- let parent = activeEffect;
224
- let lastShouldTrack = shouldTrack;
225
- while (parent) {
226
- if (parent === this) {
227
- return;
228
- }
229
- parent = parent.parent;
230
- }
231
- try {
232
- this.parent = activeEffect;
233
- activeEffect = this;
234
- shouldTrack = true;
235
- trackOpBit = 1 << ++effectTrackDepth;
236
- if (effectTrackDepth <= maxMarkerBits) {
237
- initDepMarkers(this);
238
- }
239
- else {
240
- cleanupEffect(this);
241
- }
242
- return this.fn();
243
- }
244
- finally {
245
- if (effectTrackDepth <= maxMarkerBits) {
246
- finalizeDepMarkers(this);
247
- }
248
- trackOpBit = 1 << --effectTrackDepth;
249
- activeEffect = this.parent;
250
- shouldTrack = lastShouldTrack;
251
- this.parent = undefined;
252
- if (this.deferStop) {
253
- this.stop();
254
- }
255
- }
256
- }
257
- stop() {
258
- // stopped while running itself - defer the cleanup
259
- if (activeEffect === this) {
260
- this.deferStop = true;
261
- }
262
- else if (this.active) {
263
- cleanupEffect(this);
264
- if (this.onStop) {
265
- this.onStop();
266
- }
267
- this.active = false;
268
- }
269
- }
270
- }
271
- function cleanupEffect(effect) {
272
- const { deps } = effect;
273
- if (deps.length) {
274
- for (let i = 0; i < deps.length; i++) {
275
- deps[i].delete(effect);
276
- }
277
- deps.length = 0;
278
- }
279
- }
280
- function effect(fn, options) {
281
- if (fn.effect) {
282
- fn = fn.effect.fn;
283
- }
284
- const _effect = new ReactiveEffect(fn);
285
- if (options) {
286
- extend(_effect, options);
287
- if (options.scope)
288
- recordEffectScope(_effect, options.scope);
289
- }
290
- if (!options || !options.lazy) {
291
- _effect.run();
292
- }
293
- const runner = _effect.run.bind(_effect);
294
- runner.effect = _effect;
295
- return runner;
296
- }
297
- function stop(runner) {
298
- runner.effect.stop();
299
- }
300
- let shouldTrack = true;
301
- const trackStack = [];
302
- function pauseTracking() {
303
- trackStack.push(shouldTrack);
304
- shouldTrack = false;
305
- }
306
- function enableTracking() {
307
- trackStack.push(shouldTrack);
308
- shouldTrack = true;
309
- }
310
- function resetTracking() {
311
- const last = trackStack.pop();
312
- shouldTrack = last === undefined ? true : last;
313
- }
314
- function track(target, type, key) {
315
- if (shouldTrack && activeEffect) {
316
- let depsMap = targetMap.get(target);
317
- if (!depsMap) {
318
- targetMap.set(target, (depsMap = new Map()));
319
- }
320
- let dep = depsMap.get(key);
321
- if (!dep) {
322
- depsMap.set(key, (dep = createDep()));
323
- }
324
- const eventInfo = { effect: activeEffect, target, type, key }
325
- ;
326
- trackEffects(dep, eventInfo);
327
- }
328
- }
329
- function trackEffects(dep, debuggerEventExtraInfo) {
330
- let shouldTrack = false;
331
- if (effectTrackDepth <= maxMarkerBits) {
332
- if (!newTracked(dep)) {
333
- dep.n |= trackOpBit; // set newly tracked
334
- shouldTrack = !wasTracked(dep);
335
- }
336
- }
337
- else {
338
- // Full cleanup mode.
339
- shouldTrack = !dep.has(activeEffect);
340
- }
341
- if (shouldTrack) {
342
- dep.add(activeEffect);
343
- activeEffect.deps.push(dep);
344
- if (activeEffect.onTrack) {
345
- activeEffect.onTrack(Object.assign({ effect: activeEffect }, debuggerEventExtraInfo));
346
- }
347
- }
348
- }
349
- function trigger(target, type, key, newValue, oldValue, oldTarget) {
350
- const depsMap = targetMap.get(target);
351
- if (!depsMap) {
352
- // never been tracked
353
- return;
354
- }
355
- let deps = [];
356
- if (type === "clear" /* TriggerOpTypes.CLEAR */) {
357
- // collection being cleared
358
- // trigger all effects for target
359
- deps = [...depsMap.values()];
360
- }
361
- else if (key === 'length' && isArray(target)) {
362
- depsMap.forEach((dep, key) => {
363
- if (key === 'length' || key >= newValue) {
364
- deps.push(dep);
365
- }
366
- });
367
- }
368
- else {
369
- // schedule runs for SET | ADD | DELETE
370
- if (key !== void 0) {
371
- deps.push(depsMap.get(key));
372
- }
373
- // also run for iteration key on ADD | DELETE | Map.SET
374
- switch (type) {
375
- case "add" /* TriggerOpTypes.ADD */:
376
- if (!isArray(target)) {
377
- deps.push(depsMap.get(ITERATE_KEY));
378
- if (isMap(target)) {
379
- deps.push(depsMap.get(MAP_KEY_ITERATE_KEY));
380
- }
381
- }
382
- else if (isIntegerKey(key)) {
383
- // new index added to array -> length changes
384
- deps.push(depsMap.get('length'));
385
- }
386
- break;
387
- case "delete" /* TriggerOpTypes.DELETE */:
388
- if (!isArray(target)) {
389
- deps.push(depsMap.get(ITERATE_KEY));
390
- if (isMap(target)) {
391
- deps.push(depsMap.get(MAP_KEY_ITERATE_KEY));
392
- }
393
- }
394
- break;
395
- case "set" /* TriggerOpTypes.SET */:
396
- if (isMap(target)) {
397
- deps.push(depsMap.get(ITERATE_KEY));
398
- }
399
- break;
400
- }
401
- }
402
- const eventInfo = { target, type, key, newValue, oldValue, oldTarget }
403
- ;
404
- if (deps.length === 1) {
405
- if (deps[0]) {
406
- {
407
- triggerEffects(deps[0], eventInfo);
408
- }
409
- }
410
- }
411
- else {
412
- const effects = [];
413
- for (const dep of deps) {
414
- if (dep) {
415
- effects.push(...dep);
416
- }
417
- }
418
- {
419
- triggerEffects(createDep(effects), eventInfo);
420
- }
421
- }
422
- }
423
- function triggerEffects(dep, debuggerEventExtraInfo) {
424
- // spread into array for stabilization
425
- const effects = isArray(dep) ? dep : [...dep];
426
- for (const effect of effects) {
427
- if (effect.computed) {
428
- triggerEffect(effect, debuggerEventExtraInfo);
429
- }
430
- }
431
- for (const effect of effects) {
432
- if (!effect.computed) {
433
- triggerEffect(effect, debuggerEventExtraInfo);
434
- }
435
- }
436
- }
437
- function triggerEffect(effect, debuggerEventExtraInfo) {
438
- if (effect !== activeEffect || effect.allowRecurse) {
439
- if (effect.onTrigger) {
440
- effect.onTrigger(extend({ effect }, debuggerEventExtraInfo));
441
- }
442
- if (effect.scheduler) {
443
- effect.scheduler();
444
- }
445
- else {
446
- effect.run();
447
- }
448
- }
203
+ const targetMap = new WeakMap();
204
+ // The number of effects currently being tracked recursively.
205
+ let effectTrackDepth = 0;
206
+ let trackOpBit = 1;
207
+ /**
208
+ * The bitwise track markers support at most 30 levels of recursion.
209
+ * This value is chosen to enable modern JS engines to use a SMI on all platforms.
210
+ * When recursion depth is greater, fall back to using a full cleanup.
211
+ */
212
+ const maxMarkerBits = 30;
213
+ let activeEffect;
214
+ const ITERATE_KEY = Symbol('iterate' );
215
+ const MAP_KEY_ITERATE_KEY = Symbol('Map key iterate' );
216
+ class ReactiveEffect {
217
+ constructor(fn, scheduler = null, scope) {
218
+ this.fn = fn;
219
+ this.scheduler = scheduler;
220
+ this.active = true;
221
+ this.deps = [];
222
+ this.parent = undefined;
223
+ recordEffectScope(this, scope);
224
+ }
225
+ run() {
226
+ if (!this.active) {
227
+ return this.fn();
228
+ }
229
+ let parent = activeEffect;
230
+ let lastShouldTrack = shouldTrack;
231
+ while (parent) {
232
+ if (parent === this) {
233
+ return;
234
+ }
235
+ parent = parent.parent;
236
+ }
237
+ try {
238
+ this.parent = activeEffect;
239
+ activeEffect = this;
240
+ shouldTrack = true;
241
+ trackOpBit = 1 << ++effectTrackDepth;
242
+ if (effectTrackDepth <= maxMarkerBits) {
243
+ initDepMarkers(this);
244
+ }
245
+ else {
246
+ cleanupEffect(this);
247
+ }
248
+ return this.fn();
249
+ }
250
+ finally {
251
+ if (effectTrackDepth <= maxMarkerBits) {
252
+ finalizeDepMarkers(this);
253
+ }
254
+ trackOpBit = 1 << --effectTrackDepth;
255
+ activeEffect = this.parent;
256
+ shouldTrack = lastShouldTrack;
257
+ this.parent = undefined;
258
+ if (this.deferStop) {
259
+ this.stop();
260
+ }
261
+ }
262
+ }
263
+ stop() {
264
+ // stopped while running itself - defer the cleanup
265
+ if (activeEffect === this) {
266
+ this.deferStop = true;
267
+ }
268
+ else if (this.active) {
269
+ cleanupEffect(this);
270
+ if (this.onStop) {
271
+ this.onStop();
272
+ }
273
+ this.active = false;
274
+ }
275
+ }
276
+ }
277
+ function cleanupEffect(effect) {
278
+ const { deps } = effect;
279
+ if (deps.length) {
280
+ for (let i = 0; i < deps.length; i++) {
281
+ deps[i].delete(effect);
282
+ }
283
+ deps.length = 0;
284
+ }
285
+ }
286
+ function effect(fn, options) {
287
+ if (fn.effect) {
288
+ fn = fn.effect.fn;
289
+ }
290
+ const _effect = new ReactiveEffect(fn);
291
+ if (options) {
292
+ extend(_effect, options);
293
+ if (options.scope)
294
+ recordEffectScope(_effect, options.scope);
295
+ }
296
+ if (!options || !options.lazy) {
297
+ _effect.run();
298
+ }
299
+ const runner = _effect.run.bind(_effect);
300
+ runner.effect = _effect;
301
+ return runner;
302
+ }
303
+ function stop(runner) {
304
+ runner.effect.stop();
305
+ }
306
+ let shouldTrack = true;
307
+ const trackStack = [];
308
+ function pauseTracking() {
309
+ trackStack.push(shouldTrack);
310
+ shouldTrack = false;
311
+ }
312
+ function enableTracking() {
313
+ trackStack.push(shouldTrack);
314
+ shouldTrack = true;
315
+ }
316
+ function resetTracking() {
317
+ const last = trackStack.pop();
318
+ shouldTrack = last === undefined ? true : last;
319
+ }
320
+ function track(target, type, key) {
321
+ if (shouldTrack && activeEffect) {
322
+ let depsMap = targetMap.get(target);
323
+ if (!depsMap) {
324
+ targetMap.set(target, (depsMap = new Map()));
325
+ }
326
+ let dep = depsMap.get(key);
327
+ if (!dep) {
328
+ depsMap.set(key, (dep = createDep()));
329
+ }
330
+ const eventInfo = { effect: activeEffect, target, type, key }
331
+ ;
332
+ trackEffects(dep, eventInfo);
333
+ }
334
+ }
335
+ function trackEffects(dep, debuggerEventExtraInfo) {
336
+ let shouldTrack = false;
337
+ if (effectTrackDepth <= maxMarkerBits) {
338
+ if (!newTracked(dep)) {
339
+ dep.n |= trackOpBit; // set newly tracked
340
+ shouldTrack = !wasTracked(dep);
341
+ }
342
+ }
343
+ else {
344
+ // Full cleanup mode.
345
+ shouldTrack = !dep.has(activeEffect);
346
+ }
347
+ if (shouldTrack) {
348
+ dep.add(activeEffect);
349
+ activeEffect.deps.push(dep);
350
+ if (activeEffect.onTrack) {
351
+ activeEffect.onTrack(Object.assign({ effect: activeEffect }, debuggerEventExtraInfo));
352
+ }
353
+ }
354
+ }
355
+ function trigger(target, type, key, newValue, oldValue, oldTarget) {
356
+ const depsMap = targetMap.get(target);
357
+ if (!depsMap) {
358
+ // never been tracked
359
+ return;
360
+ }
361
+ let deps = [];
362
+ if (type === "clear" /* TriggerOpTypes.CLEAR */) {
363
+ // collection being cleared
364
+ // trigger all effects for target
365
+ deps = [...depsMap.values()];
366
+ }
367
+ else if (key === 'length' && isArray(target)) {
368
+ const newLength = toNumber(newValue);
369
+ depsMap.forEach((dep, key) => {
370
+ if (key === 'length' || key >= newLength) {
371
+ deps.push(dep);
372
+ }
373
+ });
374
+ }
375
+ else {
376
+ // schedule runs for SET | ADD | DELETE
377
+ if (key !== void 0) {
378
+ deps.push(depsMap.get(key));
379
+ }
380
+ // also run for iteration key on ADD | DELETE | Map.SET
381
+ switch (type) {
382
+ case "add" /* TriggerOpTypes.ADD */:
383
+ if (!isArray(target)) {
384
+ deps.push(depsMap.get(ITERATE_KEY));
385
+ if (isMap(target)) {
386
+ deps.push(depsMap.get(MAP_KEY_ITERATE_KEY));
387
+ }
388
+ }
389
+ else if (isIntegerKey(key)) {
390
+ // new index added to array -> length changes
391
+ deps.push(depsMap.get('length'));
392
+ }
393
+ break;
394
+ case "delete" /* TriggerOpTypes.DELETE */:
395
+ if (!isArray(target)) {
396
+ deps.push(depsMap.get(ITERATE_KEY));
397
+ if (isMap(target)) {
398
+ deps.push(depsMap.get(MAP_KEY_ITERATE_KEY));
399
+ }
400
+ }
401
+ break;
402
+ case "set" /* TriggerOpTypes.SET */:
403
+ if (isMap(target)) {
404
+ deps.push(depsMap.get(ITERATE_KEY));
405
+ }
406
+ break;
407
+ }
408
+ }
409
+ const eventInfo = { target, type, key, newValue, oldValue, oldTarget }
410
+ ;
411
+ if (deps.length === 1) {
412
+ if (deps[0]) {
413
+ {
414
+ triggerEffects(deps[0], eventInfo);
415
+ }
416
+ }
417
+ }
418
+ else {
419
+ const effects = [];
420
+ for (const dep of deps) {
421
+ if (dep) {
422
+ effects.push(...dep);
423
+ }
424
+ }
425
+ {
426
+ triggerEffects(createDep(effects), eventInfo);
427
+ }
428
+ }
429
+ }
430
+ function triggerEffects(dep, debuggerEventExtraInfo) {
431
+ // spread into array for stabilization
432
+ const effects = isArray(dep) ? dep : [...dep];
433
+ for (const effect of effects) {
434
+ if (effect.computed) {
435
+ triggerEffect(effect, debuggerEventExtraInfo);
436
+ }
437
+ }
438
+ for (const effect of effects) {
439
+ if (!effect.computed) {
440
+ triggerEffect(effect, debuggerEventExtraInfo);
441
+ }
442
+ }
443
+ }
444
+ function triggerEffect(effect, debuggerEventExtraInfo) {
445
+ if (effect !== activeEffect || effect.allowRecurse) {
446
+ if (effect.onTrigger) {
447
+ effect.onTrigger(extend({ effect }, debuggerEventExtraInfo));
448
+ }
449
+ if (effect.scheduler) {
450
+ effect.scheduler();
451
+ }
452
+ else {
453
+ effect.run();
454
+ }
455
+ }
449
456
  }
450
457
 
451
- const isNonTrackableKeys = /*#__PURE__*/ makeMap(`__proto__,__v_isRef,__isVue`);
452
- const builtInSymbols = new Set(
453
- /*#__PURE__*/
454
- Object.getOwnPropertyNames(Symbol)
455
- // ios10.x Object.getOwnPropertyNames(Symbol) can enumerate 'arguments' and 'caller'
456
- // but accessing them on Symbol leads to TypeError because Symbol is a strict mode
457
- // function
458
- .filter(key => key !== 'arguments' && key !== 'caller')
459
- .map(key => Symbol[key])
460
- .filter(isSymbol));
461
- const get = /*#__PURE__*/ createGetter();
462
- const shallowGet = /*#__PURE__*/ createGetter(false, true);
463
- const readonlyGet = /*#__PURE__*/ createGetter(true);
464
- const shallowReadonlyGet = /*#__PURE__*/ createGetter(true, true);
465
- const arrayInstrumentations = /*#__PURE__*/ createArrayInstrumentations();
466
- function createArrayInstrumentations() {
467
- const instrumentations = {};
468
- ['includes', 'indexOf', 'lastIndexOf'].forEach(key => {
469
- instrumentations[key] = function (...args) {
470
- const arr = toRaw(this);
471
- for (let i = 0, l = this.length; i < l; i++) {
472
- track(arr, "get" /* TrackOpTypes.GET */, i + '');
473
- }
474
- // we run the method using the original args first (which may be reactive)
475
- const res = arr[key](...args);
476
- if (res === -1 || res === false) {
477
- // if that didn't work, run it again using raw values.
478
- return arr[key](...args.map(toRaw));
479
- }
480
- else {
481
- return res;
482
- }
483
- };
484
- });
485
- ['push', 'pop', 'shift', 'unshift', 'splice'].forEach(key => {
486
- instrumentations[key] = function (...args) {
487
- pauseTracking();
488
- const res = toRaw(this)[key].apply(this, args);
489
- resetTracking();
490
- return res;
491
- };
492
- });
493
- return instrumentations;
494
- }
495
- function createGetter(isReadonly = false, shallow = false) {
496
- return function get(target, key, receiver) {
497
- if (key === "__v_isReactive" /* ReactiveFlags.IS_REACTIVE */) {
498
- return !isReadonly;
499
- }
500
- else if (key === "__v_isReadonly" /* ReactiveFlags.IS_READONLY */) {
501
- return isReadonly;
502
- }
503
- else if (key === "__v_isShallow" /* ReactiveFlags.IS_SHALLOW */) {
504
- return shallow;
505
- }
506
- else if (key === "__v_raw" /* ReactiveFlags.RAW */ &&
507
- receiver ===
508
- (isReadonly
509
- ? shallow
510
- ? shallowReadonlyMap
511
- : readonlyMap
512
- : shallow
513
- ? shallowReactiveMap
514
- : reactiveMap).get(target)) {
515
- return target;
516
- }
517
- const targetIsArray = isArray(target);
518
- if (!isReadonly && targetIsArray && hasOwn(arrayInstrumentations, key)) {
519
- return Reflect.get(arrayInstrumentations, key, receiver);
520
- }
521
- const res = Reflect.get(target, key, receiver);
522
- if (isSymbol(key) ? builtInSymbols.has(key) : isNonTrackableKeys(key)) {
523
- return res;
524
- }
525
- if (!isReadonly) {
526
- track(target, "get" /* TrackOpTypes.GET */, key);
527
- }
528
- if (shallow) {
529
- return res;
530
- }
531
- if (isRef(res)) {
532
- // ref unwrapping - skip unwrap for Array + integer key.
533
- return targetIsArray && isIntegerKey(key) ? res : res.value;
534
- }
535
- if (isObject(res)) {
536
- // Convert returned value into a proxy as well. we do the isObject check
537
- // here to avoid invalid value warning. Also need to lazy access readonly
538
- // and reactive here to avoid circular dependency.
539
- return isReadonly ? readonly(res) : reactive(res);
540
- }
541
- return res;
542
- };
543
- }
544
- const set = /*#__PURE__*/ createSetter();
545
- const shallowSet = /*#__PURE__*/ createSetter(true);
546
- function createSetter(shallow = false) {
547
- return function set(target, key, value, receiver) {
548
- let oldValue = target[key];
549
- if (isReadonly(oldValue) && isRef(oldValue) && !isRef(value)) {
550
- return false;
551
- }
552
- if (!shallow) {
553
- if (!isShallow(value) && !isReadonly(value)) {
554
- oldValue = toRaw(oldValue);
555
- value = toRaw(value);
556
- }
557
- if (!isArray(target) && isRef(oldValue) && !isRef(value)) {
558
- oldValue.value = value;
559
- return true;
560
- }
561
- }
562
- const hadKey = isArray(target) && isIntegerKey(key)
563
- ? Number(key) < target.length
564
- : hasOwn(target, key);
565
- const result = Reflect.set(target, key, value, receiver);
566
- // don't trigger if target is something up in the prototype chain of original
567
- if (target === toRaw(receiver)) {
568
- if (!hadKey) {
569
- trigger(target, "add" /* TriggerOpTypes.ADD */, key, value);
570
- }
571
- else if (hasChanged(value, oldValue)) {
572
- trigger(target, "set" /* TriggerOpTypes.SET */, key, value, oldValue);
573
- }
574
- }
575
- return result;
576
- };
577
- }
578
- function deleteProperty(target, key) {
579
- const hadKey = hasOwn(target, key);
580
- const oldValue = target[key];
581
- const result = Reflect.deleteProperty(target, key);
582
- if (result && hadKey) {
583
- trigger(target, "delete" /* TriggerOpTypes.DELETE */, key, undefined, oldValue);
584
- }
585
- return result;
586
- }
587
- function has(target, key) {
588
- const result = Reflect.has(target, key);
589
- if (!isSymbol(key) || !builtInSymbols.has(key)) {
590
- track(target, "has" /* TrackOpTypes.HAS */, key);
591
- }
592
- return result;
593
- }
594
- function ownKeys(target) {
595
- track(target, "iterate" /* TrackOpTypes.ITERATE */, isArray(target) ? 'length' : ITERATE_KEY);
596
- return Reflect.ownKeys(target);
597
- }
598
- const mutableHandlers = {
599
- get,
600
- set,
601
- deleteProperty,
602
- has,
603
- ownKeys
604
- };
605
- const readonlyHandlers = {
606
- get: readonlyGet,
607
- set(target, key) {
608
- {
609
- warn(`Set operation on key "${String(key)}" failed: target is readonly.`, target);
610
- }
611
- return true;
612
- },
613
- deleteProperty(target, key) {
614
- {
615
- warn(`Delete operation on key "${String(key)}" failed: target is readonly.`, target);
616
- }
617
- return true;
618
- }
619
- };
620
- const shallowReactiveHandlers = /*#__PURE__*/ extend({}, mutableHandlers, {
621
- get: shallowGet,
622
- set: shallowSet
623
- });
624
- // Props handlers are special in the sense that it should not unwrap top-level
625
- // refs (in order to allow refs to be explicitly passed down), but should
626
- // retain the reactivity of the normal readonly object.
627
- const shallowReadonlyHandlers = /*#__PURE__*/ extend({}, readonlyHandlers, {
628
- get: shallowReadonlyGet
458
+ const isNonTrackableKeys = /*#__PURE__*/ makeMap(`__proto__,__v_isRef,__isVue`);
459
+ const builtInSymbols = new Set(
460
+ /*#__PURE__*/
461
+ Object.getOwnPropertyNames(Symbol)
462
+ // ios10.x Object.getOwnPropertyNames(Symbol) can enumerate 'arguments' and 'caller'
463
+ // but accessing them on Symbol leads to TypeError because Symbol is a strict mode
464
+ // function
465
+ .filter(key => key !== 'arguments' && key !== 'caller')
466
+ .map(key => Symbol[key])
467
+ .filter(isSymbol));
468
+ const get = /*#__PURE__*/ createGetter();
469
+ const shallowGet = /*#__PURE__*/ createGetter(false, true);
470
+ const readonlyGet = /*#__PURE__*/ createGetter(true);
471
+ const shallowReadonlyGet = /*#__PURE__*/ createGetter(true, true);
472
+ const arrayInstrumentations = /*#__PURE__*/ createArrayInstrumentations();
473
+ function createArrayInstrumentations() {
474
+ const instrumentations = {};
475
+ ['includes', 'indexOf', 'lastIndexOf'].forEach(key => {
476
+ instrumentations[key] = function (...args) {
477
+ const arr = toRaw(this);
478
+ for (let i = 0, l = this.length; i < l; i++) {
479
+ track(arr, "get" /* TrackOpTypes.GET */, i + '');
480
+ }
481
+ // we run the method using the original args first (which may be reactive)
482
+ const res = arr[key](...args);
483
+ if (res === -1 || res === false) {
484
+ // if that didn't work, run it again using raw values.
485
+ return arr[key](...args.map(toRaw));
486
+ }
487
+ else {
488
+ return res;
489
+ }
490
+ };
491
+ });
492
+ ['push', 'pop', 'shift', 'unshift', 'splice'].forEach(key => {
493
+ instrumentations[key] = function (...args) {
494
+ pauseTracking();
495
+ const res = toRaw(this)[key].apply(this, args);
496
+ resetTracking();
497
+ return res;
498
+ };
499
+ });
500
+ return instrumentations;
501
+ }
502
+ function createGetter(isReadonly = false, shallow = false) {
503
+ return function get(target, key, receiver) {
504
+ if (key === "__v_isReactive" /* ReactiveFlags.IS_REACTIVE */) {
505
+ return !isReadonly;
506
+ }
507
+ else if (key === "__v_isReadonly" /* ReactiveFlags.IS_READONLY */) {
508
+ return isReadonly;
509
+ }
510
+ else if (key === "__v_isShallow" /* ReactiveFlags.IS_SHALLOW */) {
511
+ return shallow;
512
+ }
513
+ else if (key === "__v_raw" /* ReactiveFlags.RAW */ &&
514
+ receiver ===
515
+ (isReadonly
516
+ ? shallow
517
+ ? shallowReadonlyMap
518
+ : readonlyMap
519
+ : shallow
520
+ ? shallowReactiveMap
521
+ : reactiveMap).get(target)) {
522
+ return target;
523
+ }
524
+ const targetIsArray = isArray(target);
525
+ if (!isReadonly && targetIsArray && hasOwn(arrayInstrumentations, key)) {
526
+ return Reflect.get(arrayInstrumentations, key, receiver);
527
+ }
528
+ const res = Reflect.get(target, key, receiver);
529
+ if (isSymbol(key) ? builtInSymbols.has(key) : isNonTrackableKeys(key)) {
530
+ return res;
531
+ }
532
+ if (!isReadonly) {
533
+ track(target, "get" /* TrackOpTypes.GET */, key);
534
+ }
535
+ if (shallow) {
536
+ return res;
537
+ }
538
+ if (isRef(res)) {
539
+ // ref unwrapping - skip unwrap for Array + integer key.
540
+ return targetIsArray && isIntegerKey(key) ? res : res.value;
541
+ }
542
+ if (isObject(res)) {
543
+ // Convert returned value into a proxy as well. we do the isObject check
544
+ // here to avoid invalid value warning. Also need to lazy access readonly
545
+ // and reactive here to avoid circular dependency.
546
+ return isReadonly ? readonly(res) : reactive(res);
547
+ }
548
+ return res;
549
+ };
550
+ }
551
+ const set = /*#__PURE__*/ createSetter();
552
+ const shallowSet = /*#__PURE__*/ createSetter(true);
553
+ function createSetter(shallow = false) {
554
+ return function set(target, key, value, receiver) {
555
+ let oldValue = target[key];
556
+ if (isReadonly(oldValue) && isRef(oldValue) && !isRef(value)) {
557
+ return false;
558
+ }
559
+ if (!shallow) {
560
+ if (!isShallow(value) && !isReadonly(value)) {
561
+ oldValue = toRaw(oldValue);
562
+ value = toRaw(value);
563
+ }
564
+ if (!isArray(target) && isRef(oldValue) && !isRef(value)) {
565
+ oldValue.value = value;
566
+ return true;
567
+ }
568
+ }
569
+ const hadKey = isArray(target) && isIntegerKey(key)
570
+ ? Number(key) < target.length
571
+ : hasOwn(target, key);
572
+ const result = Reflect.set(target, key, value, receiver);
573
+ // don't trigger if target is something up in the prototype chain of original
574
+ if (target === toRaw(receiver)) {
575
+ if (!hadKey) {
576
+ trigger(target, "add" /* TriggerOpTypes.ADD */, key, value);
577
+ }
578
+ else if (hasChanged(value, oldValue)) {
579
+ trigger(target, "set" /* TriggerOpTypes.SET */, key, value, oldValue);
580
+ }
581
+ }
582
+ return result;
583
+ };
584
+ }
585
+ function deleteProperty(target, key) {
586
+ const hadKey = hasOwn(target, key);
587
+ const oldValue = target[key];
588
+ const result = Reflect.deleteProperty(target, key);
589
+ if (result && hadKey) {
590
+ trigger(target, "delete" /* TriggerOpTypes.DELETE */, key, undefined, oldValue);
591
+ }
592
+ return result;
593
+ }
594
+ function has(target, key) {
595
+ const result = Reflect.has(target, key);
596
+ if (!isSymbol(key) || !builtInSymbols.has(key)) {
597
+ track(target, "has" /* TrackOpTypes.HAS */, key);
598
+ }
599
+ return result;
600
+ }
601
+ function ownKeys(target) {
602
+ track(target, "iterate" /* TrackOpTypes.ITERATE */, isArray(target) ? 'length' : ITERATE_KEY);
603
+ return Reflect.ownKeys(target);
604
+ }
605
+ const mutableHandlers = {
606
+ get,
607
+ set,
608
+ deleteProperty,
609
+ has,
610
+ ownKeys
611
+ };
612
+ const readonlyHandlers = {
613
+ get: readonlyGet,
614
+ set(target, key) {
615
+ {
616
+ warn(`Set operation on key "${String(key)}" failed: target is readonly.`, target);
617
+ }
618
+ return true;
619
+ },
620
+ deleteProperty(target, key) {
621
+ {
622
+ warn(`Delete operation on key "${String(key)}" failed: target is readonly.`, target);
623
+ }
624
+ return true;
625
+ }
626
+ };
627
+ const shallowReactiveHandlers = /*#__PURE__*/ extend({}, mutableHandlers, {
628
+ get: shallowGet,
629
+ set: shallowSet
630
+ });
631
+ // Props handlers are special in the sense that it should not unwrap top-level
632
+ // refs (in order to allow refs to be explicitly passed down), but should
633
+ // retain the reactivity of the normal readonly object.
634
+ const shallowReadonlyHandlers = /*#__PURE__*/ extend({}, readonlyHandlers, {
635
+ get: shallowReadonlyGet
629
636
  });
630
637
 
631
- const toShallow = (value) => value;
632
- const getProto = (v) => Reflect.getPrototypeOf(v);
633
- function get$1(target, key, isReadonly = false, isShallow = false) {
634
- // #1772: readonly(reactive(Map)) should return readonly + reactive version
635
- // of the value
636
- target = target["__v_raw" /* ReactiveFlags.RAW */];
637
- const rawTarget = toRaw(target);
638
- const rawKey = toRaw(key);
639
- if (!isReadonly) {
640
- if (key !== rawKey) {
641
- track(rawTarget, "get" /* TrackOpTypes.GET */, key);
642
- }
643
- track(rawTarget, "get" /* TrackOpTypes.GET */, rawKey);
644
- }
645
- const { has } = getProto(rawTarget);
646
- const wrap = isShallow ? toShallow : isReadonly ? toReadonly : toReactive;
647
- if (has.call(rawTarget, key)) {
648
- return wrap(target.get(key));
649
- }
650
- else if (has.call(rawTarget, rawKey)) {
651
- return wrap(target.get(rawKey));
652
- }
653
- else if (target !== rawTarget) {
654
- // #3602 readonly(reactive(Map))
655
- // ensure that the nested reactive `Map` can do tracking for itself
656
- target.get(key);
657
- }
658
- }
659
- function has$1(key, isReadonly = false) {
660
- const target = this["__v_raw" /* ReactiveFlags.RAW */];
661
- const rawTarget = toRaw(target);
662
- const rawKey = toRaw(key);
663
- if (!isReadonly) {
664
- if (key !== rawKey) {
665
- track(rawTarget, "has" /* TrackOpTypes.HAS */, key);
666
- }
667
- track(rawTarget, "has" /* TrackOpTypes.HAS */, rawKey);
668
- }
669
- return key === rawKey
670
- ? target.has(key)
671
- : target.has(key) || target.has(rawKey);
672
- }
673
- function size(target, isReadonly = false) {
674
- target = target["__v_raw" /* ReactiveFlags.RAW */];
675
- !isReadonly && track(toRaw(target), "iterate" /* TrackOpTypes.ITERATE */, ITERATE_KEY);
676
- return Reflect.get(target, 'size', target);
677
- }
678
- function add(value) {
679
- value = toRaw(value);
680
- const target = toRaw(this);
681
- const proto = getProto(target);
682
- const hadKey = proto.has.call(target, value);
683
- if (!hadKey) {
684
- target.add(value);
685
- trigger(target, "add" /* TriggerOpTypes.ADD */, value, value);
686
- }
687
- return this;
688
- }
689
- function set$1(key, value) {
690
- value = toRaw(value);
691
- const target = toRaw(this);
692
- const { has, get } = getProto(target);
693
- let hadKey = has.call(target, key);
694
- if (!hadKey) {
695
- key = toRaw(key);
696
- hadKey = has.call(target, key);
697
- }
698
- else {
699
- checkIdentityKeys(target, has, key);
700
- }
701
- const oldValue = get.call(target, key);
702
- target.set(key, value);
703
- if (!hadKey) {
704
- trigger(target, "add" /* TriggerOpTypes.ADD */, key, value);
705
- }
706
- else if (hasChanged(value, oldValue)) {
707
- trigger(target, "set" /* TriggerOpTypes.SET */, key, value, oldValue);
708
- }
709
- return this;
710
- }
711
- function deleteEntry(key) {
712
- const target = toRaw(this);
713
- const { has, get } = getProto(target);
714
- let hadKey = has.call(target, key);
715
- if (!hadKey) {
716
- key = toRaw(key);
717
- hadKey = has.call(target, key);
718
- }
719
- else {
720
- checkIdentityKeys(target, has, key);
721
- }
722
- const oldValue = get ? get.call(target, key) : undefined;
723
- // forward the operation before queueing reactions
724
- const result = target.delete(key);
725
- if (hadKey) {
726
- trigger(target, "delete" /* TriggerOpTypes.DELETE */, key, undefined, oldValue);
727
- }
728
- return result;
729
- }
730
- function clear() {
731
- const target = toRaw(this);
732
- const hadItems = target.size !== 0;
733
- const oldTarget = isMap(target)
734
- ? new Map(target)
735
- : new Set(target)
736
- ;
737
- // forward the operation before queueing reactions
738
- const result = target.clear();
739
- if (hadItems) {
740
- trigger(target, "clear" /* TriggerOpTypes.CLEAR */, undefined, undefined, oldTarget);
741
- }
742
- return result;
743
- }
744
- function createForEach(isReadonly, isShallow) {
745
- return function forEach(callback, thisArg) {
746
- const observed = this;
747
- const target = observed["__v_raw" /* ReactiveFlags.RAW */];
748
- const rawTarget = toRaw(target);
749
- const wrap = isShallow ? toShallow : isReadonly ? toReadonly : toReactive;
750
- !isReadonly && track(rawTarget, "iterate" /* TrackOpTypes.ITERATE */, ITERATE_KEY);
751
- return target.forEach((value, key) => {
752
- // important: make sure the callback is
753
- // 1. invoked with the reactive map as `this` and 3rd arg
754
- // 2. the value received should be a corresponding reactive/readonly.
755
- return callback.call(thisArg, wrap(value), wrap(key), observed);
756
- });
757
- };
758
- }
759
- function createIterableMethod(method, isReadonly, isShallow) {
760
- return function (...args) {
761
- const target = this["__v_raw" /* ReactiveFlags.RAW */];
762
- const rawTarget = toRaw(target);
763
- const targetIsMap = isMap(rawTarget);
764
- const isPair = method === 'entries' || (method === Symbol.iterator && targetIsMap);
765
- const isKeyOnly = method === 'keys' && targetIsMap;
766
- const innerIterator = target[method](...args);
767
- const wrap = isShallow ? toShallow : isReadonly ? toReadonly : toReactive;
768
- !isReadonly &&
769
- track(rawTarget, "iterate" /* TrackOpTypes.ITERATE */, isKeyOnly ? MAP_KEY_ITERATE_KEY : ITERATE_KEY);
770
- // return a wrapped iterator which returns observed versions of the
771
- // values emitted from the real iterator
772
- return {
773
- // iterator protocol
774
- next() {
775
- const { value, done } = innerIterator.next();
776
- return done
777
- ? { value, done }
778
- : {
779
- value: isPair ? [wrap(value[0]), wrap(value[1])] : wrap(value),
780
- done
781
- };
782
- },
783
- // iterable protocol
784
- [Symbol.iterator]() {
785
- return this;
786
- }
787
- };
788
- };
789
- }
790
- function createReadonlyMethod(type) {
791
- return function (...args) {
792
- {
793
- const key = args[0] ? `on key "${args[0]}" ` : ``;
794
- console.warn(`${capitalize(type)} operation ${key}failed: target is readonly.`, toRaw(this));
795
- }
796
- return type === "delete" /* TriggerOpTypes.DELETE */ ? false : this;
797
- };
798
- }
799
- function createInstrumentations() {
800
- const mutableInstrumentations = {
801
- get(key) {
802
- return get$1(this, key);
803
- },
804
- get size() {
805
- return size(this);
806
- },
807
- has: has$1,
808
- add,
809
- set: set$1,
810
- delete: deleteEntry,
811
- clear,
812
- forEach: createForEach(false, false)
813
- };
814
- const shallowInstrumentations = {
815
- get(key) {
816
- return get$1(this, key, false, true);
817
- },
818
- get size() {
819
- return size(this);
820
- },
821
- has: has$1,
822
- add,
823
- set: set$1,
824
- delete: deleteEntry,
825
- clear,
826
- forEach: createForEach(false, true)
827
- };
828
- const readonlyInstrumentations = {
829
- get(key) {
830
- return get$1(this, key, true);
831
- },
832
- get size() {
833
- return size(this, true);
834
- },
835
- has(key) {
836
- return has$1.call(this, key, true);
837
- },
838
- add: createReadonlyMethod("add" /* TriggerOpTypes.ADD */),
839
- set: createReadonlyMethod("set" /* TriggerOpTypes.SET */),
840
- delete: createReadonlyMethod("delete" /* TriggerOpTypes.DELETE */),
841
- clear: createReadonlyMethod("clear" /* TriggerOpTypes.CLEAR */),
842
- forEach: createForEach(true, false)
843
- };
844
- const shallowReadonlyInstrumentations = {
845
- get(key) {
846
- return get$1(this, key, true, true);
847
- },
848
- get size() {
849
- return size(this, true);
850
- },
851
- has(key) {
852
- return has$1.call(this, key, true);
853
- },
854
- add: createReadonlyMethod("add" /* TriggerOpTypes.ADD */),
855
- set: createReadonlyMethod("set" /* TriggerOpTypes.SET */),
856
- delete: createReadonlyMethod("delete" /* TriggerOpTypes.DELETE */),
857
- clear: createReadonlyMethod("clear" /* TriggerOpTypes.CLEAR */),
858
- forEach: createForEach(true, true)
859
- };
860
- const iteratorMethods = ['keys', 'values', 'entries', Symbol.iterator];
861
- iteratorMethods.forEach(method => {
862
- mutableInstrumentations[method] = createIterableMethod(method, false, false);
863
- readonlyInstrumentations[method] = createIterableMethod(method, true, false);
864
- shallowInstrumentations[method] = createIterableMethod(method, false, true);
865
- shallowReadonlyInstrumentations[method] = createIterableMethod(method, true, true);
866
- });
867
- return [
868
- mutableInstrumentations,
869
- readonlyInstrumentations,
870
- shallowInstrumentations,
871
- shallowReadonlyInstrumentations
872
- ];
873
- }
874
- const [mutableInstrumentations, readonlyInstrumentations, shallowInstrumentations, shallowReadonlyInstrumentations] = /* #__PURE__*/ createInstrumentations();
875
- function createInstrumentationGetter(isReadonly, shallow) {
876
- const instrumentations = shallow
877
- ? isReadonly
878
- ? shallowReadonlyInstrumentations
879
- : shallowInstrumentations
880
- : isReadonly
881
- ? readonlyInstrumentations
882
- : mutableInstrumentations;
883
- return (target, key, receiver) => {
884
- if (key === "__v_isReactive" /* ReactiveFlags.IS_REACTIVE */) {
885
- return !isReadonly;
886
- }
887
- else if (key === "__v_isReadonly" /* ReactiveFlags.IS_READONLY */) {
888
- return isReadonly;
889
- }
890
- else if (key === "__v_raw" /* ReactiveFlags.RAW */) {
891
- return target;
892
- }
893
- return Reflect.get(hasOwn(instrumentations, key) && key in target
894
- ? instrumentations
895
- : target, key, receiver);
896
- };
897
- }
898
- const mutableCollectionHandlers = {
899
- get: /*#__PURE__*/ createInstrumentationGetter(false, false)
900
- };
901
- const shallowCollectionHandlers = {
902
- get: /*#__PURE__*/ createInstrumentationGetter(false, true)
903
- };
904
- const readonlyCollectionHandlers = {
905
- get: /*#__PURE__*/ createInstrumentationGetter(true, false)
906
- };
907
- const shallowReadonlyCollectionHandlers = {
908
- get: /*#__PURE__*/ createInstrumentationGetter(true, true)
909
- };
910
- function checkIdentityKeys(target, has, key) {
911
- const rawKey = toRaw(key);
912
- if (rawKey !== key && has.call(target, rawKey)) {
913
- const type = toRawType(target);
914
- console.warn(`Reactive ${type} contains both the raw and reactive ` +
915
- `versions of the same object${type === `Map` ? ` as keys` : ``}, ` +
916
- `which can lead to inconsistencies. ` +
917
- `Avoid differentiating between the raw and reactive versions ` +
918
- `of an object and only use the reactive version if possible.`);
919
- }
638
+ const toShallow = (value) => value;
639
+ const getProto = (v) => Reflect.getPrototypeOf(v);
640
+ function get$1(target, key, isReadonly = false, isShallow = false) {
641
+ // #1772: readonly(reactive(Map)) should return readonly + reactive version
642
+ // of the value
643
+ target = target["__v_raw" /* ReactiveFlags.RAW */];
644
+ const rawTarget = toRaw(target);
645
+ const rawKey = toRaw(key);
646
+ if (!isReadonly) {
647
+ if (key !== rawKey) {
648
+ track(rawTarget, "get" /* TrackOpTypes.GET */, key);
649
+ }
650
+ track(rawTarget, "get" /* TrackOpTypes.GET */, rawKey);
651
+ }
652
+ const { has } = getProto(rawTarget);
653
+ const wrap = isShallow ? toShallow : isReadonly ? toReadonly : toReactive;
654
+ if (has.call(rawTarget, key)) {
655
+ return wrap(target.get(key));
656
+ }
657
+ else if (has.call(rawTarget, rawKey)) {
658
+ return wrap(target.get(rawKey));
659
+ }
660
+ else if (target !== rawTarget) {
661
+ // #3602 readonly(reactive(Map))
662
+ // ensure that the nested reactive `Map` can do tracking for itself
663
+ target.get(key);
664
+ }
665
+ }
666
+ function has$1(key, isReadonly = false) {
667
+ const target = this["__v_raw" /* ReactiveFlags.RAW */];
668
+ const rawTarget = toRaw(target);
669
+ const rawKey = toRaw(key);
670
+ if (!isReadonly) {
671
+ if (key !== rawKey) {
672
+ track(rawTarget, "has" /* TrackOpTypes.HAS */, key);
673
+ }
674
+ track(rawTarget, "has" /* TrackOpTypes.HAS */, rawKey);
675
+ }
676
+ return key === rawKey
677
+ ? target.has(key)
678
+ : target.has(key) || target.has(rawKey);
679
+ }
680
+ function size(target, isReadonly = false) {
681
+ target = target["__v_raw" /* ReactiveFlags.RAW */];
682
+ !isReadonly && track(toRaw(target), "iterate" /* TrackOpTypes.ITERATE */, ITERATE_KEY);
683
+ return Reflect.get(target, 'size', target);
684
+ }
685
+ function add(value) {
686
+ value = toRaw(value);
687
+ const target = toRaw(this);
688
+ const proto = getProto(target);
689
+ const hadKey = proto.has.call(target, value);
690
+ if (!hadKey) {
691
+ target.add(value);
692
+ trigger(target, "add" /* TriggerOpTypes.ADD */, value, value);
693
+ }
694
+ return this;
695
+ }
696
+ function set$1(key, value) {
697
+ value = toRaw(value);
698
+ const target = toRaw(this);
699
+ const { has, get } = getProto(target);
700
+ let hadKey = has.call(target, key);
701
+ if (!hadKey) {
702
+ key = toRaw(key);
703
+ hadKey = has.call(target, key);
704
+ }
705
+ else {
706
+ checkIdentityKeys(target, has, key);
707
+ }
708
+ const oldValue = get.call(target, key);
709
+ target.set(key, value);
710
+ if (!hadKey) {
711
+ trigger(target, "add" /* TriggerOpTypes.ADD */, key, value);
712
+ }
713
+ else if (hasChanged(value, oldValue)) {
714
+ trigger(target, "set" /* TriggerOpTypes.SET */, key, value, oldValue);
715
+ }
716
+ return this;
717
+ }
718
+ function deleteEntry(key) {
719
+ const target = toRaw(this);
720
+ const { has, get } = getProto(target);
721
+ let hadKey = has.call(target, key);
722
+ if (!hadKey) {
723
+ key = toRaw(key);
724
+ hadKey = has.call(target, key);
725
+ }
726
+ else {
727
+ checkIdentityKeys(target, has, key);
728
+ }
729
+ const oldValue = get ? get.call(target, key) : undefined;
730
+ // forward the operation before queueing reactions
731
+ const result = target.delete(key);
732
+ if (hadKey) {
733
+ trigger(target, "delete" /* TriggerOpTypes.DELETE */, key, undefined, oldValue);
734
+ }
735
+ return result;
736
+ }
737
+ function clear() {
738
+ const target = toRaw(this);
739
+ const hadItems = target.size !== 0;
740
+ const oldTarget = isMap(target)
741
+ ? new Map(target)
742
+ : new Set(target)
743
+ ;
744
+ // forward the operation before queueing reactions
745
+ const result = target.clear();
746
+ if (hadItems) {
747
+ trigger(target, "clear" /* TriggerOpTypes.CLEAR */, undefined, undefined, oldTarget);
748
+ }
749
+ return result;
750
+ }
751
+ function createForEach(isReadonly, isShallow) {
752
+ return function forEach(callback, thisArg) {
753
+ const observed = this;
754
+ const target = observed["__v_raw" /* ReactiveFlags.RAW */];
755
+ const rawTarget = toRaw(target);
756
+ const wrap = isShallow ? toShallow : isReadonly ? toReadonly : toReactive;
757
+ !isReadonly && track(rawTarget, "iterate" /* TrackOpTypes.ITERATE */, ITERATE_KEY);
758
+ return target.forEach((value, key) => {
759
+ // important: make sure the callback is
760
+ // 1. invoked with the reactive map as `this` and 3rd arg
761
+ // 2. the value received should be a corresponding reactive/readonly.
762
+ return callback.call(thisArg, wrap(value), wrap(key), observed);
763
+ });
764
+ };
765
+ }
766
+ function createIterableMethod(method, isReadonly, isShallow) {
767
+ return function (...args) {
768
+ const target = this["__v_raw" /* ReactiveFlags.RAW */];
769
+ const rawTarget = toRaw(target);
770
+ const targetIsMap = isMap(rawTarget);
771
+ const isPair = method === 'entries' || (method === Symbol.iterator && targetIsMap);
772
+ const isKeyOnly = method === 'keys' && targetIsMap;
773
+ const innerIterator = target[method](...args);
774
+ const wrap = isShallow ? toShallow : isReadonly ? toReadonly : toReactive;
775
+ !isReadonly &&
776
+ track(rawTarget, "iterate" /* TrackOpTypes.ITERATE */, isKeyOnly ? MAP_KEY_ITERATE_KEY : ITERATE_KEY);
777
+ // return a wrapped iterator which returns observed versions of the
778
+ // values emitted from the real iterator
779
+ return {
780
+ // iterator protocol
781
+ next() {
782
+ const { value, done } = innerIterator.next();
783
+ return done
784
+ ? { value, done }
785
+ : {
786
+ value: isPair ? [wrap(value[0]), wrap(value[1])] : wrap(value),
787
+ done
788
+ };
789
+ },
790
+ // iterable protocol
791
+ [Symbol.iterator]() {
792
+ return this;
793
+ }
794
+ };
795
+ };
796
+ }
797
+ function createReadonlyMethod(type) {
798
+ return function (...args) {
799
+ {
800
+ const key = args[0] ? `on key "${args[0]}" ` : ``;
801
+ console.warn(`${capitalize(type)} operation ${key}failed: target is readonly.`, toRaw(this));
802
+ }
803
+ return type === "delete" /* TriggerOpTypes.DELETE */ ? false : this;
804
+ };
805
+ }
806
+ function createInstrumentations() {
807
+ const mutableInstrumentations = {
808
+ get(key) {
809
+ return get$1(this, key);
810
+ },
811
+ get size() {
812
+ return size(this);
813
+ },
814
+ has: has$1,
815
+ add,
816
+ set: set$1,
817
+ delete: deleteEntry,
818
+ clear,
819
+ forEach: createForEach(false, false)
820
+ };
821
+ const shallowInstrumentations = {
822
+ get(key) {
823
+ return get$1(this, key, false, true);
824
+ },
825
+ get size() {
826
+ return size(this);
827
+ },
828
+ has: has$1,
829
+ add,
830
+ set: set$1,
831
+ delete: deleteEntry,
832
+ clear,
833
+ forEach: createForEach(false, true)
834
+ };
835
+ const readonlyInstrumentations = {
836
+ get(key) {
837
+ return get$1(this, key, true);
838
+ },
839
+ get size() {
840
+ return size(this, true);
841
+ },
842
+ has(key) {
843
+ return has$1.call(this, key, true);
844
+ },
845
+ add: createReadonlyMethod("add" /* TriggerOpTypes.ADD */),
846
+ set: createReadonlyMethod("set" /* TriggerOpTypes.SET */),
847
+ delete: createReadonlyMethod("delete" /* TriggerOpTypes.DELETE */),
848
+ clear: createReadonlyMethod("clear" /* TriggerOpTypes.CLEAR */),
849
+ forEach: createForEach(true, false)
850
+ };
851
+ const shallowReadonlyInstrumentations = {
852
+ get(key) {
853
+ return get$1(this, key, true, true);
854
+ },
855
+ get size() {
856
+ return size(this, true);
857
+ },
858
+ has(key) {
859
+ return has$1.call(this, key, true);
860
+ },
861
+ add: createReadonlyMethod("add" /* TriggerOpTypes.ADD */),
862
+ set: createReadonlyMethod("set" /* TriggerOpTypes.SET */),
863
+ delete: createReadonlyMethod("delete" /* TriggerOpTypes.DELETE */),
864
+ clear: createReadonlyMethod("clear" /* TriggerOpTypes.CLEAR */),
865
+ forEach: createForEach(true, true)
866
+ };
867
+ const iteratorMethods = ['keys', 'values', 'entries', Symbol.iterator];
868
+ iteratorMethods.forEach(method => {
869
+ mutableInstrumentations[method] = createIterableMethod(method, false, false);
870
+ readonlyInstrumentations[method] = createIterableMethod(method, true, false);
871
+ shallowInstrumentations[method] = createIterableMethod(method, false, true);
872
+ shallowReadonlyInstrumentations[method] = createIterableMethod(method, true, true);
873
+ });
874
+ return [
875
+ mutableInstrumentations,
876
+ readonlyInstrumentations,
877
+ shallowInstrumentations,
878
+ shallowReadonlyInstrumentations
879
+ ];
880
+ }
881
+ const [mutableInstrumentations, readonlyInstrumentations, shallowInstrumentations, shallowReadonlyInstrumentations] = /* #__PURE__*/ createInstrumentations();
882
+ function createInstrumentationGetter(isReadonly, shallow) {
883
+ const instrumentations = shallow
884
+ ? isReadonly
885
+ ? shallowReadonlyInstrumentations
886
+ : shallowInstrumentations
887
+ : isReadonly
888
+ ? readonlyInstrumentations
889
+ : mutableInstrumentations;
890
+ return (target, key, receiver) => {
891
+ if (key === "__v_isReactive" /* ReactiveFlags.IS_REACTIVE */) {
892
+ return !isReadonly;
893
+ }
894
+ else if (key === "__v_isReadonly" /* ReactiveFlags.IS_READONLY */) {
895
+ return isReadonly;
896
+ }
897
+ else if (key === "__v_raw" /* ReactiveFlags.RAW */) {
898
+ return target;
899
+ }
900
+ return Reflect.get(hasOwn(instrumentations, key) && key in target
901
+ ? instrumentations
902
+ : target, key, receiver);
903
+ };
904
+ }
905
+ const mutableCollectionHandlers = {
906
+ get: /*#__PURE__*/ createInstrumentationGetter(false, false)
907
+ };
908
+ const shallowCollectionHandlers = {
909
+ get: /*#__PURE__*/ createInstrumentationGetter(false, true)
910
+ };
911
+ const readonlyCollectionHandlers = {
912
+ get: /*#__PURE__*/ createInstrumentationGetter(true, false)
913
+ };
914
+ const shallowReadonlyCollectionHandlers = {
915
+ get: /*#__PURE__*/ createInstrumentationGetter(true, true)
916
+ };
917
+ function checkIdentityKeys(target, has, key) {
918
+ const rawKey = toRaw(key);
919
+ if (rawKey !== key && has.call(target, rawKey)) {
920
+ const type = toRawType(target);
921
+ console.warn(`Reactive ${type} contains both the raw and reactive ` +
922
+ `versions of the same object${type === `Map` ? ` as keys` : ``}, ` +
923
+ `which can lead to inconsistencies. ` +
924
+ `Avoid differentiating between the raw and reactive versions ` +
925
+ `of an object and only use the reactive version if possible.`);
926
+ }
920
927
  }
921
928
 
922
- const reactiveMap = new WeakMap();
923
- const shallowReactiveMap = new WeakMap();
924
- const readonlyMap = new WeakMap();
925
- const shallowReadonlyMap = new WeakMap();
926
- function targetTypeMap(rawType) {
927
- switch (rawType) {
928
- case 'Object':
929
- case 'Array':
930
- return 1 /* TargetType.COMMON */;
931
- case 'Map':
932
- case 'Set':
933
- case 'WeakMap':
934
- case 'WeakSet':
935
- return 2 /* TargetType.COLLECTION */;
936
- default:
937
- return 0 /* TargetType.INVALID */;
938
- }
939
- }
940
- function getTargetType(value) {
941
- return value["__v_skip" /* ReactiveFlags.SKIP */] || !Object.isExtensible(value)
942
- ? 0 /* TargetType.INVALID */
943
- : targetTypeMap(toRawType(value));
944
- }
945
- function reactive(target) {
946
- // if trying to observe a readonly proxy, return the readonly version.
947
- if (isReadonly(target)) {
948
- return target;
949
- }
950
- return createReactiveObject(target, false, mutableHandlers, mutableCollectionHandlers, reactiveMap);
951
- }
952
- /**
953
- * Return a shallowly-reactive copy of the original object, where only the root
954
- * level properties are reactive. It also does not auto-unwrap refs (even at the
955
- * root level).
956
- */
957
- function shallowReactive(target) {
958
- return createReactiveObject(target, false, shallowReactiveHandlers, shallowCollectionHandlers, shallowReactiveMap);
959
- }
960
- /**
961
- * Creates a readonly copy of the original object. Note the returned copy is not
962
- * made reactive, but `readonly` can be called on an already reactive object.
963
- */
964
- function readonly(target) {
965
- return createReactiveObject(target, true, readonlyHandlers, readonlyCollectionHandlers, readonlyMap);
966
- }
967
- /**
968
- * Returns a reactive-copy of the original object, where only the root level
969
- * properties are readonly, and does NOT unwrap refs nor recursively convert
970
- * returned properties.
971
- * This is used for creating the props proxy object for stateful components.
972
- */
973
- function shallowReadonly(target) {
974
- return createReactiveObject(target, true, shallowReadonlyHandlers, shallowReadonlyCollectionHandlers, shallowReadonlyMap);
975
- }
976
- function createReactiveObject(target, isReadonly, baseHandlers, collectionHandlers, proxyMap) {
977
- if (!isObject(target)) {
978
- {
979
- console.warn(`value cannot be made reactive: ${String(target)}`);
980
- }
981
- return target;
982
- }
983
- // target is already a Proxy, return it.
984
- // exception: calling readonly() on a reactive object
985
- if (target["__v_raw" /* ReactiveFlags.RAW */] &&
986
- !(isReadonly && target["__v_isReactive" /* ReactiveFlags.IS_REACTIVE */])) {
987
- return target;
988
- }
989
- // target already has corresponding Proxy
990
- const existingProxy = proxyMap.get(target);
991
- if (existingProxy) {
992
- return existingProxy;
993
- }
994
- // only specific value types can be observed.
995
- const targetType = getTargetType(target);
996
- if (targetType === 0 /* TargetType.INVALID */) {
997
- return target;
998
- }
999
- const proxy = new Proxy(target, targetType === 2 /* TargetType.COLLECTION */ ? collectionHandlers : baseHandlers);
1000
- proxyMap.set(target, proxy);
1001
- return proxy;
1002
- }
1003
- function isReactive(value) {
1004
- if (isReadonly(value)) {
1005
- return isReactive(value["__v_raw" /* ReactiveFlags.RAW */]);
1006
- }
1007
- return !!(value && value["__v_isReactive" /* ReactiveFlags.IS_REACTIVE */]);
1008
- }
1009
- function isReadonly(value) {
1010
- return !!(value && value["__v_isReadonly" /* ReactiveFlags.IS_READONLY */]);
1011
- }
1012
- function isShallow(value) {
1013
- return !!(value && value["__v_isShallow" /* ReactiveFlags.IS_SHALLOW */]);
1014
- }
1015
- function isProxy(value) {
1016
- return isReactive(value) || isReadonly(value);
1017
- }
1018
- function toRaw(observed) {
1019
- const raw = observed && observed["__v_raw" /* ReactiveFlags.RAW */];
1020
- return raw ? toRaw(raw) : observed;
1021
- }
1022
- function markRaw(value) {
1023
- def(value, "__v_skip" /* ReactiveFlags.SKIP */, true);
1024
- return value;
1025
- }
1026
- const toReactive = (value) => isObject(value) ? reactive(value) : value;
929
+ const reactiveMap = new WeakMap();
930
+ const shallowReactiveMap = new WeakMap();
931
+ const readonlyMap = new WeakMap();
932
+ const shallowReadonlyMap = new WeakMap();
933
+ function targetTypeMap(rawType) {
934
+ switch (rawType) {
935
+ case 'Object':
936
+ case 'Array':
937
+ return 1 /* TargetType.COMMON */;
938
+ case 'Map':
939
+ case 'Set':
940
+ case 'WeakMap':
941
+ case 'WeakSet':
942
+ return 2 /* TargetType.COLLECTION */;
943
+ default:
944
+ return 0 /* TargetType.INVALID */;
945
+ }
946
+ }
947
+ function getTargetType(value) {
948
+ return value["__v_skip" /* ReactiveFlags.SKIP */] || !Object.isExtensible(value)
949
+ ? 0 /* TargetType.INVALID */
950
+ : targetTypeMap(toRawType(value));
951
+ }
952
+ function reactive(target) {
953
+ // if trying to observe a readonly proxy, return the readonly version.
954
+ if (isReadonly(target)) {
955
+ return target;
956
+ }
957
+ return createReactiveObject(target, false, mutableHandlers, mutableCollectionHandlers, reactiveMap);
958
+ }
959
+ /**
960
+ * Return a shallowly-reactive copy of the original object, where only the root
961
+ * level properties are reactive. It also does not auto-unwrap refs (even at the
962
+ * root level).
963
+ */
964
+ function shallowReactive(target) {
965
+ return createReactiveObject(target, false, shallowReactiveHandlers, shallowCollectionHandlers, shallowReactiveMap);
966
+ }
967
+ /**
968
+ * Creates a readonly copy of the original object. Note the returned copy is not
969
+ * made reactive, but `readonly` can be called on an already reactive object.
970
+ */
971
+ function readonly(target) {
972
+ return createReactiveObject(target, true, readonlyHandlers, readonlyCollectionHandlers, readonlyMap);
973
+ }
974
+ /**
975
+ * Returns a reactive-copy of the original object, where only the root level
976
+ * properties are readonly, and does NOT unwrap refs nor recursively convert
977
+ * returned properties.
978
+ * This is used for creating the props proxy object for stateful components.
979
+ */
980
+ function shallowReadonly(target) {
981
+ return createReactiveObject(target, true, shallowReadonlyHandlers, shallowReadonlyCollectionHandlers, shallowReadonlyMap);
982
+ }
983
+ function createReactiveObject(target, isReadonly, baseHandlers, collectionHandlers, proxyMap) {
984
+ if (!isObject(target)) {
985
+ {
986
+ console.warn(`value cannot be made reactive: ${String(target)}`);
987
+ }
988
+ return target;
989
+ }
990
+ // target is already a Proxy, return it.
991
+ // exception: calling readonly() on a reactive object
992
+ if (target["__v_raw" /* ReactiveFlags.RAW */] &&
993
+ !(isReadonly && target["__v_isReactive" /* ReactiveFlags.IS_REACTIVE */])) {
994
+ return target;
995
+ }
996
+ // target already has corresponding Proxy
997
+ const existingProxy = proxyMap.get(target);
998
+ if (existingProxy) {
999
+ return existingProxy;
1000
+ }
1001
+ // only specific value types can be observed.
1002
+ const targetType = getTargetType(target);
1003
+ if (targetType === 0 /* TargetType.INVALID */) {
1004
+ return target;
1005
+ }
1006
+ const proxy = new Proxy(target, targetType === 2 /* TargetType.COLLECTION */ ? collectionHandlers : baseHandlers);
1007
+ proxyMap.set(target, proxy);
1008
+ return proxy;
1009
+ }
1010
+ function isReactive(value) {
1011
+ if (isReadonly(value)) {
1012
+ return isReactive(value["__v_raw" /* ReactiveFlags.RAW */]);
1013
+ }
1014
+ return !!(value && value["__v_isReactive" /* ReactiveFlags.IS_REACTIVE */]);
1015
+ }
1016
+ function isReadonly(value) {
1017
+ return !!(value && value["__v_isReadonly" /* ReactiveFlags.IS_READONLY */]);
1018
+ }
1019
+ function isShallow(value) {
1020
+ return !!(value && value["__v_isShallow" /* ReactiveFlags.IS_SHALLOW */]);
1021
+ }
1022
+ function isProxy(value) {
1023
+ return isReactive(value) || isReadonly(value);
1024
+ }
1025
+ function toRaw(observed) {
1026
+ const raw = observed && observed["__v_raw" /* ReactiveFlags.RAW */];
1027
+ return raw ? toRaw(raw) : observed;
1028
+ }
1029
+ function markRaw(value) {
1030
+ def(value, "__v_skip" /* ReactiveFlags.SKIP */, true);
1031
+ return value;
1032
+ }
1033
+ const toReactive = (value) => isObject(value) ? reactive(value) : value;
1027
1034
  const toReadonly = (value) => isObject(value) ? readonly(value) : value;
1028
1035
 
1029
- function trackRefValue(ref) {
1030
- if (shouldTrack && activeEffect) {
1031
- ref = toRaw(ref);
1032
- {
1033
- trackEffects(ref.dep || (ref.dep = createDep()), {
1034
- target: ref,
1035
- type: "get" /* TrackOpTypes.GET */,
1036
- key: 'value'
1037
- });
1038
- }
1039
- }
1040
- }
1041
- function triggerRefValue(ref, newVal) {
1042
- ref = toRaw(ref);
1043
- if (ref.dep) {
1044
- {
1045
- triggerEffects(ref.dep, {
1046
- target: ref,
1047
- type: "set" /* TriggerOpTypes.SET */,
1048
- key: 'value',
1049
- newValue: newVal
1050
- });
1051
- }
1052
- }
1053
- }
1054
- function isRef(r) {
1055
- return !!(r && r.__v_isRef === true);
1056
- }
1057
- function ref(value) {
1058
- return createRef(value, false);
1059
- }
1060
- function shallowRef(value) {
1061
- return createRef(value, true);
1062
- }
1063
- function createRef(rawValue, shallow) {
1064
- if (isRef(rawValue)) {
1065
- return rawValue;
1066
- }
1067
- return new RefImpl(rawValue, shallow);
1068
- }
1069
- class RefImpl {
1070
- constructor(value, __v_isShallow) {
1071
- this.__v_isShallow = __v_isShallow;
1072
- this.dep = undefined;
1073
- this.__v_isRef = true;
1074
- this._rawValue = __v_isShallow ? value : toRaw(value);
1075
- this._value = __v_isShallow ? value : toReactive(value);
1076
- }
1077
- get value() {
1078
- trackRefValue(this);
1079
- return this._value;
1080
- }
1081
- set value(newVal) {
1082
- const useDirectValue = this.__v_isShallow || isShallow(newVal) || isReadonly(newVal);
1083
- newVal = useDirectValue ? newVal : toRaw(newVal);
1084
- if (hasChanged(newVal, this._rawValue)) {
1085
- this._rawValue = newVal;
1086
- this._value = useDirectValue ? newVal : toReactive(newVal);
1087
- triggerRefValue(this, newVal);
1088
- }
1089
- }
1090
- }
1091
- function triggerRef(ref) {
1092
- triggerRefValue(ref, ref.value );
1093
- }
1094
- function unref(ref) {
1095
- return isRef(ref) ? ref.value : ref;
1096
- }
1097
- const shallowUnwrapHandlers = {
1098
- get: (target, key, receiver) => unref(Reflect.get(target, key, receiver)),
1099
- set: (target, key, value, receiver) => {
1100
- const oldValue = target[key];
1101
- if (isRef(oldValue) && !isRef(value)) {
1102
- oldValue.value = value;
1103
- return true;
1104
- }
1105
- else {
1106
- return Reflect.set(target, key, value, receiver);
1107
- }
1108
- }
1109
- };
1110
- function proxyRefs(objectWithRefs) {
1111
- return isReactive(objectWithRefs)
1112
- ? objectWithRefs
1113
- : new Proxy(objectWithRefs, shallowUnwrapHandlers);
1114
- }
1115
- class CustomRefImpl {
1116
- constructor(factory) {
1117
- this.dep = undefined;
1118
- this.__v_isRef = true;
1119
- const { get, set } = factory(() => trackRefValue(this), () => triggerRefValue(this));
1120
- this._get = get;
1121
- this._set = set;
1122
- }
1123
- get value() {
1124
- return this._get();
1125
- }
1126
- set value(newVal) {
1127
- this._set(newVal);
1128
- }
1129
- }
1130
- function customRef(factory) {
1131
- return new CustomRefImpl(factory);
1132
- }
1133
- function toRefs(object) {
1134
- if (!isProxy(object)) {
1135
- console.warn(`toRefs() expects a reactive object but received a plain one.`);
1136
- }
1137
- const ret = isArray(object) ? new Array(object.length) : {};
1138
- for (const key in object) {
1139
- ret[key] = toRef(object, key);
1140
- }
1141
- return ret;
1142
- }
1143
- class ObjectRefImpl {
1144
- constructor(_object, _key, _defaultValue) {
1145
- this._object = _object;
1146
- this._key = _key;
1147
- this._defaultValue = _defaultValue;
1148
- this.__v_isRef = true;
1149
- }
1150
- get value() {
1151
- const val = this._object[this._key];
1152
- return val === undefined ? this._defaultValue : val;
1153
- }
1154
- set value(newVal) {
1155
- this._object[this._key] = newVal;
1156
- }
1157
- }
1158
- function toRef(object, key, defaultValue) {
1159
- const val = object[key];
1160
- return isRef(val)
1161
- ? val
1162
- : new ObjectRefImpl(object, key, defaultValue);
1036
+ function trackRefValue(ref) {
1037
+ if (shouldTrack && activeEffect) {
1038
+ ref = toRaw(ref);
1039
+ {
1040
+ trackEffects(ref.dep || (ref.dep = createDep()), {
1041
+ target: ref,
1042
+ type: "get" /* TrackOpTypes.GET */,
1043
+ key: 'value'
1044
+ });
1045
+ }
1046
+ }
1047
+ }
1048
+ function triggerRefValue(ref, newVal) {
1049
+ ref = toRaw(ref);
1050
+ if (ref.dep) {
1051
+ {
1052
+ triggerEffects(ref.dep, {
1053
+ target: ref,
1054
+ type: "set" /* TriggerOpTypes.SET */,
1055
+ key: 'value',
1056
+ newValue: newVal
1057
+ });
1058
+ }
1059
+ }
1060
+ }
1061
+ function isRef(r) {
1062
+ return !!(r && r.__v_isRef === true);
1063
+ }
1064
+ function ref(value) {
1065
+ return createRef(value, false);
1066
+ }
1067
+ function shallowRef(value) {
1068
+ return createRef(value, true);
1069
+ }
1070
+ function createRef(rawValue, shallow) {
1071
+ if (isRef(rawValue)) {
1072
+ return rawValue;
1073
+ }
1074
+ return new RefImpl(rawValue, shallow);
1075
+ }
1076
+ class RefImpl {
1077
+ constructor(value, __v_isShallow) {
1078
+ this.__v_isShallow = __v_isShallow;
1079
+ this.dep = undefined;
1080
+ this.__v_isRef = true;
1081
+ this._rawValue = __v_isShallow ? value : toRaw(value);
1082
+ this._value = __v_isShallow ? value : toReactive(value);
1083
+ }
1084
+ get value() {
1085
+ trackRefValue(this);
1086
+ return this._value;
1087
+ }
1088
+ set value(newVal) {
1089
+ const useDirectValue = this.__v_isShallow || isShallow(newVal) || isReadonly(newVal);
1090
+ newVal = useDirectValue ? newVal : toRaw(newVal);
1091
+ if (hasChanged(newVal, this._rawValue)) {
1092
+ this._rawValue = newVal;
1093
+ this._value = useDirectValue ? newVal : toReactive(newVal);
1094
+ triggerRefValue(this, newVal);
1095
+ }
1096
+ }
1097
+ }
1098
+ function triggerRef(ref) {
1099
+ triggerRefValue(ref, ref.value );
1100
+ }
1101
+ function unref(ref) {
1102
+ return isRef(ref) ? ref.value : ref;
1103
+ }
1104
+ const shallowUnwrapHandlers = {
1105
+ get: (target, key, receiver) => unref(Reflect.get(target, key, receiver)),
1106
+ set: (target, key, value, receiver) => {
1107
+ const oldValue = target[key];
1108
+ if (isRef(oldValue) && !isRef(value)) {
1109
+ oldValue.value = value;
1110
+ return true;
1111
+ }
1112
+ else {
1113
+ return Reflect.set(target, key, value, receiver);
1114
+ }
1115
+ }
1116
+ };
1117
+ function proxyRefs(objectWithRefs) {
1118
+ return isReactive(objectWithRefs)
1119
+ ? objectWithRefs
1120
+ : new Proxy(objectWithRefs, shallowUnwrapHandlers);
1121
+ }
1122
+ class CustomRefImpl {
1123
+ constructor(factory) {
1124
+ this.dep = undefined;
1125
+ this.__v_isRef = true;
1126
+ const { get, set } = factory(() => trackRefValue(this), () => triggerRefValue(this));
1127
+ this._get = get;
1128
+ this._set = set;
1129
+ }
1130
+ get value() {
1131
+ return this._get();
1132
+ }
1133
+ set value(newVal) {
1134
+ this._set(newVal);
1135
+ }
1136
+ }
1137
+ function customRef(factory) {
1138
+ return new CustomRefImpl(factory);
1139
+ }
1140
+ function toRefs(object) {
1141
+ if (!isProxy(object)) {
1142
+ console.warn(`toRefs() expects a reactive object but received a plain one.`);
1143
+ }
1144
+ const ret = isArray(object) ? new Array(object.length) : {};
1145
+ for (const key in object) {
1146
+ ret[key] = toRef(object, key);
1147
+ }
1148
+ return ret;
1149
+ }
1150
+ class ObjectRefImpl {
1151
+ constructor(_object, _key, _defaultValue) {
1152
+ this._object = _object;
1153
+ this._key = _key;
1154
+ this._defaultValue = _defaultValue;
1155
+ this.__v_isRef = true;
1156
+ }
1157
+ get value() {
1158
+ const val = this._object[this._key];
1159
+ return val === undefined ? this._defaultValue : val;
1160
+ }
1161
+ set value(newVal) {
1162
+ this._object[this._key] = newVal;
1163
+ }
1164
+ }
1165
+ function toRef(object, key, defaultValue) {
1166
+ const val = object[key];
1167
+ return isRef(val)
1168
+ ? val
1169
+ : new ObjectRefImpl(object, key, defaultValue);
1163
1170
  }
1164
1171
 
1165
- var _a;
1166
- class ComputedRefImpl {
1167
- constructor(getter, _setter, isReadonly, isSSR) {
1168
- this._setter = _setter;
1169
- this.dep = undefined;
1170
- this.__v_isRef = true;
1171
- this[_a] = false;
1172
- this._dirty = true;
1173
- this.effect = new ReactiveEffect(getter, () => {
1174
- if (!this._dirty) {
1175
- this._dirty = true;
1176
- triggerRefValue(this);
1177
- }
1178
- });
1179
- this.effect.computed = this;
1180
- this.effect.active = this._cacheable = !isSSR;
1181
- this["__v_isReadonly" /* ReactiveFlags.IS_READONLY */] = isReadonly;
1182
- }
1183
- get value() {
1184
- // the computed ref may get wrapped by other proxies e.g. readonly() #3376
1185
- const self = toRaw(this);
1186
- trackRefValue(self);
1187
- if (self._dirty || !self._cacheable) {
1188
- self._dirty = false;
1189
- self._value = self.effect.run();
1190
- }
1191
- return self._value;
1192
- }
1193
- set value(newValue) {
1194
- this._setter(newValue);
1195
- }
1196
- }
1197
- _a = "__v_isReadonly" /* ReactiveFlags.IS_READONLY */;
1198
- function computed(getterOrOptions, debugOptions, isSSR = false) {
1199
- let getter;
1200
- let setter;
1201
- const onlyGetter = isFunction(getterOrOptions);
1202
- if (onlyGetter) {
1203
- getter = getterOrOptions;
1204
- setter = () => {
1205
- console.warn('Write operation failed: computed value is readonly');
1206
- }
1207
- ;
1208
- }
1209
- else {
1210
- getter = getterOrOptions.get;
1211
- setter = getterOrOptions.set;
1212
- }
1213
- const cRef = new ComputedRefImpl(getter, setter, onlyGetter || !setter, isSSR);
1214
- if (debugOptions && !isSSR) {
1215
- cRef.effect.onTrack = debugOptions.onTrack;
1216
- cRef.effect.onTrigger = debugOptions.onTrigger;
1217
- }
1218
- return cRef;
1172
+ var _a;
1173
+ class ComputedRefImpl {
1174
+ constructor(getter, _setter, isReadonly, isSSR) {
1175
+ this._setter = _setter;
1176
+ this.dep = undefined;
1177
+ this.__v_isRef = true;
1178
+ this[_a] = false;
1179
+ this._dirty = true;
1180
+ this.effect = new ReactiveEffect(getter, () => {
1181
+ if (!this._dirty) {
1182
+ this._dirty = true;
1183
+ triggerRefValue(this);
1184
+ }
1185
+ });
1186
+ this.effect.computed = this;
1187
+ this.effect.active = this._cacheable = !isSSR;
1188
+ this["__v_isReadonly" /* ReactiveFlags.IS_READONLY */] = isReadonly;
1189
+ }
1190
+ get value() {
1191
+ // the computed ref may get wrapped by other proxies e.g. readonly() #3376
1192
+ const self = toRaw(this);
1193
+ trackRefValue(self);
1194
+ if (self._dirty || !self._cacheable) {
1195
+ self._dirty = false;
1196
+ self._value = self.effect.run();
1197
+ }
1198
+ return self._value;
1199
+ }
1200
+ set value(newValue) {
1201
+ this._setter(newValue);
1202
+ }
1203
+ }
1204
+ _a = "__v_isReadonly" /* ReactiveFlags.IS_READONLY */;
1205
+ function computed(getterOrOptions, debugOptions, isSSR = false) {
1206
+ let getter;
1207
+ let setter;
1208
+ const onlyGetter = isFunction(getterOrOptions);
1209
+ if (onlyGetter) {
1210
+ getter = getterOrOptions;
1211
+ setter = () => {
1212
+ console.warn('Write operation failed: computed value is readonly');
1213
+ }
1214
+ ;
1215
+ }
1216
+ else {
1217
+ getter = getterOrOptions.get;
1218
+ setter = getterOrOptions.set;
1219
+ }
1220
+ const cRef = new ComputedRefImpl(getter, setter, onlyGetter || !setter, isSSR);
1221
+ if (debugOptions && !isSSR) {
1222
+ cRef.effect.onTrack = debugOptions.onTrack;
1223
+ cRef.effect.onTrigger = debugOptions.onTrigger;
1224
+ }
1225
+ return cRef;
1219
1226
  }
1220
1227
 
1221
- var _a$1;
1222
- const tick = /*#__PURE__*/ Promise.resolve();
1223
- const queue = [];
1224
- let queued = false;
1225
- const scheduler = (fn) => {
1226
- queue.push(fn);
1227
- if (!queued) {
1228
- queued = true;
1229
- tick.then(flush);
1230
- }
1231
- };
1232
- const flush = () => {
1233
- for (let i = 0; i < queue.length; i++) {
1234
- queue[i]();
1235
- }
1236
- queue.length = 0;
1237
- queued = false;
1238
- };
1239
- class DeferredComputedRefImpl {
1240
- constructor(getter) {
1241
- this.dep = undefined;
1242
- this._dirty = true;
1243
- this.__v_isRef = true;
1244
- this[_a$1] = true;
1245
- let compareTarget;
1246
- let hasCompareTarget = false;
1247
- let scheduled = false;
1248
- this.effect = new ReactiveEffect(getter, (computedTrigger) => {
1249
- if (this.dep) {
1250
- if (computedTrigger) {
1251
- compareTarget = this._value;
1252
- hasCompareTarget = true;
1253
- }
1254
- else if (!scheduled) {
1255
- const valueToCompare = hasCompareTarget ? compareTarget : this._value;
1256
- scheduled = true;
1257
- hasCompareTarget = false;
1258
- scheduler(() => {
1259
- if (this.effect.active && this._get() !== valueToCompare) {
1260
- triggerRefValue(this);
1261
- }
1262
- scheduled = false;
1263
- });
1264
- }
1265
- // chained upstream computeds are notified synchronously to ensure
1266
- // value invalidation in case of sync access; normal effects are
1267
- // deferred to be triggered in scheduler.
1268
- for (const e of this.dep) {
1269
- if (e.computed instanceof DeferredComputedRefImpl) {
1270
- e.scheduler(true /* computedTrigger */);
1271
- }
1272
- }
1273
- }
1274
- this._dirty = true;
1275
- });
1276
- this.effect.computed = this;
1277
- }
1278
- _get() {
1279
- if (this._dirty) {
1280
- this._dirty = false;
1281
- return (this._value = this.effect.run());
1282
- }
1283
- return this._value;
1284
- }
1285
- get value() {
1286
- trackRefValue(this);
1287
- // the computed ref may get wrapped by other proxies e.g. readonly() #3376
1288
- return toRaw(this)._get();
1289
- }
1290
- }
1291
- _a$1 = "__v_isReadonly" /* ReactiveFlags.IS_READONLY */;
1292
- function deferredComputed(getter) {
1293
- return new DeferredComputedRefImpl(getter);
1228
+ var _a$1;
1229
+ const tick = /*#__PURE__*/ Promise.resolve();
1230
+ const queue = [];
1231
+ let queued = false;
1232
+ const scheduler = (fn) => {
1233
+ queue.push(fn);
1234
+ if (!queued) {
1235
+ queued = true;
1236
+ tick.then(flush);
1237
+ }
1238
+ };
1239
+ const flush = () => {
1240
+ for (let i = 0; i < queue.length; i++) {
1241
+ queue[i]();
1242
+ }
1243
+ queue.length = 0;
1244
+ queued = false;
1245
+ };
1246
+ class DeferredComputedRefImpl {
1247
+ constructor(getter) {
1248
+ this.dep = undefined;
1249
+ this._dirty = true;
1250
+ this.__v_isRef = true;
1251
+ this[_a$1] = true;
1252
+ let compareTarget;
1253
+ let hasCompareTarget = false;
1254
+ let scheduled = false;
1255
+ this.effect = new ReactiveEffect(getter, (computedTrigger) => {
1256
+ if (this.dep) {
1257
+ if (computedTrigger) {
1258
+ compareTarget = this._value;
1259
+ hasCompareTarget = true;
1260
+ }
1261
+ else if (!scheduled) {
1262
+ const valueToCompare = hasCompareTarget ? compareTarget : this._value;
1263
+ scheduled = true;
1264
+ hasCompareTarget = false;
1265
+ scheduler(() => {
1266
+ if (this.effect.active && this._get() !== valueToCompare) {
1267
+ triggerRefValue(this);
1268
+ }
1269
+ scheduled = false;
1270
+ });
1271
+ }
1272
+ // chained upstream computeds are notified synchronously to ensure
1273
+ // value invalidation in case of sync access; normal effects are
1274
+ // deferred to be triggered in scheduler.
1275
+ for (const e of this.dep) {
1276
+ if (e.computed instanceof DeferredComputedRefImpl) {
1277
+ e.scheduler(true /* computedTrigger */);
1278
+ }
1279
+ }
1280
+ }
1281
+ this._dirty = true;
1282
+ });
1283
+ this.effect.computed = this;
1284
+ }
1285
+ _get() {
1286
+ if (this._dirty) {
1287
+ this._dirty = false;
1288
+ return (this._value = this.effect.run());
1289
+ }
1290
+ return this._value;
1291
+ }
1292
+ get value() {
1293
+ trackRefValue(this);
1294
+ // the computed ref may get wrapped by other proxies e.g. readonly() #3376
1295
+ return toRaw(this)._get();
1296
+ }
1297
+ }
1298
+ _a$1 = "__v_isReadonly" /* ReactiveFlags.IS_READONLY */;
1299
+ function deferredComputed(getter) {
1300
+ return new DeferredComputedRefImpl(getter);
1294
1301
  }
1295
1302
 
1296
1303
  export { EffectScope, ITERATE_KEY, ReactiveEffect, computed, customRef, deferredComputed, effect, effectScope, enableTracking, getCurrentScope, isProxy, isReactive, isReadonly, isRef, isShallow, markRaw, onScopeDispose, pauseTracking, proxyRefs, reactive, readonly, ref, resetTracking, shallowReactive, shallowReadonly, shallowRef, stop, toRaw, toRef, toRefs, track, trigger, triggerRef, unref };