· 5 years ago · Nov 17, 2020, 06:32 PM
1(function (global, factory) {
2 typeof exports === 'object' && typeof module !== 'undefined' ? factory(exports, require('vue')) :
3 typeof define === 'function' && define.amd ? define(['exports', 'vue'], factory) :
4 (global = global || self, factory(global.VueCompositionAPI = {}, global.Vue));
5}(this, (function (exports, Vue) { 'use strict';
6
7 Vue = Vue && Object.prototype.hasOwnProperty.call(Vue, 'default') ? Vue['default'] : Vue;
8
9 var toString = function (x) { return Object.prototype.toString.call(x); };
10 function isNative(Ctor) {
11 return typeof Ctor === 'function' && /native code/.test(Ctor.toString());
12 }
13 var hasSymbol = typeof Symbol !== 'undefined' &&
14 isNative(Symbol) &&
15 typeof Reflect !== 'undefined' &&
16 isNative(Reflect.ownKeys);
17 var noopFn = function (_) { return _; };
18 var sharedPropertyDefinition = {
19 enumerable: true,
20 configurable: true,
21 get: noopFn,
22 set: noopFn,
23 };
24 function proxy(target, key, _a) {
25 var get = _a.get, set = _a.set;
26 sharedPropertyDefinition.get = get || noopFn;
27 sharedPropertyDefinition.set = set || noopFn;
28 Object.defineProperty(target, key, sharedPropertyDefinition);
29 }
30 function def(obj, key, val, enumerable) {
31 Object.defineProperty(obj, key, {
32 value: val,
33 enumerable: !!enumerable,
34 writable: true,
35 configurable: true,
36 });
37 }
38 function hasOwn(obj, key) {
39 return Object.hasOwnProperty.call(obj, key);
40 }
41 function assert(condition, msg) {
42 if (!condition)
43 throw new Error("[vue-composition-api] " + msg);
44 }
45 function isArray(x) {
46 return Array.isArray(x);
47 }
48 function isObject(val) {
49 return val !== null && typeof val === 'object';
50 }
51 function isPlainObject(x) {
52 return toString(x) === '[object Object]';
53 }
54 function isFunction(x) {
55 return typeof x === 'function';
56 }
57 function warn(msg, vm) {
58 Vue.util.warn(msg, vm);
59 }
60 function logError(err, vm, info) {
61 {
62 warn("Error in " + info + ": \"" + err.toString() + "\"", vm);
63 }
64 if (typeof window !== 'undefined' && typeof console !== 'undefined') {
65 console.error(err);
66 }
67 else {
68 throw err;
69 }
70 }
71
72 var vueConstructor = null;
73 var currentInstance = null;
74 var PluginInstalledFlag = '__composition_api_installed__';
75 function isPluginInstalled() {
76 return !!vueConstructor;
77 }
78 function isVueRegistered(Vue) {
79 return hasOwn(Vue, PluginInstalledFlag);
80 }
81 function getVueConstructor() {
82 {
83 assert(vueConstructor, "must call Vue.use(VueCompositionAPI) before using any function.");
84 }
85 return vueConstructor;
86 }
87 function setVueConstructor(Vue) {
88 vueConstructor = Vue;
89 Object.defineProperty(Vue, PluginInstalledFlag, {
90 configurable: true,
91 writable: true,
92 value: true,
93 });
94 }
95 function getCurrentInstance() {
96 return currentInstance;
97 }
98 function setCurrentInstance(vm) {
99 currentInstance = vm;
100 }
101
102 function currentVMInFn(hook) {
103 var vm = getCurrentInstance();
104 if ( !vm) {
105 warn(hook + " is called when there is no active component instance to be " +
106 "associated with. " +
107 "Lifecycle injection APIs can only be used during execution of setup().");
108 }
109 return vm;
110 }
111 function defineComponentInstance(Ctor, options) {
112 if (options === void 0) { options = {}; }
113 var silent = Ctor.config.silent;
114 Ctor.config.silent = true;
115 var vm = new Ctor(options);
116 Ctor.config.silent = silent;
117 return vm;
118 }
119 function isComponentInstance(obj) {
120 var Vue = getVueConstructor();
121 return Vue && obj instanceof Vue;
122 }
123 function createSlotProxy(vm, slotName) {
124 return function () {
125 var args = [];
126 for (var _i = 0; _i < arguments.length; _i++) {
127 args[_i] = arguments[_i];
128 }
129 if (!vm.$scopedSlots[slotName]) {
130 return warn("slots." + slotName + "() got called outside of the \"render()\" scope", vm);
131 }
132 return vm.$scopedSlots[slotName].apply(vm, args);
133 };
134 }
135 function resolveSlots(slots, normalSlots) {
136 var res;
137 if (!slots) {
138 res = {};
139 }
140 else if (slots._normalized) {
141 // fast path 1: child component re-render only, parent did not change
142 return slots._normalized;
143 }
144 else {
145 res = {};
146 for (var key in slots) {
147 if (slots[key] && key[0] !== '$') {
148 res[key] = true;
149 }
150 }
151 }
152 // expose normal slots on scopedSlots
153 for (var key in normalSlots) {
154 if (!(key in res)) {
155 res[key] = true;
156 }
157 }
158 return res;
159 }
160
161 /*! *****************************************************************************
162 Copyright (c) Microsoft Corporation.
163
164 Permission to use, copy, modify, and/or distribute this software for any
165 purpose with or without fee is hereby granted.
166
167 THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH
168 REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY
169 AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT,
170 INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM
171 LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR
172 OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
173 PERFORMANCE OF THIS SOFTWARE.
174 ***************************************************************************** */
175
176 var __assign = function() {
177 __assign = Object.assign || function __assign(t) {
178 for (var s, i = 1, n = arguments.length; i < n; i++) {
179 s = arguments[i];
180 for (var p in s) if (Object.prototype.hasOwnProperty.call(s, p)) t[p] = s[p];
181 }
182 return t;
183 };
184 return __assign.apply(this, arguments);
185 };
186
187 function __values(o) {
188 var s = typeof Symbol === "function" && Symbol.iterator, m = s && o[s], i = 0;
189 if (m) return m.call(o);
190 if (o && typeof o.length === "number") return {
191 next: function () {
192 if (o && i >= o.length) o = void 0;
193 return { value: o && o[i++], done: !o };
194 }
195 };
196 throw new TypeError(s ? "Object is not iterable." : "Symbol.iterator is not defined.");
197 }
198
199 function __read(o, n) {
200 var m = typeof Symbol === "function" && o[Symbol.iterator];
201 if (!m) return o;
202 var i = m.call(o), r, ar = [], e;
203 try {
204 while ((n === void 0 || n-- > 0) && !(r = i.next()).done) ar.push(r.value);
205 }
206 catch (error) { e = { error: error }; }
207 finally {
208 try {
209 if (r && !r.done && (m = i["return"])) m.call(i);
210 }
211 finally { if (e) throw e.error; }
212 }
213 return ar;
214 }
215
216 function __spread() {
217 for (var ar = [], i = 0; i < arguments.length; i++)
218 ar = ar.concat(__read(arguments[i]));
219 return ar;
220 }
221
222 function createSymbol(name) {
223 return hasSymbol ? Symbol.for(name) : name;
224 }
225 var WatcherPreFlushQueueKey = createSymbol('composition-api.preFlushQueue');
226 var WatcherPostFlushQueueKey = createSymbol('composition-api.postFlushQueue');
227 var AccessControlIdentifierKey = createSymbol('composition-api.accessControlIdentifier');
228 var ReactiveIdentifierKey = createSymbol('composition-api.reactiveIdentifier');
229 var RawIdentifierKey = createSymbol('composition-api.rawIdentifierKey');
230 // must be a string, symbol key is ignored in reactive
231 var RefKey = 'composition-api.refKey';
232
233 var RefImpl = /** @class */ (function () {
234 function RefImpl(_a) {
235 var get = _a.get, set = _a.set;
236 proxy(this, 'value', {
237 get: get,
238 set: set,
239 });
240 }
241 return RefImpl;
242 }());
243 function createRef(options) {
244 // seal the ref, this could prevent ref from being observed
245 // It's safe to seal the ref, since we really shouldn't extend it.
246 // related issues: #79
247 return Object.seal(new RefImpl(options));
248 }
249 function ref(raw) {
250 var _a;
251 if (isRef(raw)) {
252 return raw;
253 }
254 var value = reactive((_a = {}, _a[RefKey] = raw, _a));
255 return createRef({
256 get: function () { return value[RefKey]; },
257 set: function (v) { return (value[RefKey] = v); },
258 });
259 }
260 function isRef(value) {
261 return value instanceof RefImpl;
262 }
263 function unref(ref) {
264 return isRef(ref) ? ref.value : ref;
265 }
266 function toRefs(obj) {
267 if (!isPlainObject(obj))
268 return obj;
269 if ( !isReactive(obj)) {
270 warn("toRefs() expects a reactive object but received a plain one.");
271 }
272 var ret = {};
273 for (var key in obj) {
274 ret[key] = toRef(obj, key);
275 }
276 return ret;
277 }
278 function customRef(factory) {
279 var version = ref(0);
280 return createRef(factory(function () { return void version.value; }, function () {
281 ++version.value;
282 }));
283 }
284 function toRef(object, key) {
285 var v = object[key];
286 if (isRef(v))
287 return v;
288 return createRef({
289 get: function () { return object[key]; },
290 set: function (v) { return (object[key] = v); },
291 });
292 }
293 function shallowRef(raw) {
294 var _a;
295 if (isRef(raw)) {
296 return raw;
297 }
298 var value = shallowReactive((_a = {}, _a[RefKey] = raw, _a));
299 return createRef({
300 get: function () { return value[RefKey]; },
301 set: function (v) { return (value[RefKey] = v); },
302 });
303 }
304 function triggerRef(value) {
305 if (!isRef(value))
306 return;
307 value.value = value.value;
308 }
309
310 var AccessControlIdentifier = {};
311 var ReactiveIdentifier = {};
312 var RawIdentifier = {};
313 function isRaw(obj) {
314 return (hasOwn(obj, RawIdentifierKey) && obj[RawIdentifierKey] === RawIdentifier);
315 }
316 function isReactive(obj) {
317 return (isObject(obj) &&
318 Object.isExtensible(obj) &&
319 hasOwn(obj, ReactiveIdentifierKey) &&
320 obj[ReactiveIdentifierKey] === ReactiveIdentifier);
321 }
322 /**
323 * Proxing property access of target.
324 * We can do unwrapping and other things here.
325 */
326 function setupAccessControl(target) {
327 if (!isPlainObject(target) ||
328 isRaw(target) ||
329 Array.isArray(target) ||
330 isRef(target) ||
331 isComponentInstance(target)) {
332 return;
333 }
334 if (hasOwn(target, AccessControlIdentifierKey) &&
335 target[AccessControlIdentifierKey] === AccessControlIdentifier) {
336 return;
337 }
338 if (Object.isExtensible(target)) {
339 def(target, AccessControlIdentifierKey, AccessControlIdentifier);
340 }
341 var keys = Object.keys(target);
342 for (var i = 0; i < keys.length; i++) {
343 defineAccessControl(target, keys[i]);
344 }
345 }
346 /**
347 * Auto unwrapping when access property
348 */
349 function defineAccessControl(target, key, val) {
350 if (key === '__ob__')
351 return;
352 var getter;
353 var setter;
354 var property = Object.getOwnPropertyDescriptor(target, key);
355 if (property) {
356 if (property.configurable === false) {
357 return;
358 }
359 getter = property.get;
360 setter = property.set;
361 if ((!getter || setter) /* not only have getter */ &&
362 arguments.length === 2) {
363 val = target[key];
364 }
365 }
366 setupAccessControl(val);
367 Object.defineProperty(target, key, {
368 enumerable: true,
369 configurable: true,
370 get: function getterHandler() {
371 var value = getter ? getter.call(target) : val;
372 // if the key is equal to RefKey, skip the unwrap logic
373 if (key !== RefKey && isRef(value)) {
374 return value.value;
375 }
376 else {
377 return value;
378 }
379 },
380 set: function setterHandler(newVal) {
381 if (getter && !setter)
382 return;
383 var value = getter ? getter.call(target) : val;
384 // If the key is equal to RefKey, skip the unwrap logic
385 // If and only if "value" is ref and "newVal" is not a ref,
386 // the assignment should be proxied to "value" ref.
387 if (key !== RefKey && isRef(value) && !isRef(newVal)) {
388 value.value = newVal;
389 }
390 else if (setter) {
391 setter.call(target, newVal);
392 }
393 else {
394 val = newVal;
395 }
396 setupAccessControl(newVal);
397 },
398 });
399 }
400 function observe(obj) {
401 var Vue = getVueConstructor();
402 var observed;
403 if (Vue.observable) {
404 observed = Vue.observable(obj);
405 }
406 else {
407 var vm = defineComponentInstance(Vue, {
408 data: {
409 $$state: obj,
410 },
411 });
412 observed = vm._data.$$state;
413 }
414 return observed;
415 }
416 function shallowReactive(obj) {
417 var e_1, _a;
418 if ( !obj) {
419 warn('"shallowReactive()" is called without provide an "object".');
420 // @ts-ignore
421 return;
422 }
423 if (!isPlainObject(obj) ||
424 isReactive(obj) ||
425 isRaw(obj) ||
426 !Object.isExtensible(obj)) {
427 return obj;
428 }
429 var observed = observe({});
430 markReactive(observed, true);
431 setupAccessControl(observed);
432 var ob = observed.__ob__;
433 var _loop_1 = function (key) {
434 var val = obj[key];
435 var getter;
436 var setter;
437 var property = Object.getOwnPropertyDescriptor(obj, key);
438 if (property) {
439 if (property.configurable === false) {
440 return "continue";
441 }
442 getter = property.get;
443 setter = property.set;
444 if ((!getter || setter) /* not only have getter */ &&
445 arguments_1.length === 2) {
446 val = obj[key];
447 }
448 }
449 // setupAccessControl(val);
450 Object.defineProperty(observed, key, {
451 enumerable: true,
452 configurable: true,
453 get: function getterHandler() {
454 var value = getter ? getter.call(obj) : val;
455 ob.dep.depend();
456 return value;
457 },
458 set: function setterHandler(newVal) {
459 if (getter && !setter)
460 return;
461 if (setter) {
462 setter.call(obj, newVal);
463 }
464 else {
465 val = newVal;
466 }
467 ob.dep.notify();
468 },
469 });
470 };
471 var arguments_1 = arguments;
472 try {
473 for (var _b = __values(Object.keys(obj)), _c = _b.next(); !_c.done; _c = _b.next()) {
474 var key = _c.value;
475 _loop_1(key);
476 }
477 }
478 catch (e_1_1) { e_1 = { error: e_1_1 }; }
479 finally {
480 try {
481 if (_c && !_c.done && (_a = _b.return)) _a.call(_b);
482 }
483 finally { if (e_1) throw e_1.error; }
484 }
485 return observed;
486 }
487 function markReactive(target, shallow) {
488 if (shallow === void 0) { shallow = false; }
489 if (!isPlainObject(target) ||
490 isRaw(target) ||
491 Array.isArray(target) ||
492 isRef(target) ||
493 isComponentInstance(target)) {
494 return;
495 }
496 if (hasOwn(target, ReactiveIdentifierKey) &&
497 target[ReactiveIdentifierKey] === ReactiveIdentifier) {
498 return;
499 }
500 if (Object.isExtensible(target)) {
501 def(target, ReactiveIdentifierKey, ReactiveIdentifier);
502 }
503 if (shallow) {
504 return;
505 }
506 var keys = Object.keys(target);
507 for (var i = 0; i < keys.length; i++) {
508 markReactive(target[keys[i]]);
509 }
510 }
511 /**
512 * Make obj reactivity
513 */
514 function reactive(obj) {
515 if ( !obj) {
516 warn('"reactive()" is called without provide an "object".');
517 // @ts-ignore
518 return;
519 }
520 if (!isPlainObject(obj) ||
521 isReactive(obj) ||
522 isRaw(obj) ||
523 !Object.isExtensible(obj)) {
524 return obj;
525 }
526 var observed = observe(obj);
527 // def(obj, ReactiveIdentifierKey, ReactiveIdentifier);
528 markReactive(obj);
529 setupAccessControl(observed);
530 return observed;
531 }
532 /**
533 * Make sure obj can't be a reactive
534 */
535 function markRaw(obj) {
536 if (!isPlainObject(obj) || !Object.isExtensible(obj)) {
537 return obj;
538 }
539 // set the vue observable flag at obj
540 def(obj, '__ob__', observe({}).__ob__);
541 // mark as Raw
542 def(obj, RawIdentifierKey, RawIdentifier);
543 return obj;
544 }
545 function toRaw(observed) {
546 if (isRaw(observed) || !Object.isExtensible(observed)) {
547 return observed;
548 }
549 return observed.__ob__.value || observed;
550 }
551
552 function isUndef(v) {
553 return v === undefined || v === null;
554 }
555 function isPrimitive(value) {
556 return (typeof value === 'string' ||
557 typeof value === 'number' ||
558 // $flow-disable-line
559 typeof value === 'symbol' ||
560 typeof value === 'boolean');
561 }
562 function isValidArrayIndex(val) {
563 var n = parseFloat(String(val));
564 return n >= 0 && Math.floor(n) === n && isFinite(val);
565 }
566 /**
567 * Set a property on an object. Adds the new property, triggers change
568 * notification and intercept it's subsequent access if the property doesn't
569 * already exist.
570 */
571 function set(target, key, val) {
572 var Vue = getVueConstructor();
573 var _a = Vue.util, warn = _a.warn, defineReactive = _a.defineReactive;
574 if ( (isUndef(target) || isPrimitive(target))) {
575 warn("Cannot set reactive property on undefined, null, or primitive value: " + target);
576 }
577 if (isArray(target) && isValidArrayIndex(key)) {
578 target.length = Math.max(target.length, key);
579 target.splice(key, 1, val);
580 return val;
581 }
582 if (key in target && !(key in Object.prototype)) {
583 target[key] = val;
584 return val;
585 }
586 var ob = target.__ob__;
587 if (target._isVue || (ob && ob.vmCount)) {
588
589 warn('Avoid adding reactive properties to a Vue instance or its root $data ' +
590 'at runtime - declare it upfront in the data option.');
591 return val;
592 }
593 if (!ob) {
594 target[key] = val;
595 return val;
596 }
597 defineReactive(ob.value, key, val);
598 // IMPORTANT: define access control before trigger watcher
599 defineAccessControl(target, key, val);
600 markReactive(ob.value[key]);
601 ob.dep.notify();
602 return val;
603 }
604
605 function unwrapRefProxy(value, map) {
606 var e_1, _a;
607 if (map === void 0) { map = new WeakMap(); }
608 if (map.has(value)) {
609 return map.get(value);
610 }
611 if (isFunction(value) ||
612 isArray(value) ||
613 isReactive(value) ||
614 !isPlainObject(value) ||
615 !Object.isExtensible(value) ||
616 isRef(value) ||
617 isRaw(value)) {
618 return value;
619 }
620 var obj = {};
621 map.set(value, obj);
622 // copy symbols over
623 Object.getOwnPropertySymbols(value).forEach(function (s) { return (obj[s] = value[s]); });
624 // copy __ob__
625 if (hasOwn(value, '__ob__')) {
626 Object.defineProperty(obj, '__ob__', {
627 enumerable: false,
628 value: value.__ob__,
629 });
630 }
631 var _loop_1 = function (k) {
632 var r = value[k];
633 // don't process on falsy or raw
634 if (!r || isRaw(r)) {
635 obj[k] = r;
636 }
637 // if is a ref, create a proxy to retrieve the value,
638 else if (isRef(r)) {
639 var set = function (v) { return (r.value = v); };
640 var get = function () { return r.value; };
641 proxy(obj, k, { get: get, set: set });
642 }
643 else {
644 obj[k] = unwrapRefProxy(r, map);
645 }
646 };
647 try {
648 for (var _b = __values(Object.keys(value)), _c = _b.next(); !_c.done; _c = _b.next()) {
649 var k = _c.value;
650 _loop_1(k);
651 }
652 }
653 catch (e_1_1) { e_1 = { error: e_1_1 }; }
654 finally {
655 try {
656 if (_c && !_c.done && (_a = _b.return)) _a.call(_b);
657 }
658 finally { if (e_1) throw e_1.error; }
659 }
660 return obj;
661 }
662
663 var genName = function (name) { return "on" + (name[0].toUpperCase() + name.slice(1)); };
664 function createLifeCycle(lifeCyclehook) {
665 return function (callback) {
666 var vm = currentVMInFn(genName(lifeCyclehook));
667 if (vm) {
668 injectHookOption(getVueConstructor(), vm, lifeCyclehook, callback);
669 }
670 };
671 }
672 function injectHookOption(Vue, vm, hook, val) {
673 var options = vm.$options;
674 var mergeFn = Vue.config.optionMergeStrategies[hook];
675 options[hook] = mergeFn(options[hook], wrapHookCall(vm, val));
676 }
677 function wrapHookCall(vm, fn) {
678 return function () {
679 var args = [];
680 for (var _i = 0; _i < arguments.length; _i++) {
681 args[_i] = arguments[_i];
682 }
683 var preVm = getCurrentInstance();
684 setCurrentInstance(vm);
685 try {
686 return fn.apply(void 0, __spread(args));
687 }
688 finally {
689 setCurrentInstance(preVm);
690 }
691 };
692 }
693 // export const onCreated = createLifeCycle('created');
694 var onBeforeMount = createLifeCycle('beforeMount');
695 var onMounted = createLifeCycle('mounted');
696 var onBeforeUpdate = createLifeCycle('beforeUpdate');
697 var onUpdated = createLifeCycle('updated');
698 var onBeforeUnmount = createLifeCycle('beforeDestroy');
699 var onUnmounted = createLifeCycle('destroyed');
700 var onErrorCaptured = createLifeCycle('errorCaptured');
701 var onActivated = createLifeCycle('activated');
702 var onDeactivated = createLifeCycle('deactivated');
703 var onServerPrefetch = createLifeCycle('serverPrefetch');
704
705 var fallbackVM;
706 function flushPreQueue() {
707 flushQueue(this, WatcherPreFlushQueueKey);
708 }
709 function flushPostQueue() {
710 flushQueue(this, WatcherPostFlushQueueKey);
711 }
712 function hasWatchEnv(vm) {
713 return vm[WatcherPreFlushQueueKey] !== undefined;
714 }
715 function installWatchEnv(vm) {
716 vm[WatcherPreFlushQueueKey] = [];
717 vm[WatcherPostFlushQueueKey] = [];
718 vm.$on('hook:beforeUpdate', flushPreQueue);
719 vm.$on('hook:updated', flushPostQueue);
720 }
721 function getWatcherOption(options) {
722 return __assign({
723 immediate: false,
724 deep: false,
725 flush: 'post',
726 }, options);
727 }
728 function getWatchEffectOption(options) {
729 return __assign({
730 immediate: true,
731 deep: false,
732 flush: 'post',
733 }, options);
734 }
735 function getWatcherVM() {
736 var vm = getCurrentInstance();
737 if (!vm) {
738 if (!fallbackVM) {
739 fallbackVM = defineComponentInstance(getVueConstructor());
740 }
741 vm = fallbackVM;
742 }
743 else if (!hasWatchEnv(vm)) {
744 installWatchEnv(vm);
745 }
746 return vm;
747 }
748 function flushQueue(vm, key) {
749 var queue = vm[key];
750 for (var index = 0; index < queue.length; index++) {
751 queue[index]();
752 }
753 queue.length = 0;
754 }
755 function queueFlushJob(vm, fn, mode) {
756 // flush all when beforeUpdate and updated are not fired
757 var fallbackFlush = function () {
758 vm.$nextTick(function () {
759 if (vm[WatcherPreFlushQueueKey].length) {
760 flushQueue(vm, WatcherPreFlushQueueKey);
761 }
762 if (vm[WatcherPostFlushQueueKey].length) {
763 flushQueue(vm, WatcherPostFlushQueueKey);
764 }
765 });
766 };
767 switch (mode) {
768 case 'pre':
769 fallbackFlush();
770 vm[WatcherPreFlushQueueKey].push(fn);
771 break;
772 case 'post':
773 fallbackFlush();
774 vm[WatcherPostFlushQueueKey].push(fn);
775 break;
776 default:
777 assert(false, "flush must be one of [\"post\", \"pre\", \"sync\"], but got " + mode);
778 break;
779 }
780 }
781 function createVueWatcher(vm, getter, callback, options) {
782 var index = vm._watchers.length;
783 // @ts-ignore: use undocumented options
784 vm.$watch(getter, callback, {
785 immediate: options.immediateInvokeCallback,
786 deep: options.deep,
787 lazy: options.noRun,
788 sync: options.sync,
789 before: options.before,
790 });
791 return vm._watchers[index];
792 }
793 // We have to monkeypatch the teardown function so Vue will run
794 // runCleanup() when it tears down the watcher on unmmount.
795 function patchWatcherTeardown(watcher, runCleanup) {
796 var _teardown = watcher.teardown;
797 watcher.teardown = function () {
798 var args = [];
799 for (var _i = 0; _i < arguments.length; _i++) {
800 args[_i] = arguments[_i];
801 }
802 _teardown.apply(watcher, args);
803 runCleanup();
804 };
805 }
806 function createWatcher(vm, source, cb, options) {
807 var flushMode = options.flush;
808 var isSync = flushMode === 'sync';
809 var cleanup;
810 var registerCleanup = function (fn) {
811 cleanup = function () {
812 try {
813 fn();
814 }
815 catch (error) {
816 logError(error, vm, 'onCleanup()');
817 }
818 };
819 };
820 // cleanup before running getter again
821 var runCleanup = function () {
822 if (cleanup) {
823 cleanup();
824 cleanup = null;
825 }
826 };
827 var createScheduler = function (fn) {
828 if (isSync ||
829 /* without a current active instance, ignore pre|post mode */ vm ===
830 fallbackVM) {
831 return fn;
832 }
833 return (function () {
834 var args = [];
835 for (var _i = 0; _i < arguments.length; _i++) {
836 args[_i] = arguments[_i];
837 }
838 return queueFlushJob(vm, function () {
839 fn.apply(void 0, __spread(args));
840 }, flushMode);
841 });
842 };
843 // effect watch
844 if (cb === null) {
845 var running_1 = false;
846 var getter_1 = function () {
847 // preventing the watch callback being call in the same execution
848 if (running_1) {
849 return;
850 }
851 try {
852 running_1 = true;
853 source(registerCleanup);
854 }
855 finally {
856 running_1 = false;
857 }
858 };
859 var watcher_1 = createVueWatcher(vm, getter_1, noopFn, {
860 deep: options.deep || false,
861 sync: isSync,
862 before: runCleanup,
863 });
864 patchWatcherTeardown(watcher_1, runCleanup);
865 // enable the watcher update
866 watcher_1.lazy = false;
867 var originGet = watcher_1.get.bind(watcher_1);
868 // always run watchEffect
869 watcher_1.get = createScheduler(originGet);
870 return function () {
871 watcher_1.teardown();
872 };
873 }
874 var deep = options.deep;
875 var getter;
876 if (Array.isArray(source)) {
877 getter = function () { return source.map(function (s) { return (isRef(s) ? s.value : s()); }); };
878 }
879 else if (isRef(source)) {
880 getter = function () { return source.value; };
881 }
882 else if (isReactive(source)) {
883 getter = function () { return source; };
884 deep = true;
885 }
886 else if (isFunction(source)) {
887 getter = source;
888 }
889 else {
890 getter = noopFn;
891 warn("Invalid watch source: " + JSON.stringify(source) + ".\n A watch source can only be a getter/effect function, a ref, a reactive object, or an array of these types.", vm);
892 }
893 var applyCb = function (n, o) {
894 // cleanup before running cb again
895 runCleanup();
896 cb(n, o, registerCleanup);
897 };
898 var callback = createScheduler(applyCb);
899 if (options.immediate) {
900 var originalCallback_1 = callback;
901 // `shiftCallback` is used to handle the first sync effect run.
902 // The subsequent callbacks will redirect to `callback`.
903 var shiftCallback_1 = function (n, o) {
904 shiftCallback_1 = originalCallback_1;
905 applyCb(n, o);
906 };
907 callback = function (n, o) {
908 shiftCallback_1(n, o);
909 };
910 }
911 // @ts-ignore: use undocumented option "sync"
912 var stop = vm.$watch(getter, callback, {
913 immediate: options.immediate,
914 deep: deep,
915 sync: isSync,
916 });
917 // Once again, we have to hack the watcher for proper teardown
918 var watcher = vm._watchers[vm._watchers.length - 1];
919 patchWatcherTeardown(watcher, runCleanup);
920 return function () {
921 stop();
922 };
923 }
924 function watchEffect(effect, options) {
925 var opts = getWatchEffectOption(options);
926 var vm = getWatcherVM();
927 return createWatcher(vm, effect, null, opts);
928 }
929 // implementation
930 function watch(source, cb, options) {
931 var callback = null;
932 if (typeof cb === 'function') {
933 // source watch
934 callback = cb;
935 }
936 else {
937 // effect watch
938 {
939 warn("`watch(fn, options?)` signature has been moved to a separate API. " +
940 "Use `watchEffect(fn, options?)` instead. `watch` now only " +
941 "supports `watch(source, cb, options?) signature.");
942 }
943 options = cb;
944 callback = null;
945 }
946 var opts = getWatcherOption(options);
947 var vm = getWatcherVM();
948 return createWatcher(vm, source, callback, opts);
949 }
950
951 // implement
952 function computed(options) {
953 var vm = getCurrentInstance();
954 var get, set;
955 if (typeof options === 'function') {
956 get = options;
957 }
958 else {
959 get = options.get;
960 set = options.set;
961 }
962 var computedHost = defineComponentInstance(getVueConstructor(), {
963 computed: {
964 $$state: {
965 get: get,
966 set: set,
967 },
968 },
969 });
970 vm && vm.$on('hook:destroyed', function () { return computedHost.$destroy(); });
971 return createRef({
972 get: function () { return computedHost.$$state; },
973 set: function (v) {
974 if ( !set) {
975 warn('Computed property was assigned to but it has no setter.', vm);
976 return;
977 }
978 computedHost.$$state = v;
979 },
980 });
981 }
982
983 var NOT_FOUND = {};
984 function resolveInject(provideKey, vm) {
985 var source = vm;
986 while (source) {
987 // @ts-ignore
988 if (source._provided && hasOwn(source._provided, provideKey)) {
989 //@ts-ignore
990 return source._provided[provideKey];
991 }
992 source = source.$parent;
993 }
994 return NOT_FOUND;
995 }
996 function provide(key, value) {
997 var vm = currentVMInFn('provide');
998 if (!vm)
999 return;
1000 if (!vm._provided) {
1001 var provideCache_1 = {};
1002 Object.defineProperty(vm, '_provided', {
1003 get: function () { return provideCache_1; },
1004 set: function (v) { return Object.assign(provideCache_1, v); },
1005 });
1006 }
1007 vm._provided[key] = value;
1008 }
1009 function inject(key, defaultValue) {
1010 if (!key) {
1011 return defaultValue;
1012 }
1013 var vm = getCurrentInstance();
1014 if (vm) {
1015 var val = resolveInject(key, vm);
1016 if (val !== NOT_FOUND) {
1017 return val;
1018 }
1019 else {
1020 if (defaultValue === undefined && true) {
1021 warn("Injection \"" + String(key) + "\" not found", vm);
1022 }
1023 return defaultValue;
1024 }
1025 }
1026 else {
1027 warn("inject() can only be used inside setup() or functional components.");
1028 }
1029 }
1030
1031 var EMPTY_OBJ = Object.freeze({})
1032 ;
1033 var useCSSModule = function (name) {
1034 if (name === void 0) { name = '$style'; }
1035 var instance = getCurrentInstance();
1036 if (!instance) {
1037 warn("useCSSModule must be called inside setup()");
1038 return EMPTY_OBJ;
1039 }
1040 var mod = instance[name];
1041 if (!mod) {
1042
1043 warn("Current instance does not have CSS module named \"" + name + "\".");
1044 return EMPTY_OBJ;
1045 }
1046 return mod;
1047 };
1048
1049 function createApp(rootComponent, rootProps) {
1050 if (rootProps === void 0) { rootProps = undefined; }
1051 var V = getVueConstructor();
1052 var mountedVM = undefined;
1053 return {
1054 config: V.config,
1055 use: V.use.bind(V),
1056 mixin: V.mixin.bind(V),
1057 component: V.component.bind(V),
1058 directive: V.directive.bind(V),
1059 mount: function (el, hydrating) {
1060 if (!mountedVM) {
1061 mountedVM = new V(__assign({ propsData: rootProps }, rootComponent));
1062 mountedVM.$mount(el, hydrating);
1063 return mountedVM;
1064 }
1065 else {
1066 {
1067 warn("App has already been mounted.\n" +
1068 "If you want to remount the same app, move your app creation logic " +
1069 "into a factory function and create fresh app instances for each " +
1070 "mount - e.g. `const createMyApp = () => createApp(App)`");
1071 }
1072 return mountedVM;
1073 }
1074 },
1075 unmount: function () {
1076 if (mountedVM) {
1077 mountedVM.$destroy();
1078 mountedVM = undefined;
1079 }
1080 else {
1081 warn("Cannot unmount an app that is not mounted.");
1082 }
1083 },
1084 };
1085 }
1086
1087 var nextTick = function nextTick() {
1088 var _a;
1089 var args = [];
1090 for (var _i = 0; _i < arguments.length; _i++) {
1091 args[_i] = arguments[_i];
1092 }
1093 return (_a = getVueConstructor()) === null || _a === void 0 ? void 0 : _a.nextTick.apply(this, args);
1094 };
1095
1096 var fallbackCreateElement;
1097 var createElement = function createElement() {
1098 var args = [];
1099 for (var _i = 0; _i < arguments.length; _i++) {
1100 args[_i] = arguments[_i];
1101 }
1102 var instance = getCurrentInstance();
1103 if (!instance) {
1104 warn('`createElement()` has been called outside of render function.');
1105 if (!fallbackCreateElement) {
1106 fallbackCreateElement = defineComponentInstance(getVueConstructor())
1107 .$createElement;
1108 }
1109 return fallbackCreateElement.apply(fallbackCreateElement, args);
1110 }
1111 return instance.$createElement.apply(instance, args);
1112 };
1113
1114 function set$1(vm, key, value) {
1115 var state = (vm.__composition_api_state__ =
1116 vm.__composition_api_state__ || {});
1117 state[key] = value;
1118 }
1119 function get(vm, key) {
1120 return (vm.__composition_api_state__ || {})[key];
1121 }
1122 var vmStateManager = {
1123 set: set$1,
1124 get: get,
1125 };
1126
1127 function asVmProperty(vm, propName, propValue) {
1128 var props = vm.$options.props;
1129 if (!(propName in vm) && !(props && hasOwn(props, propName))) {
1130 proxy(vm, propName, {
1131 get: function () { return propValue.value; },
1132 set: function (val) {
1133 propValue.value = val;
1134 },
1135 });
1136 {
1137 // expose binding to Vue Devtool as a data property
1138 // delay this until state has been resolved to prevent repeated works
1139 vm.$nextTick(function () {
1140 proxy(vm._data, propName, {
1141 get: function () { return propValue.value; },
1142 set: function (val) {
1143 propValue.value = val;
1144 },
1145 });
1146 });
1147 }
1148 }
1149 else {
1150 if (props && hasOwn(props, propName)) {
1151 warn("The setup binding property \"" + propName + "\" is already declared as a prop.", vm);
1152 }
1153 else {
1154 warn("The setup binding property \"" + propName + "\" is already declared.", vm);
1155 }
1156 }
1157 }
1158 function updateTemplateRef(vm) {
1159 var rawBindings = vmStateManager.get(vm, 'rawBindings') || {};
1160 if (!rawBindings || !Object.keys(rawBindings).length)
1161 return;
1162 var refs = vm.$refs;
1163 var oldRefKeys = vmStateManager.get(vm, 'refs') || [];
1164 for (var index = 0; index < oldRefKeys.length; index++) {
1165 var key = oldRefKeys[index];
1166 var setupValue = rawBindings[key];
1167 if (!refs[key] && setupValue && isRef(setupValue)) {
1168 setupValue.value = null;
1169 }
1170 }
1171 var newKeys = Object.keys(refs);
1172 var validNewKeys = [];
1173 for (var index = 0; index < newKeys.length; index++) {
1174 var key = newKeys[index];
1175 var setupValue = rawBindings[key];
1176 if (refs[key] && setupValue && isRef(setupValue)) {
1177 setupValue.value = refs[key];
1178 validNewKeys.push(key);
1179 }
1180 }
1181 vmStateManager.set(vm, 'refs', validNewKeys);
1182 }
1183 function resolveScopedSlots(vm, slotsProxy) {
1184 var parentVNode = vm.$options._parentVnode;
1185 if (!parentVNode)
1186 return;
1187 var prevSlots = vmStateManager.get(vm, 'slots') || [];
1188 var curSlots = resolveSlots(parentVNode.data.scopedSlots, vm.$slots);
1189 // remove staled slots
1190 for (var index = 0; index < prevSlots.length; index++) {
1191 var key = prevSlots[index];
1192 if (!curSlots[key]) {
1193 delete slotsProxy[key];
1194 }
1195 }
1196 // proxy fresh slots
1197 var slotNames = Object.keys(curSlots);
1198 for (var index = 0; index < slotNames.length; index++) {
1199 var key = slotNames[index];
1200 if (!slotsProxy[key]) {
1201 slotsProxy[key] = createSlotProxy(vm, key);
1202 }
1203 }
1204 vmStateManager.set(vm, 'slots', slotNames);
1205 }
1206 function activateCurrentInstance(vm, fn, onError) {
1207 var preVm = getCurrentInstance();
1208 setCurrentInstance(vm);
1209 try {
1210 return fn(vm);
1211 }
1212 catch (err) {
1213 if (onError) {
1214 onError(err);
1215 }
1216 else {
1217 throw err;
1218 }
1219 }
1220 finally {
1221 setCurrentInstance(preVm);
1222 }
1223 }
1224
1225 function mixin(Vue) {
1226 Vue.mixin({
1227 beforeCreate: functionApiInit,
1228 mounted: function () {
1229 updateTemplateRef(this);
1230 },
1231 updated: function () {
1232 updateTemplateRef(this);
1233 },
1234 });
1235 /**
1236 * Vuex init hook, injected into each instances init hooks list.
1237 */
1238 function functionApiInit() {
1239 var vm = this;
1240 var $options = vm.$options;
1241 var setup = $options.setup, render = $options.render;
1242 if (render) {
1243 // keep currentInstance accessible for createElement
1244 $options.render = function () {
1245 var _this = this;
1246 var args = [];
1247 for (var _i = 0; _i < arguments.length; _i++) {
1248 args[_i] = arguments[_i];
1249 }
1250 return activateCurrentInstance(vm, function () { return render.apply(_this, args); });
1251 };
1252 }
1253 if (!setup) {
1254 return;
1255 }
1256 if (typeof setup !== 'function') {
1257 {
1258 warn('The "setup" option should be a function that returns a object in component definitions.', vm);
1259 }
1260 return;
1261 }
1262 var data = $options.data;
1263 // wrapper the data option, so we can invoke setup before data get resolved
1264 $options.data = function wrappedData() {
1265 initSetup(vm, vm.$props);
1266 return typeof data === 'function'
1267 ? data.call(vm, vm)
1268 : data || {};
1269 };
1270 }
1271 function initSetup(vm, props) {
1272 if (props === void 0) { props = {}; }
1273 var setup = vm.$options.setup;
1274 var ctx = createSetupContext(vm);
1275 // mark props as reactive
1276 markReactive(props);
1277 // resolve scopedSlots and slots to functions
1278 resolveScopedSlots(vm, ctx.slots);
1279 var binding;
1280 activateCurrentInstance(vm, function () {
1281 binding = setup(props, ctx);
1282 });
1283 if (!binding)
1284 return;
1285 if (isFunction(binding)) {
1286 // keep typescript happy with the binding type.
1287 var bindingFunc_1 = binding;
1288 // keep currentInstance accessible for createElement
1289 vm.$options.render = function () {
1290 resolveScopedSlots(vm, ctx.slots);
1291 return activateCurrentInstance(vm, function () { return bindingFunc_1(); });
1292 };
1293 return;
1294 }
1295 if (isPlainObject(binding)) {
1296 var bindingObj_1 = binding;
1297 vmStateManager.set(vm, 'rawBindings', binding);
1298 Object.keys(binding).forEach(function (name) {
1299 var bindingValue = bindingObj_1[name];
1300 // only make primitive value reactive
1301 if (!isRef(bindingValue)) {
1302 if (isReactive(bindingValue)) {
1303 bindingValue = ref(bindingValue);
1304 }
1305 else {
1306 // bind function to the vm, this will make `this` = vm
1307 if (isFunction(bindingValue)) {
1308 bindingValue = bindingValue.bind(vm);
1309 }
1310 // unwrap all ref properties
1311 var unwrapped = unwrapRefProxy(bindingValue);
1312 // mark the object as reactive
1313 markReactive(unwrapped);
1314 // a non-reactive should not don't get reactivity
1315 bindingValue = ref(markRaw(unwrapped));
1316 }
1317 }
1318 asVmProperty(vm, name, bindingValue);
1319 });
1320 return;
1321 }
1322 {
1323 assert(false, "\"setup\" must return a \"Object\" or a \"Function\", got \"" + Object.prototype.toString
1324 .call(binding)
1325 .slice(8, -1) + "\"");
1326 }
1327 }
1328 function createSetupContext(vm) {
1329 var ctx = {
1330 slots: {},
1331 };
1332 var props = [
1333 'root',
1334 'parent',
1335 'refs',
1336 'attrs',
1337 'listeners',
1338 'isServer',
1339 'ssrContext',
1340 ];
1341 var methodReturnVoid = ['emit'];
1342 props.forEach(function (key) {
1343 var _a;
1344 var targetKey;
1345 var srcKey;
1346 if (Array.isArray(key)) {
1347 _a = __read(key, 2), targetKey = _a[0], srcKey = _a[1];
1348 }
1349 else {
1350 targetKey = srcKey = key;
1351 }
1352 srcKey = "$" + srcKey;
1353 proxy(ctx, targetKey, {
1354 get: function () { return vm[srcKey]; },
1355 set: function () {
1356 warn("Cannot assign to '" + targetKey + "' because it is a read-only property", vm);
1357 },
1358 });
1359 });
1360 methodReturnVoid.forEach(function (key) {
1361 var srcKey = "$" + key;
1362 proxy(ctx, key, {
1363 get: function () {
1364 return function () {
1365 var args = [];
1366 for (var _i = 0; _i < arguments.length; _i++) {
1367 args[_i] = arguments[_i];
1368 }
1369 var fn = vm[srcKey];
1370 fn.apply(vm, args);
1371 };
1372 },
1373 });
1374 });
1375 return ctx;
1376 }
1377 }
1378
1379 /**
1380 * Helper that recursively merges two data objects together.
1381 */
1382 function mergeData(from, to) {
1383 if (!from)
1384 return to;
1385 if (!to)
1386 return from;
1387 var key;
1388 var toVal;
1389 var fromVal;
1390 var keys = hasSymbol ? Reflect.ownKeys(from) : Object.keys(from);
1391 for (var i = 0; i < keys.length; i++) {
1392 key = keys[i];
1393 // in case the object is already observed...
1394 if (key === '__ob__')
1395 continue;
1396 toVal = to[key];
1397 fromVal = from[key];
1398 if (!hasOwn(to, key)) {
1399 to[key] = fromVal;
1400 }
1401 else if (toVal !== fromVal &&
1402 isPlainObject(toVal) &&
1403 !isRef(toVal) &&
1404 isPlainObject(fromVal) &&
1405 !isRef(fromVal)) {
1406 mergeData(fromVal, toVal);
1407 }
1408 }
1409 return to;
1410 }
1411 function install(Vue) {
1412 if (isPluginInstalled() || isVueRegistered(Vue)) {
1413 {
1414 assert(false, 'already installed. Vue.use(VueCompositionAPI) should be called only once.');
1415 }
1416 return;
1417 }
1418 {
1419 if (Vue.version[0] !== '2' || Vue.version[1] !== '.') {
1420 assert(false, "only works with Vue 2, v" + Vue.version + " found.");
1421 }
1422 }
1423 Vue.config.optionMergeStrategies.setup = function (parent, child) {
1424 return function mergedSetupFn(props, context) {
1425 return mergeData(typeof parent === 'function' ? parent(props, context) || {} : undefined, typeof child === 'function' ? child(props, context) || {} : undefined);
1426 };
1427 };
1428 setVueConstructor(Vue);
1429 mixin(Vue);
1430 }
1431 var Plugin = {
1432 install: function (Vue) { return install(Vue); },
1433 };
1434
1435 // implementation, close to no-op
1436 function defineComponent(options) {
1437 return options;
1438 }
1439
1440 // auto install when using CDN
1441 if (typeof window !== 'undefined' && window.Vue) {
1442 window.Vue.use(Plugin);
1443 }
1444
1445 exports.computed = computed;
1446 exports.createApp = createApp;
1447 exports.customRef = customRef;
1448 exports.default = Plugin;
1449 exports.defineComponent = defineComponent;
1450 exports.getCurrentInstance = getCurrentInstance;
1451 exports.h = createElement;
1452 exports.inject = inject;
1453 exports.isReactive = isReactive;
1454 exports.isRef = isRef;
1455 exports.markRaw = markRaw;
1456 exports.markReactive = markReactive;
1457 exports.nextTick = nextTick;
1458 exports.onActivated = onActivated;
1459 exports.onBeforeMount = onBeforeMount;
1460 exports.onBeforeUnmount = onBeforeUnmount;
1461 exports.onBeforeUpdate = onBeforeUpdate;
1462 exports.onDeactivated = onDeactivated;
1463 exports.onErrorCaptured = onErrorCaptured;
1464 exports.onMounted = onMounted;
1465 exports.onServerPrefetch = onServerPrefetch;
1466 exports.onUnmounted = onUnmounted;
1467 exports.onUpdated = onUpdated;
1468 exports.provide = provide;
1469 exports.reactive = reactive;
1470 exports.ref = ref;
1471 exports.set = set;
1472 exports.shallowReactive = shallowReactive;
1473 exports.shallowRef = shallowRef;
1474 exports.toRaw = toRaw;
1475 exports.toRef = toRef;
1476 exports.toRefs = toRefs;
1477 exports.triggerRef = triggerRef;
1478 exports.unref = unref;
1479 exports.useCSSModule = useCSSModule;
1480 exports.watch = watch;
1481 exports.watchEffect = watchEffect;
1482
1483 Object.defineProperty(exports, '__esModule', { value: true });
1484
1485})));