From f8d69861d5359b4a319f68bbfc6f318dc2423b6a Mon Sep 17 00:00:00 2001 From: fxy060608 Date: Fri, 4 Sep 2020 13:42:00 +0800 Subject: [PATCH] chore: sync mp-vue --- .prettierignore | 3 +- packages/uni-mp-vue/lib/vue.runtime.esm.js | 7031 ++++++++++---------- 2 files changed, 3365 insertions(+), 3669 deletions(-) diff --git a/.prettierignore b/.prettierignore index 53c37a166..90d45b85a 100644 --- a/.prettierignore +++ b/.prettierignore @@ -1 +1,2 @@ -dist \ No newline at end of file +dist +lib \ No newline at end of file diff --git a/packages/uni-mp-vue/lib/vue.runtime.esm.js b/packages/uni-mp-vue/lib/vue.runtime.esm.js index ef400f16e..ab948e1d9 100644 --- a/packages/uni-mp-vue/lib/vue.runtime.esm.js +++ b/packages/uni-mp-vue/lib/vue.runtime.esm.js @@ -1,1846 +1,1720 @@ -import { - EMPTY_OBJ, - isArray, - isIntegerKey, - isSymbol, - extend, - hasOwn, - isObject, - hasChanged, - capitalize, - toRawType, - def, - isFunction, - NOOP, - isString, - isPromise, - hyphenate, - isOn, - isReservedProp, - camelize, - EMPTY_ARR, - makeMap, - remove, - NO, - isGloballyWhitelisted, - toTypeString, - invokeArrayFns -} from '@vue/shared' -export { camelize } from '@vue/shared' +import { EMPTY_OBJ, isArray, isIntegerKey, isSymbol, extend, hasOwn, isObject, hasChanged, capitalize, toRawType, def, isFunction, NOOP, isString, isPromise, hyphenate, isOn, isReservedProp, camelize, EMPTY_ARR, makeMap, remove, NO, isGloballyWhitelisted, toTypeString, invokeArrayFns } from '@vue/shared'; +export { camelize } from '@vue/shared'; -const targetMap = new WeakMap() -const effectStack = [] -let activeEffect -const ITERATE_KEY = Symbol( - process.env.NODE_ENV !== 'production' ? 'iterate' : '' -) -const MAP_KEY_ITERATE_KEY = Symbol( - process.env.NODE_ENV !== 'production' ? 'Map key iterate' : '' -) -function isEffect(fn) { - return fn && fn._isEffect === true -} -function effect(fn, options = EMPTY_OBJ) { - if (isEffect(fn)) { - fn = fn.raw - } - const effect = createReactiveEffect(fn, options) - if (!options.lazy) { - effect() - } - return effect -} -function stop(effect) { - if (effect.active) { - cleanup(effect) - if (effect.options.onStop) { - effect.options.onStop() - } - effect.active = false - } -} -let uid = 0 -function createReactiveEffect(fn, options) { - const effect = function reactiveEffect() { - if (!effect.active) { - return options.scheduler ? undefined : fn() - } - if (!effectStack.includes(effect)) { - cleanup(effect) - try { - enableTracking() - effectStack.push(effect) - activeEffect = effect - return fn() - } finally { - effectStack.pop() - resetTracking() - activeEffect = effectStack[effectStack.length - 1] - } - } - } - effect.id = uid++ - effect._isEffect = true - effect.active = true - effect.raw = fn - effect.deps = [] - effect.options = options - return effect -} -function cleanup(effect) { - const { deps } = effect - if (deps.length) { - for (let i = 0; i < deps.length; i++) { - deps[i].delete(effect) - } - deps.length = 0 - } -} -let shouldTrack = true -const trackStack = [] -function pauseTracking() { - trackStack.push(shouldTrack) - shouldTrack = false -} -function enableTracking() { - trackStack.push(shouldTrack) - shouldTrack = true -} -function resetTracking() { - const last = trackStack.pop() - shouldTrack = last === undefined ? true : last -} -function track(target, type, key) { - if (!shouldTrack || activeEffect === undefined) { - return - } - let depsMap = targetMap.get(target) - if (!depsMap) { - targetMap.set(target, (depsMap = new Map())) - } - let dep = depsMap.get(key) - if (!dep) { - depsMap.set(key, (dep = new Set())) - } - if (!dep.has(activeEffect)) { - dep.add(activeEffect) - activeEffect.deps.push(dep) - if (process.env.NODE_ENV !== 'production' && activeEffect.options.onTrack) { - activeEffect.options.onTrack({ - effect: activeEffect, - target, - type, - key - }) - } - } -} -function trigger(target, type, key, newValue, oldValue, oldTarget) { - const depsMap = targetMap.get(target) - if (!depsMap) { - // never been tracked - return - } - const effects = new Set() - const add = effectsToAdd => { - if (effectsToAdd) { - effectsToAdd.forEach(effect => { - if (effect !== activeEffect) { - effects.add(effect) - } - }) - } - } - if (type === 'clear' /* CLEAR */) { - // collection being cleared - // trigger all effects for target - depsMap.forEach(add) - } else if (key === 'length' && isArray(target)) { - depsMap.forEach((dep, key) => { - if (key === 'length' || key >= newValue) { - add(dep) - } - }) - } else { - // schedule runs for SET | ADD | DELETE - if (key !== void 0) { - add(depsMap.get(key)) - } - // also run for iteration key on ADD | DELETE | Map.SET - const shouldTriggerIteration = - (type === 'add' /* ADD */ && (!isArray(target) || isIntegerKey(key))) || - (type === 'delete' /* DELETE */ && !isArray(target)) - if ( - shouldTriggerIteration || - (type === 'set' /* SET */ && target instanceof Map) - ) { - add(depsMap.get(isArray(target) ? 'length' : ITERATE_KEY)) - } - if (shouldTriggerIteration && target instanceof Map) { - add(depsMap.get(MAP_KEY_ITERATE_KEY)) - } - } - const run = effect => { - if (process.env.NODE_ENV !== 'production' && effect.options.onTrigger) { - effect.options.onTrigger({ - effect, - target, - key, - type, - newValue, - oldValue, - oldTarget - }) - } - if (effect.options.scheduler) { - effect.options.scheduler(effect) - } else { - effect() - } - } - effects.forEach(run) +const targetMap = new WeakMap(); +const effectStack = []; +let activeEffect; +const ITERATE_KEY = Symbol((process.env.NODE_ENV !== 'production') ? 'iterate' : ''); +const MAP_KEY_ITERATE_KEY = Symbol((process.env.NODE_ENV !== 'production') ? 'Map key iterate' : ''); +function isEffect(fn) { + return fn && fn._isEffect === true; +} +function effect(fn, options = EMPTY_OBJ) { + if (isEffect(fn)) { + fn = fn.raw; + } + const effect = createReactiveEffect(fn, options); + if (!options.lazy) { + effect(); + } + return effect; +} +function stop(effect) { + if (effect.active) { + cleanup(effect); + if (effect.options.onStop) { + effect.options.onStop(); + } + effect.active = false; + } +} +let uid = 0; +function createReactiveEffect(fn, options) { + const effect = function reactiveEffect() { + if (!effect.active) { + return options.scheduler ? undefined : fn(); + } + if (!effectStack.includes(effect)) { + cleanup(effect); + try { + enableTracking(); + effectStack.push(effect); + activeEffect = effect; + return fn(); + } + finally { + effectStack.pop(); + resetTracking(); + activeEffect = effectStack[effectStack.length - 1]; + } + } + }; + effect.id = uid++; + effect._isEffect = true; + effect.active = true; + effect.raw = fn; + effect.deps = []; + effect.options = options; + return effect; +} +function cleanup(effect) { + const { deps } = effect; + if (deps.length) { + for (let i = 0; i < deps.length; i++) { + deps[i].delete(effect); + } + deps.length = 0; + } +} +let shouldTrack = true; +const trackStack = []; +function pauseTracking() { + trackStack.push(shouldTrack); + shouldTrack = false; +} +function enableTracking() { + trackStack.push(shouldTrack); + shouldTrack = true; +} +function resetTracking() { + const last = trackStack.pop(); + shouldTrack = last === undefined ? true : last; +} +function track(target, type, key) { + if (!shouldTrack || activeEffect === undefined) { + return; + } + let depsMap = targetMap.get(target); + if (!depsMap) { + targetMap.set(target, (depsMap = new Map())); + } + let dep = depsMap.get(key); + if (!dep) { + depsMap.set(key, (dep = new Set())); + } + if (!dep.has(activeEffect)) { + dep.add(activeEffect); + activeEffect.deps.push(dep); + if ((process.env.NODE_ENV !== 'production') && activeEffect.options.onTrack) { + activeEffect.options.onTrack({ + effect: activeEffect, + target, + type, + key + }); + } + } +} +function trigger(target, type, key, newValue, oldValue, oldTarget) { + const depsMap = targetMap.get(target); + if (!depsMap) { + // never been tracked + return; + } + const effects = new Set(); + const add = (effectsToAdd) => { + if (effectsToAdd) { + effectsToAdd.forEach(effect => { + if (effect !== activeEffect) { + effects.add(effect); + } + }); + } + }; + if (type === "clear" /* CLEAR */) { + // collection being cleared + // trigger all effects for target + depsMap.forEach(add); + } + else if (key === 'length' && isArray(target)) { + depsMap.forEach((dep, key) => { + if (key === 'length' || key >= newValue) { + add(dep); + } + }); + } + else { + // schedule runs for SET | ADD | DELETE + if (key !== void 0) { + add(depsMap.get(key)); + } + // also run for iteration key on ADD | DELETE | Map.SET + const shouldTriggerIteration = (type === "add" /* ADD */ && + (!isArray(target) || isIntegerKey(key))) || + (type === "delete" /* DELETE */ && !isArray(target)); + if (shouldTriggerIteration || + (type === "set" /* SET */ && target instanceof Map)) { + add(depsMap.get(isArray(target) ? 'length' : ITERATE_KEY)); + } + if (shouldTriggerIteration && target instanceof Map) { + add(depsMap.get(MAP_KEY_ITERATE_KEY)); + } + } + const run = (effect) => { + if ((process.env.NODE_ENV !== 'production') && effect.options.onTrigger) { + effect.options.onTrigger({ + effect, + target, + key, + type, + newValue, + oldValue, + oldTarget + }); + } + if (effect.options.scheduler) { + effect.options.scheduler(effect); + } + else { + effect(); + } + }; + effects.forEach(run); } -const builtInSymbols = new Set( - Object.getOwnPropertyNames(Symbol) - .map(key => Symbol[key]) - .filter(isSymbol) -) -const get = /*#__PURE__*/ createGetter() -const shallowGet = /*#__PURE__*/ createGetter(false, true) -const readonlyGet = /*#__PURE__*/ createGetter(true) -const shallowReadonlyGet = /*#__PURE__*/ createGetter(true, true) -const arrayInstrumentations = {} -;['includes', 'indexOf', 'lastIndexOf'].forEach(key => { - arrayInstrumentations[key] = function(...args) { - const arr = toRaw(this) - for (let i = 0, l = this.length; i < l; i++) { - track(arr, 'get' /* GET */, i + '') - } - // we run the method using the original args first (which may be reactive) - const res = arr[key](...args) - if (res === -1 || res === false) { - // if that didn't work, run it again using raw values. - return arr[key](...args.map(toRaw)) - } else { - return res - } - } -}) -function createGetter(isReadonly = false, shallow = false) { - return function get(target, key, receiver) { - if (key === '__v_isReactive' /* IS_REACTIVE */) { - return !isReadonly - } else if (key === '__v_isReadonly' /* IS_READONLY */) { - return isReadonly - } else if ( - key === '__v_raw' /* RAW */ && - receiver === (isReadonly ? readonlyMap : reactiveMap).get(target) - ) { - return target - } - const targetIsArray = isArray(target) - if (targetIsArray && hasOwn(arrayInstrumentations, key)) { - return Reflect.get(arrayInstrumentations, key, receiver) - } - const res = Reflect.get(target, key, receiver) - const keyIsSymbol = isSymbol(key) - if ( - keyIsSymbol - ? builtInSymbols.has(key) - : key === `__proto__` || key === `__v_isRef` - ) { - return res - } - if (!isReadonly) { - track(target, 'get' /* GET */, key) - } - if (shallow) { - return res - } - if (isRef(res)) { - // ref unwrapping - does not apply for Array + integer key. - const shouldUnwrap = !targetIsArray || !isIntegerKey(key) - return shouldUnwrap ? res.value : res - } - if (isObject(res)) { - // Convert returned value into a proxy as well. we do the isObject check - // here to avoid invalid value warning. Also need to lazy access readonly - // and reactive here to avoid circular dependency. - return isReadonly ? readonly(res) : reactive(res) - } - return res - } -} -const set = /*#__PURE__*/ createSetter() -const shallowSet = /*#__PURE__*/ createSetter(true) -function createSetter(shallow = false) { - return function set(target, key, value, receiver) { - const oldValue = target[key] - if (!shallow) { - value = toRaw(value) - if (!isArray(target) && isRef(oldValue) && !isRef(value)) { - oldValue.value = value - return true - } - } - const hadKey = - isArray(target) && isIntegerKey(key) - ? Number(key) < target.length - : hasOwn(target, key) - const result = Reflect.set(target, key, value, receiver) - // don't trigger if target is something up in the prototype chain of original - if (target === toRaw(receiver)) { - if (!hadKey) { - trigger(target, 'add' /* ADD */, key, value) - } else if (hasChanged(value, oldValue)) { - trigger(target, 'set' /* SET */, key, value, oldValue) - } - } - return result - } -} -function deleteProperty(target, key) { - const hadKey = hasOwn(target, key) - const oldValue = target[key] - const result = Reflect.deleteProperty(target, key) - if (result && hadKey) { - trigger(target, 'delete' /* DELETE */, key, undefined, oldValue) - } - return result -} -function has(target, key) { - const result = Reflect.has(target, key) - if (!isSymbol(key) || !builtInSymbols.has(key)) { - track(target, 'has' /* HAS */, key) - } - return result -} -function ownKeys(target) { - track(target, 'iterate' /* ITERATE */, ITERATE_KEY) - return Reflect.ownKeys(target) -} -const mutableHandlers = { - get, - set, - deleteProperty, - has, - ownKeys -} -const readonlyHandlers = { - get: readonlyGet, - set(target, key) { - if (process.env.NODE_ENV !== 'production') { - console.warn( - `Set operation on key "${String(key)}" failed: target is readonly.`, - target - ) - } - return true - }, - deleteProperty(target, key) { - if (process.env.NODE_ENV !== 'production') { - console.warn( - `Delete operation on key "${String(key)}" failed: target is readonly.`, - target - ) - } - return true - } -} -const shallowReactiveHandlers = extend({}, mutableHandlers, { - get: shallowGet, - set: shallowSet -}) -// Props handlers are special in the sense that it should not unwrap top-level -// refs (in order to allow refs to be explicitly passed down), but should -// retain the reactivity of the normal readonly object. -const shallowReadonlyHandlers = extend({}, readonlyHandlers, { - get: shallowReadonlyGet -}) +const builtInSymbols = new Set(Object.getOwnPropertyNames(Symbol) + .map(key => Symbol[key]) + .filter(isSymbol)); +const get = /*#__PURE__*/ createGetter(); +const shallowGet = /*#__PURE__*/ createGetter(false, true); +const readonlyGet = /*#__PURE__*/ createGetter(true); +const shallowReadonlyGet = /*#__PURE__*/ createGetter(true, true); +const arrayInstrumentations = {}; +['includes', 'indexOf', 'lastIndexOf'].forEach(key => { + arrayInstrumentations[key] = function (...args) { + const arr = toRaw(this); + for (let i = 0, l = this.length; i < l; i++) { + track(arr, "get" /* GET */, i + ''); + } + // we run the method using the original args first (which may be reactive) + const res = arr[key](...args); + if (res === -1 || res === false) { + // if that didn't work, run it again using raw values. + return arr[key](...args.map(toRaw)); + } + else { + return res; + } + }; +}); +function createGetter(isReadonly = false, shallow = false) { + return function get(target, key, receiver) { + if (key === "__v_isReactive" /* IS_REACTIVE */) { + return !isReadonly; + } + else if (key === "__v_isReadonly" /* IS_READONLY */) { + return isReadonly; + } + else if (key === "__v_raw" /* RAW */ && + receiver === (isReadonly ? readonlyMap : reactiveMap).get(target)) { + return target; + } + const targetIsArray = isArray(target); + if (targetIsArray && hasOwn(arrayInstrumentations, key)) { + return Reflect.get(arrayInstrumentations, key, receiver); + } + const res = Reflect.get(target, key, receiver); + const keyIsSymbol = isSymbol(key); + if (keyIsSymbol + ? builtInSymbols.has(key) + : key === `__proto__` || key === `__v_isRef`) { + return res; + } + if (!isReadonly) { + track(target, "get" /* GET */, key); + } + if (shallow) { + return res; + } + if (isRef(res)) { + // ref unwrapping - does not apply for Array + integer key. + const shouldUnwrap = !targetIsArray || !isIntegerKey(key); + return shouldUnwrap ? res.value : res; + } + if (isObject(res)) { + // Convert returned value into a proxy as well. we do the isObject check + // here to avoid invalid value warning. Also need to lazy access readonly + // and reactive here to avoid circular dependency. + return isReadonly ? readonly(res) : reactive(res); + } + return res; + }; +} +const set = /*#__PURE__*/ createSetter(); +const shallowSet = /*#__PURE__*/ createSetter(true); +function createSetter(shallow = false) { + return function set(target, key, value, receiver) { + const oldValue = target[key]; + if (!shallow) { + value = toRaw(value); + if (!isArray(target) && isRef(oldValue) && !isRef(value)) { + oldValue.value = value; + return true; + } + } + const hadKey = isArray(target) && isIntegerKey(key) + ? Number(key) < target.length + : hasOwn(target, key); + const result = Reflect.set(target, key, value, receiver); + // don't trigger if target is something up in the prototype chain of original + if (target === toRaw(receiver)) { + if (!hadKey) { + trigger(target, "add" /* ADD */, key, value); + } + else if (hasChanged(value, oldValue)) { + trigger(target, "set" /* SET */, key, value, oldValue); + } + } + return result; + }; +} +function deleteProperty(target, key) { + const hadKey = hasOwn(target, key); + const oldValue = target[key]; + const result = Reflect.deleteProperty(target, key); + if (result && hadKey) { + trigger(target, "delete" /* DELETE */, key, undefined, oldValue); + } + return result; +} +function has(target, key) { + const result = Reflect.has(target, key); + if (!isSymbol(key) || !builtInSymbols.has(key)) { + track(target, "has" /* HAS */, key); + } + return result; +} +function ownKeys(target) { + track(target, "iterate" /* ITERATE */, ITERATE_KEY); + return Reflect.ownKeys(target); +} +const mutableHandlers = { + get, + set, + deleteProperty, + has, + ownKeys +}; +const readonlyHandlers = { + get: readonlyGet, + set(target, key) { + if ((process.env.NODE_ENV !== 'production')) { + console.warn(`Set operation on key "${String(key)}" failed: target is readonly.`, target); + } + return true; + }, + deleteProperty(target, key) { + if ((process.env.NODE_ENV !== 'production')) { + console.warn(`Delete operation on key "${String(key)}" failed: target is readonly.`, target); + } + return true; + } +}; +const shallowReactiveHandlers = extend({}, mutableHandlers, { + get: shallowGet, + set: shallowSet +}); +// Props handlers are special in the sense that it should not unwrap top-level +// refs (in order to allow refs to be explicitly passed down), but should +// retain the reactivity of the normal readonly object. +const shallowReadonlyHandlers = extend({}, readonlyHandlers, { + get: shallowReadonlyGet +}); -const toReactive = value => (isObject(value) ? reactive(value) : value) -const toReadonly = value => (isObject(value) ? readonly(value) : value) -const toShallow = value => value -const getProto = v => Reflect.getPrototypeOf(v) -function get$1(target, key, isReadonly = false, isShallow = false) { - // #1772: readonly(reactive(Map)) should return readonly + reactive version - // of the value - target = target['__v_raw' /* RAW */] - const rawTarget = toRaw(target) - const rawKey = toRaw(key) - if (key !== rawKey) { - !isReadonly && track(rawTarget, 'get' /* GET */, key) - } - !isReadonly && track(rawTarget, 'get' /* GET */, rawKey) - const { has } = getProto(rawTarget) - const wrap = isReadonly ? toReadonly : isShallow ? toShallow : toReactive - if (has.call(rawTarget, key)) { - return wrap(target.get(key)) - } else if (has.call(rawTarget, rawKey)) { - return wrap(target.get(rawKey)) - } -} -function has$1(key, isReadonly = false) { - const target = this['__v_raw' /* RAW */] - const rawTarget = toRaw(target) - const rawKey = toRaw(key) - if (key !== rawKey) { - !isReadonly && track(rawTarget, 'has' /* HAS */, key) - } - !isReadonly && track(rawTarget, 'has' /* HAS */, rawKey) - return key === rawKey - ? target.has(key) - : target.has(key) || target.has(rawKey) -} -function size(target, isReadonly = false) { - target = target['__v_raw' /* RAW */] - !isReadonly && track(toRaw(target), 'iterate' /* ITERATE */, ITERATE_KEY) - return Reflect.get(target, 'size', target) -} -function add(value) { - value = toRaw(value) - const target = toRaw(this) - const proto = getProto(target) - const hadKey = proto.has.call(target, value) - const result = proto.add.call(target, value) - if (!hadKey) { - trigger(target, 'add' /* ADD */, value, value) - } - return result -} -function set$1(key, value) { - value = toRaw(value) - const target = toRaw(this) - const { has, get, set } = getProto(target) - let hadKey = has.call(target, key) - if (!hadKey) { - key = toRaw(key) - hadKey = has.call(target, key) - } else if (process.env.NODE_ENV !== 'production') { - checkIdentityKeys(target, has, key) - } - const oldValue = get.call(target, key) - const result = set.call(target, key, value) - if (!hadKey) { - trigger(target, 'add' /* ADD */, key, value) - } else if (hasChanged(value, oldValue)) { - trigger(target, 'set' /* SET */, key, value, oldValue) - } - return result -} -function deleteEntry(key) { - const target = toRaw(this) - const { has, get, delete: del } = getProto(target) - let hadKey = has.call(target, key) - if (!hadKey) { - key = toRaw(key) - hadKey = has.call(target, key) - } else if (process.env.NODE_ENV !== 'production') { - checkIdentityKeys(target, has, key) - } - const oldValue = get ? get.call(target, key) : undefined - // forward the operation before queueing reactions - const result = del.call(target, key) - if (hadKey) { - trigger(target, 'delete' /* DELETE */, key, undefined, oldValue) - } - return result -} -function clear() { - const target = toRaw(this) - const hadItems = target.size !== 0 - const oldTarget = - process.env.NODE_ENV !== 'production' - ? target instanceof Map - ? new Map(target) - : new Set(target) - : undefined - // forward the operation before queueing reactions - const result = getProto(target).clear.call(target) - if (hadItems) { - trigger(target, 'clear' /* CLEAR */, undefined, undefined, oldTarget) - } - return result -} -function createForEach(isReadonly, isShallow) { - return function forEach(callback, thisArg) { - const observed = this - const target = observed['__v_raw' /* RAW */] - const rawTarget = toRaw(target) - const wrap = isReadonly ? toReadonly : isShallow ? toShallow : toReactive - !isReadonly && track(rawTarget, 'iterate' /* ITERATE */, ITERATE_KEY) - return target.forEach((value, key) => { - // important: make sure the callback is - // 1. invoked with the reactive map as `this` and 3rd arg - // 2. the value received should be a corresponding reactive/readonly. - return callback.call(thisArg, wrap(value), wrap(key), observed) - }) - } -} -function createIterableMethod(method, isReadonly, isShallow) { - return function(...args) { - const target = this['__v_raw' /* RAW */] - const rawTarget = toRaw(target) - const isMap = rawTarget instanceof Map - const isPair = method === 'entries' || (method === Symbol.iterator && isMap) - const isKeyOnly = method === 'keys' && isMap - const innerIterator = target[method](...args) - const wrap = isReadonly ? toReadonly : isShallow ? toShallow : toReactive - !isReadonly && - track( - rawTarget, - 'iterate' /* ITERATE */, - isKeyOnly ? MAP_KEY_ITERATE_KEY : ITERATE_KEY - ) - // return a wrapped iterator which returns observed versions of the - // values emitted from the real iterator - return { - // iterator protocol - next() { - const { value, done } = innerIterator.next() - return done - ? { value, done } - : { - value: isPair ? [wrap(value[0]), wrap(value[1])] : wrap(value), - done - } - }, - // iterable protocol - [Symbol.iterator]() { - return this - } - } - } -} -function createReadonlyMethod(type) { - return function(...args) { - if (process.env.NODE_ENV !== 'production') { - const key = args[0] ? `on key "${args[0]}" ` : `` - console.warn( - `${capitalize(type)} operation ${key}failed: target is readonly.`, - toRaw(this) - ) - } - return type === 'delete' /* DELETE */ ? false : this - } -} -const mutableInstrumentations = { - get(key) { - return get$1(this, key) - }, - get size() { - return size(this) - }, - has: has$1, - add, - set: set$1, - delete: deleteEntry, - clear, - forEach: createForEach(false, false) -} -const shallowInstrumentations = { - get(key) { - return get$1(this, key, false, true) - }, - get size() { - return size(this) - }, - has: has$1, - add, - set: set$1, - delete: deleteEntry, - clear, - forEach: createForEach(false, true) -} -const readonlyInstrumentations = { - get(key) { - return get$1(this, key, true) - }, - get size() { - return size(this, true) - }, - has(key) { - return has$1.call(this, key, true) - }, - add: createReadonlyMethod('add' /* ADD */), - set: createReadonlyMethod('set' /* SET */), - delete: createReadonlyMethod('delete' /* DELETE */), - clear: createReadonlyMethod('clear' /* CLEAR */), - forEach: createForEach(true, false) -} -const iteratorMethods = ['keys', 'values', 'entries', Symbol.iterator] -iteratorMethods.forEach(method => { - mutableInstrumentations[method] = createIterableMethod(method, false, false) - readonlyInstrumentations[method] = createIterableMethod(method, true, false) - shallowInstrumentations[method] = createIterableMethod(method, false, true) -}) -function createInstrumentationGetter(isReadonly, shallow) { - const instrumentations = shallow - ? shallowInstrumentations - : isReadonly - ? readonlyInstrumentations - : mutableInstrumentations - return (target, key, receiver) => { - if (key === '__v_isReactive' /* IS_REACTIVE */) { - return !isReadonly - } else if (key === '__v_isReadonly' /* IS_READONLY */) { - return isReadonly - } else if (key === '__v_raw' /* RAW */) { - return target - } - return Reflect.get( - hasOwn(instrumentations, key) && key in target - ? instrumentations - : target, - key, - receiver - ) - } -} -const mutableCollectionHandlers = { - get: createInstrumentationGetter(false, false) -} -const shallowCollectionHandlers = { - get: createInstrumentationGetter(false, true) -} -const readonlyCollectionHandlers = { - get: createInstrumentationGetter(true, false) -} -function checkIdentityKeys(target, has, key) { - const rawKey = toRaw(key) - if (rawKey !== key && has.call(target, rawKey)) { - const type = toRawType(target) - console.warn( - `Reactive ${type} contains both the raw and reactive ` + - `versions of the same object${type === `Map` ? `as keys` : ``}, ` + - `which can lead to inconsistencies. ` + - `Avoid differentiating between the raw and reactive versions ` + - `of an object and only use the reactive version if possible.` - ) - } +const toReactive = (value) => isObject(value) ? reactive(value) : value; +const toReadonly = (value) => isObject(value) ? readonly(value) : value; +const toShallow = (value) => value; +const getProto = (v) => Reflect.getPrototypeOf(v); +function get$1(target, key, isReadonly = false, isShallow = false) { + // #1772: readonly(reactive(Map)) should return readonly + reactive version + // of the value + target = target["__v_raw" /* RAW */]; + const rawTarget = toRaw(target); + const rawKey = toRaw(key); + if (key !== rawKey) { + !isReadonly && track(rawTarget, "get" /* GET */, key); + } + !isReadonly && track(rawTarget, "get" /* GET */, rawKey); + const { has } = getProto(rawTarget); + const wrap = isReadonly ? toReadonly : isShallow ? toShallow : toReactive; + if (has.call(rawTarget, key)) { + return wrap(target.get(key)); + } + else if (has.call(rawTarget, rawKey)) { + return wrap(target.get(rawKey)); + } +} +function has$1(key, isReadonly = false) { + const target = this["__v_raw" /* RAW */]; + const rawTarget = toRaw(target); + const rawKey = toRaw(key); + if (key !== rawKey) { + !isReadonly && track(rawTarget, "has" /* HAS */, key); + } + !isReadonly && track(rawTarget, "has" /* HAS */, rawKey); + return key === rawKey + ? target.has(key) + : target.has(key) || target.has(rawKey); +} +function size(target, isReadonly = false) { + target = target["__v_raw" /* RAW */]; + !isReadonly && track(toRaw(target), "iterate" /* ITERATE */, ITERATE_KEY); + return Reflect.get(target, 'size', target); +} +function add(value) { + value = toRaw(value); + const target = toRaw(this); + const proto = getProto(target); + const hadKey = proto.has.call(target, value); + const result = proto.add.call(target, value); + if (!hadKey) { + trigger(target, "add" /* ADD */, value, value); + } + return result; +} +function set$1(key, value) { + value = toRaw(value); + const target = toRaw(this); + const { has, get, set } = getProto(target); + let hadKey = has.call(target, key); + if (!hadKey) { + key = toRaw(key); + hadKey = has.call(target, key); + } + else if ((process.env.NODE_ENV !== 'production')) { + checkIdentityKeys(target, has, key); + } + const oldValue = get.call(target, key); + const result = set.call(target, key, value); + if (!hadKey) { + trigger(target, "add" /* ADD */, key, value); + } + else if (hasChanged(value, oldValue)) { + trigger(target, "set" /* SET */, key, value, oldValue); + } + return result; +} +function deleteEntry(key) { + const target = toRaw(this); + const { has, get, delete: del } = getProto(target); + let hadKey = has.call(target, key); + if (!hadKey) { + key = toRaw(key); + hadKey = has.call(target, key); + } + else if ((process.env.NODE_ENV !== 'production')) { + checkIdentityKeys(target, has, key); + } + const oldValue = get ? get.call(target, key) : undefined; + // forward the operation before queueing reactions + const result = del.call(target, key); + if (hadKey) { + trigger(target, "delete" /* DELETE */, key, undefined, oldValue); + } + return result; +} +function clear() { + const target = toRaw(this); + const hadItems = target.size !== 0; + const oldTarget = (process.env.NODE_ENV !== 'production') + ? target instanceof Map + ? new Map(target) + : new Set(target) + : undefined; + // forward the operation before queueing reactions + const result = getProto(target).clear.call(target); + if (hadItems) { + trigger(target, "clear" /* CLEAR */, undefined, undefined, oldTarget); + } + return result; +} +function createForEach(isReadonly, isShallow) { + return function forEach(callback, thisArg) { + const observed = this; + const target = observed["__v_raw" /* RAW */]; + const rawTarget = toRaw(target); + const wrap = isReadonly ? toReadonly : isShallow ? toShallow : toReactive; + !isReadonly && track(rawTarget, "iterate" /* ITERATE */, ITERATE_KEY); + return target.forEach((value, key) => { + // important: make sure the callback is + // 1. invoked with the reactive map as `this` and 3rd arg + // 2. the value received should be a corresponding reactive/readonly. + return callback.call(thisArg, wrap(value), wrap(key), observed); + }); + }; +} +function createIterableMethod(method, isReadonly, isShallow) { + return function (...args) { + const target = this["__v_raw" /* RAW */]; + const rawTarget = toRaw(target); + const isMap = rawTarget instanceof Map; + const isPair = method === 'entries' || (method === Symbol.iterator && isMap); + const isKeyOnly = method === 'keys' && isMap; + const innerIterator = target[method](...args); + const wrap = isReadonly ? toReadonly : isShallow ? toShallow : toReactive; + !isReadonly && + track(rawTarget, "iterate" /* ITERATE */, isKeyOnly ? MAP_KEY_ITERATE_KEY : ITERATE_KEY); + // return a wrapped iterator which returns observed versions of the + // values emitted from the real iterator + return { + // iterator protocol + next() { + const { value, done } = innerIterator.next(); + return done + ? { value, done } + : { + value: isPair ? [wrap(value[0]), wrap(value[1])] : wrap(value), + done + }; + }, + // iterable protocol + [Symbol.iterator]() { + return this; + } + }; + }; +} +function createReadonlyMethod(type) { + return function (...args) { + if ((process.env.NODE_ENV !== 'production')) { + const key = args[0] ? `on key "${args[0]}" ` : ``; + console.warn(`${capitalize(type)} operation ${key}failed: target is readonly.`, toRaw(this)); + } + return type === "delete" /* DELETE */ ? false : this; + }; +} +const mutableInstrumentations = { + get(key) { + return get$1(this, key); + }, + get size() { + return size(this); + }, + has: has$1, + add, + set: set$1, + delete: deleteEntry, + clear, + forEach: createForEach(false, false) +}; +const shallowInstrumentations = { + get(key) { + return get$1(this, key, false, true); + }, + get size() { + return size(this); + }, + has: has$1, + add, + set: set$1, + delete: deleteEntry, + clear, + forEach: createForEach(false, true) +}; +const readonlyInstrumentations = { + get(key) { + return get$1(this, key, true); + }, + get size() { + return size(this, true); + }, + has(key) { + return has$1.call(this, key, true); + }, + add: createReadonlyMethod("add" /* ADD */), + set: createReadonlyMethod("set" /* SET */), + delete: createReadonlyMethod("delete" /* DELETE */), + clear: createReadonlyMethod("clear" /* CLEAR */), + forEach: createForEach(true, false) +}; +const iteratorMethods = ['keys', 'values', 'entries', Symbol.iterator]; +iteratorMethods.forEach(method => { + mutableInstrumentations[method] = createIterableMethod(method, false, false); + readonlyInstrumentations[method] = createIterableMethod(method, true, false); + shallowInstrumentations[method] = createIterableMethod(method, false, true); +}); +function createInstrumentationGetter(isReadonly, shallow) { + const instrumentations = shallow + ? shallowInstrumentations + : isReadonly + ? readonlyInstrumentations + : mutableInstrumentations; + return (target, key, receiver) => { + if (key === "__v_isReactive" /* IS_REACTIVE */) { + return !isReadonly; + } + else if (key === "__v_isReadonly" /* IS_READONLY */) { + return isReadonly; + } + else if (key === "__v_raw" /* RAW */) { + return target; + } + return Reflect.get(hasOwn(instrumentations, key) && key in target + ? instrumentations + : target, key, receiver); + }; +} +const mutableCollectionHandlers = { + get: createInstrumentationGetter(false, false) +}; +const shallowCollectionHandlers = { + get: createInstrumentationGetter(false, true) +}; +const readonlyCollectionHandlers = { + get: createInstrumentationGetter(true, false) +}; +function checkIdentityKeys(target, has, key) { + const rawKey = toRaw(key); + if (rawKey !== key && has.call(target, rawKey)) { + const type = toRawType(target); + console.warn(`Reactive ${type} contains both the raw and reactive ` + + `versions of the same object${type === `Map` ? `as keys` : ``}, ` + + `which can lead to inconsistencies. ` + + `Avoid differentiating between the raw and reactive versions ` + + `of an object and only use the reactive version if possible.`); + } } -const reactiveMap = new WeakMap() -const readonlyMap = new WeakMap() -function targetTypeMap(rawType) { - switch (rawType) { - case 'Object': - case 'Array': - return 1 /* COMMON */ - case 'Map': - case 'Set': - case 'WeakMap': - case 'WeakSet': - return 2 /* COLLECTION */ - default: - return 0 /* INVALID */ - } -} -function getTargetType(value) { - return value['__v_skip' /* SKIP */] || !Object.isExtensible(value) - ? 0 /* INVALID */ - : targetTypeMap(toRawType(value)) -} -function reactive(target) { - // if trying to observe a readonly proxy, return the readonly version. - if (target && target['__v_isReadonly' /* IS_READONLY */]) { - return target - } - return createReactiveObject( - target, - false, - mutableHandlers, - mutableCollectionHandlers - ) -} -// Return a reactive-copy of the original object, where only the root level -// properties are reactive, and does NOT unwrap refs nor recursively convert -// returned properties. -function shallowReactive(target) { - return createReactiveObject( - target, - false, - shallowReactiveHandlers, - shallowCollectionHandlers - ) -} -function readonly(target) { - return createReactiveObject( - target, - true, - readonlyHandlers, - readonlyCollectionHandlers - ) -} -// Return a reactive-copy of the original object, where only the root level -// properties are readonly, and does NOT unwrap refs nor recursively convert -// returned properties. -// This is used for creating the props proxy object for stateful components. -function shallowReadonly(target) { - return createReactiveObject( - target, - true, - shallowReadonlyHandlers, - readonlyCollectionHandlers - ) -} -function createReactiveObject( - target, - isReadonly, - baseHandlers, - collectionHandlers -) { - if (!isObject(target)) { - if (process.env.NODE_ENV !== 'production') { - console.warn(`value cannot be made reactive: ${String(target)}`) - } - return target - } - // target is already a Proxy, return it. - // exception: calling readonly() on a reactive object - if ( - target['__v_raw' /* RAW */] && - !(isReadonly && target['__v_isReactive' /* IS_REACTIVE */]) - ) { - return target - } - // target already has corresponding Proxy - const proxyMap = isReadonly ? readonlyMap : reactiveMap - const existingProxy = proxyMap.get(target) - if (existingProxy) { - return existingProxy - } - // only a whitelist of value types can be observed. - const targetType = getTargetType(target) - if (targetType === 0 /* INVALID */) { - return target - } - const proxy = new Proxy( - target, - targetType === 2 /* COLLECTION */ ? collectionHandlers : baseHandlers - ) - proxyMap.set(target, proxy) - return proxy -} -function isReactive(value) { - if (isReadonly(value)) { - return isReactive(value['__v_raw' /* RAW */]) - } - return !!(value && value['__v_isReactive' /* IS_REACTIVE */]) -} -function isReadonly(value) { - return !!(value && value['__v_isReadonly' /* IS_READONLY */]) -} -function isProxy(value) { - return isReactive(value) || isReadonly(value) -} -function toRaw(observed) { - return (observed && toRaw(observed['__v_raw' /* RAW */])) || observed -} -function markRaw(value) { - def(value, '__v_skip' /* SKIP */, true) - return value +const reactiveMap = new WeakMap(); +const readonlyMap = new WeakMap(); +function targetTypeMap(rawType) { + switch (rawType) { + case 'Object': + case 'Array': + return 1 /* COMMON */; + case 'Map': + case 'Set': + case 'WeakMap': + case 'WeakSet': + return 2 /* COLLECTION */; + default: + return 0 /* INVALID */; + } +} +function getTargetType(value) { + return value["__v_skip" /* SKIP */] || !Object.isExtensible(value) + ? 0 /* INVALID */ + : targetTypeMap(toRawType(value)); +} +function reactive(target) { + // if trying to observe a readonly proxy, return the readonly version. + if (target && target["__v_isReadonly" /* IS_READONLY */]) { + return target; + } + return createReactiveObject(target, false, mutableHandlers, mutableCollectionHandlers); +} +// Return a reactive-copy of the original object, where only the root level +// properties are reactive, and does NOT unwrap refs nor recursively convert +// returned properties. +function shallowReactive(target) { + return createReactiveObject(target, false, shallowReactiveHandlers, shallowCollectionHandlers); +} +function readonly(target) { + return createReactiveObject(target, true, readonlyHandlers, readonlyCollectionHandlers); +} +// Return a reactive-copy of the original object, where only the root level +// properties are readonly, and does NOT unwrap refs nor recursively convert +// returned properties. +// This is used for creating the props proxy object for stateful components. +function shallowReadonly(target) { + return createReactiveObject(target, true, shallowReadonlyHandlers, readonlyCollectionHandlers); +} +function createReactiveObject(target, isReadonly, baseHandlers, collectionHandlers) { + if (!isObject(target)) { + if ((process.env.NODE_ENV !== 'production')) { + console.warn(`value cannot be made reactive: ${String(target)}`); + } + return target; + } + // target is already a Proxy, return it. + // exception: calling readonly() on a reactive object + if (target["__v_raw" /* RAW */] && + !(isReadonly && target["__v_isReactive" /* IS_REACTIVE */])) { + return target; + } + // target already has corresponding Proxy + const proxyMap = isReadonly ? readonlyMap : reactiveMap; + const existingProxy = proxyMap.get(target); + if (existingProxy) { + return existingProxy; + } + // only a whitelist of value types can be observed. + const targetType = getTargetType(target); + if (targetType === 0 /* INVALID */) { + return target; + } + const proxy = new Proxy(target, targetType === 2 /* COLLECTION */ ? collectionHandlers : baseHandlers); + proxyMap.set(target, proxy); + return proxy; +} +function isReactive(value) { + if (isReadonly(value)) { + return isReactive(value["__v_raw" /* RAW */]); + } + return !!(value && value["__v_isReactive" /* IS_REACTIVE */]); +} +function isReadonly(value) { + return !!(value && value["__v_isReadonly" /* IS_READONLY */]); +} +function isProxy(value) { + return isReactive(value) || isReadonly(value); +} +function toRaw(observed) { + return ((observed && toRaw(observed["__v_raw" /* RAW */])) || observed); +} +function markRaw(value) { + def(value, "__v_skip" /* SKIP */, true); + return value; } -const convert = val => (isObject(val) ? reactive(val) : val) -function isRef(r) { - return Boolean(r && r.__v_isRef === true) -} -function ref(value) { - return createRef(value) -} -function shallowRef(value) { - return createRef(value, true) -} -class RefImpl { - constructor(_rawValue, _shallow = false) { - this._rawValue = _rawValue - this._shallow = _shallow - this.__v_isRef = true - this._value = _shallow ? _rawValue : convert(_rawValue) - } - get value() { - track(toRaw(this), 'get' /* GET */, 'value') - return this._value - } - set value(newVal) { - if (hasChanged(toRaw(newVal), this._rawValue)) { - this._rawValue = newVal - this._value = this._shallow ? newVal : convert(newVal) - trigger(toRaw(this), 'set' /* SET */, 'value', newVal) - } - } -} -function createRef(rawValue, shallow = false) { - if (isRef(rawValue)) { - return rawValue - } - return new RefImpl(rawValue, shallow) -} -function triggerRef(ref) { - trigger( - ref, - 'set' /* SET */, - 'value', - process.env.NODE_ENV !== 'production' ? ref.value : void 0 - ) -} -function unref(ref) { - return isRef(ref) ? ref.value : ref -} -const shallowUnwrapHandlers = { - get: (target, key, receiver) => unref(Reflect.get(target, key, receiver)), - set: (target, key, value, receiver) => { - const oldValue = target[key] - if (isRef(oldValue) && !isRef(value)) { - oldValue.value = value - return true - } else { - return Reflect.set(target, key, value, receiver) - } - } -} -function proxyRefs(objectWithRefs) { - return isReactive(objectWithRefs) - ? objectWithRefs - : new Proxy(objectWithRefs, shallowUnwrapHandlers) -} -class CustomRefImpl { - constructor(factory) { - this.__v_isRef = true - const { get, set } = factory( - () => track(this, 'get' /* GET */, 'value'), - () => trigger(this, 'set' /* SET */, 'value') - ) - this._get = get - this._set = set - } - get value() { - return this._get() - } - set value(newVal) { - this._set(newVal) - } -} -function customRef(factory) { - return new CustomRefImpl(factory) -} -function toRefs(object) { - if (process.env.NODE_ENV !== 'production' && !isProxy(object)) { - console.warn(`toRefs() expects a reactive object but received a plain one.`) - } - const ret = isArray(object) ? new Array(object.length) : {} - for (const key in object) { - ret[key] = toRef(object, key) - } - return ret -} -class ObjectRefImpl { - constructor(_object, _key) { - this._object = _object - this._key = _key - this.__v_isRef = true - } - get value() { - return this._object[this._key] - } - set value(newVal) { - this._object[this._key] = newVal - } -} -function toRef(object, key) { - return new ObjectRefImpl(object, key) +const convert = (val) => isObject(val) ? reactive(val) : val; +function isRef(r) { + return Boolean(r && r.__v_isRef === true); +} +function ref(value) { + return createRef(value); +} +function shallowRef(value) { + return createRef(value, true); +} +class RefImpl { + constructor(_rawValue, _shallow = false) { + this._rawValue = _rawValue; + this._shallow = _shallow; + this.__v_isRef = true; + this._value = _shallow ? _rawValue : convert(_rawValue); + } + get value() { + track(toRaw(this), "get" /* GET */, 'value'); + return this._value; + } + set value(newVal) { + if (hasChanged(toRaw(newVal), this._rawValue)) { + this._rawValue = newVal; + this._value = this._shallow ? newVal : convert(newVal); + trigger(toRaw(this), "set" /* SET */, 'value', newVal); + } + } +} +function createRef(rawValue, shallow = false) { + if (isRef(rawValue)) { + return rawValue; + } + return new RefImpl(rawValue, shallow); +} +function triggerRef(ref) { + trigger(ref, "set" /* SET */, 'value', (process.env.NODE_ENV !== 'production') ? ref.value : void 0); +} +function unref(ref) { + return isRef(ref) ? ref.value : ref; +} +const shallowUnwrapHandlers = { + get: (target, key, receiver) => unref(Reflect.get(target, key, receiver)), + set: (target, key, value, receiver) => { + const oldValue = target[key]; + if (isRef(oldValue) && !isRef(value)) { + oldValue.value = value; + return true; + } + else { + return Reflect.set(target, key, value, receiver); + } + } +}; +function proxyRefs(objectWithRefs) { + return isReactive(objectWithRefs) + ? objectWithRefs + : new Proxy(objectWithRefs, shallowUnwrapHandlers); +} +class CustomRefImpl { + constructor(factory) { + this.__v_isRef = true; + const { get, set } = factory(() => track(this, "get" /* GET */, 'value'), () => trigger(this, "set" /* SET */, 'value')); + this._get = get; + this._set = set; + } + get value() { + return this._get(); + } + set value(newVal) { + this._set(newVal); + } +} +function customRef(factory) { + return new CustomRefImpl(factory); +} +function toRefs(object) { + if ((process.env.NODE_ENV !== 'production') && !isProxy(object)) { + console.warn(`toRefs() expects a reactive object but received a plain one.`); + } + const ret = isArray(object) ? new Array(object.length) : {}; + for (const key in object) { + ret[key] = toRef(object, key); + } + return ret; +} +class ObjectRefImpl { + constructor(_object, _key) { + this._object = _object; + this._key = _key; + this.__v_isRef = true; + } + get value() { + return this._object[this._key]; + } + set value(newVal) { + this._object[this._key] = newVal; + } +} +function toRef(object, key) { + return new ObjectRefImpl(object, key); } -class ComputedRefImpl { - constructor(getter, _setter, isReadonly) { - this._setter = _setter - this._dirty = true - this.__v_isRef = true - this.effect = effect(getter, { - lazy: true, - scheduler: () => { - if (!this._dirty) { - this._dirty = true - trigger(toRaw(this), 'set' /* SET */, 'value') - } - } - }) - this['__v_isReadonly' /* IS_READONLY */] = isReadonly - } - get value() { - if (this._dirty) { - this._value = this.effect() - this._dirty = false - } - track(toRaw(this), 'get' /* GET */, 'value') - return this._value - } - set value(newValue) { - this._setter(newValue) - } -} -function computed(getterOrOptions) { - let getter - let setter - if (isFunction(getterOrOptions)) { - getter = getterOrOptions - setter = - process.env.NODE_ENV !== 'production' - ? () => { - console.warn('Write operation failed: computed value is readonly') - } - : NOOP - } else { - getter = getterOrOptions.get - setter = getterOrOptions.set - } - return new ComputedRefImpl( - getter, - setter, - isFunction(getterOrOptions) || !getterOrOptions.set - ) +class ComputedRefImpl { + constructor(getter, _setter, isReadonly) { + this._setter = _setter; + this._dirty = true; + this.__v_isRef = true; + this.effect = effect(getter, { + lazy: true, + scheduler: () => { + if (!this._dirty) { + this._dirty = true; + trigger(toRaw(this), "set" /* SET */, 'value'); + } + } + }); + this["__v_isReadonly" /* IS_READONLY */] = isReadonly; + } + get value() { + if (this._dirty) { + this._value = this.effect(); + this._dirty = false; + } + track(toRaw(this), "get" /* GET */, 'value'); + return this._value; + } + set value(newValue) { + this._setter(newValue); + } +} +function computed(getterOrOptions) { + let getter; + let setter; + if (isFunction(getterOrOptions)) { + getter = getterOrOptions; + setter = (process.env.NODE_ENV !== 'production') + ? () => { + console.warn('Write operation failed: computed value is readonly'); + } + : NOOP; + } + else { + getter = getterOrOptions.get; + setter = getterOrOptions.set; + } + return new ComputedRefImpl(getter, setter, isFunction(getterOrOptions) || !getterOrOptions.set); } -const stack = [] -function pushWarningContext(vnode) { - stack.push(vnode) -} -function popWarningContext() { - stack.pop() -} -function warn(msg, ...args) { - // avoid props formatting or warn handler tracking deps that might be mutated - // during patch, leading to infinite recursion. - pauseTracking() - const instance = stack.length ? stack[stack.length - 1].component : null - const appWarnHandler = instance && instance.appContext.config.warnHandler - const trace = getComponentTrace() - if (appWarnHandler) { - callWithErrorHandling(appWarnHandler, instance, 11 /* APP_WARN_HANDLER */, [ - msg + args.join(''), - instance && instance.proxy, - trace - .map(({ vnode }) => `at <${formatComponentName(instance, vnode.type)}>`) - .join('\n'), - trace - ]) - } else { - const warnArgs = [`[Vue warn]: ${msg}`, ...args] - /* istanbul ignore if */ - if ( - trace.length && - // avoid spamming console during tests - !false - ) { - warnArgs.push(`\n`, ...formatTrace(trace)) - } - console.warn(...warnArgs) - } - resetTracking() -} -function getComponentTrace() { - let currentVNode = stack[stack.length - 1] - if (!currentVNode) { - return [] - } - // we can't just use the stack because it will be incomplete during updates - // that did not start from the root. Re-construct the parent chain using - // instance parent pointers. - const normalizedStack = [] - while (currentVNode) { - const last = normalizedStack[0] - if (last && last.vnode === currentVNode) { - last.recurseCount++ - } else { - normalizedStack.push({ - vnode: currentVNode, - recurseCount: 0 - }) - } - const parentInstance = - currentVNode.component && currentVNode.component.parent - currentVNode = parentInstance && parentInstance.vnode - } - return normalizedStack -} -/* istanbul ignore next */ -function formatTrace(trace) { - const logs = [] - trace.forEach((entry, i) => { - logs.push(...(i === 0 ? [] : [`\n`]), ...formatTraceEntry(entry)) - }) - return logs -} -function formatTraceEntry({ vnode, recurseCount }) { - const postfix = - recurseCount > 0 ? `... (${recurseCount} recursive calls)` : `` - const isRoot = vnode.component ? vnode.component.parent == null : false - const open = ` at <${formatComponentName( - vnode.component, - vnode.type, - isRoot - )}` - const close = `>` + postfix - return vnode.props - ? [open, ...formatProps(vnode.props), close] - : [open + close] -} -/* istanbul ignore next */ -function formatProps(props) { - const res = [] - const keys = Object.keys(props) - keys.slice(0, 3).forEach(key => { - res.push(...formatProp(key, props[key])) - }) - if (keys.length > 3) { - res.push(` ...`) - } - return res -} -/* istanbul ignore next */ -function formatProp(key, value, raw) { - if (isString(value)) { - value = JSON.stringify(value) - return raw ? value : [`${key}=${value}`] - } else if ( - typeof value === 'number' || - typeof value === 'boolean' || - value == null - ) { - return raw ? value : [`${key}=${value}`] - } else if (isRef(value)) { - value = formatProp(key, toRaw(value.value), true) - return raw ? value : [`${key}=Ref<`, value, `>`] - } else if (isFunction(value)) { - return [`${key}=fn${value.name ? `<${value.name}>` : ``}`] - } else { - value = toRaw(value) - return raw ? value : [`${key}=`, value] - } +const stack = []; +function pushWarningContext(vnode) { + stack.push(vnode); +} +function popWarningContext() { + stack.pop(); +} +function warn(msg, ...args) { + // avoid props formatting or warn handler tracking deps that might be mutated + // during patch, leading to infinite recursion. + pauseTracking(); + const instance = stack.length ? stack[stack.length - 1].component : null; + const appWarnHandler = instance && instance.appContext.config.warnHandler; + const trace = getComponentTrace(); + if (appWarnHandler) { + callWithErrorHandling(appWarnHandler, instance, 11 /* APP_WARN_HANDLER */, [ + msg + args.join(''), + instance && instance.proxy, + trace + .map(({ vnode }) => `at <${formatComponentName(instance, vnode.type)}>`) + .join('\n'), + trace + ]); + } + else { + const warnArgs = [`[Vue warn]: ${msg}`, ...args]; + /* istanbul ignore if */ + if (trace.length && + // avoid spamming console during tests + !false) { + warnArgs.push(`\n`, ...formatTrace(trace)); + } + console.warn(...warnArgs); + } + resetTracking(); +} +function getComponentTrace() { + let currentVNode = stack[stack.length - 1]; + if (!currentVNode) { + return []; + } + // we can't just use the stack because it will be incomplete during updates + // that did not start from the root. Re-construct the parent chain using + // instance parent pointers. + const normalizedStack = []; + while (currentVNode) { + const last = normalizedStack[0]; + if (last && last.vnode === currentVNode) { + last.recurseCount++; + } + else { + normalizedStack.push({ + vnode: currentVNode, + recurseCount: 0 + }); + } + const parentInstance = currentVNode.component && currentVNode.component.parent; + currentVNode = parentInstance && parentInstance.vnode; + } + return normalizedStack; +} +/* istanbul ignore next */ +function formatTrace(trace) { + const logs = []; + trace.forEach((entry, i) => { + logs.push(...(i === 0 ? [] : [`\n`]), ...formatTraceEntry(entry)); + }); + return logs; +} +function formatTraceEntry({ vnode, recurseCount }) { + const postfix = recurseCount > 0 ? `... (${recurseCount} recursive calls)` : ``; + const isRoot = vnode.component ? vnode.component.parent == null : false; + const open = ` at <${formatComponentName(vnode.component, vnode.type, isRoot)}`; + const close = `>` + postfix; + return vnode.props + ? [open, ...formatProps(vnode.props), close] + : [open + close]; +} +/* istanbul ignore next */ +function formatProps(props) { + const res = []; + const keys = Object.keys(props); + keys.slice(0, 3).forEach(key => { + res.push(...formatProp(key, props[key])); + }); + if (keys.length > 3) { + res.push(` ...`); + } + return res; +} +/* istanbul ignore next */ +function formatProp(key, value, raw) { + if (isString(value)) { + value = JSON.stringify(value); + return raw ? value : [`${key}=${value}`]; + } + else if (typeof value === 'number' || + typeof value === 'boolean' || + value == null) { + return raw ? value : [`${key}=${value}`]; + } + else if (isRef(value)) { + value = formatProp(key, toRaw(value.value), true); + return raw ? value : [`${key}=Ref<`, value, `>`]; + } + else if (isFunction(value)) { + return [`${key}=fn${value.name ? `<${value.name}>` : ``}`]; + } + else { + value = toRaw(value); + return raw ? value : [`${key}=`, value]; + } } -const ErrorTypeStrings = { - ['bc' /* BEFORE_CREATE */]: 'beforeCreate hook', - ['c' /* CREATED */]: 'created hook', - ['bm' /* BEFORE_MOUNT */]: 'beforeMount hook', - ['m' /* MOUNTED */]: 'mounted hook', - ['bu' /* BEFORE_UPDATE */]: 'beforeUpdate hook', - ['u' /* UPDATED */]: 'updated', - ['bum' /* BEFORE_UNMOUNT */]: 'beforeUnmount hook', - ['um' /* UNMOUNTED */]: 'unmounted hook', - ['a' /* ACTIVATED */]: 'activated hook', - ['da' /* DEACTIVATED */]: 'deactivated hook', - ['ec' /* ERROR_CAPTURED */]: 'errorCaptured hook', - ['rtc' /* RENDER_TRACKED */]: 'renderTracked hook', - ['rtg' /* RENDER_TRIGGERED */]: 'renderTriggered hook', - [0 /* SETUP_FUNCTION */]: 'setup function', - [1 /* RENDER_FUNCTION */]: 'render function', - [2 /* WATCH_GETTER */]: 'watcher getter', - [3 /* WATCH_CALLBACK */]: 'watcher callback', - [4 /* WATCH_CLEANUP */]: 'watcher cleanup function', - [5 /* NATIVE_EVENT_HANDLER */]: 'native event handler', - [6 /* COMPONENT_EVENT_HANDLER */]: 'component event handler', - [7 /* VNODE_HOOK */]: 'vnode hook', - [8 /* DIRECTIVE_HOOK */]: 'directive hook', - [9 /* TRANSITION_HOOK */]: 'transition hook', - [10 /* APP_ERROR_HANDLER */]: 'app errorHandler', - [11 /* APP_WARN_HANDLER */]: 'app warnHandler', - [12 /* FUNCTION_REF */]: 'ref function', - [13 /* ASYNC_COMPONENT_LOADER */]: 'async component loader', - [14 /* SCHEDULER */]: - 'scheduler flush. This is likely a Vue internals bug. ' + - 'Please open an issue at https://new-issue.vuejs.org/?repo=vuejs/vue-next' -} -function callWithErrorHandling(fn, instance, type, args) { - let res - try { - res = args ? fn(...args) : fn() - } catch (err) { - handleError(err, instance, type) - } - return res -} -function callWithAsyncErrorHandling(fn, instance, type, args) { - if (isFunction(fn)) { - const res = callWithErrorHandling(fn, instance, type, args) - if (res && isPromise(res)) { - res.catch(err => { - handleError(err, instance, type) - }) - } - return res - } - const values = [] - for (let i = 0; i < fn.length; i++) { - values.push(callWithAsyncErrorHandling(fn[i], instance, type, args)) - } - return values -} -function handleError(err, instance, type) { - const contextVNode = instance ? instance.vnode : null - if (instance) { - let cur = instance.parent - // the exposed instance is the render proxy to keep it consistent with 2.x - const exposedInstance = instance.proxy - // in production the hook receives only the error code - const errorInfo = - process.env.NODE_ENV !== 'production' - ? ErrorTypeStrings[type] || type - : type // fixed by xxxxxxx - while (cur) { - const errorCapturedHooks = cur.ec - if (errorCapturedHooks) { - for (let i = 0; i < errorCapturedHooks.length; i++) { - if (errorCapturedHooks[i](err, exposedInstance, errorInfo)) { - return - } - } - } - cur = cur.parent - } - // app-level handling - const appErrorHandler = instance.appContext.config.errorHandler - if (appErrorHandler) { - callWithErrorHandling(appErrorHandler, null, 10 /* APP_ERROR_HANDLER */, [ - err, - exposedInstance, - errorInfo - ]) - return - } - } - logError(err, type, contextVNode) -} -// fixed by xxxxxx -function logError(err, type, contextVNode) { - if (process.env.NODE_ENV !== 'production') { - const info = ErrorTypeStrings[type] || type // fixed by xxxxxx - if (contextVNode) { - pushWarningContext(contextVNode) - } - warn(`Unhandled error${info ? ` during execution of ${info}` : ``}`) - if (contextVNode) { - popWarningContext() - } - // crash in dev so it's more noticeable - throw err - } else { - // recover in prod to reduce the impact on end-user - console.error(err) - } +const ErrorTypeStrings = { + ["bc" /* BEFORE_CREATE */]: 'beforeCreate hook', + ["c" /* CREATED */]: 'created hook', + ["bm" /* BEFORE_MOUNT */]: 'beforeMount hook', + ["m" /* MOUNTED */]: 'mounted hook', + ["bu" /* BEFORE_UPDATE */]: 'beforeUpdate hook', + ["u" /* UPDATED */]: 'updated', + ["bum" /* BEFORE_UNMOUNT */]: 'beforeUnmount hook', + ["um" /* UNMOUNTED */]: 'unmounted hook', + ["a" /* ACTIVATED */]: 'activated hook', + ["da" /* DEACTIVATED */]: 'deactivated hook', + ["ec" /* ERROR_CAPTURED */]: 'errorCaptured hook', + ["rtc" /* RENDER_TRACKED */]: 'renderTracked hook', + ["rtg" /* RENDER_TRIGGERED */]: 'renderTriggered hook', + [0 /* SETUP_FUNCTION */]: 'setup function', + [1 /* RENDER_FUNCTION */]: 'render function', + [2 /* WATCH_GETTER */]: 'watcher getter', + [3 /* WATCH_CALLBACK */]: 'watcher callback', + [4 /* WATCH_CLEANUP */]: 'watcher cleanup function', + [5 /* NATIVE_EVENT_HANDLER */]: 'native event handler', + [6 /* COMPONENT_EVENT_HANDLER */]: 'component event handler', + [7 /* VNODE_HOOK */]: 'vnode hook', + [8 /* DIRECTIVE_HOOK */]: 'directive hook', + [9 /* TRANSITION_HOOK */]: 'transition hook', + [10 /* APP_ERROR_HANDLER */]: 'app errorHandler', + [11 /* APP_WARN_HANDLER */]: 'app warnHandler', + [12 /* FUNCTION_REF */]: 'ref function', + [13 /* ASYNC_COMPONENT_LOADER */]: 'async component loader', + [14 /* SCHEDULER */]: 'scheduler flush. This is likely a Vue internals bug. ' + + 'Please open an issue at https://new-issue.vuejs.org/?repo=vuejs/vue-next' +}; +function callWithErrorHandling(fn, instance, type, args) { + let res; + try { + res = args ? fn(...args) : fn(); + } + catch (err) { + handleError(err, instance, type); + } + return res; +} +function callWithAsyncErrorHandling(fn, instance, type, args) { + if (isFunction(fn)) { + const res = callWithErrorHandling(fn, instance, type, args); + if (res && isPromise(res)) { + res.catch(err => { + handleError(err, instance, type); + }); + } + return res; + } + const values = []; + for (let i = 0; i < fn.length; i++) { + values.push(callWithAsyncErrorHandling(fn[i], instance, type, args)); + } + return values; +} +function handleError(err, instance, type) { + const contextVNode = instance ? instance.vnode : null; + if (instance) { + let cur = instance.parent; + // the exposed instance is the render proxy to keep it consistent with 2.x + const exposedInstance = instance.proxy; + // in production the hook receives only the error code + const errorInfo = (process.env.NODE_ENV !== 'production') ? ErrorTypeStrings[type] || type : type; // fixed by xxxxxxx + while (cur) { + const errorCapturedHooks = cur.ec; + if (errorCapturedHooks) { + for (let i = 0; i < errorCapturedHooks.length; i++) { + if (errorCapturedHooks[i](err, exposedInstance, errorInfo)) { + return; + } + } + } + cur = cur.parent; + } + // app-level handling + const appErrorHandler = instance.appContext.config.errorHandler; + if (appErrorHandler) { + callWithErrorHandling(appErrorHandler, null, 10 /* APP_ERROR_HANDLER */, [err, exposedInstance, errorInfo]); + return; + } + } + logError(err, type, contextVNode); +} +// fixed by xxxxxx +function logError(err, type, contextVNode) { + if ((process.env.NODE_ENV !== 'production')) { + const info = ErrorTypeStrings[type] || type; // fixed by xxxxxx + if (contextVNode) { + pushWarningContext(contextVNode); + } + warn(`Unhandled error${info ? ` during execution of ${info}` : ``}`); + if (contextVNode) { + popWarningContext(); + } + // crash in dev so it's more noticeable + throw err; + } + else { + // recover in prod to reduce the impact on end-user + console.error(err); + } } -let isFlushing = false -let isFlushPending = false -// fixed by xxxxxx -const queue = [] -let flushIndex = 0 -const pendingPreFlushCbs = [] -let activePreFlushCbs = null -let preFlushIndex = 0 -const pendingPostFlushCbs = [] -let activePostFlushCbs = null -let postFlushIndex = 0 -const resolvedPromise = Promise.resolve() -let currentFlushPromise = null -let currentPreFlushParentJob = null -const RECURSION_LIMIT = 100 -function nextTick(fn) { - const p = currentFlushPromise || resolvedPromise - return fn ? p.then(fn) : p -} -function queueJob(job) { - // the dedupe search uses the startIndex argument of Array.includes() - // by default the search index includes the current job that is being run - // so it cannot recursively trigger itself again. - // if the job is a watch() callback, the search will start with a +1 index to - // allow it recursively trigger itself - it is the user's responsibility to - // ensure it doesn't end up in an infinite loop. - if ( - (!queue.length || - !queue.includes( - job, - isFlushing && job.allowRecurse ? flushIndex + 1 : flushIndex - )) && - job !== currentPreFlushParentJob - ) { - queue.push(job) - queueFlush() - } -} -function queueFlush() { - if (!isFlushing && !isFlushPending) { - isFlushPending = true - currentFlushPromise = resolvedPromise.then(flushJobs) - } -} -function queueCb(cb, activeQueue, pendingQueue, index) { - if (!isArray(cb)) { - if ( - !activeQueue || - !activeQueue.includes(cb, cb.allowRecurse ? index + 1 : index) - ) { - pendingQueue.push(cb) - } - } else { - // if cb is an array, it is a component lifecycle hook which can only be - // triggered by a job, which is already deduped in the main queue, so - // we can skip duplicate check here to improve perf - pendingQueue.push(...cb) - } - queueFlush() -} -function queuePreFlushCb(cb) { - queueCb(cb, activePreFlushCbs, pendingPreFlushCbs, preFlushIndex) -} -function queuePostFlushCb(cb) { - queueCb(cb, activePostFlushCbs, pendingPostFlushCbs, postFlushIndex) -} -function flushPreFlushCbs(seen, parentJob = null) { - if (pendingPreFlushCbs.length) { - currentPreFlushParentJob = parentJob - activePreFlushCbs = [...new Set(pendingPreFlushCbs)] - pendingPreFlushCbs.length = 0 - if (process.env.NODE_ENV !== 'production') { - seen = seen || new Map() - } - for ( - preFlushIndex = 0; - preFlushIndex < activePreFlushCbs.length; - preFlushIndex++ - ) { - if (process.env.NODE_ENV !== 'production') { - checkRecursiveUpdates(seen, activePreFlushCbs[preFlushIndex]) - } - activePreFlushCbs[preFlushIndex]() - } - activePreFlushCbs = null - preFlushIndex = 0 - currentPreFlushParentJob = null - // recursively flush until it drains - flushPreFlushCbs(seen, parentJob) - } -} -function flushPostFlushCbs(seen) { - if (pendingPostFlushCbs.length) { - const deduped = [...new Set(pendingPostFlushCbs)] - pendingPostFlushCbs.length = 0 - // #1947 already has active queue, nested flushPostFlushCbs call - if (activePostFlushCbs) { - activePostFlushCbs.push(...deduped) - return - } - activePostFlushCbs = deduped - if (process.env.NODE_ENV !== 'production') { - seen = seen || new Map() - } - activePostFlushCbs.sort((a, b) => getId(a) - getId(b)) - for ( - postFlushIndex = 0; - postFlushIndex < activePostFlushCbs.length; - postFlushIndex++ - ) { - if (process.env.NODE_ENV !== 'production') { - checkRecursiveUpdates(seen, activePostFlushCbs[postFlushIndex]) - } - activePostFlushCbs[postFlushIndex]() - } - activePostFlushCbs = null - postFlushIndex = 0 - } +let isFlushing = false; +let isFlushPending = false; +// fixed by xxxxxx +const queue = []; +let flushIndex = 0; +const pendingPreFlushCbs = []; +let activePreFlushCbs = null; +let preFlushIndex = 0; +const pendingPostFlushCbs = []; +let activePostFlushCbs = null; +let postFlushIndex = 0; +const resolvedPromise = Promise.resolve(); +let currentFlushPromise = null; +let currentPreFlushParentJob = null; +const RECURSION_LIMIT = 100; +function nextTick(fn) { + const p = currentFlushPromise || resolvedPromise; + return fn ? p.then(fn) : p; +} +function queueJob(job) { + // the dedupe search uses the startIndex argument of Array.includes() + // by default the search index includes the current job that is being run + // so it cannot recursively trigger itself again. + // if the job is a watch() callback, the search will start with a +1 index to + // allow it recursively trigger itself - it is the user's responsibility to + // ensure it doesn't end up in an infinite loop. + if ((!queue.length || + !queue.includes(job, isFlushing && job.allowRecurse ? flushIndex + 1 : flushIndex)) && + job !== currentPreFlushParentJob) { + queue.push(job); + queueFlush(); + } +} +function queueFlush() { + if (!isFlushing && !isFlushPending) { + isFlushPending = true; + currentFlushPromise = resolvedPromise.then(flushJobs); + } +} +function queueCb(cb, activeQueue, pendingQueue, index) { + if (!isArray(cb)) { + if (!activeQueue || + !activeQueue.includes(cb, cb.allowRecurse ? index + 1 : index)) { + pendingQueue.push(cb); + } + } + else { + // if cb is an array, it is a component lifecycle hook which can only be + // triggered by a job, which is already deduped in the main queue, so + // we can skip duplicate check here to improve perf + pendingQueue.push(...cb); + } + queueFlush(); +} +function queuePreFlushCb(cb) { + queueCb(cb, activePreFlushCbs, pendingPreFlushCbs, preFlushIndex); +} +function queuePostFlushCb(cb) { + queueCb(cb, activePostFlushCbs, pendingPostFlushCbs, postFlushIndex); +} +function flushPreFlushCbs(seen, parentJob = null) { + if (pendingPreFlushCbs.length) { + currentPreFlushParentJob = parentJob; + activePreFlushCbs = [...new Set(pendingPreFlushCbs)]; + pendingPreFlushCbs.length = 0; + if ((process.env.NODE_ENV !== 'production')) { + seen = seen || new Map(); + } + for (preFlushIndex = 0; preFlushIndex < activePreFlushCbs.length; preFlushIndex++) { + if ((process.env.NODE_ENV !== 'production')) { + checkRecursiveUpdates(seen, activePreFlushCbs[preFlushIndex]); + } + activePreFlushCbs[preFlushIndex](); + } + activePreFlushCbs = null; + preFlushIndex = 0; + currentPreFlushParentJob = null; + // recursively flush until it drains + flushPreFlushCbs(seen, parentJob); + } +} +function flushPostFlushCbs(seen) { + if (pendingPostFlushCbs.length) { + const deduped = [...new Set(pendingPostFlushCbs)]; + pendingPostFlushCbs.length = 0; + // #1947 already has active queue, nested flushPostFlushCbs call + if (activePostFlushCbs) { + activePostFlushCbs.push(...deduped); + return; + } + activePostFlushCbs = deduped; + if ((process.env.NODE_ENV !== 'production')) { + seen = seen || new Map(); + } + activePostFlushCbs.sort((a, b) => getId(a) - getId(b)); + for (postFlushIndex = 0; postFlushIndex < activePostFlushCbs.length; postFlushIndex++) { + if ((process.env.NODE_ENV !== 'production')) { + checkRecursiveUpdates(seen, activePostFlushCbs[postFlushIndex]); + } + activePostFlushCbs[postFlushIndex](); + } + activePostFlushCbs = null; + postFlushIndex = 0; + } +} +const getId = (job) => job.id == null ? Infinity : job.id; +function flushJobs(seen) { + isFlushPending = false; + isFlushing = true; + if ((process.env.NODE_ENV !== 'production')) { + seen = seen || new Map(); + } + flushPreFlushCbs(seen); + // Sort queue before flush. + // This ensures that: + // 1. Components are updated from parent to child. (because parent is always + // created before the child so its render effect will have smaller + // priority number) + // 2. If a component is unmounted during a parent component's update, + // its update can be skipped. + // Jobs can never be null before flush starts, since they are only invalidated + // during execution of another flushed job. + queue.sort((a, b) => getId(a) - getId(b)); + try { + for (flushIndex = 0; flushIndex < queue.length; flushIndex++) { + const job = queue[flushIndex]; + if (job) { + if ((process.env.NODE_ENV !== 'production')) { + checkRecursiveUpdates(seen, job); + } + callWithErrorHandling(job, null, 14 /* SCHEDULER */); + } + } + } + finally { + flushIndex = 0; + queue.length = 0; + flushPostFlushCbs(seen); + isFlushing = false; + currentFlushPromise = null; + // some postFlushCb queued jobs! + // keep flushing until it drains. + if (queue.length || pendingPostFlushCbs.length) { + flushJobs(seen); + } + } +} +function checkRecursiveUpdates(seen, fn) { + if (!seen.has(fn)) { + seen.set(fn, 1); + } + else { + const count = seen.get(fn); + if (count > RECURSION_LIMIT) { + throw new Error(`Maximum recursive updates exceeded. ` + + `This means you have a reactive effect that is mutating its own ` + + `dependencies and thus recursively triggering itself. Possible sources ` + + `include component template, render function, updated hook or ` + + `watcher source function.`); + } + else { + seen.set(fn, count + 1); + } + } } -const getId = job => (job.id == null ? Infinity : job.id) -function flushJobs(seen) { - isFlushPending = false - isFlushing = true - if (process.env.NODE_ENV !== 'production') { - seen = seen || new Map() - } - flushPreFlushCbs(seen) - // Sort queue before flush. - // This ensures that: - // 1. Components are updated from parent to child. (because parent is always - // created before the child so its render effect will have smaller - // priority number) - // 2. If a component is unmounted during a parent component's update, - // its update can be skipped. - // Jobs can never be null before flush starts, since they are only invalidated - // during execution of another flushed job. - queue.sort((a, b) => getId(a) - getId(b)) - try { - for (flushIndex = 0; flushIndex < queue.length; flushIndex++) { - const job = queue[flushIndex] - if (job) { - if (process.env.NODE_ENV !== 'production') { - checkRecursiveUpdates(seen, job) - } - callWithErrorHandling(job, null, 14 /* SCHEDULER */) - } - } - } finally { - flushIndex = 0 - queue.length = 0 - flushPostFlushCbs(seen) - isFlushing = false - currentFlushPromise = null - // some postFlushCb queued jobs! - // keep flushing until it drains. - if (queue.length || pendingPostFlushCbs.length) { - flushJobs(seen) - } - } -} -function checkRecursiveUpdates(seen, fn) { - if (!seen.has(fn)) { - seen.set(fn, 1) - } else { - const count = seen.get(fn) - if (count > RECURSION_LIMIT) { - throw new Error( - `Maximum recursive updates exceeded. ` + - `This means you have a reactive effect that is mutating its own ` + - `dependencies and thus recursively triggering itself. Possible sources ` + - `include component template, render function, updated hook or ` + - `watcher source function.` - ) - } else { - seen.set(fn, count + 1) - } - } -} - -// mark the current rendering instance for asset resolution (e.g. -// resolveComponent, resolveDirective) during render -let currentRenderingInstance = null -function markAttrsAccessed() {} -function emit(instance, event, ...args) { - const props = instance.vnode.props || EMPTY_OBJ - if (process.env.NODE_ENV !== 'production') { - const { - emitsOptions, - propsOptions: [propsOptions] - } = instance - if (emitsOptions) { - if (!(event in emitsOptions)) { - if (!propsOptions || !(`on` + capitalize(event) in propsOptions)) { - warn( - `Component emitted event "${event}" but it is neither declared in ` + - `the emits option nor as an "on${capitalize(event)}" prop.` - ) - } - } else { - const validator = emitsOptions[event] - if (isFunction(validator)) { - const isValid = validator(...args) - if (!isValid) { - warn( - `Invalid event arguments: event validation failed for event "${event}".` - ) - } - } - } - } - } - if (process.env.NODE_ENV !== 'production' || false); - let handlerName = `on${capitalize(event)}` - let handler = props[handlerName] - // for v-model update:xxx events, also trigger kebab-case equivalent - // for props passed via kebab-case - if (!handler && event.startsWith('update:')) { - handlerName = `on${capitalize(hyphenate(event))}` - handler = props[handlerName] - } - if (!handler) { - handler = props[handlerName + `Once`] - if (!instance.emitted) { - ;(instance.emitted = {})[handlerName] = true - } else if (instance.emitted[handlerName]) { - return - } - } - if (handler) { - callWithAsyncErrorHandling( - handler, - instance, - 6 /* COMPONENT_EVENT_HANDLER */, - args - ) - } -} -function normalizeEmitsOptions(comp, appContext, asMixin = false) { - const appId = appContext.app ? appContext.app._uid : -1 - const cache = comp.__emits || (comp.__emits = {}) - const cached = cache[appId] - if (cached !== undefined) { - return cached - } - const raw = comp.emits - let normalized = {} - // apply mixin/extends props - let hasExtends = false - if (__VUE_OPTIONS_API__ && !isFunction(comp)) { - const extendEmits = raw => { - hasExtends = true - extend(normalized, normalizeEmitsOptions(raw, appContext, true)) - } - if (!asMixin && appContext.mixins.length) { - appContext.mixins.forEach(extendEmits) - } - if (comp.extends) { - extendEmits(comp.extends) - } - if (comp.mixins) { - comp.mixins.forEach(extendEmits) - } - } - if (!raw && !hasExtends) { - return (cache[appId] = null) - } - if (isArray(raw)) { - raw.forEach(key => (normalized[key] = null)) - } else { - extend(normalized, raw) - } - return (cache[appId] = normalized) -} -// Check if an incoming prop key is a declared emit event listener. -// e.g. With `emits: { click: null }`, props named `onClick` and `onclick` are -// both considered matched listeners. -function isEmitListener(options, key) { - if (!options || !isOn(key)) { - return false - } - key = key.replace(/Once$/, '') - return ( - hasOwn(options, key[2].toLowerCase() + key.slice(3)) || - hasOwn(options, key.slice(2)) - ) +// mark the current rendering instance for asset resolution (e.g. +// resolveComponent, resolveDirective) during render +let currentRenderingInstance = null; +function markAttrsAccessed() { } -function initProps( - instance, - rawProps, - isStateful, // result of bitwise flag comparison - isSSR = false -) { - const props = {} - const attrs = {} - // def(attrs, InternalObjectKey, 1) // fixed by xxxxxx - def(attrs, '__vInternal', 1) - setFullProps(instance, rawProps, props, attrs) - // validation - if (process.env.NODE_ENV !== 'production') { - validateProps(props, instance) - } - if (isStateful) { - // stateful - instance.props = isSSR ? props : shallowReactive(props) - } else { - if (!instance.type.props) { - // functional w/ optional props, props === attrs - instance.props = attrs - } else { - // functional w/ declared props - instance.props = props - } - } - instance.attrs = attrs -} -function setFullProps(instance, rawProps, props, attrs) { - const [options, needCastKeys] = instance.propsOptions - if (rawProps) { - for (const key in rawProps) { - const value = rawProps[key] - // key, ref are reserved and never passed down - if (isReservedProp(key)) { - continue - } - // prop option names are camelized during normalization, so to support - // kebab -> camel conversion here we need to camelize the key. - let camelKey - if (options && hasOwn(options, (camelKey = camelize(key)))) { - props[camelKey] = value - } else if (!isEmitListener(instance.emitsOptions, key)) { - // Any non-declared (either as a prop or an emitted event) props are put - // into a separate `attrs` object for spreading. Make sure to preserve - // original key casing - attrs[key] = value - } - } - } - if (needCastKeys) { - const rawCurrentProps = toRaw(props) - for (let i = 0; i < needCastKeys.length; i++) { - const key = needCastKeys[i] - props[key] = resolvePropValue( - options, - rawCurrentProps, - key, - rawCurrentProps[key] - ) - } - } -} -function resolvePropValue(options, props, key, value) { - const opt = options[key] - if (opt != null) { - const hasDefault = hasOwn(opt, 'default') - // default values - if (hasDefault && value === undefined) { - const defaultValue = opt.default - value = - opt.type !== Function && isFunction(defaultValue) - ? defaultValue(props) - : defaultValue - } - // boolean casting - if (opt[0 /* shouldCast */]) { - if (!hasOwn(props, key) && !hasDefault) { - value = false - } else if ( - opt[1 /* shouldCastTrue */] && - (value === '' || value === hyphenate(key)) - ) { - value = true - } - } - } - return value -} -function normalizePropsOptions(comp, appContext, asMixin = false) { - const appId = appContext.app ? appContext.app._uid : -1 - const cache = comp.__props || (comp.__props = {}) - const cached = cache[appId] - if (cached) { - return cached - } - const raw = comp.props - const normalized = {} - const needCastKeys = [] - // apply mixin/extends props - let hasExtends = false - if (__VUE_OPTIONS_API__ && !isFunction(comp)) { - const extendProps = raw => { - hasExtends = true - const [props, keys] = normalizePropsOptions(raw, appContext, true) - extend(normalized, props) - if (keys) needCastKeys.push(...keys) - } - if (!asMixin && appContext.mixins.length) { - appContext.mixins.forEach(extendProps) - } - if (comp.extends) { - extendProps(comp.extends) - } - if (comp.mixins) { - comp.mixins.forEach(extendProps) - } - } - if (!raw && !hasExtends) { - return (cache[appId] = EMPTY_ARR) - } - if (isArray(raw)) { - for (let i = 0; i < raw.length; i++) { - if (process.env.NODE_ENV !== 'production' && !isString(raw[i])) { - warn(`props must be strings when using array syntax.`, raw[i]) - } - const normalizedKey = camelize(raw[i]) - if (validatePropName(normalizedKey)) { - normalized[normalizedKey] = EMPTY_OBJ - } - } - } else if (raw) { - if (process.env.NODE_ENV !== 'production' && !isObject(raw)) { - warn(`invalid props options`, raw) - } - for (const key in raw) { - const normalizedKey = camelize(key) - if (validatePropName(normalizedKey)) { - const opt = raw[key] - const prop = (normalized[normalizedKey] = - isArray(opt) || isFunction(opt) ? { type: opt } : opt) - if (prop) { - const booleanIndex = getTypeIndex(Boolean, prop.type) - const stringIndex = getTypeIndex(String, prop.type) - prop[0 /* shouldCast */] = booleanIndex > -1 - prop[1 /* shouldCastTrue */] = - stringIndex < 0 || booleanIndex < stringIndex - // if the prop needs boolean casting or default value - if (booleanIndex > -1 || hasOwn(prop, 'default')) { - needCastKeys.push(normalizedKey) - } - } - } - } - } - return (cache[appId] = [normalized, needCastKeys]) -} -// use function string name to check type constructors -// so that it works across vms / iframes. -function getType(ctor) { - const match = ctor && ctor.toString().match(/^\s*function (\w+)/) - return match ? match[1] : '' -} -function isSameType(a, b) { - return getType(a) === getType(b) -} -function getTypeIndex(type, expectedTypes) { - if (isArray(expectedTypes)) { - for (let i = 0, len = expectedTypes.length; i < len; i++) { - if (isSameType(expectedTypes[i], type)) { - return i - } - } - } else if (isFunction(expectedTypes)) { - return isSameType(expectedTypes, type) ? 0 : -1 - } - return -1 -} -/** - * dev only - */ -function validateProps(props, instance) { - const rawValues = toRaw(props) - const options = instance.propsOptions[0] - for (const key in options) { - let opt = options[key] - if (opt == null) continue - validateProp(key, rawValues[key], opt, !hasOwn(rawValues, key)) - } -} -/** - * dev only - */ -function validatePropName(key) { - if (key[0] !== '$') { - return true - } else if (process.env.NODE_ENV !== 'production') { - warn(`Invalid prop name: "${key}" is a reserved property.`) - } - return false -} -/** - * dev only - */ -function validateProp(name, value, prop, isAbsent) { - const { type, required, validator } = prop - // required! - if (required && isAbsent) { - warn('Missing required prop: "' + name + '"') - return - } - // missing but optional - if (value == null && !prop.required) { - return - } - // type check - if (type != null && type !== true) { - let isValid = false - const types = isArray(type) ? type : [type] - const expectedTypes = [] - // value is valid as long as one of the specified types match - for (let i = 0; i < types.length && !isValid; i++) { - const { valid, expectedType } = assertType(value, types[i]) - expectedTypes.push(expectedType || '') - isValid = valid - } - if (!isValid) { - warn(getInvalidTypeMessage(name, value, expectedTypes)) - return - } - } - // custom validator - if (validator && !validator(value)) { - warn('Invalid prop: custom validator check failed for prop "' + name + '".') - } -} -const isSimpleType = /*#__PURE__*/ makeMap( - 'String,Number,Boolean,Function,Symbol' -) -/** - * dev only - */ -function assertType(value, type) { - let valid - const expectedType = getType(type) - if (isSimpleType(expectedType)) { - const t = typeof value - valid = t === expectedType.toLowerCase() - // for primitive wrapper objects - if (!valid && t === 'object') { - valid = value instanceof type - } - } else if (expectedType === 'Object') { - valid = isObject(value) - } else if (expectedType === 'Array') { - valid = isArray(value) - } else { - valid = value instanceof type - } - return { - valid, - expectedType - } -} -/** - * dev only - */ -function getInvalidTypeMessage(name, value, expectedTypes) { - let message = - `Invalid prop: type check failed for prop "${name}".` + - ` Expected ${expectedTypes.map(capitalize).join(', ')}` - const expectedType = expectedTypes[0] - const receivedType = toRawType(value) - const expectedValue = styleValue(value, expectedType) - const receivedValue = styleValue(value, receivedType) - // check if we need to specify expected value - if ( - expectedTypes.length === 1 && - isExplicable(expectedType) && - !isBoolean(expectedType, receivedType) - ) { - message += ` with value ${expectedValue}` - } - message += `, got ${receivedType} ` - // check if we need to specify received value - if (isExplicable(receivedType)) { - message += `with value ${receivedValue}.` - } - return message -} -/** - * dev only - */ -function styleValue(value, type) { - if (type === 'String') { - return `"${value}"` - } else if (type === 'Number') { - return `${Number(value)}` - } else { - return `${value}` - } -} -/** - * dev only - */ -function isExplicable(type) { - const explicitTypes = ['string', 'number', 'boolean'] - return explicitTypes.some(elem => type.toLowerCase() === elem) -} -/** - * dev only - */ -function isBoolean(...args) { - return args.some(elem => elem.toLowerCase() === 'boolean') +function emit(instance, event, ...args) { + const props = instance.vnode.props || EMPTY_OBJ; + if ((process.env.NODE_ENV !== 'production')) { + const { emitsOptions, propsOptions: [propsOptions] } = instance; + if (emitsOptions) { + if (!(event in emitsOptions)) { + if (!propsOptions || !(`on` + capitalize(event) in propsOptions)) { + warn(`Component emitted event "${event}" but it is neither declared in ` + + `the emits option nor as an "on${capitalize(event)}" prop.`); + } + } + else { + const validator = emitsOptions[event]; + if (isFunction(validator)) { + const isValid = validator(...args); + if (!isValid) { + warn(`Invalid event arguments: event validation failed for event "${event}".`); + } + } + } + } + } + if ((process.env.NODE_ENV !== 'production') || false) ; + let handlerName = `on${capitalize(event)}`; + let handler = props[handlerName]; + // for v-model update:xxx events, also trigger kebab-case equivalent + // for props passed via kebab-case + if (!handler && event.startsWith('update:')) { + handlerName = `on${capitalize(hyphenate(event))}`; + handler = props[handlerName]; + } + if (!handler) { + handler = props[handlerName + `Once`]; + if (!instance.emitted) { + (instance.emitted = {})[handlerName] = true; + } + else if (instance.emitted[handlerName]) { + return; + } + } + if (handler) { + callWithAsyncErrorHandling(handler, instance, 6 /* COMPONENT_EVENT_HANDLER */, args); + } +} +function normalizeEmitsOptions(comp, appContext, asMixin = false) { + const appId = appContext.app ? appContext.app._uid : -1; + const cache = comp.__emits || (comp.__emits = {}); + const cached = cache[appId]; + if (cached !== undefined) { + return cached; + } + const raw = comp.emits; + let normalized = {}; + // apply mixin/extends props + let hasExtends = false; + if (__VUE_OPTIONS_API__ && !isFunction(comp)) { + const extendEmits = (raw) => { + hasExtends = true; + extend(normalized, normalizeEmitsOptions(raw, appContext, true)); + }; + if (!asMixin && appContext.mixins.length) { + appContext.mixins.forEach(extendEmits); + } + if (comp.extends) { + extendEmits(comp.extends); + } + if (comp.mixins) { + comp.mixins.forEach(extendEmits); + } + } + if (!raw && !hasExtends) { + return (cache[appId] = null); + } + if (isArray(raw)) { + raw.forEach(key => (normalized[key] = null)); + } + else { + extend(normalized, raw); + } + return (cache[appId] = normalized); +} +// Check if an incoming prop key is a declared emit event listener. +// e.g. With `emits: { click: null }`, props named `onClick` and `onclick` are +// both considered matched listeners. +function isEmitListener(options, key) { + if (!options || !isOn(key)) { + return false; + } + key = key.replace(/Once$/, ''); + return (hasOwn(options, key[2].toLowerCase() + key.slice(3)) || + hasOwn(options, key.slice(2))); } -function injectHook(type, hook, target = currentInstance, prepend = false) { - if (target) { - const hooks = target[type] || (target[type] = []) - // cache the error handling wrapper for injected hooks so the same hook - // can be properly deduped by the scheduler. "__weh" stands for "with error - // handling". - const wrappedHook = - hook.__weh || - (hook.__weh = (...args) => { - if (target.isUnmounted) { - return - } - // disable tracking inside all lifecycle hooks - // since they can potentially be called inside effects. - pauseTracking() - // Set currentInstance during hook invocation. - // This assumes the hook does not synchronously trigger other hooks, which - // can only be false when the user does something really funky. - setCurrentInstance(target) - const res = callWithAsyncErrorHandling(hook, target, type, args) - setCurrentInstance(null) - resetTracking() - return res - }) - if (prepend) { - hooks.unshift(wrappedHook) - } else { - hooks.push(wrappedHook) - } - return wrappedHook - } else if (process.env.NODE_ENV !== 'production') { - const apiName = `on${capitalize( - ErrorTypeStrings[type].replace(/ hook$/, '') - )}` - warn( - `${apiName} is called when there is no active component instance to be ` + - `associated with. ` + - `Lifecycle injection APIs can only be used during execution of setup().` + - `` - ) - } -} -const createHook = lifecycle => (hook, target = currentInstance) => - // post-create lifecycle registrations are noops during SSR - !isInSSRComponentSetup && injectHook(lifecycle, hook, target) -const onBeforeMount = createHook('bm' /* BEFORE_MOUNT */) -const onMounted = createHook('m' /* MOUNTED */) -const onBeforeUpdate = createHook('bu' /* BEFORE_UPDATE */) -const onUpdated = createHook('u' /* UPDATED */) -const onBeforeUnmount = createHook('bum' /* BEFORE_UNMOUNT */) -const onUnmounted = createHook('um' /* UNMOUNTED */) -const onRenderTriggered = createHook('rtg' /* RENDER_TRIGGERED */) -const onRenderTracked = createHook('rtc' /* RENDER_TRACKED */) -const onErrorCaptured = (hook, target = currentInstance) => { - injectHook('ec' /* ERROR_CAPTURED */, hook, target) +function initProps(instance, rawProps, isStateful, // result of bitwise flag comparison +isSSR = false) { + const props = {}; + const attrs = {}; + // def(attrs, InternalObjectKey, 1) // fixed by xxxxxx + def(attrs, '__vInternal', 1); + setFullProps(instance, rawProps, props, attrs); + // validation + if ((process.env.NODE_ENV !== 'production')) { + validateProps(props, instance); + } + if (isStateful) { + // stateful + instance.props = isSSR ? props : shallowReactive(props); + } + else { + if (!instance.type.props) { + // functional w/ optional props, props === attrs + instance.props = attrs; + } + else { + // functional w/ declared props + instance.props = props; + } + } + instance.attrs = attrs; +} +function setFullProps(instance, rawProps, props, attrs) { + const [options, needCastKeys] = instance.propsOptions; + if (rawProps) { + for (const key in rawProps) { + const value = rawProps[key]; + // key, ref are reserved and never passed down + if (isReservedProp(key)) { + continue; + } + // prop option names are camelized during normalization, so to support + // kebab -> camel conversion here we need to camelize the key. + let camelKey; + if (options && hasOwn(options, (camelKey = camelize(key)))) { + props[camelKey] = value; + } + else if (!isEmitListener(instance.emitsOptions, key)) { + // Any non-declared (either as a prop or an emitted event) props are put + // into a separate `attrs` object for spreading. Make sure to preserve + // original key casing + attrs[key] = value; + } + } + } + if (needCastKeys) { + const rawCurrentProps = toRaw(props); + for (let i = 0; i < needCastKeys.length; i++) { + const key = needCastKeys[i]; + props[key] = resolvePropValue(options, rawCurrentProps, key, rawCurrentProps[key]); + } + } +} +function resolvePropValue(options, props, key, value) { + const opt = options[key]; + if (opt != null) { + const hasDefault = hasOwn(opt, 'default'); + // default values + if (hasDefault && value === undefined) { + const defaultValue = opt.default; + value = + opt.type !== Function && isFunction(defaultValue) + ? defaultValue(props) + : defaultValue; + } + // boolean casting + if (opt[0 /* shouldCast */]) { + if (!hasOwn(props, key) && !hasDefault) { + value = false; + } + else if (opt[1 /* shouldCastTrue */] && + (value === '' || value === hyphenate(key))) { + value = true; + } + } + } + return value; +} +function normalizePropsOptions(comp, appContext, asMixin = false) { + const appId = appContext.app ? appContext.app._uid : -1; + const cache = comp.__props || (comp.__props = {}); + const cached = cache[appId]; + if (cached) { + return cached; + } + const raw = comp.props; + const normalized = {}; + const needCastKeys = []; + // apply mixin/extends props + let hasExtends = false; + if (__VUE_OPTIONS_API__ && !isFunction(comp)) { + const extendProps = (raw) => { + hasExtends = true; + const [props, keys] = normalizePropsOptions(raw, appContext, true); + extend(normalized, props); + if (keys) + needCastKeys.push(...keys); + }; + if (!asMixin && appContext.mixins.length) { + appContext.mixins.forEach(extendProps); + } + if (comp.extends) { + extendProps(comp.extends); + } + if (comp.mixins) { + comp.mixins.forEach(extendProps); + } + } + if (!raw && !hasExtends) { + return (cache[appId] = EMPTY_ARR); + } + if (isArray(raw)) { + for (let i = 0; i < raw.length; i++) { + if ((process.env.NODE_ENV !== 'production') && !isString(raw[i])) { + warn(`props must be strings when using array syntax.`, raw[i]); + } + const normalizedKey = camelize(raw[i]); + if (validatePropName(normalizedKey)) { + normalized[normalizedKey] = EMPTY_OBJ; + } + } + } + else if (raw) { + if ((process.env.NODE_ENV !== 'production') && !isObject(raw)) { + warn(`invalid props options`, raw); + } + for (const key in raw) { + const normalizedKey = camelize(key); + if (validatePropName(normalizedKey)) { + const opt = raw[key]; + const prop = (normalized[normalizedKey] = + isArray(opt) || isFunction(opt) ? { type: opt } : opt); + if (prop) { + const booleanIndex = getTypeIndex(Boolean, prop.type); + const stringIndex = getTypeIndex(String, prop.type); + prop[0 /* shouldCast */] = booleanIndex > -1; + prop[1 /* shouldCastTrue */] = + stringIndex < 0 || booleanIndex < stringIndex; + // if the prop needs boolean casting or default value + if (booleanIndex > -1 || hasOwn(prop, 'default')) { + needCastKeys.push(normalizedKey); + } + } + } + } + } + return (cache[appId] = [normalized, needCastKeys]); +} +// use function string name to check type constructors +// so that it works across vms / iframes. +function getType(ctor) { + const match = ctor && ctor.toString().match(/^\s*function (\w+)/); + return match ? match[1] : ''; +} +function isSameType(a, b) { + return getType(a) === getType(b); +} +function getTypeIndex(type, expectedTypes) { + if (isArray(expectedTypes)) { + for (let i = 0, len = expectedTypes.length; i < len; i++) { + if (isSameType(expectedTypes[i], type)) { + return i; + } + } + } + else if (isFunction(expectedTypes)) { + return isSameType(expectedTypes, type) ? 0 : -1; + } + return -1; +} +/** + * dev only + */ +function validateProps(props, instance) { + const rawValues = toRaw(props); + const options = instance.propsOptions[0]; + for (const key in options) { + let opt = options[key]; + if (opt == null) + continue; + validateProp(key, rawValues[key], opt, !hasOwn(rawValues, key)); + } +} +/** + * dev only + */ +function validatePropName(key) { + if (key[0] !== '$') { + return true; + } + else if ((process.env.NODE_ENV !== 'production')) { + warn(`Invalid prop name: "${key}" is a reserved property.`); + } + return false; +} +/** + * dev only + */ +function validateProp(name, value, prop, isAbsent) { + const { type, required, validator } = prop; + // required! + if (required && isAbsent) { + warn('Missing required prop: "' + name + '"'); + return; + } + // missing but optional + if (value == null && !prop.required) { + return; + } + // type check + if (type != null && type !== true) { + let isValid = false; + const types = isArray(type) ? type : [type]; + const expectedTypes = []; + // value is valid as long as one of the specified types match + for (let i = 0; i < types.length && !isValid; i++) { + const { valid, expectedType } = assertType(value, types[i]); + expectedTypes.push(expectedType || ''); + isValid = valid; + } + if (!isValid) { + warn(getInvalidTypeMessage(name, value, expectedTypes)); + return; + } + } + // custom validator + if (validator && !validator(value)) { + warn('Invalid prop: custom validator check failed for prop "' + name + '".'); + } +} +const isSimpleType = /*#__PURE__*/ makeMap('String,Number,Boolean,Function,Symbol'); +/** + * dev only + */ +function assertType(value, type) { + let valid; + const expectedType = getType(type); + if (isSimpleType(expectedType)) { + const t = typeof value; + valid = t === expectedType.toLowerCase(); + // for primitive wrapper objects + if (!valid && t === 'object') { + valid = value instanceof type; + } + } + else if (expectedType === 'Object') { + valid = isObject(value); + } + else if (expectedType === 'Array') { + valid = isArray(value); + } + else { + valid = value instanceof type; + } + return { + valid, + expectedType + }; +} +/** + * dev only + */ +function getInvalidTypeMessage(name, value, expectedTypes) { + let message = `Invalid prop: type check failed for prop "${name}".` + + ` Expected ${expectedTypes.map(capitalize).join(', ')}`; + const expectedType = expectedTypes[0]; + const receivedType = toRawType(value); + const expectedValue = styleValue(value, expectedType); + const receivedValue = styleValue(value, receivedType); + // check if we need to specify expected value + if (expectedTypes.length === 1 && + isExplicable(expectedType) && + !isBoolean(expectedType, receivedType)) { + message += ` with value ${expectedValue}`; + } + message += `, got ${receivedType} `; + // check if we need to specify received value + if (isExplicable(receivedType)) { + message += `with value ${receivedValue}.`; + } + return message; +} +/** + * dev only + */ +function styleValue(value, type) { + if (type === 'String') { + return `"${value}"`; + } + else if (type === 'Number') { + return `${Number(value)}`; + } + else { + return `${value}`; + } +} +/** + * dev only + */ +function isExplicable(type) { + const explicitTypes = ['string', 'number', 'boolean']; + return explicitTypes.some(elem => type.toLowerCase() === elem); +} +/** + * dev only + */ +function isBoolean(...args) { + return args.some(elem => elem.toLowerCase() === 'boolean'); } -const isKeepAlive = vnode => vnode.type.__isKeepAlive -function onActivated(hook, target) { - registerKeepAliveHook(hook, 'a' /* ACTIVATED */, target) -} -function onDeactivated(hook, target) { - registerKeepAliveHook(hook, 'da' /* DEACTIVATED */, target) -} -function registerKeepAliveHook(hook, type, target = currentInstance) { - // cache the deactivate branch check wrapper for injected hooks so the same - // hook can be properly deduped by the scheduler. "__wdc" stands for "with - // deactivation check". - const wrappedHook = - hook.__wdc || - (hook.__wdc = () => { - // only fire the hook if the target instance is NOT in a deactivated branch. - let current = target - while (current) { - if (current.isDeactivated) { - return - } - current = current.parent - } - hook() - }) - injectHook(type, wrappedHook, target) - // In addition to registering it on the target instance, we walk up the parent - // chain and register it on all ancestor instances that are keep-alive roots. - // This avoids the need to walk the entire component tree when invoking these - // hooks, and more importantly, avoids the need to track child components in - // arrays. - if (target) { - let current = target.parent - while (current && current.parent) { - if (isKeepAlive(current.parent.vnode)) { - injectToKeepAliveRoot(wrappedHook, type, target, current) - } - current = current.parent - } - } -} -function injectToKeepAliveRoot(hook, type, target, keepAliveRoot) { - // injectHook wraps the original for error handling, so make sure to remove - // the wrapped version. - const injected = injectHook(type, hook, keepAliveRoot, true /* prepend */) - onUnmounted(() => { - remove(keepAliveRoot[type], injected) - }, target) +function injectHook(type, hook, target = currentInstance, prepend = false) { + if (target) { + const hooks = target[type] || (target[type] = []); + // cache the error handling wrapper for injected hooks so the same hook + // can be properly deduped by the scheduler. "__weh" stands for "with error + // handling". + const wrappedHook = hook.__weh || + (hook.__weh = (...args) => { + if (target.isUnmounted) { + return; + } + // disable tracking inside all lifecycle hooks + // since they can potentially be called inside effects. + pauseTracking(); + // Set currentInstance during hook invocation. + // This assumes the hook does not synchronously trigger other hooks, which + // can only be false when the user does something really funky. + setCurrentInstance(target); + const res = callWithAsyncErrorHandling(hook, target, type, args); + setCurrentInstance(null); + resetTracking(); + return res; + }); + if (prepend) { + hooks.unshift(wrappedHook); + } + else { + hooks.push(wrappedHook); + } + return wrappedHook; + } + else if ((process.env.NODE_ENV !== 'production')) { + const apiName = `on${capitalize(ErrorTypeStrings[type].replace(/ hook$/, ''))}`; + warn(`${apiName} is called when there is no active component instance to be ` + + `associated with. ` + + `Lifecycle injection APIs can only be used during execution of setup().` + + ( ``)); + } +} +const createHook = (lifecycle) => (hook, target = currentInstance) => +// post-create lifecycle registrations are noops during SSR +!isInSSRComponentSetup && injectHook(lifecycle, hook, target); +const onBeforeMount = createHook("bm" /* BEFORE_MOUNT */); +const onMounted = createHook("m" /* MOUNTED */); +const onBeforeUpdate = createHook("bu" /* BEFORE_UPDATE */); +const onUpdated = createHook("u" /* UPDATED */); +const onBeforeUnmount = createHook("bum" /* BEFORE_UNMOUNT */); +const onUnmounted = createHook("um" /* UNMOUNTED */); +const onRenderTriggered = createHook("rtg" /* RENDER_TRIGGERED */); +const onRenderTracked = createHook("rtc" /* RENDER_TRACKED */); +const onErrorCaptured = (hook, target = currentInstance) => { + injectHook("ec" /* ERROR_CAPTURED */, hook, target); +}; + +const isKeepAlive = (vnode) => vnode.type.__isKeepAlive; +function onActivated(hook, target) { + registerKeepAliveHook(hook, "a" /* ACTIVATED */, target); +} +function onDeactivated(hook, target) { + registerKeepAliveHook(hook, "da" /* DEACTIVATED */, target); +} +function registerKeepAliveHook(hook, type, target = currentInstance) { + // cache the deactivate branch check wrapper for injected hooks so the same + // hook can be properly deduped by the scheduler. "__wdc" stands for "with + // deactivation check". + const wrappedHook = hook.__wdc || + (hook.__wdc = () => { + // only fire the hook if the target instance is NOT in a deactivated branch. + let current = target; + while (current) { + if (current.isDeactivated) { + return; + } + current = current.parent; + } + hook(); + }); + injectHook(type, wrappedHook, target); + // In addition to registering it on the target instance, we walk up the parent + // chain and register it on all ancestor instances that are keep-alive roots. + // This avoids the need to walk the entire component tree when invoking these + // hooks, and more importantly, avoids the need to track child components in + // arrays. + if (target) { + let current = target.parent; + while (current && current.parent) { + if (isKeepAlive(current.parent.vnode)) { + injectToKeepAliveRoot(wrappedHook, type, target, current); + } + current = current.parent; + } + } +} +function injectToKeepAliveRoot(hook, type, target, keepAliveRoot) { + // injectHook wraps the original for error handling, so make sure to remove + // the wrapped version. + const injected = injectHook(type, hook, keepAliveRoot, true /* prepend */); + onUnmounted(() => { + remove(keepAliveRoot[type], injected); + }, target); } /** @@ -1854,1882 +1728,1703 @@ return withDirectives(h(comp), [ [foo, this.x], [bar, this.y] ]) -*/ -const isBuiltInDirective = /*#__PURE__*/ makeMap( - 'bind,cloak,else-if,else,for,html,if,model,on,once,pre,show,slot,text' -) -function validateDirectiveName(name) { - if (isBuiltInDirective(name)) { - warn('Do not use built-in directive ids as custom directive id: ' + name) - } +*/ +const isBuiltInDirective = /*#__PURE__*/ makeMap('bind,cloak,else-if,else,for,html,if,model,on,once,pre,show,slot,text'); +function validateDirectiveName(name) { + if (isBuiltInDirective(name)) { + warn('Do not use built-in directive ids as custom directive id: ' + name); + } } -function createAppContext() { - return { - app: null, - config: { - isNativeTag: NO, - performance: false, - globalProperties: {}, - optionMergeStrategies: {}, - isCustomElement: NO, - errorHandler: undefined, - warnHandler: undefined - }, - mixins: [], - components: {}, - directives: {}, - provides: Object.create(null) - } -} -let uid$1 = 0 -// fixed by xxxxxx -function createAppAPI() { - return function createApp(rootComponent, rootProps = null) { - if (rootProps != null && !isObject(rootProps)) { - process.env.NODE_ENV !== 'production' && - warn(`root props passed to app.mount() must be an object.`) - rootProps = null - } - const context = createAppContext() - const installedPlugins = new Set() - // fixed by xxxxxx - // let isMounted = false - const app = (context.app = { - _uid: uid$1++, - _component: rootComponent, - _props: rootProps, - _container: null, - _context: context, - version, - get config() { - return context.config - }, - set config(v) { - if (process.env.NODE_ENV !== 'production') { - warn( - `app.config cannot be replaced. Modify individual options instead.` - ) - } - }, - use(plugin, ...options) { - if (installedPlugins.has(plugin)) { - process.env.NODE_ENV !== 'production' && - warn(`Plugin has already been applied to target app.`) - } else if (plugin && isFunction(plugin.install)) { - installedPlugins.add(plugin) - plugin.install(app, ...options) - } else if (isFunction(plugin)) { - installedPlugins.add(plugin) - plugin(app, ...options) - } else if (process.env.NODE_ENV !== 'production') { - warn( - `A plugin must either be a function or an object with an "install" ` + - `function.` - ) - } - return app - }, - mixin(mixin) { - if (__VUE_OPTIONS_API__) { - if (!context.mixins.includes(mixin)) { - context.mixins.push(mixin) - } else if (process.env.NODE_ENV !== 'production') { - warn( - 'Mixin has already been applied to target app' + - (mixin.name ? `: ${mixin.name}` : '') - ) - } - } else if (process.env.NODE_ENV !== 'production') { - warn('Mixins are only available in builds supporting Options API') - } - return app - }, - component(name, component) { - if (process.env.NODE_ENV !== 'production') { - validateComponentName(name, context.config) - } - if (!component) { - return context.components[name] - } - if (process.env.NODE_ENV !== 'production' && context.components[name]) { - warn(`Component "${name}" has already been registered in target app.`) - } - context.components[name] = component - return app - }, - directive(name, directive) { - if (process.env.NODE_ENV !== 'production') { - validateDirectiveName(name) - } - if (!directive) { - return context.directives[name] - } - if (process.env.NODE_ENV !== 'production' && context.directives[name]) { - warn(`Directive "${name}" has already been registered in target app.`) - } - context.directives[name] = directive - return app - }, - // fixed by xxxxxx - mount() {}, - // fixed by xxxxxx - unmount() {}, - provide(key, value) { - if (process.env.NODE_ENV !== 'production' && key in context.provides) { - warn( - `App already provides property with key "${String(key)}". ` + - `It will be overwritten with the new value.` - ) - } - // TypeScript doesn't allow symbols as index type - // https://github.com/Microsoft/TypeScript/issues/24587 - context.provides[key] = value - return app - } - }) - return app - } +function createAppContext() { + return { + app: null, + config: { + isNativeTag: NO, + performance: false, + globalProperties: {}, + optionMergeStrategies: {}, + isCustomElement: NO, + errorHandler: undefined, + warnHandler: undefined + }, + mixins: [], + components: {}, + directives: {}, + provides: Object.create(null) + }; +} +let uid$1 = 0; +// fixed by xxxxxx +function createAppAPI() { + return function createApp(rootComponent, rootProps = null) { + if (rootProps != null && !isObject(rootProps)) { + (process.env.NODE_ENV !== 'production') && warn(`root props passed to app.mount() must be an object.`); + rootProps = null; + } + const context = createAppContext(); + const installedPlugins = new Set(); + // fixed by xxxxxx + // let isMounted = false + const app = (context.app = { + _uid: uid$1++, + _component: rootComponent, + _props: rootProps, + _container: null, + _context: context, + version, + get config() { + return context.config; + }, + set config(v) { + if ((process.env.NODE_ENV !== 'production')) { + warn(`app.config cannot be replaced. Modify individual options instead.`); + } + }, + use(plugin, ...options) { + if (installedPlugins.has(plugin)) { + (process.env.NODE_ENV !== 'production') && warn(`Plugin has already been applied to target app.`); + } + else if (plugin && isFunction(plugin.install)) { + installedPlugins.add(plugin); + plugin.install(app, ...options); + } + else if (isFunction(plugin)) { + installedPlugins.add(plugin); + plugin(app, ...options); + } + else if ((process.env.NODE_ENV !== 'production')) { + warn(`A plugin must either be a function or an object with an "install" ` + + `function.`); + } + return app; + }, + mixin(mixin) { + if (__VUE_OPTIONS_API__) { + if (!context.mixins.includes(mixin)) { + context.mixins.push(mixin); + } + else if ((process.env.NODE_ENV !== 'production')) { + warn('Mixin has already been applied to target app' + + (mixin.name ? `: ${mixin.name}` : '')); + } + } + else if ((process.env.NODE_ENV !== 'production')) { + warn('Mixins are only available in builds supporting Options API'); + } + return app; + }, + component(name, component) { + if ((process.env.NODE_ENV !== 'production')) { + validateComponentName(name, context.config); + } + if (!component) { + return context.components[name]; + } + if ((process.env.NODE_ENV !== 'production') && context.components[name]) { + warn(`Component "${name}" has already been registered in target app.`); + } + context.components[name] = component; + return app; + }, + directive(name, directive) { + if ((process.env.NODE_ENV !== 'production')) { + validateDirectiveName(name); + } + if (!directive) { + return context.directives[name]; + } + if ((process.env.NODE_ENV !== 'production') && context.directives[name]) { + warn(`Directive "${name}" has already been registered in target app.`); + } + context.directives[name] = directive; + return app; + }, + // fixed by xxxxxx + mount() { }, + // fixed by xxxxxx + unmount() { }, + provide(key, value) { + if ((process.env.NODE_ENV !== 'production') && key in context.provides) { + warn(`App already provides property with key "${String(key)}". ` + + `It will be overwritten with the new value.`); + } + // TypeScript doesn't allow symbols as index type + // https://github.com/Microsoft/TypeScript/issues/24587 + context.provides[key] = value; + return app; + } + }); + return app; + }; } -const queuePostRenderEffect = queuePostFlushCb +const queuePostRenderEffect = queuePostFlushCb; -// Simple effect. -function watchEffect(effect, options) { - return doWatch(effect, null, options) -} -// initial value for watchers to trigger on undefined initial values -const INITIAL_WATCHER_VALUE = {} -// implementation -function watch(source, cb, options) { - if (process.env.NODE_ENV !== 'production' && !isFunction(cb)) { - warn( - `\`watch(fn, options?)\` signature has been moved to a separate API. ` + - `Use \`watchEffect(fn, options?)\` instead. \`watch\` now only ` + - `supports \`watch(source, cb, options?) signature.` - ) - } - return doWatch(source, cb, options) -} -function doWatch( - source, - cb, - { immediate, deep, flush, onTrack, onTrigger } = EMPTY_OBJ, - instance = currentInstance -) { - if (process.env.NODE_ENV !== 'production' && !cb) { - if (immediate !== undefined) { - warn( - `watch() "immediate" option is only respected when using the ` + - `watch(source, callback, options?) signature.` - ) - } - if (deep !== undefined) { - warn( - `watch() "deep" option is only respected when using the ` + - `watch(source, callback, options?) signature.` - ) - } - } - const warnInvalidSource = s => { - warn( - `Invalid watch source: `, - s, - `A watch source can only be a getter/effect function, a ref, ` + - `a reactive object, or an array of these types.` - ) - } - let getter - const isRefSource = isRef(source) - if (isRefSource) { - getter = () => source.value - } else if (isReactive(source)) { - getter = () => source - deep = true - } else if (isArray(source)) { - getter = () => - source.map(s => { - if (isRef(s)) { - return s.value - } else if (isReactive(s)) { - return traverse(s) - } else if (isFunction(s)) { - return callWithErrorHandling(s, instance, 2 /* WATCH_GETTER */) - } else { - process.env.NODE_ENV !== 'production' && warnInvalidSource(s) - } - }) - } else if (isFunction(source)) { - if (cb) { - // getter with cb - getter = () => - callWithErrorHandling(source, instance, 2 /* WATCH_GETTER */) - } else { - // no cb -> simple effect - getter = () => { - if (instance && instance.isUnmounted) { - return - } - if (cleanup) { - cleanup() - } - return callWithErrorHandling(source, instance, 3 /* WATCH_CALLBACK */, [ - onInvalidate - ]) - } - } - } else { - getter = NOOP - process.env.NODE_ENV !== 'production' && warnInvalidSource(source) - } - if (cb && deep) { - const baseGetter = getter - getter = () => traverse(baseGetter()) - } - let cleanup - const onInvalidate = fn => { - cleanup = runner.options.onStop = () => { - callWithErrorHandling(fn, instance, 4 /* WATCH_CLEANUP */) - } - } - let oldValue = isArray(source) ? [] : INITIAL_WATCHER_VALUE - const job = () => { - if (!runner.active) { - return - } - if (cb) { - // watch(source, cb) - const newValue = runner() - if (deep || isRefSource || hasChanged(newValue, oldValue)) { - // cleanup before running cb again - if (cleanup) { - cleanup() - } - callWithAsyncErrorHandling(cb, instance, 3 /* WATCH_CALLBACK */, [ - newValue, - // pass undefined as the old value when it's changed for the first time - oldValue === INITIAL_WATCHER_VALUE ? undefined : oldValue, - onInvalidate - ]) - oldValue = newValue - } - } else { - // watchEffect - runner() - } - } - // important: mark the job as a watcher callback so that scheduler knows it - // it is allowed to self-trigger (#1727) - job.allowRecurse = !!cb - let scheduler - if (flush === 'sync') { - scheduler = job - } else if (flush === 'pre') { - // ensure it's queued before component updates (which have positive ids) - job.id = -1 - scheduler = () => { - if (!instance || instance.isMounted) { - queuePreFlushCb(job) - } else { - // with 'pre' option, the first call must happen before - // the component is mounted so it is called synchronously. - job() - } - } - } else { - scheduler = () => queuePostRenderEffect(job, instance && instance.suspense) - } - const runner = effect(getter, { - lazy: true, - onTrack, - onTrigger, - scheduler - }) - recordInstanceBoundEffect(runner) - // initial run - if (cb) { - if (immediate) { - job() - } else { - oldValue = runner() - } - } else { - runner() - } - return () => { - stop(runner) - if (instance) { - remove(instance.effects, runner) - } - } -} -// this.$watch -function instanceWatch(source, cb, options) { - const publicThis = this.proxy - const getter = isString(source) - ? () => publicThis[source] - : source.bind(publicThis) - return doWatch(getter, cb.bind(publicThis), options, this) -} -function traverse(value, seen = new Set()) { - if (!isObject(value) || seen.has(value)) { - return value - } - seen.add(value) - if (isRef(value)) { - traverse(value.value, seen) - } else if (isArray(value)) { - for (let i = 0; i < value.length; i++) { - traverse(value[i], seen) - } - } else if (value instanceof Map) { - value.forEach((v, key) => { - // to register mutation dep for existing keys - traverse(value.get(key), seen) - }) - } else if (value instanceof Set) { - value.forEach(v => { - traverse(v, seen) - }) - } else { - for (const key in value) { - traverse(value[key], seen) - } - } - return value +// Simple effect. +function watchEffect(effect, options) { + return doWatch(effect, null, options); +} +// initial value for watchers to trigger on undefined initial values +const INITIAL_WATCHER_VALUE = {}; +// implementation +function watch(source, cb, options) { + if ((process.env.NODE_ENV !== 'production') && !isFunction(cb)) { + warn(`\`watch(fn, options?)\` signature has been moved to a separate API. ` + + `Use \`watchEffect(fn, options?)\` instead. \`watch\` now only ` + + `supports \`watch(source, cb, options?) signature.`); + } + return doWatch(source, cb, options); +} +function doWatch(source, cb, { immediate, deep, flush, onTrack, onTrigger } = EMPTY_OBJ, instance = currentInstance) { + if ((process.env.NODE_ENV !== 'production') && !cb) { + if (immediate !== undefined) { + warn(`watch() "immediate" option is only respected when using the ` + + `watch(source, callback, options?) signature.`); + } + if (deep !== undefined) { + warn(`watch() "deep" option is only respected when using the ` + + `watch(source, callback, options?) signature.`); + } + } + const warnInvalidSource = (s) => { + warn(`Invalid watch source: `, s, `A watch source can only be a getter/effect function, a ref, ` + + `a reactive object, or an array of these types.`); + }; + let getter; + const isRefSource = isRef(source); + if (isRefSource) { + getter = () => source.value; + } + else if (isReactive(source)) { + getter = () => source; + deep = true; + } + else if (isArray(source)) { + getter = () => source.map(s => { + if (isRef(s)) { + return s.value; + } + else if (isReactive(s)) { + return traverse(s); + } + else if (isFunction(s)) { + return callWithErrorHandling(s, instance, 2 /* WATCH_GETTER */); + } + else { + (process.env.NODE_ENV !== 'production') && warnInvalidSource(s); + } + }); + } + else if (isFunction(source)) { + if (cb) { + // getter with cb + getter = () => callWithErrorHandling(source, instance, 2 /* WATCH_GETTER */); + } + else { + // no cb -> simple effect + getter = () => { + if (instance && instance.isUnmounted) { + return; + } + if (cleanup) { + cleanup(); + } + return callWithErrorHandling(source, instance, 3 /* WATCH_CALLBACK */, [onInvalidate]); + }; + } + } + else { + getter = NOOP; + (process.env.NODE_ENV !== 'production') && warnInvalidSource(source); + } + if (cb && deep) { + const baseGetter = getter; + getter = () => traverse(baseGetter()); + } + let cleanup; + const onInvalidate = (fn) => { + cleanup = runner.options.onStop = () => { + callWithErrorHandling(fn, instance, 4 /* WATCH_CLEANUP */); + }; + }; + let oldValue = isArray(source) ? [] : INITIAL_WATCHER_VALUE; + const job = () => { + if (!runner.active) { + return; + } + if (cb) { + // watch(source, cb) + const newValue = runner(); + if (deep || isRefSource || hasChanged(newValue, oldValue)) { + // cleanup before running cb again + if (cleanup) { + cleanup(); + } + callWithAsyncErrorHandling(cb, instance, 3 /* WATCH_CALLBACK */, [ + newValue, + // pass undefined as the old value when it's changed for the first time + oldValue === INITIAL_WATCHER_VALUE ? undefined : oldValue, + onInvalidate + ]); + oldValue = newValue; + } + } + else { + // watchEffect + runner(); + } + }; + // important: mark the job as a watcher callback so that scheduler knows it + // it is allowed to self-trigger (#1727) + job.allowRecurse = !!cb; + let scheduler; + if (flush === 'sync') { + scheduler = job; + } + else if (flush === 'pre') { + // ensure it's queued before component updates (which have positive ids) + job.id = -1; + scheduler = () => { + if (!instance || instance.isMounted) { + queuePreFlushCb(job); + } + else { + // with 'pre' option, the first call must happen before + // the component is mounted so it is called synchronously. + job(); + } + }; + } + else { + scheduler = () => queuePostRenderEffect(job, instance && instance.suspense); + } + const runner = effect(getter, { + lazy: true, + onTrack, + onTrigger, + scheduler + }); + recordInstanceBoundEffect(runner); + // initial run + if (cb) { + if (immediate) { + job(); + } + else { + oldValue = runner(); + } + } + else { + runner(); + } + return () => { + stop(runner); + if (instance) { + remove(instance.effects, runner); + } + }; +} +// this.$watch +function instanceWatch(source, cb, options) { + const publicThis = this.proxy; + const getter = isString(source) + ? () => publicThis[source] + : source.bind(publicThis); + return doWatch(getter, cb.bind(publicThis), options, this); +} +function traverse(value, seen = new Set()) { + if (!isObject(value) || seen.has(value)) { + return value; + } + seen.add(value); + if (isRef(value)) { + traverse(value.value, seen); + } + else if (isArray(value)) { + for (let i = 0; i < value.length; i++) { + traverse(value[i], seen); + } + } + else if (value instanceof Map) { + value.forEach((v, key) => { + // to register mutation dep for existing keys + traverse(value.get(key), seen); + }); + } + else if (value instanceof Set) { + value.forEach(v => { + traverse(v, seen); + }); + } + else { + for (const key in value) { + traverse(value[key], seen); + } + } + return value; } -function provide(key, value) { - if (!currentInstance) { - if (process.env.NODE_ENV !== 'production') { - warn(`provide() can only be used inside setup().`) - } - } else { - let provides = currentInstance.provides - // by default an instance inherits its parent's provides object - // but when it needs to provide values of its own, it creates its - // own provides object using parent provides object as prototype. - // this way in `inject` we can simply look up injections from direct - // parent and let the prototype chain do the work. - const parentProvides = - currentInstance.parent && currentInstance.parent.provides - if (parentProvides === provides) { - provides = currentInstance.provides = Object.create(parentProvides) - } - // TS doesn't allow symbol as index type - provides[key] = value - } -} -function inject(key, defaultValue) { - // fallback to `currentRenderingInstance` so that this can be called in - // a functional component - const instance = currentInstance || currentRenderingInstance - if (instance) { - const provides = instance.provides - if (key in provides) { - // TS doesn't allow symbol as index type - return provides[key] - } else if (arguments.length > 1) { - return defaultValue - } else if (process.env.NODE_ENV !== 'production') { - warn(`injection "${String(key)}" not found.`) - } - } else if (process.env.NODE_ENV !== 'production') { - warn(`inject() can only be used inside setup() or functional components.`) - } +function provide(key, value) { + if (!currentInstance) { + if ((process.env.NODE_ENV !== 'production')) { + warn(`provide() can only be used inside setup().`); + } + } + else { + let provides = currentInstance.provides; + // by default an instance inherits its parent's provides object + // but when it needs to provide values of its own, it creates its + // own provides object using parent provides object as prototype. + // this way in `inject` we can simply look up injections from direct + // parent and let the prototype chain do the work. + const parentProvides = currentInstance.parent && currentInstance.parent.provides; + if (parentProvides === provides) { + provides = currentInstance.provides = Object.create(parentProvides); + } + // TS doesn't allow symbol as index type + provides[key] = value; + } +} +function inject(key, defaultValue) { + // fallback to `currentRenderingInstance` so that this can be called in + // a functional component + const instance = currentInstance || currentRenderingInstance; + if (instance) { + const provides = instance.provides; + if (key in provides) { + // TS doesn't allow symbol as index type + return provides[key]; + } + else if (arguments.length > 1) { + return defaultValue; + } + else if ((process.env.NODE_ENV !== 'production')) { + warn(`injection "${String(key)}" not found.`); + } + } + else if ((process.env.NODE_ENV !== 'production')) { + warn(`inject() can only be used inside setup() or functional components.`); + } } -function createDuplicateChecker() { - const cache = Object.create(null) - return (type, key) => { - if (cache[key]) { - warn(`${type} property "${key}" is already defined in ${cache[key]}.`) - } else { - cache[key] = type - } - } -} -let isInBeforeCreate = false -function applyOptions( - instance, - options, - deferredData = [], - deferredWatch = [], - asMixin = false -) { - const { - // composition - mixins, - extends: extendsOptions, - // state - data: dataOptions, - computed: computedOptions, - methods, - watch: watchOptions, - provide: provideOptions, - inject: injectOptions, - // assets - components, - directives, - // lifecycle - beforeMount, - mounted, - beforeUpdate, - updated, - activated, - deactivated, - beforeUnmount, - unmounted, - render, - renderTracked, - renderTriggered, - errorCaptured - } = options - const publicThis = instance.proxy - const ctx = instance.ctx - const globalMixins = instance.appContext.mixins - if (asMixin && render && instance.render === NOOP) { - instance.render = render - } - // applyOptions is called non-as-mixin once per instance - if (!asMixin) { - isInBeforeCreate = true - callSyncHook('beforeCreate', options, publicThis, globalMixins) - isInBeforeCreate = false - // global mixins are applied first - applyMixins(instance, globalMixins, deferredData, deferredWatch) - } - // extending a base component... - if (extendsOptions) { - applyOptions(instance, extendsOptions, deferredData, deferredWatch, true) - } - // local mixins - if (mixins) { - applyMixins(instance, mixins, deferredData, deferredWatch) - } - const checkDuplicateProperties = - process.env.NODE_ENV !== 'production' ? createDuplicateChecker() : null - if (process.env.NODE_ENV !== 'production') { - const [propsOptions] = instance.propsOptions - if (propsOptions) { - for (const key in propsOptions) { - checkDuplicateProperties('Props' /* PROPS */, key) - } - } - } - // options initialization order (to be consistent with Vue 2): - // - props (already done outside of this function) - // - inject - // - methods - // - data (deferred since it relies on `this` access) - // - computed - // - watch (deferred since it relies on `this` access) - // fixed by xxxxxx - if (!__VUE_CREATED_DEFERRED__ && injectOptions) { - if (isArray(injectOptions)) { - for (let i = 0; i < injectOptions.length; i++) { - const key = injectOptions[i] - ctx[key] = inject(key) - if (process.env.NODE_ENV !== 'production') { - checkDuplicateProperties('Inject' /* INJECT */, key) - } - } - } else { - for (const key in injectOptions) { - const opt = injectOptions[key] - if (isObject(opt)) { - ctx[key] = inject(opt.from, opt.default) - } else { - ctx[key] = inject(opt) - } - if (process.env.NODE_ENV !== 'production') { - checkDuplicateProperties('Inject' /* INJECT */, key) - } - } - } - } - if (methods) { - for (const key in methods) { - const methodHandler = methods[key] - if (isFunction(methodHandler)) { - ctx[key] = methodHandler.bind(publicThis) - if (process.env.NODE_ENV !== 'production') { - checkDuplicateProperties('Methods' /* METHODS */, key) - } - } else if (process.env.NODE_ENV !== 'production') { - warn( - `Method "${key}" has type "${typeof methodHandler}" in the component definition. ` + - `Did you reference the function correctly?` - ) - } - } - } - if (!asMixin) { - if (deferredData.length) { - deferredData.forEach(dataFn => resolveData(instance, dataFn, publicThis)) - } - if (dataOptions) { - resolveData(instance, dataOptions, publicThis) - } - if (process.env.NODE_ENV !== 'production') { - const rawData = toRaw(instance.data) - for (const key in rawData) { - checkDuplicateProperties('Data' /* DATA */, key) - // expose data on ctx during dev - if (key[0] !== '$' && key[0] !== '_') { - Object.defineProperty(ctx, key, { - configurable: true, - enumerable: true, - get: () => rawData[key], - set: NOOP - }) - } - } - } - } else if (dataOptions) { - deferredData.push(dataOptions) - } - if (computedOptions) { - for (const key in computedOptions) { - const opt = computedOptions[key] - const get = isFunction(opt) - ? opt.bind(publicThis, publicThis) - : isFunction(opt.get) - ? opt.get.bind(publicThis, publicThis) - : NOOP - if (process.env.NODE_ENV !== 'production' && get === NOOP) { - warn(`Computed property "${key}" has no getter.`) - } - const set = - !isFunction(opt) && isFunction(opt.set) - ? opt.set.bind(publicThis) - : process.env.NODE_ENV !== 'production' - ? () => { - warn( - `Write operation failed: computed property "${key}" is readonly.` - ) - } - : NOOP - const c = computed$1({ - get, - set - }) - Object.defineProperty(ctx, key, { - enumerable: true, - configurable: true, - get: () => c.value, - set: v => (c.value = v) - }) - if (process.env.NODE_ENV !== 'production') { - checkDuplicateProperties('Computed' /* COMPUTED */, key) - } - } - } - if (watchOptions) { - deferredWatch.push(watchOptions) - } - if (!asMixin && deferredWatch.length) { - deferredWatch.forEach(watchOptions => { - for (const key in watchOptions) { - createWatcher(watchOptions[key], ctx, publicThis, key) - } - }) - } - // fixed by xxxxxx - if (!__VUE_CREATED_DEFERRED__ && provideOptions) { - const provides = isFunction(provideOptions) - ? provideOptions.call(publicThis) - : provideOptions - for (const key in provides) { - provide(key, provides[key]) - } - } - // asset options. - // To reduce memory usage, only components with mixins or extends will have - // resolved asset registry attached to instance. - if (asMixin) { - if (components) { - extend( - instance.components || - (instance.components = extend({}, instance.type.components)), - components - ) - } - if (directives) { - extend( - instance.directives || - (instance.directives = extend({}, instance.type.directives)), - directives - ) - } - } - // fixed by xxxxxx - // lifecycle options - if (__VUE_CREATED_DEFERRED__) { - ctx.$callSyncHook = function(name) { - return callSyncHook(name, options, publicThis, globalMixins) - } - } else if (!asMixin) { - callSyncHook('created', options, publicThis, globalMixins) - } - if (beforeMount) { - onBeforeMount(beforeMount.bind(publicThis)) - } - if (mounted) { - onMounted(mounted.bind(publicThis)) - } - if (beforeUpdate) { - onBeforeUpdate(beforeUpdate.bind(publicThis)) - } - if (updated) { - onUpdated(updated.bind(publicThis)) - } - if (activated) { - onActivated(activated.bind(publicThis)) - } - if (deactivated) { - onDeactivated(deactivated.bind(publicThis)) - } - if (errorCaptured) { - onErrorCaptured(errorCaptured.bind(publicThis)) - } - if (renderTracked) { - onRenderTracked(renderTracked.bind(publicThis)) - } - if (renderTriggered) { - onRenderTriggered(renderTriggered.bind(publicThis)) - } - if (beforeUnmount) { - onBeforeUnmount(beforeUnmount.bind(publicThis)) - } - if (unmounted) { - onUnmounted(unmounted.bind(publicThis)) - } - // fixed by xxxxxx - if (instance.ctx.$onApplyOptions) { - instance.ctx.$onApplyOptions(options, instance, publicThis) - } -} -function callSyncHook(name, options, ctx, globalMixins) { - callHookFromMixins(name, globalMixins, ctx) - const { extends: base, mixins } = options - if (base) { - callHookFromExtends(name, base, ctx) - } - if (mixins) { - callHookFromMixins(name, mixins, ctx) - } - const selfHook = options[name] - if (selfHook) { - selfHook.call(ctx) - } -} -function callHookFromExtends(name, base, ctx) { - if (base.extends) { - callHookFromExtends(name, base.extends, ctx) - } - const baseHook = base[name] - if (baseHook) { - baseHook.call(ctx) - } -} -function callHookFromMixins(name, mixins, ctx) { - for (let i = 0; i < mixins.length; i++) { - const chainedMixins = mixins[i].mixins - if (chainedMixins) { - callHookFromMixins(name, chainedMixins, ctx) - } - const fn = mixins[i][name] - if (fn) { - fn.call(ctx) - } - } -} -function applyMixins(instance, mixins, deferredData, deferredWatch) { - for (let i = 0; i < mixins.length; i++) { - applyOptions(instance, mixins[i], deferredData, deferredWatch, true) - } -} -function resolveData(instance, dataFn, publicThis) { - if (process.env.NODE_ENV !== 'production' && !isFunction(dataFn)) { - warn( - `The data option must be a function. ` + - `Plain object usage is no longer supported.` - ) - } - const data = dataFn.call(publicThis, publicThis) - if (process.env.NODE_ENV !== 'production' && isPromise(data)) { - warn( - `data() returned a Promise - note data() cannot be async; If you ` + - `intend to perform data fetching before component renders, use ` + - `async setup() + .` - ) - } - if (!isObject(data)) { - process.env.NODE_ENV !== 'production' && - warn(`data() should return an object.`) - } else if (instance.data === EMPTY_OBJ) { - instance.data = reactive(data) - } else { - // existing data: this is a mixin or extends. - extend(instance.data, data) - } -} -function createWatcher(raw, ctx, publicThis, key) { - const getter = () => publicThis[key] - if (isString(raw)) { - const handler = ctx[raw] - if (isFunction(handler)) { - watch(getter, handler) - } else if (process.env.NODE_ENV !== 'production') { - warn(`Invalid watch handler specified by key "${raw}"`, handler) - } - } else if (isFunction(raw)) { - watch(getter, raw.bind(publicThis)) - } else if (isObject(raw)) { - if (isArray(raw)) { - raw.forEach(r => createWatcher(r, ctx, publicThis, key)) - } else { - const handler = isFunction(raw.handler) - ? raw.handler.bind(publicThis) - : ctx[raw.handler] - if (isFunction(handler)) { - watch(getter, handler, raw) - } else if (process.env.NODE_ENV !== 'production') { - warn(`Invalid watch handler specified by key "${raw.handler}"`, handler) - } - } - } else if (process.env.NODE_ENV !== 'production') { - warn(`Invalid watch option: "${key}"`) - } -} -function resolveMergedOptions(instance) { - const raw = instance.type - const { __merged, mixins, extends: extendsOptions } = raw - if (__merged) return __merged - const globalMixins = instance.appContext.mixins - if (!globalMixins.length && !mixins && !extendsOptions) return raw - const options = {} - globalMixins.forEach(m => mergeOptions(options, m, instance)) - mergeOptions(options, raw, instance) - return (raw.__merged = options) -} -function mergeOptions(to, from, instance) { - const strats = instance.appContext.config.optionMergeStrategies - const { mixins, extends: extendsOptions } = from - extendsOptions && mergeOptions(to, extendsOptions, instance) - mixins && mixins.forEach(m => mergeOptions(to, m, instance)) - for (const key in from) { - if (strats && hasOwn(strats, key)) { - to[key] = strats[key](to[key], from[key], instance.proxy, key) - } else { - to[key] = from[key] - } - } +function createDuplicateChecker() { + const cache = Object.create(null); + return (type, key) => { + if (cache[key]) { + warn(`${type} property "${key}" is already defined in ${cache[key]}.`); + } + else { + cache[key] = type; + } + }; +} +let isInBeforeCreate = false; +function applyOptions(instance, options, deferredData = [], deferredWatch = [], asMixin = false) { + const { + // composition + mixins, extends: extendsOptions, + // state + data: dataOptions, computed: computedOptions, methods, watch: watchOptions, provide: provideOptions, inject: injectOptions, + // assets + components, directives, + // lifecycle + beforeMount, mounted, beforeUpdate, updated, activated, deactivated, beforeUnmount, unmounted, render, renderTracked, renderTriggered, errorCaptured } = options; + const publicThis = instance.proxy; + const ctx = instance.ctx; + const globalMixins = instance.appContext.mixins; + if (asMixin && render && instance.render === NOOP) { + instance.render = render; + } + // applyOptions is called non-as-mixin once per instance + if (!asMixin) { + isInBeforeCreate = true; + callSyncHook('beforeCreate', options, publicThis, globalMixins); + isInBeforeCreate = false; + // global mixins are applied first + applyMixins(instance, globalMixins, deferredData, deferredWatch); + } + // extending a base component... + if (extendsOptions) { + applyOptions(instance, extendsOptions, deferredData, deferredWatch, true); + } + // local mixins + if (mixins) { + applyMixins(instance, mixins, deferredData, deferredWatch); + } + const checkDuplicateProperties = (process.env.NODE_ENV !== 'production') ? createDuplicateChecker() : null; + if ((process.env.NODE_ENV !== 'production')) { + const [propsOptions] = instance.propsOptions; + if (propsOptions) { + for (const key in propsOptions) { + checkDuplicateProperties("Props" /* PROPS */, key); + } + } + } + // options initialization order (to be consistent with Vue 2): + // - props (already done outside of this function) + // - inject + // - methods + // - data (deferred since it relies on `this` access) + // - computed + // - watch (deferred since it relies on `this` access) + // fixed by xxxxxx + if (!__VUE_CREATED_DEFERRED__ && injectOptions) { + if (isArray(injectOptions)) { + for (let i = 0; i < injectOptions.length; i++) { + const key = injectOptions[i]; + ctx[key] = inject(key); + if ((process.env.NODE_ENV !== 'production')) { + checkDuplicateProperties("Inject" /* INJECT */, key); + } + } + } + else { + for (const key in injectOptions) { + const opt = injectOptions[key]; + if (isObject(opt)) { + ctx[key] = inject(opt.from, opt.default); + } + else { + ctx[key] = inject(opt); + } + if ((process.env.NODE_ENV !== 'production')) { + checkDuplicateProperties("Inject" /* INJECT */, key); + } + } + } + } + if (methods) { + for (const key in methods) { + const methodHandler = methods[key]; + if (isFunction(methodHandler)) { + ctx[key] = methodHandler.bind(publicThis); + if ((process.env.NODE_ENV !== 'production')) { + checkDuplicateProperties("Methods" /* METHODS */, key); + } + } + else if ((process.env.NODE_ENV !== 'production')) { + warn(`Method "${key}" has type "${typeof methodHandler}" in the component definition. ` + + `Did you reference the function correctly?`); + } + } + } + if (!asMixin) { + if (deferredData.length) { + deferredData.forEach(dataFn => resolveData(instance, dataFn, publicThis)); + } + if (dataOptions) { + resolveData(instance, dataOptions, publicThis); + } + if ((process.env.NODE_ENV !== 'production')) { + const rawData = toRaw(instance.data); + for (const key in rawData) { + checkDuplicateProperties("Data" /* DATA */, key); + // expose data on ctx during dev + if (key[0] !== '$' && key[0] !== '_') { + Object.defineProperty(ctx, key, { + configurable: true, + enumerable: true, + get: () => rawData[key], + set: NOOP + }); + } + } + } + } + else if (dataOptions) { + deferredData.push(dataOptions); + } + if (computedOptions) { + for (const key in computedOptions) { + const opt = computedOptions[key]; + const get = isFunction(opt) + ? opt.bind(publicThis, publicThis) + : isFunction(opt.get) + ? opt.get.bind(publicThis, publicThis) + : NOOP; + if ((process.env.NODE_ENV !== 'production') && get === NOOP) { + warn(`Computed property "${key}" has no getter.`); + } + const set = !isFunction(opt) && isFunction(opt.set) + ? opt.set.bind(publicThis) + : (process.env.NODE_ENV !== 'production') + ? () => { + warn(`Write operation failed: computed property "${key}" is readonly.`); + } + : NOOP; + const c = computed$1({ + get, + set + }); + Object.defineProperty(ctx, key, { + enumerable: true, + configurable: true, + get: () => c.value, + set: v => (c.value = v) + }); + if ((process.env.NODE_ENV !== 'production')) { + checkDuplicateProperties("Computed" /* COMPUTED */, key); + } + } + } + if (watchOptions) { + deferredWatch.push(watchOptions); + } + if (!asMixin && deferredWatch.length) { + deferredWatch.forEach(watchOptions => { + for (const key in watchOptions) { + createWatcher(watchOptions[key], ctx, publicThis, key); + } + }); + } + // fixed by xxxxxx + if (!__VUE_CREATED_DEFERRED__ && provideOptions) { + const provides = isFunction(provideOptions) + ? provideOptions.call(publicThis) + : provideOptions; + for (const key in provides) { + provide(key, provides[key]); + } + } + // asset options. + // To reduce memory usage, only components with mixins or extends will have + // resolved asset registry attached to instance. + if (asMixin) { + if (components) { + extend(instance.components || + (instance.components = extend({}, instance.type.components)), components); + } + if (directives) { + extend(instance.directives || + (instance.directives = extend({}, instance.type.directives)), directives); + } + } + // fixed by xxxxxx + // lifecycle options + if (__VUE_CREATED_DEFERRED__) { + ctx.$callSyncHook = function (name) { + return callSyncHook(name, options, publicThis, globalMixins); + }; + } + else if (!asMixin) { + callSyncHook('created', options, publicThis, globalMixins); + } + if (beforeMount) { + onBeforeMount(beforeMount.bind(publicThis)); + } + if (mounted) { + onMounted(mounted.bind(publicThis)); + } + if (beforeUpdate) { + onBeforeUpdate(beforeUpdate.bind(publicThis)); + } + if (updated) { + onUpdated(updated.bind(publicThis)); + } + if (activated) { + onActivated(activated.bind(publicThis)); + } + if (deactivated) { + onDeactivated(deactivated.bind(publicThis)); + } + if (errorCaptured) { + onErrorCaptured(errorCaptured.bind(publicThis)); + } + if (renderTracked) { + onRenderTracked(renderTracked.bind(publicThis)); + } + if (renderTriggered) { + onRenderTriggered(renderTriggered.bind(publicThis)); + } + if (beforeUnmount) { + onBeforeUnmount(beforeUnmount.bind(publicThis)); + } + if (unmounted) { + onUnmounted(unmounted.bind(publicThis)); + } + // fixed by xxxxxx + if (instance.ctx.$onApplyOptions) { + instance.ctx.$onApplyOptions(options, instance, publicThis); + } +} +function callSyncHook(name, options, ctx, globalMixins) { + callHookFromMixins(name, globalMixins, ctx); + const { extends: base, mixins } = options; + if (base) { + callHookFromExtends(name, base, ctx); + } + if (mixins) { + callHookFromMixins(name, mixins, ctx); + } + const selfHook = options[name]; + if (selfHook) { + selfHook.call(ctx); + } +} +function callHookFromExtends(name, base, ctx) { + if (base.extends) { + callHookFromExtends(name, base.extends, ctx); + } + const baseHook = base[name]; + if (baseHook) { + baseHook.call(ctx); + } +} +function callHookFromMixins(name, mixins, ctx) { + for (let i = 0; i < mixins.length; i++) { + const chainedMixins = mixins[i].mixins; + if (chainedMixins) { + callHookFromMixins(name, chainedMixins, ctx); + } + const fn = mixins[i][name]; + if (fn) { + fn.call(ctx); + } + } +} +function applyMixins(instance, mixins, deferredData, deferredWatch) { + for (let i = 0; i < mixins.length; i++) { + applyOptions(instance, mixins[i], deferredData, deferredWatch, true); + } +} +function resolveData(instance, dataFn, publicThis) { + if ((process.env.NODE_ENV !== 'production') && !isFunction(dataFn)) { + warn(`The data option must be a function. ` + + `Plain object usage is no longer supported.`); + } + const data = dataFn.call(publicThis, publicThis); + if ((process.env.NODE_ENV !== 'production') && isPromise(data)) { + warn(`data() returned a Promise - note data() cannot be async; If you ` + + `intend to perform data fetching before component renders, use ` + + `async setup() + .`); + } + if (!isObject(data)) { + (process.env.NODE_ENV !== 'production') && warn(`data() should return an object.`); + } + else if (instance.data === EMPTY_OBJ) { + instance.data = reactive(data); + } + else { + // existing data: this is a mixin or extends. + extend(instance.data, data); + } +} +function createWatcher(raw, ctx, publicThis, key) { + const getter = () => publicThis[key]; + if (isString(raw)) { + const handler = ctx[raw]; + if (isFunction(handler)) { + watch(getter, handler); + } + else if ((process.env.NODE_ENV !== 'production')) { + warn(`Invalid watch handler specified by key "${raw}"`, handler); + } + } + else if (isFunction(raw)) { + watch(getter, raw.bind(publicThis)); + } + else if (isObject(raw)) { + if (isArray(raw)) { + raw.forEach(r => createWatcher(r, ctx, publicThis, key)); + } + else { + const handler = isFunction(raw.handler) + ? raw.handler.bind(publicThis) + : ctx[raw.handler]; + if (isFunction(handler)) { + watch(getter, handler, raw); + } + else if ((process.env.NODE_ENV !== 'production')) { + warn(`Invalid watch handler specified by key "${raw.handler}"`, handler); + } + } + } + else if ((process.env.NODE_ENV !== 'production')) { + warn(`Invalid watch option: "${key}"`); + } +} +function resolveMergedOptions(instance) { + const raw = instance.type; + const { __merged, mixins, extends: extendsOptions } = raw; + if (__merged) + return __merged; + const globalMixins = instance.appContext.mixins; + if (!globalMixins.length && !mixins && !extendsOptions) + return raw; + const options = {}; + globalMixins.forEach(m => mergeOptions(options, m, instance)); + mergeOptions(options, raw, instance); + return (raw.__merged = options); +} +function mergeOptions(to, from, instance) { + const strats = instance.appContext.config.optionMergeStrategies; + const { mixins, extends: extendsOptions } = from; + extendsOptions && mergeOptions(to, extendsOptions, instance); + mixins && + mixins.forEach((m) => mergeOptions(to, m, instance)); + for (const key in from) { + if (strats && hasOwn(strats, key)) { + to[key] = strats[key](to[key], from[key], instance.proxy, key); + } + else { + to[key] = from[key]; + } + } } -const publicPropertiesMap = extend(Object.create(null), { - $: i => i, - $el: i => i.vnode.el, - $data: i => i.data, - $props: i => - process.env.NODE_ENV !== 'production' ? shallowReadonly(i.props) : i.props, - $attrs: i => - process.env.NODE_ENV !== 'production' ? shallowReadonly(i.attrs) : i.attrs, - $slots: i => - process.env.NODE_ENV !== 'production' ? shallowReadonly(i.slots) : i.slots, - $refs: i => - process.env.NODE_ENV !== 'production' ? shallowReadonly(i.refs) : i.refs, - $parent: i => i.parent && i.parent.proxy, - $root: i => i.root && i.root.proxy, - $emit: i => i.emit, - $options: i => (__VUE_OPTIONS_API__ ? resolveMergedOptions(i) : i.type), - $forceUpdate: i => () => queueJob(i.update), - // $nextTick: () => nextTick, // fixed by xxxxxx - $watch: i => (__VUE_OPTIONS_API__ ? instanceWatch.bind(i) : NOOP) -}) -const PublicInstanceProxyHandlers = { - get({ _: instance }, key) { - const { - ctx, - setupState, - data, - props, - accessCache, - type, - appContext - } = instance - // let @vue/reactivity know it should never observe Vue public instances. - if (key === '__v_skip' /* SKIP */) { - return true - } - // data / props / ctx - // This getter gets called for every property access on the render context - // during render and is a major hotspot. The most expensive part of this - // is the multiple hasOwn() calls. It's much faster to do a simple property - // access on a plain object, so we use an accessCache object (with null - // prototype) to memoize what access type a key corresponds to. - let normalizedProps - if (key[0] !== '$') { - const n = accessCache[key] - if (n !== undefined) { - switch (n) { - case 0 /* SETUP */: - return setupState[key] - case 1 /* DATA */: - return data[key] - case 3 /* CONTEXT */: - return ctx[key] - case 2 /* PROPS */: - return props[key] - // default: just fallthrough - } - } else if (setupState !== EMPTY_OBJ && hasOwn(setupState, key)) { - accessCache[key] = 0 /* SETUP */ - return setupState[key] - } else if (data !== EMPTY_OBJ && hasOwn(data, key)) { - accessCache[key] = 1 /* DATA */ - return data[key] - } else if ( - // only cache other properties when instance has declared (thus stable) - // props - (normalizedProps = instance.propsOptions[0]) && - hasOwn(normalizedProps, key) - ) { - accessCache[key] = 2 /* PROPS */ - return props[key] - } else if (ctx !== EMPTY_OBJ && hasOwn(ctx, key)) { - accessCache[key] = 3 /* CONTEXT */ - return ctx[key] - } else if (!__VUE_OPTIONS_API__ || !isInBeforeCreate) { - accessCache[key] = 4 /* OTHER */ - } - } - const publicGetter = publicPropertiesMap[key] - let cssModule, globalProperties - // public $xxx properties - if (publicGetter) { - if (key === '$attrs') { - track(instance, 'get' /* GET */, key) - process.env.NODE_ENV !== 'production' && markAttrsAccessed() - } - return publicGetter(instance) - } else if ( - // css module (injected by vue-loader) - (cssModule = type.__cssModules) && - (cssModule = cssModule[key]) - ) { - return cssModule - } else if (ctx !== EMPTY_OBJ && hasOwn(ctx, key)) { - // user may set custom properties to `this` that start with `$` - accessCache[key] = 3 /* CONTEXT */ - return ctx[key] - } else if ( - // global properties - ((globalProperties = appContext.config.globalProperties), - hasOwn(globalProperties, key)) - ) { - return globalProperties[key] - } else if ( - process.env.NODE_ENV !== 'production' && - currentRenderingInstance && - (!isString(key) || - // #1091 avoid internal isRef/isVNode checks on component instance leading - // to infinite warning loop - key.indexOf('__v') !== 0) - ) { - if ( - data !== EMPTY_OBJ && - (key[0] === '$' || key[0] === '_') && - hasOwn(data, key) - ) { - warn( - `Property ${JSON.stringify( - key - )} must be accessed via $data because it starts with a reserved ` + - `character ("$" or "_") and is not proxied on the render context.` - ) - } else { - warn( - `Property ${JSON.stringify(key)} was accessed during render ` + - `but is not defined on instance.` - ) - } - } - }, - set({ _: instance }, key, value) { - const { data, setupState, ctx } = instance - if (setupState !== EMPTY_OBJ && hasOwn(setupState, key)) { - setupState[key] = value - } else if (data !== EMPTY_OBJ && hasOwn(data, key)) { - data[key] = value - } else if (key in instance.props) { - process.env.NODE_ENV !== 'production' && - warn( - `Attempting to mutate prop "${key}". Props are readonly.`, - instance - ) - return false - } - if (key[0] === '$' && key.slice(1) in instance) { - process.env.NODE_ENV !== 'production' && - warn( - `Attempting to mutate public property "${key}". ` + - `Properties starting with $ are reserved and readonly.`, - instance - ) - return false - } else { - if ( - process.env.NODE_ENV !== 'production' && - key in instance.appContext.config.globalProperties - ) { - Object.defineProperty(ctx, key, { - enumerable: true, - configurable: true, - value - }) - } else { - ctx[key] = value - } - } - return true - }, - has( - { - _: { data, setupState, accessCache, ctx, appContext, propsOptions } - }, - key - ) { - let normalizedProps - return ( - accessCache[key] !== undefined || - (data !== EMPTY_OBJ && hasOwn(data, key)) || - (setupState !== EMPTY_OBJ && hasOwn(setupState, key)) || - ((normalizedProps = propsOptions[0]) && hasOwn(normalizedProps, key)) || - hasOwn(ctx, key) || - hasOwn(publicPropertiesMap, key) || - hasOwn(appContext.config.globalProperties, key) - ) - } -} -if (process.env.NODE_ENV !== 'production' && !false) { - PublicInstanceProxyHandlers.ownKeys = target => { - warn( - `Avoid app logic that relies on enumerating keys on a component instance. ` + - `The keys will be empty in production mode to avoid performance overhead.` - ) - return Reflect.ownKeys(target) - } -} -const RuntimeCompiledPublicInstanceProxyHandlers = extend( - {}, - PublicInstanceProxyHandlers, - { - get(target, key) { - // fast path for unscopables when using `with` block - if (key === Symbol.unscopables) { - return - } - return PublicInstanceProxyHandlers.get(target, key, target) - }, - has(_, key) { - const has = key[0] !== '_' && !isGloballyWhitelisted(key) - if ( - process.env.NODE_ENV !== 'production' && - !has && - PublicInstanceProxyHandlers.has(_, key) - ) { - warn( - `Property ${JSON.stringify( - key - )} should not start with _ which is a reserved prefix for Vue internals.` - ) - } - return has - } - } -) -// In dev mode, the proxy target exposes the same properties as seen on `this` -// for easier console inspection. In prod mode it will be an empty object so -// these properties definitions can be skipped. -function createRenderContext(instance) { - const target = {} - // expose internal instance for proxy handlers - Object.defineProperty(target, `_`, { - configurable: true, - enumerable: false, - get: () => instance - }) - // expose public properties - Object.keys(publicPropertiesMap).forEach(key => { - Object.defineProperty(target, key, { - configurable: true, - enumerable: false, - get: () => publicPropertiesMap[key](instance), - // intercepted by the proxy so no need for implementation, - // but needed to prevent set errors - set: NOOP - }) - }) - // expose global properties - const { globalProperties } = instance.appContext.config - Object.keys(globalProperties).forEach(key => { - Object.defineProperty(target, key, { - configurable: true, - enumerable: false, - get: () => globalProperties[key], - set: NOOP - }) - }) - return target -} -// dev only -function exposePropsOnRenderContext(instance) { - const { - ctx, - propsOptions: [propsOptions] - } = instance - if (propsOptions) { - Object.keys(propsOptions).forEach(key => { - Object.defineProperty(ctx, key, { - enumerable: true, - configurable: true, - get: () => instance.props[key], - set: NOOP - }) - }) - } -} -// dev only -function exposeSetupStateOnRenderContext(instance) { - const { ctx, setupState } = instance - Object.keys(toRaw(setupState)).forEach(key => { - if (key[0] === '$' || key[0] === '_') { - warn( - `setup() return property ${JSON.stringify( - key - )} should not start with "$" or "_" ` + - `which are reserved prefixes for Vue internals.` - ) - return - } - Object.defineProperty(ctx, key, { - enumerable: true, - configurable: true, - get: () => setupState[key], - set: NOOP - }) - }) +const publicPropertiesMap = extend(Object.create(null), { + $: i => i, + $el: i => i.vnode.el, + $data: i => i.data, + $props: i => ((process.env.NODE_ENV !== 'production') ? shallowReadonly(i.props) : i.props), + $attrs: i => ((process.env.NODE_ENV !== 'production') ? shallowReadonly(i.attrs) : i.attrs), + $slots: i => ((process.env.NODE_ENV !== 'production') ? shallowReadonly(i.slots) : i.slots), + $refs: i => ((process.env.NODE_ENV !== 'production') ? shallowReadonly(i.refs) : i.refs), + $parent: i => i.parent && i.parent.proxy, + $root: i => i.root && i.root.proxy, + $emit: i => i.emit, + $options: i => (__VUE_OPTIONS_API__ ? resolveMergedOptions(i) : i.type), + $forceUpdate: i => () => queueJob(i.update), + // $nextTick: () => nextTick, // fixed by xxxxxx + $watch: i => (__VUE_OPTIONS_API__ ? instanceWatch.bind(i) : NOOP) +}); +const PublicInstanceProxyHandlers = { + get({ _: instance }, key) { + const { ctx, setupState, data, props, accessCache, type, appContext } = instance; + // let @vue/reactivity know it should never observe Vue public instances. + if (key === "__v_skip" /* SKIP */) { + return true; + } + // data / props / ctx + // This getter gets called for every property access on the render context + // during render and is a major hotspot. The most expensive part of this + // is the multiple hasOwn() calls. It's much faster to do a simple property + // access on a plain object, so we use an accessCache object (with null + // prototype) to memoize what access type a key corresponds to. + let normalizedProps; + if (key[0] !== '$') { + const n = accessCache[key]; + if (n !== undefined) { + switch (n) { + case 0 /* SETUP */: + return setupState[key]; + case 1 /* DATA */: + return data[key]; + case 3 /* CONTEXT */: + return ctx[key]; + case 2 /* PROPS */: + return props[key]; + // default: just fallthrough + } + } + else if (setupState !== EMPTY_OBJ && hasOwn(setupState, key)) { + accessCache[key] = 0 /* SETUP */; + return setupState[key]; + } + else if (data !== EMPTY_OBJ && hasOwn(data, key)) { + accessCache[key] = 1 /* DATA */; + return data[key]; + } + else if ( + // only cache other properties when instance has declared (thus stable) + // props + (normalizedProps = instance.propsOptions[0]) && + hasOwn(normalizedProps, key)) { + accessCache[key] = 2 /* PROPS */; + return props[key]; + } + else if (ctx !== EMPTY_OBJ && hasOwn(ctx, key)) { + accessCache[key] = 3 /* CONTEXT */; + return ctx[key]; + } + else if (!__VUE_OPTIONS_API__ || !isInBeforeCreate) { + accessCache[key] = 4 /* OTHER */; + } + } + const publicGetter = publicPropertiesMap[key]; + let cssModule, globalProperties; + // public $xxx properties + if (publicGetter) { + if (key === '$attrs') { + track(instance, "get" /* GET */, key); + (process.env.NODE_ENV !== 'production') && markAttrsAccessed(); + } + return publicGetter(instance); + } + else if ( + // css module (injected by vue-loader) + (cssModule = type.__cssModules) && + (cssModule = cssModule[key])) { + return cssModule; + } + else if (ctx !== EMPTY_OBJ && hasOwn(ctx, key)) { + // user may set custom properties to `this` that start with `$` + accessCache[key] = 3 /* CONTEXT */; + return ctx[key]; + } + else if ( + // global properties + ((globalProperties = appContext.config.globalProperties), + hasOwn(globalProperties, key))) { + return globalProperties[key]; + } + else if ((process.env.NODE_ENV !== 'production') && + currentRenderingInstance && + (!isString(key) || + // #1091 avoid internal isRef/isVNode checks on component instance leading + // to infinite warning loop + key.indexOf('__v') !== 0)) { + if (data !== EMPTY_OBJ && + (key[0] === '$' || key[0] === '_') && + hasOwn(data, key)) { + warn(`Property ${JSON.stringify(key)} must be accessed via $data because it starts with a reserved ` + + `character ("$" or "_") and is not proxied on the render context.`); + } + else { + warn(`Property ${JSON.stringify(key)} was accessed during render ` + + `but is not defined on instance.`); + } + } + }, + set({ _: instance }, key, value) { + const { data, setupState, ctx } = instance; + if (setupState !== EMPTY_OBJ && hasOwn(setupState, key)) { + setupState[key] = value; + } + else if (data !== EMPTY_OBJ && hasOwn(data, key)) { + data[key] = value; + } + else if (key in instance.props) { + (process.env.NODE_ENV !== 'production') && + warn(`Attempting to mutate prop "${key}". Props are readonly.`, instance); + return false; + } + if (key[0] === '$' && key.slice(1) in instance) { + (process.env.NODE_ENV !== 'production') && + warn(`Attempting to mutate public property "${key}". ` + + `Properties starting with $ are reserved and readonly.`, instance); + return false; + } + else { + if ((process.env.NODE_ENV !== 'production') && key in instance.appContext.config.globalProperties) { + Object.defineProperty(ctx, key, { + enumerable: true, + configurable: true, + value + }); + } + else { + ctx[key] = value; + } + } + return true; + }, + has({ _: { data, setupState, accessCache, ctx, appContext, propsOptions } }, key) { + let normalizedProps; + return (accessCache[key] !== undefined || + (data !== EMPTY_OBJ && hasOwn(data, key)) || + (setupState !== EMPTY_OBJ && hasOwn(setupState, key)) || + ((normalizedProps = propsOptions[0]) && hasOwn(normalizedProps, key)) || + hasOwn(ctx, key) || + hasOwn(publicPropertiesMap, key) || + hasOwn(appContext.config.globalProperties, key)); + } +}; +if ((process.env.NODE_ENV !== 'production') && !false) { + PublicInstanceProxyHandlers.ownKeys = (target) => { + warn(`Avoid app logic that relies on enumerating keys on a component instance. ` + + `The keys will be empty in production mode to avoid performance overhead.`); + return Reflect.ownKeys(target); + }; +} +const RuntimeCompiledPublicInstanceProxyHandlers = extend({}, PublicInstanceProxyHandlers, { + get(target, key) { + // fast path for unscopables when using `with` block + if (key === Symbol.unscopables) { + return; + } + return PublicInstanceProxyHandlers.get(target, key, target); + }, + has(_, key) { + const has = key[0] !== '_' && !isGloballyWhitelisted(key); + if ((process.env.NODE_ENV !== 'production') && !has && PublicInstanceProxyHandlers.has(_, key)) { + warn(`Property ${JSON.stringify(key)} should not start with _ which is a reserved prefix for Vue internals.`); + } + return has; + } +}); +// In dev mode, the proxy target exposes the same properties as seen on `this` +// for easier console inspection. In prod mode it will be an empty object so +// these properties definitions can be skipped. +function createRenderContext(instance) { + const target = {}; + // expose internal instance for proxy handlers + Object.defineProperty(target, `_`, { + configurable: true, + enumerable: false, + get: () => instance + }); + // expose public properties + Object.keys(publicPropertiesMap).forEach(key => { + Object.defineProperty(target, key, { + configurable: true, + enumerable: false, + get: () => publicPropertiesMap[key](instance), + // intercepted by the proxy so no need for implementation, + // but needed to prevent set errors + set: NOOP + }); + }); + // expose global properties + const { globalProperties } = instance.appContext.config; + Object.keys(globalProperties).forEach(key => { + Object.defineProperty(target, key, { + configurable: true, + enumerable: false, + get: () => globalProperties[key], + set: NOOP + }); + }); + return target; +} +// dev only +function exposePropsOnRenderContext(instance) { + const { ctx, propsOptions: [propsOptions] } = instance; + if (propsOptions) { + Object.keys(propsOptions).forEach(key => { + Object.defineProperty(ctx, key, { + enumerable: true, + configurable: true, + get: () => instance.props[key], + set: NOOP + }); + }); + } +} +// dev only +function exposeSetupStateOnRenderContext(instance) { + const { ctx, setupState } = instance; + Object.keys(toRaw(setupState)).forEach(key => { + if (key[0] === '$' || key[0] === '_') { + warn(`setup() return property ${JSON.stringify(key)} should not start with "$" or "_" ` + + `which are reserved prefixes for Vue internals.`); + return; + } + Object.defineProperty(ctx, key, { + enumerable: true, + configurable: true, + get: () => setupState[key], + set: NOOP + }); + }); } -const emptyAppContext = createAppContext() -let uid$2 = 0 -function createComponentInstance(vnode, parent, suspense) { - const type = vnode.type - // inherit parent app context - or - if root, adopt from root vnode - const appContext = - (parent ? parent.appContext : vnode.appContext) || emptyAppContext - const instance = { - uid: uid$2++, - vnode, - type, - parent, - appContext, - root: null, - next: null, - subTree: null, - update: null, - render: null, - proxy: null, - withProxy: null, - effects: null, - provides: parent ? parent.provides : Object.create(appContext.provides), - accessCache: null, - renderCache: [], - // local resovled assets - components: null, - directives: null, - // resolved props and emits options - propsOptions: normalizePropsOptions(type, appContext), - emitsOptions: normalizeEmitsOptions(type, appContext), - // emit - emit: null, - emitted: null, - // state - ctx: EMPTY_OBJ, - data: EMPTY_OBJ, - props: EMPTY_OBJ, - attrs: EMPTY_OBJ, - slots: EMPTY_OBJ, - refs: EMPTY_OBJ, - setupState: EMPTY_OBJ, - setupContext: null, - // suspense related - suspense, - asyncDep: null, - asyncResolved: false, - // lifecycle hooks - // not using enums here because it results in computed properties - isMounted: false, - isUnmounted: false, - isDeactivated: false, - bc: null, - c: null, - bm: null, - m: null, - bu: null, - u: null, - um: null, - bum: null, - da: null, - a: null, - rtg: null, - rtc: null, - ec: null - } - if (process.env.NODE_ENV !== 'production') { - instance.ctx = createRenderContext(instance) - } else { - instance.ctx = { _: instance } - } - instance.root = parent ? parent.root : instance - instance.emit = emit.bind(null, instance) - if (process.env.NODE_ENV !== 'production' || false); - return instance -} -let currentInstance = null -const setCurrentInstance = instance => { - currentInstance = instance -} -const isBuiltInTag = /*#__PURE__*/ makeMap('slot,component') -function validateComponentName(name, config) { - const appIsNativeTag = config.isNativeTag || NO - if (isBuiltInTag(name) || appIsNativeTag(name)) { - warn( - 'Do not use built-in or reserved HTML elements as component id: ' + name - ) - } -} -let isInSSRComponentSetup = false -function setupComponent(instance, isSSR = false) { - isInSSRComponentSetup = isSSR - const { props, /* children, */ shapeFlag } = instance.vnode - const isStateful = shapeFlag & 4 /* STATEFUL_COMPONENT */ - initProps(instance, props, isStateful, isSSR) - // initSlots(instance, children) // fixed by xxxxxx - const setupResult = isStateful - ? setupStatefulComponent(instance, isSSR) - : undefined - isInSSRComponentSetup = false - return setupResult -} -function setupStatefulComponent(instance, isSSR) { - const Component = instance.type - if (process.env.NODE_ENV !== 'production') { - if (Component.name) { - validateComponentName(Component.name, instance.appContext.config) - } - if (Component.components) { - const names = Object.keys(Component.components) - for (let i = 0; i < names.length; i++) { - validateComponentName(names[i], instance.appContext.config) - } - } - if (Component.directives) { - const names = Object.keys(Component.directives) - for (let i = 0; i < names.length; i++) { - validateDirectiveName(names[i]) - } - } - } - // 0. create render proxy property access cache - instance.accessCache = {} - // 1. create public instance / render proxy - // also mark it raw so it's never observed - instance.proxy = new Proxy(instance.ctx, PublicInstanceProxyHandlers) - if (process.env.NODE_ENV !== 'production') { - exposePropsOnRenderContext(instance) - } - // 2. call setup() - const { setup } = Component - if (setup) { - const setupContext = (instance.setupContext = - setup.length > 1 ? createSetupContext(instance) : null) - currentInstance = instance - pauseTracking() - const setupResult = callWithErrorHandling( - setup, - instance, - 0 /* SETUP_FUNCTION */, - [ - process.env.NODE_ENV !== 'production' - ? shallowReadonly(instance.props) - : instance.props, - setupContext - ] - ) - resetTracking() - currentInstance = null - if (isPromise(setupResult)) { - if (isSSR) { - // return the promise so server-renderer can wait on it - return setupResult.then(resolvedResult => { - handleSetupResult(instance, resolvedResult) - }) - } else if (process.env.NODE_ENV !== 'production') { - warn( - `setup() returned a Promise, but the version of Vue you are using ` + - `does not support it yet.` - ) - } - } else { - handleSetupResult(instance, setupResult) - } - } else { - finishComponentSetup(instance) - } -} -function handleSetupResult(instance, setupResult, isSSR) { - if (isFunction(setupResult)) { - // setup returned an inline render function - instance.render = setupResult - } else if (isObject(setupResult)) { - // if ((process.env.NODE_ENV !== 'production') && isVNode(setupResult)) { - // warn( - // `setup() should not return VNodes directly - ` + - // `return a render function instead.` - // ) - // } - // setup returned bindings. - // assuming a render function compiled from template is present. - if (process.env.NODE_ENV !== 'production' || false) { - instance.devtoolsRawSetupState = setupResult - } - instance.setupState = proxyRefs(setupResult) - if (process.env.NODE_ENV !== 'production') { - exposeSetupStateOnRenderContext(instance) - } - } else if ( - process.env.NODE_ENV !== 'production' && - setupResult !== undefined - ) { - warn( - `setup() should return an object. Received: ${ - setupResult === null ? 'null' : typeof setupResult - }` - ) - } - finishComponentSetup(instance) -} -function finishComponentSetup(instance, isSSR) { - const Component = instance.type - // template / render function normalization - if (!instance.render) { - instance.render = Component.render || NOOP - // for runtime-compiled render functions using `with` blocks, the render - // proxy used needs a different `has` handler which is more performant and - // also only allows a whitelist of globals to fallthrough. - if (instance.render._rc) { - instance.withProxy = new Proxy( - instance.ctx, - RuntimeCompiledPublicInstanceProxyHandlers - ) - } - } - // support for 2.x options - if (__VUE_OPTIONS_API__) { - currentInstance = instance - applyOptions(instance, Component) - currentInstance = null - } - // warn missing template/render - if ( - process.env.NODE_ENV !== 'production' && - !Component.render && - instance.render === NOOP - ) { - /* istanbul ignore if */ - if (Component.template) { - warn( - `Component provided template option but ` + - `runtime compilation is not supported in this build of Vue.` + - ` Configure your bundler to alias "vue" to "vue/dist/vue.esm-bundler.js".` /* should not happen */ - ) - } else { - warn(`Component is missing template or render function.`) - } - } -} -const attrHandlers = { - get: (target, key) => { - if (process.env.NODE_ENV !== 'production'); - return target[key] - }, - set: () => { - warn(`setupContext.attrs is readonly.`) - return false - }, - deleteProperty: () => { - warn(`setupContext.attrs is readonly.`) - return false - } -} -function createSetupContext(instance) { - if (process.env.NODE_ENV !== 'production') { - // We use getters in dev in case libs like test-utils overwrite instance - // properties (overwrites should not be done in prod) - return Object.freeze({ - get attrs() { - return new Proxy(instance.attrs, attrHandlers) - }, - get slots() { - return shallowReadonly(instance.slots) - }, - get emit() { - return (event, ...args) => instance.emit(event, ...args) - } - }) - } else { - return { - attrs: instance.attrs, - slots: instance.slots, - emit: instance.emit - } - } -} -// record effects created during a component's setup() so that they can be -// stopped when the component unmounts -function recordInstanceBoundEffect(effect) { - if (currentInstance) { - ;(currentInstance.effects || (currentInstance.effects = [])).push(effect) - } -} -const classifyRE = /(?:^|[-_])(\w)/g -const classify = str => - str.replace(classifyRE, c => c.toUpperCase()).replace(/[-_]/g, '') -/* istanbul ignore next */ -function formatComponentName(instance, Component, isRoot = false) { - let name = isFunction(Component) - ? Component.displayName || Component.name - : Component.name - if (!name && Component.__file) { - const match = Component.__file.match(/([^/\\]+)\.vue$/) - if (match) { - name = match[1] - } - } - if (!name && instance && instance.parent) { - // try to infer the name based on reverse resolution - const inferFromRegistry = registry => { - for (const key in registry) { - if (registry[key] === Component) { - return key - } - } - } - name = - inferFromRegistry( - instance.components || instance.parent.type.components - ) || inferFromRegistry(instance.appContext.components) - } - return name ? classify(name) : isRoot ? `App` : `Anonymous` +const emptyAppContext = createAppContext(); +let uid$2 = 0; +function createComponentInstance(vnode, parent, suspense) { + const type = vnode.type; + // inherit parent app context - or - if root, adopt from root vnode + const appContext = (parent ? parent.appContext : vnode.appContext) || emptyAppContext; + const instance = { + uid: uid$2++, + vnode, + type, + parent, + appContext, + root: null, + next: null, + subTree: null, + update: null, + render: null, + proxy: null, + withProxy: null, + effects: null, + provides: parent ? parent.provides : Object.create(appContext.provides), + accessCache: null, + renderCache: [], + // local resovled assets + components: null, + directives: null, + // resolved props and emits options + propsOptions: normalizePropsOptions(type, appContext), + emitsOptions: normalizeEmitsOptions(type, appContext), + // emit + emit: null, + emitted: null, + // state + ctx: EMPTY_OBJ, + data: EMPTY_OBJ, + props: EMPTY_OBJ, + attrs: EMPTY_OBJ, + slots: EMPTY_OBJ, + refs: EMPTY_OBJ, + setupState: EMPTY_OBJ, + setupContext: null, + // suspense related + suspense, + asyncDep: null, + asyncResolved: false, + // lifecycle hooks + // not using enums here because it results in computed properties + isMounted: false, + isUnmounted: false, + isDeactivated: false, + bc: null, + c: null, + bm: null, + m: null, + bu: null, + u: null, + um: null, + bum: null, + da: null, + a: null, + rtg: null, + rtc: null, + ec: null + }; + if ((process.env.NODE_ENV !== 'production')) { + instance.ctx = createRenderContext(instance); + } + else { + instance.ctx = { _: instance }; + } + instance.root = parent ? parent.root : instance; + instance.emit = emit.bind(null, instance); + if ((process.env.NODE_ENV !== 'production') || false) ; + return instance; +} +let currentInstance = null; +const setCurrentInstance = (instance) => { + currentInstance = instance; +}; +const isBuiltInTag = /*#__PURE__*/ makeMap('slot,component'); +function validateComponentName(name, config) { + const appIsNativeTag = config.isNativeTag || NO; + if (isBuiltInTag(name) || appIsNativeTag(name)) { + warn('Do not use built-in or reserved HTML elements as component id: ' + name); + } +} +let isInSSRComponentSetup = false; +function setupComponent(instance, isSSR = false) { + isInSSRComponentSetup = isSSR; + const { props, /* children, */ shapeFlag } = instance.vnode; + const isStateful = shapeFlag & 4 /* STATEFUL_COMPONENT */; + initProps(instance, props, isStateful, isSSR); + // initSlots(instance, children) // fixed by xxxxxx + const setupResult = isStateful + ? setupStatefulComponent(instance, isSSR) + : undefined; + isInSSRComponentSetup = false; + return setupResult; +} +function setupStatefulComponent(instance, isSSR) { + const Component = instance.type; + if ((process.env.NODE_ENV !== 'production')) { + if (Component.name) { + validateComponentName(Component.name, instance.appContext.config); + } + if (Component.components) { + const names = Object.keys(Component.components); + for (let i = 0; i < names.length; i++) { + validateComponentName(names[i], instance.appContext.config); + } + } + if (Component.directives) { + const names = Object.keys(Component.directives); + for (let i = 0; i < names.length; i++) { + validateDirectiveName(names[i]); + } + } + } + // 0. create render proxy property access cache + instance.accessCache = {}; + // 1. create public instance / render proxy + // also mark it raw so it's never observed + instance.proxy = new Proxy(instance.ctx, PublicInstanceProxyHandlers); + if ((process.env.NODE_ENV !== 'production')) { + exposePropsOnRenderContext(instance); + } + // 2. call setup() + const { setup } = Component; + if (setup) { + const setupContext = (instance.setupContext = + setup.length > 1 ? createSetupContext(instance) : null); + currentInstance = instance; + pauseTracking(); + const setupResult = callWithErrorHandling(setup, instance, 0 /* SETUP_FUNCTION */, [(process.env.NODE_ENV !== 'production') ? shallowReadonly(instance.props) : instance.props, setupContext]); + resetTracking(); + currentInstance = null; + if (isPromise(setupResult)) { + if (isSSR) { + // return the promise so server-renderer can wait on it + return setupResult.then((resolvedResult) => { + handleSetupResult(instance, resolvedResult); + }); + } + else if ((process.env.NODE_ENV !== 'production')) { + warn(`setup() returned a Promise, but the version of Vue you are using ` + + `does not support it yet.`); + } + } + else { + handleSetupResult(instance, setupResult); + } + } + else { + finishComponentSetup(instance); + } +} +function handleSetupResult(instance, setupResult, isSSR) { + if (isFunction(setupResult)) { + // setup returned an inline render function + instance.render = setupResult; + } + else if (isObject(setupResult)) { + // if ((process.env.NODE_ENV !== 'production') && isVNode(setupResult)) { + // warn( + // `setup() should not return VNodes directly - ` + + // `return a render function instead.` + // ) + // } + // setup returned bindings. + // assuming a render function compiled from template is present. + if ((process.env.NODE_ENV !== 'production') || false) { + instance.devtoolsRawSetupState = setupResult; + } + instance.setupState = proxyRefs(setupResult); + if ((process.env.NODE_ENV !== 'production')) { + exposeSetupStateOnRenderContext(instance); + } + } + else if ((process.env.NODE_ENV !== 'production') && setupResult !== undefined) { + warn(`setup() should return an object. Received: ${setupResult === null ? 'null' : typeof setupResult}`); + } + finishComponentSetup(instance); +} +function finishComponentSetup(instance, isSSR) { + const Component = instance.type; + // template / render function normalization + if (!instance.render) { + instance.render = (Component.render || NOOP); + // for runtime-compiled render functions using `with` blocks, the render + // proxy used needs a different `has` handler which is more performant and + // also only allows a whitelist of globals to fallthrough. + if (instance.render._rc) { + instance.withProxy = new Proxy(instance.ctx, RuntimeCompiledPublicInstanceProxyHandlers); + } + } + // support for 2.x options + if (__VUE_OPTIONS_API__) { + currentInstance = instance; + applyOptions(instance, Component); + currentInstance = null; + } + // warn missing template/render + if ((process.env.NODE_ENV !== 'production') && !Component.render && instance.render === NOOP) { + /* istanbul ignore if */ + if ( Component.template) { + warn(`Component provided template option but ` + + `runtime compilation is not supported in this build of Vue.` + + ( ` Configure your bundler to alias "vue" to "vue/dist/vue.esm-bundler.js".` + ) /* should not happen */); + } + else { + warn(`Component is missing template or render function.`); + } + } +} +const attrHandlers = { + get: (target, key) => { + if ((process.env.NODE_ENV !== 'production')) ; + return target[key]; + }, + set: () => { + warn(`setupContext.attrs is readonly.`); + return false; + }, + deleteProperty: () => { + warn(`setupContext.attrs is readonly.`); + return false; + } +}; +function createSetupContext(instance) { + if ((process.env.NODE_ENV !== 'production')) { + // We use getters in dev in case libs like test-utils overwrite instance + // properties (overwrites should not be done in prod) + return Object.freeze({ + get attrs() { + return new Proxy(instance.attrs, attrHandlers); + }, + get slots() { + return shallowReadonly(instance.slots); + }, + get emit() { + return (event, ...args) => instance.emit(event, ...args); + } + }); + } + else { + return { + attrs: instance.attrs, + slots: instance.slots, + emit: instance.emit + }; + } +} +// record effects created during a component's setup() so that they can be +// stopped when the component unmounts +function recordInstanceBoundEffect(effect) { + if (currentInstance) { + (currentInstance.effects || (currentInstance.effects = [])).push(effect); + } +} +const classifyRE = /(?:^|[-_])(\w)/g; +const classify = (str) => str.replace(classifyRE, c => c.toUpperCase()).replace(/[-_]/g, ''); +/* istanbul ignore next */ +function formatComponentName(instance, Component, isRoot = false) { + let name = isFunction(Component) + ? Component.displayName || Component.name + : Component.name; + if (!name && Component.__file) { + const match = Component.__file.match(/([^/\\]+)\.vue$/); + if (match) { + name = match[1]; + } + } + if (!name && instance && instance.parent) { + // try to infer the name based on reverse resolution + const inferFromRegistry = (registry) => { + for (const key in registry) { + if (registry[key] === Component) { + return key; + } + } + }; + name = + inferFromRegistry(instance.components || + instance.parent.type.components) || inferFromRegistry(instance.appContext.components); + } + return name ? classify(name) : isRoot ? `App` : `Anonymous`; } -function computed$1(getterOrOptions) { - const c = computed(getterOrOptions) - recordInstanceBoundEffect(c.effect) - return c +function computed$1(getterOrOptions) { + const c = computed(getterOrOptions); + recordInstanceBoundEffect(c.effect); + return c; } -// Core API ------------------------------------------------------------------ -const version = '3.0.0-rc.10' +// Core API ------------------------------------------------------------------ +const version = "3.0.0-rc.10"; -// import deepCopy from './deepCopy' -/** - * https://raw.githubusercontent.com/Tencent/westore/master/packages/westore/utils/diff.js - */ -const ARRAYTYPE = '[object Array]' -const OBJECTTYPE = '[object Object]' -// const FUNCTIONTYPE = '[object Function]' -function diff(current, pre) { - const result = {} - syncKeys(current, pre) - _diff(current, pre, '', result) - return result -} -function syncKeys(current, pre) { - current = unref(current) - if (current === pre) return - const rootCurrentType = toTypeString(current) - const rootPreType = toTypeString(pre) - if (rootCurrentType == OBJECTTYPE && rootPreType == OBJECTTYPE) { - for (let key in pre) { - const currentValue = current[key] - if (currentValue === undefined) { - current[key] = null - } else { - syncKeys(currentValue, pre[key]) - } - } - } else if (rootCurrentType == ARRAYTYPE && rootPreType == ARRAYTYPE) { - if (current.length >= pre.length) { - pre.forEach((item, index) => { - syncKeys(current[index], item) - }) - } - } -} -function _diff(current, pre, path, result) { - current = unref(current) - if (current === pre) return - const rootCurrentType = toTypeString(current) - const rootPreType = toTypeString(pre) - if (rootCurrentType == OBJECTTYPE) { - if ( - rootPreType != OBJECTTYPE || - Object.keys(current).length < Object.keys(pre).length - ) { - setResult(result, path, current) - } else { - for (let key in current) { - const currentValue = unref(current[key]) - const preValue = pre[key] - const currentType = toTypeString(currentValue) - const preType = toTypeString(preValue) - if (currentType != ARRAYTYPE && currentType != OBJECTTYPE) { - if (currentValue != preValue) { - setResult( - result, - (path == '' ? '' : path + '.') + key, - currentValue - ) - } - } else if (currentType == ARRAYTYPE) { - if (preType != ARRAYTYPE) { - setResult( - result, - (path == '' ? '' : path + '.') + key, - currentValue - ) - } else { - if (currentValue.length < preValue.length) { - setResult( - result, - (path == '' ? '' : path + '.') + key, - currentValue - ) - } else { - currentValue.forEach((item, index) => { - _diff( - item, - preValue[index], - (path == '' ? '' : path + '.') + key + '[' + index + ']', - result - ) - }) - } - } - } else if (currentType == OBJECTTYPE) { - if ( - preType != OBJECTTYPE || - Object.keys(currentValue).length < Object.keys(preValue).length - ) { - setResult( - result, - (path == '' ? '' : path + '.') + key, - currentValue - ) - } else { - for (let subKey in currentValue) { - _diff( - currentValue[subKey], - preValue[subKey], - (path == '' ? '' : path + '.') + key + '.' + subKey, - result - ) - } - } - } - } - } - } else if (rootCurrentType == ARRAYTYPE) { - if (rootPreType != ARRAYTYPE) { - setResult(result, path, current) - } else { - if (current.length < pre.length) { - setResult(result, path, current) - } else { - current.forEach((item, index) => { - _diff(item, pre[index], path + '[' + index + ']', result) - }) - } - } - } else { - setResult(result, path, current) - } -} -function setResult(result, k, v) { - result[k] = v //deepCopy(v) +// import deepCopy from './deepCopy' +/** + * https://raw.githubusercontent.com/Tencent/westore/master/packages/westore/utils/diff.js + */ +const ARRAYTYPE = '[object Array]'; +const OBJECTTYPE = '[object Object]'; +// const FUNCTIONTYPE = '[object Function]' +function diff(current, pre) { + const result = {}; + syncKeys(current, pre); + _diff(current, pre, '', result); + return result; +} +function syncKeys(current, pre) { + current = unref(current); + if (current === pre) + return; + const rootCurrentType = toTypeString(current); + const rootPreType = toTypeString(pre); + if (rootCurrentType == OBJECTTYPE && rootPreType == OBJECTTYPE) { + for (let key in pre) { + const currentValue = current[key]; + if (currentValue === undefined) { + current[key] = null; + } + else { + syncKeys(currentValue, pre[key]); + } + } + } + else if (rootCurrentType == ARRAYTYPE && rootPreType == ARRAYTYPE) { + if (current.length >= pre.length) { + pre.forEach((item, index) => { + syncKeys(current[index], item); + }); + } + } +} +function _diff(current, pre, path, result) { + current = unref(current); + if (current === pre) + return; + const rootCurrentType = toTypeString(current); + const rootPreType = toTypeString(pre); + if (rootCurrentType == OBJECTTYPE) { + if (rootPreType != OBJECTTYPE || + Object.keys(current).length < Object.keys(pre).length) { + setResult(result, path, current); + } + else { + for (let key in current) { + const currentValue = unref(current[key]); + const preValue = pre[key]; + const currentType = toTypeString(currentValue); + const preType = toTypeString(preValue); + if (currentType != ARRAYTYPE && currentType != OBJECTTYPE) { + if (currentValue != preValue) { + setResult(result, (path == '' ? '' : path + '.') + key, currentValue); + } + } + else if (currentType == ARRAYTYPE) { + if (preType != ARRAYTYPE) { + setResult(result, (path == '' ? '' : path + '.') + key, currentValue); + } + else { + if (currentValue.length < preValue.length) { + setResult(result, (path == '' ? '' : path + '.') + key, currentValue); + } + else { + currentValue.forEach((item, index) => { + _diff(item, preValue[index], (path == '' ? '' : path + '.') + key + '[' + index + ']', result); + }); + } + } + } + else if (currentType == OBJECTTYPE) { + if (preType != OBJECTTYPE || + Object.keys(currentValue).length < Object.keys(preValue).length) { + setResult(result, (path == '' ? '' : path + '.') + key, currentValue); + } + else { + for (let subKey in currentValue) { + _diff(currentValue[subKey], preValue[subKey], (path == '' ? '' : path + '.') + key + '.' + subKey, result); + } + } + } + } + } + } + else if (rootCurrentType == ARRAYTYPE) { + if (rootPreType != ARRAYTYPE) { + setResult(result, path, current); + } + else { + if (current.length < pre.length) { + setResult(result, path, current); + } + else { + current.forEach((item, index) => { + _diff(item, pre[index], path + '[' + index + ']', result); + }); + } + } + } + else { + setResult(result, path, current); + } +} +function setResult(result, k, v) { + result[k] = v; //deepCopy(v) } -function hasComponentEffect(instance) { - return queue.includes(instance.update) -} -function flushCallbacks(instance) { - const ctx = instance.ctx - const callbacks = ctx.__next_tick_callbacks - if (callbacks && callbacks.length) { - if (process.env.VUE_APP_DEBUG) { - const mpInstance = ctx.$scope - console.log( - '[' + - +new Date() + - '][' + - (mpInstance.is || mpInstance.route) + - '][' + - instance.uid + - ']:flushCallbacks[' + - callbacks.length + - ']' - ) - } - const copies = callbacks.slice(0) - callbacks.length = 0 - for (let i = 0; i < copies.length; i++) { - copies[i]() - } - } -} -function nextTick$1(instance, fn) { - const ctx = instance.ctx - if (!ctx.__next_tick_pending && !hasComponentEffect(instance)) { - if (process.env.VUE_APP_DEBUG) { - const mpInstance = ctx.$scope - console.log( - '[' + - +new Date() + - '][' + - (mpInstance.is || mpInstance.route) + - '][' + - instance.uid + - ']:nextVueTick' - ) - } - return nextTick(fn && fn.bind(instance.proxy)) - } - if (process.env.VUE_APP_DEBUG) { - const mpInstance = ctx.$scope - console.log( - '[' + - +new Date() + - '][' + - (mpInstance.is || mpInstance.route) + - '][' + - instance.uid + - ']:nextMPTick' - ) - } - let _resolve - if (!ctx.__next_tick_callbacks) { - ctx.__next_tick_callbacks = [] - } - ctx.__next_tick_callbacks.push(() => { - if (fn) { - callWithErrorHandling( - fn.bind(instance.proxy), - instance, - 14 /* SCHEDULER */ - ) - } else if (_resolve) { - _resolve(instance.proxy) - } - }) - return new Promise(resolve => { - _resolve = resolve - }) +function hasComponentEffect(instance) { + return queue.includes(instance.update); +} +function flushCallbacks(instance) { + const ctx = instance.ctx; + const callbacks = ctx.__next_tick_callbacks; + if (callbacks && callbacks.length) { + if (process.env.VUE_APP_DEBUG) { + const mpInstance = ctx.$scope; + console.log('[' + + +new Date() + + '][' + + (mpInstance.is || mpInstance.route) + + '][' + + instance.uid + + ']:flushCallbacks[' + + callbacks.length + + ']'); + } + const copies = callbacks.slice(0); + callbacks.length = 0; + for (let i = 0; i < copies.length; i++) { + copies[i](); + } + } +} +function nextTick$1(instance, fn) { + const ctx = instance.ctx; + if (!ctx.__next_tick_pending && !hasComponentEffect(instance)) { + if (process.env.VUE_APP_DEBUG) { + const mpInstance = ctx.$scope; + console.log('[' + + +new Date() + + '][' + + (mpInstance.is || mpInstance.route) + + '][' + + instance.uid + + ']:nextVueTick'); + } + return nextTick(fn && fn.bind(instance.proxy)); + } + if (process.env.VUE_APP_DEBUG) { + const mpInstance = ctx.$scope; + console.log('[' + + +new Date() + + '][' + + (mpInstance.is || mpInstance.route) + + '][' + + instance.uid + + ']:nextMPTick'); + } + let _resolve; + if (!ctx.__next_tick_callbacks) { + ctx.__next_tick_callbacks = []; + } + ctx.__next_tick_callbacks.push(() => { + if (fn) { + callWithErrorHandling(fn.bind(instance.proxy), instance, 14 /* SCHEDULER */); + } + else if (_resolve) { + _resolve(instance.proxy); + } + }); + return new Promise(resolve => { + _resolve = resolve; + }); } -function getMPInstanceData(instance, keys) { - const data = instance.data - const ret = Object.create(null) - //仅同步 data 中有的数据 - keys.forEach(key => { - ret[key] = data[key] - }) - return ret -} -function getVueInstanceData(instance) { - const { data, setupState, ctx } = instance - const keys = new Set() - const ret = Object.create(null) - Object.keys(setupState).forEach(key => { - keys.add(key) - ret[key] = setupState[key] - }) - if (data) { - Object.keys(data).forEach(key => { - if (!keys.has(key)) { - keys.add(key) - ret[key] = data[key] - } - }) - } - if (__VUE_OPTIONS_API__) { - if (ctx.$computedKeys) { - ctx.$computedKeys.forEach(key => { - if (!keys.has(key)) { - keys.add(key) - ret[key] = ctx[key] - } - }) - } - } - if (ctx.$mp) { - // TODO - extend(ret, ctx.$mp.data || {}) - } - // TODO form-field - // track - return { keys, data: JSON.parse(JSON.stringify(ret)) } -} -function patch(instance) { - const ctx = instance.ctx - const mpType = ctx.mpType - if (mpType === 'page' || mpType === 'component') { - const start = Date.now() - const mpInstance = ctx.$scope - const { keys, data } = getVueInstanceData(instance) - // data.__webviewId__ = mpInstance.data.__webviewId__ - const diffData = diff(data, getMPInstanceData(mpInstance, keys)) - if (Object.keys(diffData).length) { - if (process.env.VUE_APP_DEBUG) { - console.log( - '[' + - +new Date() + - '][' + - (mpInstance.is || mpInstance.route) + - '][' + - instance.uid + - '][耗时' + - (Date.now() - start) + - ']差量更新', - JSON.stringify(diffData) - ) - } - ctx.__next_tick_pending = true - mpInstance.setData(diffData, () => { - ctx.__next_tick_pending = false - flushCallbacks(instance) - }) - } else { - flushCallbacks(instance) - } - } +function getMPInstanceData(instance, keys) { + const data = instance.data; + const ret = Object.create(null); + //仅同步 data 中有的数据 + keys.forEach(key => { + ret[key] = data[key]; + }); + return ret; +} +function getVueInstanceData(instance) { + const { data, setupState, ctx } = instance; + const keys = new Set(); + const ret = Object.create(null); + Object.keys(setupState).forEach(key => { + keys.add(key); + ret[key] = setupState[key]; + }); + if (data) { + Object.keys(data).forEach(key => { + if (!keys.has(key)) { + keys.add(key); + ret[key] = data[key]; + } + }); + } + if (__VUE_OPTIONS_API__) { + if (ctx.$computedKeys) { + ctx.$computedKeys.forEach((key) => { + if (!keys.has(key)) { + keys.add(key); + ret[key] = ctx[key]; + } + }); + } + } + if (ctx.$mp) { + // TODO + extend(ret, ctx.$mp.data || {}); + } + // TODO form-field + // track + return { keys, data: JSON.parse(JSON.stringify(ret)) }; +} +function patch(instance) { + const ctx = instance.ctx; + const mpType = ctx.mpType; + if (mpType === 'page' || mpType === 'component') { + const start = Date.now(); + const mpInstance = ctx.$scope; + const { keys, data } = getVueInstanceData(instance); + // data.__webviewId__ = mpInstance.data.__webviewId__ + const diffData = diff(data, getMPInstanceData(mpInstance, keys)); + if (Object.keys(diffData).length) { + if (process.env.VUE_APP_DEBUG) { + console.log('[' + + +new Date() + + '][' + + (mpInstance.is || mpInstance.route) + + '][' + + instance.uid + + '][耗时' + + (Date.now() - start) + + ']差量更新', JSON.stringify(diffData)); + } + ctx.__next_tick_pending = true; + mpInstance.setData(diffData, () => { + ctx.__next_tick_pending = false; + flushCallbacks(instance); + }); + } + else { + flushCallbacks(instance); + } + } } -function initAppConfig(appConfig) { - appConfig.globalProperties.$nextTick = function $nextTick(fn) { - return nextTick$1(this.$, fn) - } +function initAppConfig(appConfig) { + appConfig.globalProperties.$nextTick = function $nextTick(fn) { + return nextTick$1(this.$, fn); + }; } -function onApplyOptions(options, instance, publicThis) { - instance.appContext.config.globalProperties.$applyOptions( - options, - instance, - publicThis - ) - const computedOptions = options.computed - if (computedOptions) { - const keys = Object.keys(computedOptions) - if (keys.length) { - const ctx = instance.ctx - if (!ctx.$computedKeys) { - ctx.$computedKeys = [] - } - ctx.$computedKeys.push(...keys) - } - } - // remove - delete instance.ctx.$onApplyOptions +function onApplyOptions(options, instance, publicThis) { + instance.appContext.config.globalProperties.$applyOptions(options, instance, publicThis); + const computedOptions = options.computed; + if (computedOptions) { + const keys = Object.keys(computedOptions); + if (keys.length) { + const ctx = instance.ctx; + if (!ctx.$computedKeys) { + ctx.$computedKeys = []; + } + ctx.$computedKeys.push(...keys); + } + } + // remove + delete instance.ctx.$onApplyOptions; } -var MPType -;(function(MPType) { - MPType['APP'] = 'app' - MPType['PAGE'] = 'page' - MPType['COMPONENT'] = 'component' -})(MPType || (MPType = {})) -const queuePostRenderEffect$1 = queuePostFlushCb -function mountComponent(initialVNode, options) { - const instance = (initialVNode.component = createComponentInstance( - initialVNode, - options.parentComponent, - null - )) - if (__VUE_OPTIONS_API__) { - instance.ctx.$onApplyOptions = onApplyOptions - instance.ctx.$children = [] - } - if (options.mpType === 'app') { - instance.render = NOOP - } - if (options.onBeforeSetup) { - options.onBeforeSetup(instance, options) - } - if (process.env.NODE_ENV !== 'production') { - pushWarningContext(initialVNode) - } - setupComponent(instance) - if (__VUE_OPTIONS_API__) { - // $children - if (options.parentComponent && instance.proxy) { - options.parentComponent.ctx.$children.push(instance.proxy) - } - } - setupRenderEffect(instance) - if (process.env.NODE_ENV !== 'production') { - popWarningContext() - } - return instance.proxy -} -const prodEffectOptions = { - scheduler: queueJob -} -function createDevEffectOptions(instance) { - return { - scheduler: queueJob, - onTrack: instance.rtc ? e => invokeArrayFns(instance.rtc, e) : void 0, - onTrigger: instance.rtg ? e => invokeArrayFns(instance.rtg, e) : void 0 - } -} -function setupRenderEffect(instance) { - // create reactive effect for rendering - instance.update = effect(function componentEffect() { - if (!instance.isMounted) { - instance.render && instance.render.call(instance.proxy) - patch(instance) - } else { - instance.render && instance.render.call(instance.proxy) - // updateComponent - const { bu, u } = instance - // beforeUpdate hook - if (bu) { - invokeArrayFns(bu) - } - patch(instance) - // updated hook - if (u) { - queuePostRenderEffect$1(u) - } - } - }, process.env.NODE_ENV !== 'production' - ? createDevEffectOptions(instance) - : prodEffectOptions) -} -function unmountComponent(instance) { - const { bum, effects, update, um } = instance - // beforeUnmount hook - if (bum) { - invokeArrayFns(bum) - } - if (effects) { - for (let i = 0; i < effects.length; i++) { - stop(effects[i]) - } - } - // update may be null if a component is unmounted before its async - // setup has resolved. - if (update) { - stop(update) - } - // unmounted hook - if (um) { - queuePostRenderEffect$1(um) - } - queuePostRenderEffect$1(() => { - instance.isUnmounted = true - }) -} -const oldCreateApp = createAppAPI() -function createVueApp(rootComponent, rootProps = null) { - const app = oldCreateApp(rootComponent, rootProps) - const appContext = app._context - initAppConfig(appContext.config) - const createVNode = initialVNode => { - initialVNode.appContext = appContext - initialVNode.shapeFlag = 6 /* COMPONENT */ - return initialVNode - } - const createComponent = function createComponent(initialVNode, options) { - return mountComponent(createVNode(initialVNode), options) - } - const destroyComponent = function destroyComponent(component) { - return component && unmountComponent(component.$) - } - app.mount = function mount() { - rootComponent.render = NOOP - const instance = mountComponent(createVNode({ type: rootComponent }), { - mpType: MPType.APP, - mpInstance: null, - parentComponent: null, - slots: [], - props: null - }) - instance.$app = app - instance.$createComponent = createComponent - instance.$destroyComponent = destroyComponent - appContext.$appInstance = instance - return instance - } - app.unmount = function unmount() { - warn(`Cannot unmount an app.`) - } - return app +var MPType; +(function (MPType) { + MPType["APP"] = "app"; + MPType["PAGE"] = "page"; + MPType["COMPONENT"] = "component"; +})(MPType || (MPType = {})); +const queuePostRenderEffect$1 = queuePostFlushCb; +function mountComponent(initialVNode, options) { + const instance = (initialVNode.component = createComponentInstance(initialVNode, options.parentComponent, null)); + if (__VUE_OPTIONS_API__) { + instance.ctx.$onApplyOptions = onApplyOptions; + instance.ctx.$children = []; + } + if (options.mpType === 'app') { + instance.render = NOOP; + } + if (options.onBeforeSetup) { + options.onBeforeSetup(instance, options); + } + if ((process.env.NODE_ENV !== 'production')) { + pushWarningContext(initialVNode); + } + setupComponent(instance); + if (__VUE_OPTIONS_API__) { + // $children + if (options.parentComponent && instance.proxy) { + options.parentComponent.ctx + .$children.push(instance.proxy); + } + } + setupRenderEffect(instance); + if ((process.env.NODE_ENV !== 'production')) { + popWarningContext(); + } + return instance.proxy; +} +const prodEffectOptions = { + scheduler: queueJob +}; +function createDevEffectOptions(instance) { + return { + scheduler: queueJob, + onTrack: instance.rtc ? e => invokeArrayFns(instance.rtc, e) : void 0, + onTrigger: instance.rtg ? e => invokeArrayFns(instance.rtg, e) : void 0 + }; +} +function setupRenderEffect(instance) { + // create reactive effect for rendering + instance.update = effect(function componentEffect() { + if (!instance.isMounted) { + instance.render && instance.render.call(instance.proxy); + patch(instance); + } + else { + instance.render && instance.render.call(instance.proxy); + // updateComponent + const { bu, u } = instance; + // beforeUpdate hook + if (bu) { + invokeArrayFns(bu); + } + patch(instance); + // updated hook + if (u) { + queuePostRenderEffect$1(u); + } + } + }, (process.env.NODE_ENV !== 'production') ? createDevEffectOptions(instance) : prodEffectOptions); +} +function unmountComponent(instance) { + const { bum, effects, update, um } = instance; + // beforeUnmount hook + if (bum) { + invokeArrayFns(bum); + } + if (effects) { + for (let i = 0; i < effects.length; i++) { + stop(effects[i]); + } + } + // update may be null if a component is unmounted before its async + // setup has resolved. + if (update) { + stop(update); + } + // unmounted hook + if (um) { + queuePostRenderEffect$1(um); + } + queuePostRenderEffect$1(() => { + instance.isUnmounted = true; + }); +} +const oldCreateApp = createAppAPI(); +function createVueApp(rootComponent, rootProps = null) { + const app = oldCreateApp(rootComponent, rootProps); + const appContext = app._context; + initAppConfig(appContext.config); + const createVNode = initialVNode => { + initialVNode.appContext = appContext; + initialVNode.shapeFlag = 6 /* COMPONENT */; + return initialVNode; + }; + const createComponent = function createComponent(initialVNode, options) { + return mountComponent(createVNode(initialVNode), options); + }; + const destroyComponent = function destroyComponent(component) { + return component && unmountComponent(component.$); + }; + app.mount = function mount() { + rootComponent.render = NOOP; + const instance = mountComponent(createVNode({ type: rootComponent }), { + mpType: MPType.APP, + mpInstance: null, + parentComponent: null, + slots: [], + props: null + }); + instance.$app = app; + instance.$createComponent = createComponent; + instance.$destroyComponent = destroyComponent; + appContext.$appInstance = instance; + return instance; + }; + app.unmount = function unmount() { + warn(`Cannot unmount an app.`); + }; + return app; } -export { - callWithAsyncErrorHandling, - callWithErrorHandling, - computed$1 as computed, - createVueApp, - customRef, - inject, - injectHook, - isInSSRComponentSetup, - isProxy, - isReactive, - isReadonly, - isRef, - logError, - markRaw, - nextTick, - onActivated, - onBeforeMount, - onBeforeUnmount, - onBeforeUpdate, - onDeactivated, - onErrorCaptured, - onMounted, - onRenderTracked, - onRenderTriggered, - onUnmounted, - onUpdated, - provide, - reactive, - readonly, - ref, - shallowReactive, - shallowReadonly, - shallowRef, - toRaw, - toRef, - toRefs, - triggerRef, - unref, - version, - warn, - watch, - watchEffect -} +export { callWithAsyncErrorHandling, callWithErrorHandling, computed$1 as computed, createVueApp, customRef, inject, injectHook, isInSSRComponentSetup, isProxy, isReactive, isReadonly, isRef, logError, markRaw, nextTick, onActivated, onBeforeMount, onBeforeUnmount, onBeforeUpdate, onDeactivated, onErrorCaptured, onMounted, onRenderTracked, onRenderTriggered, onUnmounted, onUpdated, provide, reactive, readonly, ref, shallowReactive, shallowReadonly, shallowRef, toRaw, toRef, toRefs, triggerRef, unref, version, warn, watch, watchEffect }; -- GitLab