8462 lines
252 KiB
JavaScript
8462 lines
252 KiB
JavaScript
import { isRootHook, getValueByDataPath, isUniLifecycleHook, ON_ERROR, UniLifecycleHooks, invokeCreateErrorHandler, normalizeStyle as normalizeStyle$1, dynamicSlotName, normalizeClass as normalizeClass$1 } from '@dcloudio/uni-shared';
|
||
import { isSymbol, extend, isObject, toRawType, def, hasOwn, isArray, isIntegerKey, makeMap, hasChanged, isMap, capitalize, getGlobalThis, isString, normalizeClass, normalizeStyle, isFunction, isOn, NOOP, EMPTY_OBJ, isPromise, isSet, isPlainObject, camelize, remove, toHandlerKey, hyphenate, isReservedProp, toTypeString, invokeArrayFns, isBuiltInDirective, looseToNumber, NO, EMPTY_ARR, isModelListener, toNumber, toDisplayString } from '@vue/shared';
|
||
export { EMPTY_OBJ, camelize, normalizeClass, normalizeProps, normalizeStyle, toDisplayString, toHandlerKey } from '@vue/shared';
|
||
|
||
/**
|
||
* @vue/reactivity v3.4.21
|
||
* (c) 2018-present Yuxi (Evan) You and Vue contributors
|
||
* @license MIT
|
||
**/
|
||
|
||
function warn$4(msg, ...args) {
|
||
console.warn(`[Vue warn] ${msg}`, ...args);
|
||
}
|
||
|
||
let activeEffectScope$1;
|
||
function recordEffectScope$1(effect, scope = activeEffectScope$1) {
|
||
if (scope && scope.active) {
|
||
scope.effects.push(effect);
|
||
}
|
||
}
|
||
|
||
let activeEffect$1;
|
||
let ReactiveEffect$1 = class ReactiveEffect {
|
||
constructor(fn, trigger, scheduler, scope) {
|
||
this.fn = fn;
|
||
this.trigger = trigger;
|
||
this.scheduler = scheduler;
|
||
this.active = true;
|
||
this.deps = [];
|
||
/**
|
||
* @internal
|
||
*/
|
||
this._dirtyLevel = 4;
|
||
/**
|
||
* @internal
|
||
*/
|
||
this._trackId = 0;
|
||
/**
|
||
* @internal
|
||
*/
|
||
this._runnings = 0;
|
||
/**
|
||
* @internal
|
||
*/
|
||
this._shouldSchedule = false;
|
||
/**
|
||
* @internal
|
||
*/
|
||
this._depsLength = 0;
|
||
recordEffectScope$1(this, scope);
|
||
}
|
||
get dirty() {
|
||
if (this._dirtyLevel === 2 || this._dirtyLevel === 3) {
|
||
this._dirtyLevel = 1;
|
||
pauseTracking$1();
|
||
for (let i = 0; i < this._depsLength; i++) {
|
||
const dep = this.deps[i];
|
||
if (dep.computed) {
|
||
triggerComputed$1(dep.computed);
|
||
if (this._dirtyLevel >= 4) {
|
||
break;
|
||
}
|
||
}
|
||
}
|
||
if (this._dirtyLevel === 1) {
|
||
this._dirtyLevel = 0;
|
||
}
|
||
resetTracking$1();
|
||
}
|
||
return this._dirtyLevel >= 4;
|
||
}
|
||
set dirty(v) {
|
||
this._dirtyLevel = v ? 4 : 0;
|
||
}
|
||
run() {
|
||
this._dirtyLevel = 0;
|
||
if (!this.active) {
|
||
return this.fn();
|
||
}
|
||
let lastShouldTrack = shouldTrack$1;
|
||
let lastEffect = activeEffect$1;
|
||
try {
|
||
shouldTrack$1 = true;
|
||
activeEffect$1 = this;
|
||
this._runnings++;
|
||
preCleanupEffect$1(this);
|
||
return this.fn();
|
||
} finally {
|
||
postCleanupEffect$1(this);
|
||
this._runnings--;
|
||
activeEffect$1 = lastEffect;
|
||
shouldTrack$1 = lastShouldTrack;
|
||
}
|
||
}
|
||
stop() {
|
||
var _a;
|
||
if (this.active) {
|
||
preCleanupEffect$1(this);
|
||
postCleanupEffect$1(this);
|
||
(_a = this.onStop) == null ? void 0 : _a.call(this);
|
||
this.active = false;
|
||
}
|
||
}
|
||
};
|
||
function triggerComputed$1(computed) {
|
||
return computed.value;
|
||
}
|
||
function preCleanupEffect$1(effect2) {
|
||
effect2._trackId++;
|
||
effect2._depsLength = 0;
|
||
}
|
||
function postCleanupEffect$1(effect2) {
|
||
if (effect2.deps.length > effect2._depsLength) {
|
||
for (let i = effect2._depsLength; i < effect2.deps.length; i++) {
|
||
cleanupDepEffect$1(effect2.deps[i], effect2);
|
||
}
|
||
effect2.deps.length = effect2._depsLength;
|
||
}
|
||
}
|
||
function cleanupDepEffect$1(dep, effect2) {
|
||
const trackId = dep.get(effect2);
|
||
if (trackId !== void 0 && effect2._trackId !== trackId) {
|
||
dep.delete(effect2);
|
||
if (dep.size === 0) {
|
||
dep.cleanup();
|
||
}
|
||
}
|
||
}
|
||
let shouldTrack$1 = true;
|
||
let pauseScheduleStack$1 = 0;
|
||
const trackStack$1 = [];
|
||
function pauseTracking$1() {
|
||
trackStack$1.push(shouldTrack$1);
|
||
shouldTrack$1 = false;
|
||
}
|
||
function resetTracking$1() {
|
||
const last = trackStack$1.pop();
|
||
shouldTrack$1 = last === void 0 ? true : last;
|
||
}
|
||
function pauseScheduling$1() {
|
||
pauseScheduleStack$1++;
|
||
}
|
||
function resetScheduling$1() {
|
||
pauseScheduleStack$1--;
|
||
while (!pauseScheduleStack$1 && queueEffectSchedulers$1.length) {
|
||
queueEffectSchedulers$1.shift()();
|
||
}
|
||
}
|
||
function trackEffect$1(effect2, dep, debuggerEventExtraInfo) {
|
||
var _a;
|
||
if (dep.get(effect2) !== effect2._trackId) {
|
||
dep.set(effect2, effect2._trackId);
|
||
const oldDep = effect2.deps[effect2._depsLength];
|
||
if (oldDep !== dep) {
|
||
if (oldDep) {
|
||
cleanupDepEffect$1(oldDep, effect2);
|
||
}
|
||
effect2.deps[effect2._depsLength++] = dep;
|
||
} else {
|
||
effect2._depsLength++;
|
||
}
|
||
if (!!(process.env.NODE_ENV !== "production")) {
|
||
(_a = effect2.onTrack) == null ? void 0 : _a.call(effect2, extend({ effect: effect2 }, debuggerEventExtraInfo));
|
||
}
|
||
}
|
||
}
|
||
const queueEffectSchedulers$1 = [];
|
||
function triggerEffects$1(dep, dirtyLevel, debuggerEventExtraInfo) {
|
||
var _a;
|
||
pauseScheduling$1();
|
||
for (const effect2 of dep.keys()) {
|
||
let tracking;
|
||
if (effect2._dirtyLevel < dirtyLevel && (tracking != null ? tracking : tracking = dep.get(effect2) === effect2._trackId)) {
|
||
effect2._shouldSchedule || (effect2._shouldSchedule = effect2._dirtyLevel === 0);
|
||
effect2._dirtyLevel = dirtyLevel;
|
||
}
|
||
if (effect2._shouldSchedule && (tracking != null ? tracking : tracking = dep.get(effect2) === effect2._trackId)) {
|
||
if (!!(process.env.NODE_ENV !== "production")) {
|
||
(_a = effect2.onTrigger) == null ? void 0 : _a.call(effect2, extend({ effect: effect2 }, debuggerEventExtraInfo));
|
||
}
|
||
effect2.trigger();
|
||
if ((!effect2._runnings || effect2.allowRecurse) && effect2._dirtyLevel !== 2) {
|
||
effect2._shouldSchedule = false;
|
||
if (effect2.scheduler) {
|
||
queueEffectSchedulers$1.push(effect2.scheduler);
|
||
}
|
||
}
|
||
}
|
||
}
|
||
resetScheduling$1();
|
||
}
|
||
|
||
const createDep$1 = (cleanup, computed) => {
|
||
const dep = /* @__PURE__ */ new Map();
|
||
dep.cleanup = cleanup;
|
||
dep.computed = computed;
|
||
return dep;
|
||
};
|
||
|
||
const targetMap$1 = /* @__PURE__ */ new WeakMap();
|
||
const ITERATE_KEY$1 = Symbol(!!(process.env.NODE_ENV !== "production") ? "iterate" : "");
|
||
const MAP_KEY_ITERATE_KEY$1 = Symbol(!!(process.env.NODE_ENV !== "production") ? "Map key iterate" : "");
|
||
function track$1(target, type, key) {
|
||
if (shouldTrack$1 && activeEffect$1) {
|
||
let depsMap = targetMap$1.get(target);
|
||
if (!depsMap) {
|
||
targetMap$1.set(target, depsMap = /* @__PURE__ */ new Map());
|
||
}
|
||
let dep = depsMap.get(key);
|
||
if (!dep) {
|
||
depsMap.set(key, dep = createDep$1(() => depsMap.delete(key)));
|
||
}
|
||
trackEffect$1(
|
||
activeEffect$1,
|
||
dep,
|
||
!!(process.env.NODE_ENV !== "production") ? {
|
||
target,
|
||
type,
|
||
key
|
||
} : void 0
|
||
);
|
||
}
|
||
}
|
||
function trigger$1(target, type, key, newValue, oldValue, oldTarget) {
|
||
const depsMap = targetMap$1.get(target);
|
||
if (!depsMap) {
|
||
return;
|
||
}
|
||
let deps = [];
|
||
if (type === "clear") {
|
||
deps = [...depsMap.values()];
|
||
} else if (key === "length" && isArray(target)) {
|
||
const newLength = Number(newValue);
|
||
depsMap.forEach((dep, key2) => {
|
||
if (key2 === "length" || !isSymbol(key2) && key2 >= newLength) {
|
||
deps.push(dep);
|
||
}
|
||
});
|
||
} else {
|
||
if (key !== void 0) {
|
||
deps.push(depsMap.get(key));
|
||
}
|
||
switch (type) {
|
||
case "add":
|
||
if (!isArray(target)) {
|
||
deps.push(depsMap.get(ITERATE_KEY$1));
|
||
if (isMap(target)) {
|
||
deps.push(depsMap.get(MAP_KEY_ITERATE_KEY$1));
|
||
}
|
||
} else if (isIntegerKey(key)) {
|
||
deps.push(depsMap.get("length"));
|
||
}
|
||
break;
|
||
case "delete":
|
||
if (!isArray(target)) {
|
||
deps.push(depsMap.get(ITERATE_KEY$1));
|
||
if (isMap(target)) {
|
||
deps.push(depsMap.get(MAP_KEY_ITERATE_KEY$1));
|
||
}
|
||
}
|
||
break;
|
||
case "set":
|
||
if (isMap(target)) {
|
||
deps.push(depsMap.get(ITERATE_KEY$1));
|
||
}
|
||
break;
|
||
}
|
||
}
|
||
pauseScheduling$1();
|
||
for (const dep of deps) {
|
||
if (dep) {
|
||
triggerEffects$1(
|
||
dep,
|
||
4,
|
||
!!(process.env.NODE_ENV !== "production") ? {
|
||
target,
|
||
type,
|
||
key,
|
||
newValue,
|
||
oldValue,
|
||
oldTarget
|
||
} : void 0
|
||
);
|
||
}
|
||
}
|
||
resetScheduling$1();
|
||
}
|
||
|
||
const isNonTrackableKeys$1 = /* @__PURE__ */ makeMap(`__proto__,__v_isRef,__isVue`);
|
||
const builtInSymbols$1 = new Set(
|
||
/* @__PURE__ */ Object.getOwnPropertyNames(Symbol).filter((key) => key !== "arguments" && key !== "caller").map((key) => Symbol[key]).filter(isSymbol)
|
||
);
|
||
const arrayInstrumentations$1 = /* @__PURE__ */ createArrayInstrumentations$1();
|
||
function createArrayInstrumentations$1() {
|
||
const instrumentations = {};
|
||
["includes", "indexOf", "lastIndexOf"].forEach((key) => {
|
||
instrumentations[key] = function(...args) {
|
||
const arr = toRaw$1(this);
|
||
for (let i = 0, l = this.length; i < l; i++) {
|
||
track$1(arr, "get", i + "");
|
||
}
|
||
const res = arr[key](...args);
|
||
if (res === -1 || res === false) {
|
||
return arr[key](...args.map(toRaw$1));
|
||
} else {
|
||
return res;
|
||
}
|
||
};
|
||
});
|
||
["push", "pop", "shift", "unshift", "splice"].forEach((key) => {
|
||
instrumentations[key] = function(...args) {
|
||
pauseTracking$1();
|
||
pauseScheduling$1();
|
||
const res = toRaw$1(this)[key].apply(this, args);
|
||
resetScheduling$1();
|
||
resetTracking$1();
|
||
return res;
|
||
};
|
||
});
|
||
return instrumentations;
|
||
}
|
||
function hasOwnProperty$1(key) {
|
||
const obj = toRaw$1(this);
|
||
track$1(obj, "has", key);
|
||
return obj.hasOwnProperty(key);
|
||
}
|
||
let BaseReactiveHandler$1 = class BaseReactiveHandler {
|
||
constructor(_isReadonly = false, _isShallow = false) {
|
||
this._isReadonly = _isReadonly;
|
||
this._isShallow = _isShallow;
|
||
}
|
||
get(target, key, receiver) {
|
||
const isReadonly2 = this._isReadonly, isShallow2 = this._isShallow;
|
||
if (key === "__v_isReactive") {
|
||
return !isReadonly2;
|
||
} else if (key === "__v_isReadonly") {
|
||
return isReadonly2;
|
||
} else if (key === "__v_isShallow") {
|
||
return isShallow2;
|
||
} else if (key === "__v_raw") {
|
||
if (receiver === (isReadonly2 ? isShallow2 ? shallowReadonlyMap$1 : readonlyMap$1 : isShallow2 ? shallowReactiveMap$1 : reactiveMap$1).get(target) || // receiver is not the reactive proxy, but has the same prototype
|
||
// this means the reciever is a user proxy of the reactive proxy
|
||
Object.getPrototypeOf(target) === Object.getPrototypeOf(receiver)) {
|
||
return target;
|
||
}
|
||
return;
|
||
}
|
||
const targetIsArray = isArray(target);
|
||
if (!isReadonly2) {
|
||
if (targetIsArray && hasOwn(arrayInstrumentations$1, key)) {
|
||
return Reflect.get(arrayInstrumentations$1, key, receiver);
|
||
}
|
||
if (key === "hasOwnProperty") {
|
||
return hasOwnProperty$1;
|
||
}
|
||
}
|
||
const res = Reflect.get(target, key, receiver);
|
||
if (isSymbol(key) ? builtInSymbols$1.has(key) : isNonTrackableKeys$1(key)) {
|
||
return res;
|
||
}
|
||
if (!isReadonly2) {
|
||
track$1(target, "get", key);
|
||
}
|
||
if (isShallow2) {
|
||
return res;
|
||
}
|
||
if (isRef$1(res)) {
|
||
return targetIsArray && isIntegerKey(key) ? res : res.value;
|
||
}
|
||
if (isObject(res)) {
|
||
return isReadonly2 ? readonly$1(res) : reactive$1(res);
|
||
}
|
||
return res;
|
||
}
|
||
};
|
||
let MutableReactiveHandler$1 = class MutableReactiveHandler extends BaseReactiveHandler$1 {
|
||
constructor(isShallow2 = false) {
|
||
super(false, isShallow2);
|
||
}
|
||
set(target, key, value, receiver) {
|
||
let oldValue = target[key];
|
||
if (!this._isShallow) {
|
||
const isOldValueReadonly = isReadonly$1(oldValue);
|
||
if (!isShallow$1(value) && !isReadonly$1(value)) {
|
||
oldValue = toRaw$1(oldValue);
|
||
value = toRaw$1(value);
|
||
}
|
||
if (!isArray(target) && isRef$1(oldValue) && !isRef$1(value)) {
|
||
if (isOldValueReadonly) {
|
||
return false;
|
||
} else {
|
||
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);
|
||
if (target === toRaw$1(receiver)) {
|
||
if (!hadKey) {
|
||
trigger$1(target, "add", key, value);
|
||
} else if (hasChanged(value, oldValue)) {
|
||
trigger$1(target, "set", key, value, oldValue);
|
||
}
|
||
}
|
||
return result;
|
||
}
|
||
deleteProperty(target, key) {
|
||
const hadKey = hasOwn(target, key);
|
||
const oldValue = target[key];
|
||
const result = Reflect.deleteProperty(target, key);
|
||
if (result && hadKey) {
|
||
trigger$1(target, "delete", key, void 0, oldValue);
|
||
}
|
||
return result;
|
||
}
|
||
has(target, key) {
|
||
const result = Reflect.has(target, key);
|
||
if (!isSymbol(key) || !builtInSymbols$1.has(key)) {
|
||
track$1(target, "has", key);
|
||
}
|
||
return result;
|
||
}
|
||
ownKeys(target) {
|
||
track$1(
|
||
target,
|
||
"iterate",
|
||
isArray(target) ? "length" : ITERATE_KEY$1
|
||
);
|
||
return Reflect.ownKeys(target);
|
||
}
|
||
};
|
||
let ReadonlyReactiveHandler$1 = class ReadonlyReactiveHandler extends BaseReactiveHandler$1 {
|
||
constructor(isShallow2 = false) {
|
||
super(true, isShallow2);
|
||
}
|
||
set(target, key) {
|
||
if (!!(process.env.NODE_ENV !== "production")) {
|
||
warn$4(
|
||
`Set operation on key "${String(key)}" failed: target is readonly.`,
|
||
target
|
||
);
|
||
}
|
||
return true;
|
||
}
|
||
deleteProperty(target, key) {
|
||
if (!!(process.env.NODE_ENV !== "production")) {
|
||
warn$4(
|
||
`Delete operation on key "${String(key)}" failed: target is readonly.`,
|
||
target
|
||
);
|
||
}
|
||
return true;
|
||
}
|
||
};
|
||
const mutableHandlers$1 = /* @__PURE__ */ new MutableReactiveHandler$1();
|
||
const readonlyHandlers$1 = /* @__PURE__ */ new ReadonlyReactiveHandler$1();
|
||
const shallowReadonlyHandlers$1 = /* @__PURE__ */ new ReadonlyReactiveHandler$1(true);
|
||
|
||
const toShallow$1 = (value) => value;
|
||
const getProto$1 = (v) => Reflect.getPrototypeOf(v);
|
||
function get$1(target, key, isReadonly = false, isShallow = false) {
|
||
target = target["__v_raw"];
|
||
const rawTarget = toRaw$1(target);
|
||
const rawKey = toRaw$1(key);
|
||
if (!isReadonly) {
|
||
if (hasChanged(key, rawKey)) {
|
||
track$1(rawTarget, "get", key);
|
||
}
|
||
track$1(rawTarget, "get", rawKey);
|
||
}
|
||
const { has: has2 } = getProto$1(rawTarget);
|
||
const wrap = isShallow ? toShallow$1 : isReadonly ? toReadonly$1 : toReactive$1;
|
||
if (has2.call(rawTarget, key)) {
|
||
return wrap(target.get(key));
|
||
} else if (has2.call(rawTarget, rawKey)) {
|
||
return wrap(target.get(rawKey));
|
||
} else if (target !== rawTarget) {
|
||
target.get(key);
|
||
}
|
||
}
|
||
function has$1(key, isReadonly = false) {
|
||
const target = this["__v_raw"];
|
||
const rawTarget = toRaw$1(target);
|
||
const rawKey = toRaw$1(key);
|
||
if (!isReadonly) {
|
||
if (hasChanged(key, rawKey)) {
|
||
track$1(rawTarget, "has", key);
|
||
}
|
||
track$1(rawTarget, "has", rawKey);
|
||
}
|
||
return key === rawKey ? target.has(key) : target.has(key) || target.has(rawKey);
|
||
}
|
||
function size$1(target, isReadonly = false) {
|
||
target = target["__v_raw"];
|
||
!isReadonly && track$1(toRaw$1(target), "iterate", ITERATE_KEY$1);
|
||
return Reflect.get(target, "size", target);
|
||
}
|
||
function add$1(value) {
|
||
value = toRaw$1(value);
|
||
const target = toRaw$1(this);
|
||
const proto = getProto$1(target);
|
||
const hadKey = proto.has.call(target, value);
|
||
if (!hadKey) {
|
||
target.add(value);
|
||
trigger$1(target, "add", value, value);
|
||
}
|
||
return this;
|
||
}
|
||
function set$2(key, value) {
|
||
value = toRaw$1(value);
|
||
const target = toRaw$1(this);
|
||
const { has: has2, get: get2 } = getProto$1(target);
|
||
let hadKey = has2.call(target, key);
|
||
if (!hadKey) {
|
||
key = toRaw$1(key);
|
||
hadKey = has2.call(target, key);
|
||
} else if (!!(process.env.NODE_ENV !== "production")) {
|
||
checkIdentityKeys$1(target, has2, key);
|
||
}
|
||
const oldValue = get2.call(target, key);
|
||
target.set(key, value);
|
||
if (!hadKey) {
|
||
trigger$1(target, "add", key, value);
|
||
} else if (hasChanged(value, oldValue)) {
|
||
trigger$1(target, "set", key, value, oldValue);
|
||
}
|
||
return this;
|
||
}
|
||
function deleteEntry$1(key) {
|
||
const target = toRaw$1(this);
|
||
const { has: has2, get: get2 } = getProto$1(target);
|
||
let hadKey = has2.call(target, key);
|
||
if (!hadKey) {
|
||
key = toRaw$1(key);
|
||
hadKey = has2.call(target, key);
|
||
} else if (!!(process.env.NODE_ENV !== "production")) {
|
||
checkIdentityKeys$1(target, has2, key);
|
||
}
|
||
const oldValue = get2 ? get2.call(target, key) : void 0;
|
||
const result = target.delete(key);
|
||
if (hadKey) {
|
||
trigger$1(target, "delete", key, void 0, oldValue);
|
||
}
|
||
return result;
|
||
}
|
||
function clear$1() {
|
||
const target = toRaw$1(this);
|
||
const hadItems = target.size !== 0;
|
||
const oldTarget = !!(process.env.NODE_ENV !== "production") ? isMap(target) ? new Map(target) : new Set(target) : void 0;
|
||
const result = target.clear();
|
||
if (hadItems) {
|
||
trigger$1(target, "clear", void 0, void 0, oldTarget);
|
||
}
|
||
return result;
|
||
}
|
||
function createForEach$1(isReadonly, isShallow) {
|
||
return function forEach(callback, thisArg) {
|
||
const observed = this;
|
||
const target = observed["__v_raw"];
|
||
const rawTarget = toRaw$1(target);
|
||
const wrap = isShallow ? toShallow$1 : isReadonly ? toReadonly$1 : toReactive$1;
|
||
!isReadonly && track$1(rawTarget, "iterate", ITERATE_KEY$1);
|
||
return target.forEach((value, key) => {
|
||
return callback.call(thisArg, wrap(value), wrap(key), observed);
|
||
});
|
||
};
|
||
}
|
||
function createIterableMethod$1(method, isReadonly, isShallow) {
|
||
return function(...args) {
|
||
const target = this["__v_raw"];
|
||
const rawTarget = toRaw$1(target);
|
||
const targetIsMap = isMap(rawTarget);
|
||
const isPair = method === "entries" || method === Symbol.iterator && targetIsMap;
|
||
const isKeyOnly = method === "keys" && targetIsMap;
|
||
const innerIterator = target[method](...args);
|
||
const wrap = isShallow ? toShallow$1 : isReadonly ? toReadonly$1 : toReactive$1;
|
||
!isReadonly && track$1(
|
||
rawTarget,
|
||
"iterate",
|
||
isKeyOnly ? MAP_KEY_ITERATE_KEY$1 : ITERATE_KEY$1
|
||
);
|
||
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$1(type) {
|
||
return function(...args) {
|
||
if (!!(process.env.NODE_ENV !== "production")) {
|
||
const key = args[0] ? `on key "${args[0]}" ` : ``;
|
||
warn$4(
|
||
`${capitalize(type)} operation ${key}failed: target is readonly.`,
|
||
toRaw$1(this)
|
||
);
|
||
}
|
||
return type === "delete" ? false : type === "clear" ? void 0 : this;
|
||
};
|
||
}
|
||
function createInstrumentations$1() {
|
||
const mutableInstrumentations2 = {
|
||
get(key) {
|
||
return get$1(this, key);
|
||
},
|
||
get size() {
|
||
return size$1(this);
|
||
},
|
||
has: has$1,
|
||
add: add$1,
|
||
set: set$2,
|
||
delete: deleteEntry$1,
|
||
clear: clear$1,
|
||
forEach: createForEach$1(false, false)
|
||
};
|
||
const shallowInstrumentations2 = {
|
||
get(key) {
|
||
return get$1(this, key, false, true);
|
||
},
|
||
get size() {
|
||
return size$1(this);
|
||
},
|
||
has: has$1,
|
||
add: add$1,
|
||
set: set$2,
|
||
delete: deleteEntry$1,
|
||
clear: clear$1,
|
||
forEach: createForEach$1(false, true)
|
||
};
|
||
const readonlyInstrumentations2 = {
|
||
get(key) {
|
||
return get$1(this, key, true);
|
||
},
|
||
get size() {
|
||
return size$1(this, true);
|
||
},
|
||
has(key) {
|
||
return has$1.call(this, key, true);
|
||
},
|
||
add: createReadonlyMethod$1("add"),
|
||
set: createReadonlyMethod$1("set"),
|
||
delete: createReadonlyMethod$1("delete"),
|
||
clear: createReadonlyMethod$1("clear"),
|
||
forEach: createForEach$1(true, false)
|
||
};
|
||
const shallowReadonlyInstrumentations2 = {
|
||
get(key) {
|
||
return get$1(this, key, true, true);
|
||
},
|
||
get size() {
|
||
return size$1(this, true);
|
||
},
|
||
has(key) {
|
||
return has$1.call(this, key, true);
|
||
},
|
||
add: createReadonlyMethod$1("add"),
|
||
set: createReadonlyMethod$1("set"),
|
||
delete: createReadonlyMethod$1("delete"),
|
||
clear: createReadonlyMethod$1("clear"),
|
||
forEach: createForEach$1(true, true)
|
||
};
|
||
const iteratorMethods = ["keys", "values", "entries", Symbol.iterator];
|
||
iteratorMethods.forEach((method) => {
|
||
mutableInstrumentations2[method] = createIterableMethod$1(
|
||
method,
|
||
false,
|
||
false
|
||
);
|
||
readonlyInstrumentations2[method] = createIterableMethod$1(
|
||
method,
|
||
true,
|
||
false
|
||
);
|
||
shallowInstrumentations2[method] = createIterableMethod$1(
|
||
method,
|
||
false,
|
||
true
|
||
);
|
||
shallowReadonlyInstrumentations2[method] = createIterableMethod$1(
|
||
method,
|
||
true,
|
||
true
|
||
);
|
||
});
|
||
return [
|
||
mutableInstrumentations2,
|
||
readonlyInstrumentations2,
|
||
shallowInstrumentations2,
|
||
shallowReadonlyInstrumentations2
|
||
];
|
||
}
|
||
const [
|
||
mutableInstrumentations$1,
|
||
readonlyInstrumentations$1,
|
||
shallowInstrumentations$1,
|
||
shallowReadonlyInstrumentations$1
|
||
] = /* @__PURE__ */ createInstrumentations$1();
|
||
function createInstrumentationGetter$1(isReadonly, shallow) {
|
||
const instrumentations = shallow ? isReadonly ? shallowReadonlyInstrumentations$1 : shallowInstrumentations$1 : isReadonly ? readonlyInstrumentations$1 : mutableInstrumentations$1;
|
||
return (target, key, receiver) => {
|
||
if (key === "__v_isReactive") {
|
||
return !isReadonly;
|
||
} else if (key === "__v_isReadonly") {
|
||
return isReadonly;
|
||
} else if (key === "__v_raw") {
|
||
return target;
|
||
}
|
||
return Reflect.get(
|
||
hasOwn(instrumentations, key) && key in target ? instrumentations : target,
|
||
key,
|
||
receiver
|
||
);
|
||
};
|
||
}
|
||
const mutableCollectionHandlers$1 = {
|
||
get: /* @__PURE__ */ createInstrumentationGetter$1(false, false)
|
||
};
|
||
const readonlyCollectionHandlers$1 = {
|
||
get: /* @__PURE__ */ createInstrumentationGetter$1(true, false)
|
||
};
|
||
const shallowReadonlyCollectionHandlers$1 = {
|
||
get: /* @__PURE__ */ createInstrumentationGetter$1(true, true)
|
||
};
|
||
function checkIdentityKeys$1(target, has2, key) {
|
||
const rawKey = toRaw$1(key);
|
||
if (rawKey !== key && has2.call(target, rawKey)) {
|
||
const type = toRawType(target);
|
||
warn$4(
|
||
`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$1 = /* @__PURE__ */ new WeakMap();
|
||
const shallowReactiveMap$1 = /* @__PURE__ */ new WeakMap();
|
||
const readonlyMap$1 = /* @__PURE__ */ new WeakMap();
|
||
const shallowReadonlyMap$1 = /* @__PURE__ */ new WeakMap();
|
||
function targetTypeMap$1(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$1(value) {
|
||
return value["__v_skip"] || !Object.isExtensible(value) ? 0 /* INVALID */ : targetTypeMap$1(toRawType(value));
|
||
}
|
||
function reactive$1(target) {
|
||
if (isReadonly$1(target)) {
|
||
return target;
|
||
}
|
||
return createReactiveObject$1(
|
||
target,
|
||
false,
|
||
mutableHandlers$1,
|
||
mutableCollectionHandlers$1,
|
||
reactiveMap$1
|
||
);
|
||
}
|
||
function readonly$1(target) {
|
||
return createReactiveObject$1(
|
||
target,
|
||
true,
|
||
readonlyHandlers$1,
|
||
readonlyCollectionHandlers$1,
|
||
readonlyMap$1
|
||
);
|
||
}
|
||
function shallowReadonly$1(target) {
|
||
return createReactiveObject$1(
|
||
target,
|
||
true,
|
||
shallowReadonlyHandlers$1,
|
||
shallowReadonlyCollectionHandlers$1,
|
||
shallowReadonlyMap$1
|
||
);
|
||
}
|
||
function createReactiveObject$1(target, isReadonly2, baseHandlers, collectionHandlers, proxyMap) {
|
||
if (!isObject(target)) {
|
||
if (!!(process.env.NODE_ENV !== "production")) {
|
||
warn$4(`value cannot be made reactive: ${String(target)}`);
|
||
}
|
||
return target;
|
||
}
|
||
if (target["__v_raw"] && !(isReadonly2 && target["__v_isReactive"])) {
|
||
return target;
|
||
}
|
||
const existingProxy = proxyMap.get(target);
|
||
if (existingProxy) {
|
||
return existingProxy;
|
||
}
|
||
const targetType = getTargetType$1(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$1(value) {
|
||
if (isReadonly$1(value)) {
|
||
return isReactive$1(value["__v_raw"]);
|
||
}
|
||
return !!(value && value["__v_isReactive"]);
|
||
}
|
||
function isReadonly$1(value) {
|
||
return !!(value && value["__v_isReadonly"]);
|
||
}
|
||
function isShallow$1(value) {
|
||
return !!(value && value["__v_isShallow"]);
|
||
}
|
||
function isProxy$1(value) {
|
||
return isReactive$1(value) || isReadonly$1(value);
|
||
}
|
||
function toRaw$1(observed) {
|
||
const raw = observed && observed["__v_raw"];
|
||
return raw ? toRaw$1(raw) : observed;
|
||
}
|
||
function markRaw$1(value) {
|
||
if (Object.isExtensible(value)) {
|
||
def(value, "__v_skip", true);
|
||
}
|
||
return value;
|
||
}
|
||
const toReactive$1 = (value) => isObject(value) ? reactive$1(value) : value;
|
||
const toReadonly$1 = (value) => isObject(value) ? readonly$1(value) : value;
|
||
function isRef$1(r) {
|
||
return !!(r && r.__v_isRef === true);
|
||
}
|
||
function unref$1(ref2) {
|
||
return isRef$1(ref2) ? ref2.value : ref2;
|
||
}
|
||
const shallowUnwrapHandlers$1 = {
|
||
get: (target, key, receiver) => unref$1(Reflect.get(target, key, receiver)),
|
||
set: (target, key, value, receiver) => {
|
||
const oldValue = target[key];
|
||
if (isRef$1(oldValue) && !isRef$1(value)) {
|
||
oldValue.value = value;
|
||
return true;
|
||
} else {
|
||
return Reflect.set(target, key, value, receiver);
|
||
}
|
||
}
|
||
};
|
||
function proxyRefs$1(objectWithRefs) {
|
||
return isReactive$1(objectWithRefs) ? objectWithRefs : new Proxy(objectWithRefs, shallowUnwrapHandlers$1);
|
||
}
|
||
|
||
/**
|
||
* @vue/runtime-core v3.4.21
|
||
* (c) 2018-present Yuxi (Evan) You and Vue contributors
|
||
* @license MIT
|
||
**/
|
||
|
||
const stack$1 = [];
|
||
function pushWarningContext$1(vnode) {
|
||
stack$1.push(vnode);
|
||
}
|
||
function popWarningContext$1() {
|
||
stack$1.pop();
|
||
}
|
||
function warn$1$1(msg, ...args) {
|
||
pauseTracking$1();
|
||
const instance = stack$1.length ? stack$1[stack$1.length - 1].component : null;
|
||
const appWarnHandler = instance && instance.appContext.config.warnHandler;
|
||
const trace = getComponentTrace$1();
|
||
if (appWarnHandler) {
|
||
callWithErrorHandling$1(
|
||
appWarnHandler,
|
||
instance,
|
||
11,
|
||
[
|
||
msg + args.map((a) => {
|
||
var _a, _b;
|
||
return (_b = (_a = a.toString) == null ? void 0 : _a.call(a)) != null ? _b : JSON.stringify(a);
|
||
}).join(""),
|
||
instance && instance.proxy,
|
||
trace.map(
|
||
({ vnode }) => `at <${formatComponentName$1(instance, vnode.type)}>`
|
||
).join("\n"),
|
||
trace
|
||
]
|
||
);
|
||
} else {
|
||
const warnArgs = [`[Vue warn]: ${msg}`, ...args];
|
||
if (trace.length && // avoid spamming console during tests
|
||
true) {
|
||
warnArgs.push(`
|
||
`, ...formatTrace$1(trace));
|
||
}
|
||
console.warn(...warnArgs);
|
||
}
|
||
resetTracking$1();
|
||
}
|
||
function getComponentTrace$1() {
|
||
let currentVNode = stack$1[stack$1.length - 1];
|
||
if (!currentVNode) {
|
||
return [];
|
||
}
|
||
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;
|
||
}
|
||
function formatTrace$1(trace) {
|
||
const logs = [];
|
||
trace.forEach((entry, i) => {
|
||
logs.push(...i === 0 ? [] : [`
|
||
`], ...formatTraceEntry$1(entry));
|
||
});
|
||
return logs;
|
||
}
|
||
function formatTraceEntry$1({ vnode, recurseCount }) {
|
||
const postfix = recurseCount > 0 ? `... (${recurseCount} recursive calls)` : ``;
|
||
const isRoot = vnode.component ? vnode.component.parent == null : false;
|
||
const open = ` at <${formatComponentName$1(
|
||
vnode.component,
|
||
vnode.type,
|
||
isRoot
|
||
)}`;
|
||
const close = `>` + postfix;
|
||
return vnode.props ? [open, ...formatProps$1(vnode.props), close] : [open + close];
|
||
}
|
||
function formatProps$1(props) {
|
||
const res = [];
|
||
const keys = Object.keys(props);
|
||
keys.slice(0, 3).forEach((key) => {
|
||
res.push(...formatProp$1(key, props[key]));
|
||
});
|
||
if (keys.length > 3) {
|
||
res.push(` ...`);
|
||
}
|
||
return res;
|
||
}
|
||
function formatProp$1(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$1(value)) {
|
||
value = formatProp$1(key, toRaw$1(value.value), true);
|
||
return raw ? value : [`${key}=Ref<`, value, `>`];
|
||
} else if (isFunction(value)) {
|
||
return [`${key}=fn${value.name ? `<${value.name}>` : ``}`];
|
||
} else {
|
||
value = toRaw$1(value);
|
||
return raw ? value : [`${key}=`, value];
|
||
}
|
||
}
|
||
const ErrorTypeStrings$1 = {
|
||
["sp"]: "serverPrefetch hook",
|
||
["bc"]: "beforeCreate hook",
|
||
["c"]: "created hook",
|
||
["bm"]: "beforeMount hook",
|
||
["m"]: "mounted hook",
|
||
["bu"]: "beforeUpdate hook",
|
||
["u"]: "updated",
|
||
["bum"]: "beforeUnmount hook",
|
||
["um"]: "unmounted hook",
|
||
["a"]: "activated hook",
|
||
["da"]: "deactivated hook",
|
||
["ec"]: "errorCaptured hook",
|
||
["rtc"]: "renderTracked hook",
|
||
["rtg"]: "renderTriggered hook",
|
||
[0]: "setup function",
|
||
[1]: "render function",
|
||
[2]: "watcher getter",
|
||
[3]: "watcher callback",
|
||
[4]: "watcher cleanup function",
|
||
[5]: "native event handler",
|
||
[6]: "component event handler",
|
||
[7]: "vnode hook",
|
||
[8]: "directive hook",
|
||
[9]: "transition hook",
|
||
[10]: "app errorHandler",
|
||
[11]: "app warnHandler",
|
||
[12]: "ref function",
|
||
[13]: "async component loader",
|
||
[14]: "scheduler flush. This is likely a Vue internals bug. Please open an issue at https://github.com/vuejs/core ."
|
||
};
|
||
function callWithErrorHandling$1(fn, instance, type, args) {
|
||
try {
|
||
return args ? fn(...args) : fn();
|
||
} catch (err) {
|
||
handleError$1(err, instance, type);
|
||
}
|
||
}
|
||
function callWithAsyncErrorHandling$1(fn, instance, type, args) {
|
||
if (isFunction(fn)) {
|
||
const res = callWithErrorHandling$1(fn, instance, type, args);
|
||
if (res && isPromise(res)) {
|
||
res.catch((err) => {
|
||
handleError$1(err, instance, type);
|
||
});
|
||
}
|
||
return res;
|
||
}
|
||
const values = [];
|
||
for (let i = 0; i < fn.length; i++) {
|
||
values.push(callWithAsyncErrorHandling$1(fn[i], instance, type, args));
|
||
}
|
||
return values;
|
||
}
|
||
function handleError$1(err, instance, type, throwInDev = true) {
|
||
const contextVNode = instance ? instance.vnode : null;
|
||
if (instance) {
|
||
let cur = instance.parent;
|
||
const exposedInstance = instance.proxy;
|
||
const errorInfo = !!(process.env.NODE_ENV !== "production") ? ErrorTypeStrings$1[type] : `https://vuejs.org/error-reference/#runtime-${type}`;
|
||
while (cur) {
|
||
const errorCapturedHooks = cur.ec;
|
||
if (errorCapturedHooks) {
|
||
for (let i = 0; i < errorCapturedHooks.length; i++) {
|
||
if (errorCapturedHooks[i](err, exposedInstance, errorInfo) === false) {
|
||
return;
|
||
}
|
||
}
|
||
}
|
||
cur = cur.parent;
|
||
}
|
||
const appErrorHandler = instance.appContext.config.errorHandler;
|
||
if (appErrorHandler) {
|
||
callWithErrorHandling$1(
|
||
appErrorHandler,
|
||
null,
|
||
10,
|
||
[err, exposedInstance, errorInfo]
|
||
);
|
||
return;
|
||
}
|
||
}
|
||
logError$1(err, type, contextVNode, throwInDev);
|
||
}
|
||
function logError$1(err, type, contextVNode, throwInDev = true) {
|
||
if (!!(process.env.NODE_ENV !== "production")) {
|
||
const info = ErrorTypeStrings$1[type];
|
||
if (contextVNode) {
|
||
pushWarningContext$1(contextVNode);
|
||
}
|
||
warn$1$1(`Unhandled error${info ? ` during execution of ${info}` : ``}`);
|
||
if (contextVNode) {
|
||
popWarningContext$1();
|
||
}
|
||
if (throwInDev) {
|
||
throw err;
|
||
} else {
|
||
console.error(err);
|
||
}
|
||
} else {
|
||
console.error(err);
|
||
}
|
||
}
|
||
|
||
let isFlushing$1 = false;
|
||
let isFlushPending$1 = false;
|
||
const queue$1 = [];
|
||
let flushIndex$1 = 0;
|
||
const pendingPostFlushCbs$1 = [];
|
||
let activePostFlushCbs$1 = null;
|
||
let postFlushIndex$1 = 0;
|
||
const resolvedPromise$1 = /* @__PURE__ */ Promise.resolve();
|
||
let currentFlushPromise$1 = null;
|
||
const RECURSION_LIMIT$1 = 100;
|
||
function nextTick$2(fn) {
|
||
const p = currentFlushPromise$1 || resolvedPromise$1;
|
||
return fn ? p.then(this ? fn.bind(this) : fn) : p;
|
||
}
|
||
function findInsertionIndex$1(id) {
|
||
let start = flushIndex$1 + 1;
|
||
let end = queue$1.length;
|
||
while (start < end) {
|
||
const middle = start + end >>> 1;
|
||
const middleJob = queue$1[middle];
|
||
const middleJobId = getId$1(middleJob);
|
||
if (middleJobId < id || middleJobId === id && middleJob.pre) {
|
||
start = middle + 1;
|
||
} else {
|
||
end = middle;
|
||
}
|
||
}
|
||
return start;
|
||
}
|
||
function queueJob$1(job) {
|
||
if (!queue$1.length || !queue$1.includes(
|
||
job,
|
||
isFlushing$1 && job.allowRecurse ? flushIndex$1 + 1 : flushIndex$1
|
||
)) {
|
||
if (job.id == null) {
|
||
queue$1.push(job);
|
||
} else {
|
||
queue$1.splice(findInsertionIndex$1(job.id), 0, job);
|
||
}
|
||
queueFlush$1();
|
||
}
|
||
}
|
||
function queueFlush$1() {
|
||
if (!isFlushing$1 && !isFlushPending$1) {
|
||
isFlushPending$1 = true;
|
||
currentFlushPromise$1 = resolvedPromise$1.then(flushJobs$1);
|
||
}
|
||
}
|
||
function queuePostFlushCb$1(cb) {
|
||
if (!isArray(cb)) {
|
||
if (!activePostFlushCbs$1 || !activePostFlushCbs$1.includes(
|
||
cb,
|
||
cb.allowRecurse ? postFlushIndex$1 + 1 : postFlushIndex$1
|
||
)) {
|
||
pendingPostFlushCbs$1.push(cb);
|
||
}
|
||
} else {
|
||
pendingPostFlushCbs$1.push(...cb);
|
||
}
|
||
queueFlush$1();
|
||
}
|
||
function flushPostFlushCbs$1(seen) {
|
||
if (pendingPostFlushCbs$1.length) {
|
||
const deduped = [...new Set(pendingPostFlushCbs$1)].sort(
|
||
(a, b) => getId$1(a) - getId$1(b)
|
||
);
|
||
pendingPostFlushCbs$1.length = 0;
|
||
if (activePostFlushCbs$1) {
|
||
activePostFlushCbs$1.push(...deduped);
|
||
return;
|
||
}
|
||
activePostFlushCbs$1 = deduped;
|
||
if (!!(process.env.NODE_ENV !== "production")) {
|
||
seen = seen || /* @__PURE__ */ new Map();
|
||
}
|
||
for (postFlushIndex$1 = 0; postFlushIndex$1 < activePostFlushCbs$1.length; postFlushIndex$1++) {
|
||
if (!!(process.env.NODE_ENV !== "production") && checkRecursiveUpdates$1(seen, activePostFlushCbs$1[postFlushIndex$1])) {
|
||
continue;
|
||
}
|
||
activePostFlushCbs$1[postFlushIndex$1]();
|
||
}
|
||
activePostFlushCbs$1 = null;
|
||
postFlushIndex$1 = 0;
|
||
}
|
||
}
|
||
const getId$1 = (job) => job.id == null ? Infinity : job.id;
|
||
const comparator$1 = (a, b) => {
|
||
const diff = getId$1(a) - getId$1(b);
|
||
if (diff === 0) {
|
||
if (a.pre && !b.pre)
|
||
return -1;
|
||
if (b.pre && !a.pre)
|
||
return 1;
|
||
}
|
||
return diff;
|
||
};
|
||
function flushJobs$1(seen) {
|
||
isFlushPending$1 = false;
|
||
isFlushing$1 = true;
|
||
if (!!(process.env.NODE_ENV !== "production")) {
|
||
seen = seen || /* @__PURE__ */ new Map();
|
||
}
|
||
queue$1.sort(comparator$1);
|
||
const check = !!(process.env.NODE_ENV !== "production") ? (job) => checkRecursiveUpdates$1(seen, job) : NOOP;
|
||
try {
|
||
for (flushIndex$1 = 0; flushIndex$1 < queue$1.length; flushIndex$1++) {
|
||
const job = queue$1[flushIndex$1];
|
||
if (job && job.active !== false) {
|
||
if (!!(process.env.NODE_ENV !== "production") && check(job)) {
|
||
continue;
|
||
}
|
||
callWithErrorHandling$1(job, null, 14);
|
||
}
|
||
}
|
||
} finally {
|
||
flushIndex$1 = 0;
|
||
queue$1.length = 0;
|
||
flushPostFlushCbs$1(seen);
|
||
isFlushing$1 = false;
|
||
currentFlushPromise$1 = null;
|
||
if (queue$1.length || pendingPostFlushCbs$1.length) {
|
||
flushJobs$1(seen);
|
||
}
|
||
}
|
||
}
|
||
function checkRecursiveUpdates$1(seen, fn) {
|
||
if (!seen.has(fn)) {
|
||
seen.set(fn, 1);
|
||
} else {
|
||
const count = seen.get(fn);
|
||
if (count > RECURSION_LIMIT$1) {
|
||
const instance = fn.ownerInstance;
|
||
const componentName = instance && getComponentName$1(instance.type);
|
||
handleError$1(
|
||
`Maximum recursive updates exceeded${componentName ? ` in component <${componentName}>` : ``}. 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.`,
|
||
null,
|
||
10
|
||
);
|
||
return true;
|
||
} else {
|
||
seen.set(fn, count + 1);
|
||
}
|
||
}
|
||
}
|
||
const hmrDirtyComponents = /* @__PURE__ */ new Set();
|
||
if (!!(process.env.NODE_ENV !== "production")) {
|
||
getGlobalThis().__VUE_HMR_RUNTIME__ = {
|
||
createRecord: tryWrap(createRecord),
|
||
rerender: tryWrap(rerender),
|
||
reload: tryWrap(reload)
|
||
};
|
||
}
|
||
const map = /* @__PURE__ */ new Map();
|
||
function createRecord(id, initialDef) {
|
||
if (map.has(id)) {
|
||
return false;
|
||
}
|
||
map.set(id, {
|
||
initialDef: normalizeClassComponent(initialDef),
|
||
instances: /* @__PURE__ */ new Set()
|
||
});
|
||
return true;
|
||
}
|
||
function normalizeClassComponent(component) {
|
||
return isClassComponent$1(component) ? component.__vccOpts : component;
|
||
}
|
||
function rerender(id, newRender) {
|
||
const record = map.get(id);
|
||
if (!record) {
|
||
return;
|
||
}
|
||
record.initialDef.render = newRender;
|
||
[...record.instances].forEach((instance) => {
|
||
if (newRender) {
|
||
instance.render = newRender;
|
||
normalizeClassComponent(instance.type).render = newRender;
|
||
}
|
||
instance.renderCache = [];
|
||
instance.effect.dirty = true;
|
||
instance.update();
|
||
});
|
||
}
|
||
function reload(id, newComp) {
|
||
const record = map.get(id);
|
||
if (!record)
|
||
return;
|
||
newComp = normalizeClassComponent(newComp);
|
||
updateComponentDef(record.initialDef, newComp);
|
||
const instances = [...record.instances];
|
||
for (const instance of instances) {
|
||
const oldComp = normalizeClassComponent(instance.type);
|
||
if (!hmrDirtyComponents.has(oldComp)) {
|
||
if (oldComp !== record.initialDef) {
|
||
updateComponentDef(oldComp, newComp);
|
||
}
|
||
hmrDirtyComponents.add(oldComp);
|
||
}
|
||
instance.appContext.propsCache.delete(instance.type);
|
||
instance.appContext.emitsCache.delete(instance.type);
|
||
instance.appContext.optionsCache.delete(instance.type);
|
||
if (instance.ceReload) {
|
||
hmrDirtyComponents.add(oldComp);
|
||
instance.ceReload(newComp.styles);
|
||
hmrDirtyComponents.delete(oldComp);
|
||
} else if (instance.parent) {
|
||
instance.parent.effect.dirty = true;
|
||
queueJob$1(instance.parent.update);
|
||
} else if (instance.appContext.reload) {
|
||
instance.appContext.reload();
|
||
} else if (typeof window !== "undefined") {
|
||
window.location.reload();
|
||
} else {
|
||
console.warn(
|
||
"[HMR] Root or manually mounted instance modified. Full reload required."
|
||
);
|
||
}
|
||
}
|
||
queuePostFlushCb$1(() => {
|
||
for (const instance of instances) {
|
||
hmrDirtyComponents.delete(
|
||
normalizeClassComponent(instance.type)
|
||
);
|
||
}
|
||
});
|
||
}
|
||
function updateComponentDef(oldComp, newComp) {
|
||
extend(oldComp, newComp);
|
||
for (const key in oldComp) {
|
||
if (key !== "__file" && !(key in newComp)) {
|
||
delete oldComp[key];
|
||
}
|
||
}
|
||
}
|
||
function tryWrap(fn) {
|
||
return (id, arg) => {
|
||
try {
|
||
return fn(id, arg);
|
||
} catch (e) {
|
||
console.error(e);
|
||
console.warn(
|
||
`[HMR] Something went wrong during Vue component hot-reload. Full reload required.`
|
||
);
|
||
}
|
||
};
|
||
}
|
||
|
||
let devtools$1;
|
||
let buffer$1 = [];
|
||
function setDevtoolsHook$1(hook, target) {
|
||
var _a, _b;
|
||
devtools$1 = hook;
|
||
if (devtools$1) {
|
||
devtools$1.enabled = true;
|
||
buffer$1.forEach(({ event, args }) => devtools$1.emit(event, ...args));
|
||
buffer$1 = [];
|
||
} else if (
|
||
// handle late devtools injection - only do this if we are in an actual
|
||
// browser environment to avoid the timer handle stalling test runner exit
|
||
// (#4815)
|
||
typeof window !== "undefined" && // some envs mock window but not fully
|
||
window.HTMLElement && // also exclude jsdom
|
||
!((_b = (_a = window.navigator) == null ? void 0 : _a.userAgent) == null ? void 0 : _b.includes("jsdom"))
|
||
) {
|
||
const replay = target.__VUE_DEVTOOLS_HOOK_REPLAY__ = target.__VUE_DEVTOOLS_HOOK_REPLAY__ || [];
|
||
replay.push((newHook) => {
|
||
setDevtoolsHook$1(newHook, target);
|
||
});
|
||
setTimeout(() => {
|
||
if (!devtools$1) {
|
||
target.__VUE_DEVTOOLS_HOOK_REPLAY__ = null;
|
||
buffer$1 = [];
|
||
}
|
||
}, 3e3);
|
||
} else {
|
||
buffer$1 = [];
|
||
}
|
||
}
|
||
|
||
let currentRenderingInstance$1 = null;
|
||
let currentScopeId$1 = null;
|
||
function markAttrsAccessed$1() {
|
||
}
|
||
const NULL_DYNAMIC_COMPONENT$1 = Symbol.for("v-ndc");
|
||
|
||
const isSuspense = (type) => type.__isSuspense;
|
||
function queueEffectWithSuspense(fn, suspense) {
|
||
if (suspense && suspense.pendingBranch) {
|
||
if (isArray(fn)) {
|
||
suspense.effects.push(...fn);
|
||
} else {
|
||
suspense.effects.push(fn);
|
||
}
|
||
} else {
|
||
queuePostFlushCb$1(fn);
|
||
}
|
||
}
|
||
|
||
const ssrContextKey$1 = Symbol.for("v-scx");
|
||
const useSSRContext$1 = () => {
|
||
{
|
||
const ctx = inject$1(ssrContextKey$1);
|
||
if (!ctx) {
|
||
!!(process.env.NODE_ENV !== "production") && warn$1$1(
|
||
`Server rendering context not provided. Make sure to only call useSSRContext() conditionally in the server build.`
|
||
);
|
||
}
|
||
return ctx;
|
||
}
|
||
};
|
||
const INITIAL_WATCHER_VALUE$1 = {};
|
||
function doWatch$1(source, cb, {
|
||
immediate,
|
||
deep,
|
||
flush,
|
||
once,
|
||
onTrack,
|
||
onTrigger
|
||
} = EMPTY_OBJ) {
|
||
if (cb && once) {
|
||
const _cb = cb;
|
||
cb = (...args) => {
|
||
_cb(...args);
|
||
unwatch();
|
||
};
|
||
}
|
||
if (!!(process.env.NODE_ENV !== "production") && deep !== void 0 && typeof deep === "number") {
|
||
warn$1$1(
|
||
`watch() "deep" option with number value will be used as watch depth in future versions. Please use a boolean instead to avoid potential breakage.`
|
||
);
|
||
}
|
||
if (!!(process.env.NODE_ENV !== "production") && !cb) {
|
||
if (immediate !== void 0) {
|
||
warn$1$1(
|
||
`watch() "immediate" option is only respected when using the watch(source, callback, options?) signature.`
|
||
);
|
||
}
|
||
if (deep !== void 0) {
|
||
warn$1$1(
|
||
`watch() "deep" option is only respected when using the watch(source, callback, options?) signature.`
|
||
);
|
||
}
|
||
if (once !== void 0) {
|
||
warn$1$1(
|
||
`watch() "once" option is only respected when using the watch(source, callback, options?) signature.`
|
||
);
|
||
}
|
||
}
|
||
const warnInvalidSource = (s) => {
|
||
warn$1$1(
|
||
`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.`
|
||
);
|
||
};
|
||
const instance = currentInstance$1;
|
||
const reactiveGetter = (source2) => deep === true ? source2 : (
|
||
// for deep: false, only traverse root-level properties
|
||
traverse$1(source2, deep === false ? 1 : void 0)
|
||
);
|
||
let getter;
|
||
let forceTrigger = false;
|
||
let isMultiSource = false;
|
||
if (isRef$1(source)) {
|
||
getter = () => source.value;
|
||
forceTrigger = isShallow$1(source);
|
||
} else if (isReactive$1(source)) {
|
||
getter = () => reactiveGetter(source);
|
||
forceTrigger = true;
|
||
} else if (isArray(source)) {
|
||
isMultiSource = true;
|
||
forceTrigger = source.some((s) => isReactive$1(s) || isShallow$1(s));
|
||
getter = () => source.map((s) => {
|
||
if (isRef$1(s)) {
|
||
return s.value;
|
||
} else if (isReactive$1(s)) {
|
||
return reactiveGetter(s);
|
||
} else if (isFunction(s)) {
|
||
return callWithErrorHandling$1(s, instance, 2);
|
||
} else {
|
||
!!(process.env.NODE_ENV !== "production") && warnInvalidSource(s);
|
||
}
|
||
});
|
||
} else if (isFunction(source)) {
|
||
if (cb) {
|
||
getter = () => callWithErrorHandling$1(source, instance, 2);
|
||
} else {
|
||
getter = () => {
|
||
if (cleanup) {
|
||
cleanup();
|
||
}
|
||
return callWithAsyncErrorHandling$1(
|
||
source,
|
||
instance,
|
||
3,
|
||
[onCleanup]
|
||
);
|
||
};
|
||
}
|
||
} else {
|
||
getter = NOOP;
|
||
!!(process.env.NODE_ENV !== "production") && warnInvalidSource(source);
|
||
}
|
||
if (cb && deep) {
|
||
const baseGetter = getter;
|
||
getter = () => traverse$1(baseGetter());
|
||
}
|
||
let cleanup;
|
||
let onCleanup = (fn) => {
|
||
cleanup = effect.onStop = () => {
|
||
callWithErrorHandling$1(fn, instance, 4);
|
||
cleanup = effect.onStop = void 0;
|
||
};
|
||
};
|
||
let ssrCleanup;
|
||
if (isInSSRComponentSetup$1) {
|
||
onCleanup = NOOP;
|
||
if (!cb) {
|
||
getter();
|
||
} else if (immediate) {
|
||
callWithAsyncErrorHandling$1(cb, instance, 3, [
|
||
getter(),
|
||
isMultiSource ? [] : void 0,
|
||
onCleanup
|
||
]);
|
||
}
|
||
if (flush === "sync") {
|
||
const ctx = useSSRContext$1();
|
||
ssrCleanup = ctx.__watcherHandles || (ctx.__watcherHandles = []);
|
||
} else {
|
||
return NOOP;
|
||
}
|
||
}
|
||
let oldValue = isMultiSource ? new Array(source.length).fill(INITIAL_WATCHER_VALUE$1) : INITIAL_WATCHER_VALUE$1;
|
||
const job = () => {
|
||
if (!effect.active || !effect.dirty) {
|
||
return;
|
||
}
|
||
if (cb) {
|
||
const newValue = effect.run();
|
||
if (deep || forceTrigger || (isMultiSource ? newValue.some((v, i) => hasChanged(v, oldValue[i])) : hasChanged(newValue, oldValue)) || false) {
|
||
if (cleanup) {
|
||
cleanup();
|
||
}
|
||
callWithAsyncErrorHandling$1(cb, instance, 3, [
|
||
newValue,
|
||
// pass undefined as the old value when it's changed for the first time
|
||
oldValue === INITIAL_WATCHER_VALUE$1 ? void 0 : isMultiSource && oldValue[0] === INITIAL_WATCHER_VALUE$1 ? [] : oldValue,
|
||
onCleanup
|
||
]);
|
||
oldValue = newValue;
|
||
}
|
||
} else {
|
||
effect.run();
|
||
}
|
||
};
|
||
job.allowRecurse = !!cb;
|
||
let scheduler;
|
||
if (flush === "sync") {
|
||
scheduler = job;
|
||
} else if (flush === "post") {
|
||
scheduler = () => queuePostRenderEffect$2(job, instance && instance.suspense);
|
||
} else {
|
||
job.pre = true;
|
||
if (instance)
|
||
job.id = instance.uid;
|
||
scheduler = () => queueJob$1(job);
|
||
}
|
||
const effect = new ReactiveEffect$1(getter, NOOP, scheduler);
|
||
const unwatch = () => {
|
||
effect.stop();
|
||
};
|
||
if (!!(process.env.NODE_ENV !== "production")) {
|
||
effect.onTrack = onTrack;
|
||
effect.onTrigger = onTrigger;
|
||
}
|
||
if (cb) {
|
||
if (immediate) {
|
||
job();
|
||
} else {
|
||
oldValue = effect.run();
|
||
}
|
||
} else if (flush === "post") {
|
||
queuePostRenderEffect$2(
|
||
effect.run.bind(effect),
|
||
instance && instance.suspense
|
||
);
|
||
} else {
|
||
effect.run();
|
||
}
|
||
if (ssrCleanup)
|
||
ssrCleanup.push(unwatch);
|
||
return unwatch;
|
||
}
|
||
function instanceWatch$1(source, value, options) {
|
||
const publicThis = this.proxy;
|
||
const getter = isString(source) ? source.includes(".") ? createPathGetter$1(publicThis, source) : () => publicThis[source] : source.bind(publicThis, publicThis);
|
||
let cb;
|
||
if (isFunction(value)) {
|
||
cb = value;
|
||
} else {
|
||
cb = value.handler;
|
||
options = value;
|
||
}
|
||
const reset = setCurrentInstance$1(this);
|
||
const res = doWatch$1(getter, cb.bind(publicThis), options);
|
||
reset();
|
||
return res;
|
||
}
|
||
function createPathGetter$1(ctx, path) {
|
||
const segments = path.split(".");
|
||
return () => {
|
||
let cur = ctx;
|
||
for (let i = 0; i < segments.length && cur; i++) {
|
||
cur = cur[segments[i]];
|
||
}
|
||
return cur;
|
||
};
|
||
}
|
||
function traverse$1(value, depth, currentDepth = 0, seen) {
|
||
if (!isObject(value) || value["__v_skip"]) {
|
||
return value;
|
||
}
|
||
if (depth && depth > 0) {
|
||
if (currentDepth >= depth) {
|
||
return value;
|
||
}
|
||
currentDepth++;
|
||
}
|
||
seen = seen || /* @__PURE__ */ new Set();
|
||
if (seen.has(value)) {
|
||
return value;
|
||
}
|
||
seen.add(value);
|
||
if (isRef$1(value)) {
|
||
traverse$1(value.value, depth, currentDepth, seen);
|
||
} else if (isArray(value)) {
|
||
for (let i = 0; i < value.length; i++) {
|
||
traverse$1(value[i], depth, currentDepth, seen);
|
||
}
|
||
} else if (isSet(value) || isMap(value)) {
|
||
value.forEach((v) => {
|
||
traverse$1(v, depth, currentDepth, seen);
|
||
});
|
||
} else if (isPlainObject(value)) {
|
||
for (const key in value) {
|
||
traverse$1(value[key], depth, currentDepth, seen);
|
||
}
|
||
}
|
||
return value;
|
||
}
|
||
|
||
const getPublicInstance$1 = (i) => {
|
||
if (!i)
|
||
return null;
|
||
if (isStatefulComponent$1(i))
|
||
return getExposeProxy$1(i) || i.proxy;
|
||
return getPublicInstance$1(i.parent);
|
||
};
|
||
const publicPropertiesMap$1 = (
|
||
// Move PURE marker to new line to workaround compiler discarding it
|
||
// due to type annotation
|
||
/* @__PURE__ */ extend(/* @__PURE__ */ Object.create(null), {
|
||
$: (i) => i,
|
||
$el: (i) => i.vnode.el,
|
||
$data: (i) => i.data,
|
||
$props: (i) => !!(process.env.NODE_ENV !== "production") ? shallowReadonly$1(i.props) : i.props,
|
||
$attrs: (i) => !!(process.env.NODE_ENV !== "production") ? shallowReadonly$1(i.attrs) : i.attrs,
|
||
$slots: (i) => !!(process.env.NODE_ENV !== "production") ? shallowReadonly$1(i.slots) : i.slots,
|
||
$refs: (i) => !!(process.env.NODE_ENV !== "production") ? shallowReadonly$1(i.refs) : i.refs,
|
||
$parent: (i) => getPublicInstance$1(i.parent),
|
||
$root: (i) => getPublicInstance$1(i.root),
|
||
$emit: (i) => i.emit,
|
||
$options: (i) => __VUE_OPTIONS_API__ ? resolveMergedOptions$1(i) : i.type,
|
||
$forceUpdate: (i) => i.f || (i.f = () => {
|
||
i.effect.dirty = true;
|
||
queueJob$1(i.update);
|
||
}),
|
||
$nextTick: (i) => i.n || (i.n = nextTick$2.bind(i.proxy)),
|
||
$watch: (i) => __VUE_OPTIONS_API__ ? instanceWatch$1.bind(i) : NOOP
|
||
})
|
||
);
|
||
const isReservedPrefix$1 = (key) => key === "_" || key === "$";
|
||
const hasSetupBinding$1 = (state, key) => state !== EMPTY_OBJ && !state.__isScriptSetup && hasOwn(state, key);
|
||
const PublicInstanceProxyHandlers$1 = {
|
||
get({ _: instance }, key) {
|
||
const { ctx, setupState, data, props, accessCache, type, appContext } = instance;
|
||
if (!!(process.env.NODE_ENV !== "production") && key === "__isVue") {
|
||
return true;
|
||
}
|
||
let normalizedProps;
|
||
if (key[0] !== "$") {
|
||
const n = accessCache[key];
|
||
if (n !== void 0) {
|
||
switch (n) {
|
||
case 1 /* SETUP */:
|
||
return setupState[key];
|
||
case 2 /* DATA */:
|
||
return data[key];
|
||
case 4 /* CONTEXT */:
|
||
return ctx[key];
|
||
case 3 /* PROPS */:
|
||
return props[key];
|
||
}
|
||
} else if (hasSetupBinding$1(setupState, key)) {
|
||
accessCache[key] = 1 /* SETUP */;
|
||
return setupState[key];
|
||
} else if (data !== EMPTY_OBJ && hasOwn(data, key)) {
|
||
accessCache[key] = 2 /* 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] = 3 /* PROPS */;
|
||
return props[key];
|
||
} else if (ctx !== EMPTY_OBJ && hasOwn(ctx, key)) {
|
||
accessCache[key] = 4 /* CONTEXT */;
|
||
return ctx[key];
|
||
} else if (!__VUE_OPTIONS_API__ || shouldCacheAccess$1) {
|
||
accessCache[key] = 0 /* OTHER */;
|
||
}
|
||
}
|
||
const publicGetter = publicPropertiesMap$1[key];
|
||
let cssModule, globalProperties;
|
||
if (publicGetter) {
|
||
if (key === "$attrs") {
|
||
track$1(instance, "get", key);
|
||
!!(process.env.NODE_ENV !== "production") && markAttrsAccessed$1();
|
||
} else if (!!(process.env.NODE_ENV !== "production") && key === "$slots") {
|
||
track$1(instance, "get", key);
|
||
}
|
||
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)) {
|
||
accessCache[key] = 4 /* 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$1 && (!isString(key) || // #1091 avoid internal isRef/isVNode checks on component instance leading
|
||
// to infinite warning loop
|
||
key.indexOf("__v") !== 0)) {
|
||
if (data !== EMPTY_OBJ && isReservedPrefix$1(key[0]) && hasOwn(data, key)) {
|
||
warn$1$1(
|
||
`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 if (instance === currentRenderingInstance$1) {
|
||
warn$1$1(
|
||
`Property ${JSON.stringify(key)} was accessed during render but is not defined on instance.`
|
||
);
|
||
}
|
||
}
|
||
},
|
||
set({ _: instance }, key, value) {
|
||
const { data, setupState, ctx } = instance;
|
||
if (hasSetupBinding$1(setupState, key)) {
|
||
setupState[key] = value;
|
||
return true;
|
||
} else if (!!(process.env.NODE_ENV !== "production") && setupState.__isScriptSetup && hasOwn(setupState, key)) {
|
||
warn$1$1(`Cannot mutate <script setup> binding "${key}" from Options API.`);
|
||
return false;
|
||
} else if (data !== EMPTY_OBJ && hasOwn(data, key)) {
|
||
data[key] = value;
|
||
return true;
|
||
} else if (hasOwn(instance.props, key)) {
|
||
!!(process.env.NODE_ENV !== "production") && warn$1$1(`Attempting to mutate prop "${key}". Props are readonly.`);
|
||
return false;
|
||
}
|
||
if (key[0] === "$" && key.slice(1) in instance) {
|
||
!!(process.env.NODE_ENV !== "production") && warn$1$1(
|
||
`Attempting to mutate public property "${key}". Properties starting with $ are reserved and readonly.`
|
||
);
|
||
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] || data !== EMPTY_OBJ && hasOwn(data, key) || hasSetupBinding$1(setupState, key) || (normalizedProps = propsOptions[0]) && hasOwn(normalizedProps, key) || hasOwn(ctx, key) || hasOwn(publicPropertiesMap$1, key) || hasOwn(appContext.config.globalProperties, key);
|
||
},
|
||
defineProperty(target, key, descriptor) {
|
||
if (descriptor.get != null) {
|
||
target._.accessCache[key] = 0;
|
||
} else if (hasOwn(descriptor, "value")) {
|
||
this.set(target, key, descriptor.value, null);
|
||
}
|
||
return Reflect.defineProperty(target, key, descriptor);
|
||
}
|
||
};
|
||
if (!!(process.env.NODE_ENV !== "production") && true) {
|
||
PublicInstanceProxyHandlers$1.ownKeys = (target) => {
|
||
warn$1$1(
|
||
`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);
|
||
};
|
||
}
|
||
function normalizePropsOrEmits$1(props) {
|
||
return isArray(props) ? props.reduce(
|
||
(normalized, p) => (normalized[p] = null, normalized),
|
||
{}
|
||
) : props;
|
||
}
|
||
let shouldCacheAccess$1 = true;
|
||
function resolveMergedOptions$1(instance) {
|
||
const base = instance.type;
|
||
const { mixins, extends: extendsOptions } = base;
|
||
const {
|
||
mixins: globalMixins,
|
||
optionsCache: cache,
|
||
config: { optionMergeStrategies }
|
||
} = instance.appContext;
|
||
const cached = cache.get(base);
|
||
let resolved;
|
||
if (cached) {
|
||
resolved = cached;
|
||
} else if (!globalMixins.length && !mixins && !extendsOptions) {
|
||
{
|
||
resolved = base;
|
||
}
|
||
} else {
|
||
resolved = {};
|
||
if (globalMixins.length) {
|
||
globalMixins.forEach(
|
||
(m) => mergeOptions$1(resolved, m, optionMergeStrategies, true)
|
||
);
|
||
}
|
||
mergeOptions$1(resolved, base, optionMergeStrategies);
|
||
}
|
||
if (isObject(base)) {
|
||
cache.set(base, resolved);
|
||
}
|
||
return resolved;
|
||
}
|
||
function mergeOptions$1(to, from, strats, asMixin = false) {
|
||
const { mixins, extends: extendsOptions } = from;
|
||
if (extendsOptions) {
|
||
mergeOptions$1(to, extendsOptions, strats, true);
|
||
}
|
||
if (mixins) {
|
||
mixins.forEach(
|
||
(m) => mergeOptions$1(to, m, strats, true)
|
||
);
|
||
}
|
||
for (const key in from) {
|
||
if (asMixin && key === "expose") {
|
||
!!(process.env.NODE_ENV !== "production") && warn$1$1(
|
||
`"expose" option is ignored when declared in mixins or extends. It should only be declared in the base component itself.`
|
||
);
|
||
} else {
|
||
const strat = internalOptionMergeStrats$1[key] || strats && strats[key];
|
||
to[key] = strat ? strat(to[key], from[key]) : from[key];
|
||
}
|
||
}
|
||
return to;
|
||
}
|
||
const internalOptionMergeStrats$1 = {
|
||
data: mergeDataFn$1,
|
||
props: mergeEmitsOrPropsOptions$1,
|
||
emits: mergeEmitsOrPropsOptions$1,
|
||
// objects
|
||
methods: mergeObjectOptions$1,
|
||
computed: mergeObjectOptions$1,
|
||
// lifecycle
|
||
beforeCreate: mergeAsArray$2,
|
||
created: mergeAsArray$2,
|
||
beforeMount: mergeAsArray$2,
|
||
mounted: mergeAsArray$2,
|
||
beforeUpdate: mergeAsArray$2,
|
||
updated: mergeAsArray$2,
|
||
beforeDestroy: mergeAsArray$2,
|
||
beforeUnmount: mergeAsArray$2,
|
||
destroyed: mergeAsArray$2,
|
||
unmounted: mergeAsArray$2,
|
||
activated: mergeAsArray$2,
|
||
deactivated: mergeAsArray$2,
|
||
errorCaptured: mergeAsArray$2,
|
||
serverPrefetch: mergeAsArray$2,
|
||
// assets
|
||
components: mergeObjectOptions$1,
|
||
directives: mergeObjectOptions$1,
|
||
// watch
|
||
watch: mergeWatchOptions$1,
|
||
// provide / inject
|
||
provide: mergeDataFn$1,
|
||
inject: mergeInject$1
|
||
};
|
||
function mergeDataFn$1(to, from) {
|
||
if (!from) {
|
||
return to;
|
||
}
|
||
if (!to) {
|
||
return from;
|
||
}
|
||
return function mergedDataFn() {
|
||
return (extend)(
|
||
isFunction(to) ? to.call(this, this) : to,
|
||
isFunction(from) ? from.call(this, this) : from
|
||
);
|
||
};
|
||
}
|
||
function mergeInject$1(to, from) {
|
||
return mergeObjectOptions$1(normalizeInject$1(to), normalizeInject$1(from));
|
||
}
|
||
function normalizeInject$1(raw) {
|
||
if (isArray(raw)) {
|
||
const res = {};
|
||
for (let i = 0; i < raw.length; i++) {
|
||
res[raw[i]] = raw[i];
|
||
}
|
||
return res;
|
||
}
|
||
return raw;
|
||
}
|
||
function mergeAsArray$2(to, from) {
|
||
return to ? [...new Set([].concat(to, from))] : from;
|
||
}
|
||
function mergeObjectOptions$1(to, from) {
|
||
return to ? extend(/* @__PURE__ */ Object.create(null), to, from) : from;
|
||
}
|
||
function mergeEmitsOrPropsOptions$1(to, from) {
|
||
if (to) {
|
||
if (isArray(to) && isArray(from)) {
|
||
return [.../* @__PURE__ */ new Set([...to, ...from])];
|
||
}
|
||
return extend(
|
||
/* @__PURE__ */ Object.create(null),
|
||
normalizePropsOrEmits$1(to),
|
||
normalizePropsOrEmits$1(from != null ? from : {})
|
||
);
|
||
} else {
|
||
return from;
|
||
}
|
||
}
|
||
function mergeWatchOptions$1(to, from) {
|
||
if (!to)
|
||
return from;
|
||
if (!from)
|
||
return to;
|
||
const merged = extend(/* @__PURE__ */ Object.create(null), to);
|
||
for (const key in from) {
|
||
merged[key] = mergeAsArray$2(to[key], from[key]);
|
||
}
|
||
return merged;
|
||
}
|
||
let currentApp$1 = null;
|
||
function inject$1(key, defaultValue, treatDefaultAsFactory = false) {
|
||
const instance = currentInstance$1 || currentRenderingInstance$1;
|
||
if (instance || currentApp$1) {
|
||
const provides = instance ? instance.parent == null ? instance.vnode.appContext && instance.vnode.appContext.provides : instance.parent.provides : currentApp$1._context.provides;
|
||
if (provides && key in provides) {
|
||
return provides[key];
|
||
} else if (arguments.length > 1) {
|
||
return treatDefaultAsFactory && isFunction(defaultValue) ? defaultValue.call(instance && instance.proxy) : defaultValue;
|
||
} else if (!!(process.env.NODE_ENV !== "production")) {
|
||
warn$1$1(`injection "${String(key)}" not found.`);
|
||
}
|
||
} else if (!!(process.env.NODE_ENV !== "production")) {
|
||
warn$1$1(`inject() can only be used inside setup() or functional components.`);
|
||
}
|
||
}
|
||
|
||
const queuePostRenderEffect$2 = queueEffectWithSuspense ;
|
||
|
||
const isTeleport$1 = (type) => type.__isTeleport;
|
||
|
||
const Fragment$1 = Symbol.for("v-fgt");
|
||
const Text$1 = Symbol.for("v-txt");
|
||
const Comment$1 = Symbol.for("v-cmt");
|
||
let currentBlock$1 = null;
|
||
function isVNode$1(value) {
|
||
return value ? value.__v_isVNode === true : false;
|
||
}
|
||
const createVNodeWithArgsTransform$1 = (...args) => {
|
||
return _createVNode$1(
|
||
...args
|
||
);
|
||
};
|
||
const InternalObjectKey$1 = `__vInternal`;
|
||
const normalizeKey$1 = ({ key }) => key != null ? key : null;
|
||
const normalizeRef$1 = ({
|
||
ref,
|
||
ref_key,
|
||
ref_for
|
||
}) => {
|
||
if (typeof ref === "number") {
|
||
ref = "" + ref;
|
||
}
|
||
return ref != null ? isString(ref) || isRef$1(ref) || isFunction(ref) ? { i: currentRenderingInstance$1, r: ref, k: ref_key, f: !!ref_for } : ref : null;
|
||
};
|
||
function createBaseVNode$1(type, props = null, children = null, patchFlag = 0, dynamicProps = null, shapeFlag = type === Fragment$1 ? 0 : 1, isBlockNode = false, needFullChildrenNormalization = false) {
|
||
const vnode = {
|
||
__v_isVNode: true,
|
||
__v_skip: true,
|
||
type,
|
||
props,
|
||
key: props && normalizeKey$1(props),
|
||
ref: props && normalizeRef$1(props),
|
||
scopeId: currentScopeId$1,
|
||
slotScopeIds: null,
|
||
children,
|
||
component: null,
|
||
suspense: null,
|
||
ssContent: null,
|
||
ssFallback: null,
|
||
dirs: null,
|
||
transition: null,
|
||
el: null,
|
||
anchor: null,
|
||
target: null,
|
||
targetAnchor: null,
|
||
staticCount: 0,
|
||
shapeFlag,
|
||
patchFlag,
|
||
dynamicProps,
|
||
dynamicChildren: null,
|
||
appContext: null,
|
||
ctx: currentRenderingInstance$1
|
||
};
|
||
if (needFullChildrenNormalization) {
|
||
normalizeChildren$1(vnode, children);
|
||
if (shapeFlag & 128) {
|
||
type.normalize(vnode);
|
||
}
|
||
} else if (children) {
|
||
vnode.shapeFlag |= isString(children) ? 8 : 16;
|
||
}
|
||
if (!!(process.env.NODE_ENV !== "production") && vnode.key !== vnode.key) {
|
||
warn$1$1(`VNode created with invalid key (NaN). VNode type:`, vnode.type);
|
||
}
|
||
if (// avoid a block node from tracking itself
|
||
!isBlockNode && // has current parent block
|
||
currentBlock$1 && // presence of a patch flag indicates this node needs patching on updates.
|
||
// component nodes also should always be patched, because even if the
|
||
// component doesn't need to update, it needs to persist the instance on to
|
||
// the next vnode so that it can be properly unmounted later.
|
||
(vnode.patchFlag > 0 || shapeFlag & 6) && // the EVENTS flag is only for hydration and if it is the only flag, the
|
||
// vnode should not be considered dynamic due to handler caching.
|
||
vnode.patchFlag !== 32) {
|
||
currentBlock$1.push(vnode);
|
||
}
|
||
return vnode;
|
||
}
|
||
const createVNode$2 = !!(process.env.NODE_ENV !== "production") ? createVNodeWithArgsTransform$1 : _createVNode$1;
|
||
function _createVNode$1(type, props = null, children = null, patchFlag = 0, dynamicProps = null, isBlockNode = false) {
|
||
if (!type || type === NULL_DYNAMIC_COMPONENT$1) {
|
||
if (!!(process.env.NODE_ENV !== "production") && !type) {
|
||
warn$1$1(`Invalid vnode type when creating vnode: ${type}.`);
|
||
}
|
||
type = Comment$1;
|
||
}
|
||
if (isVNode$1(type)) {
|
||
const cloned = cloneVNode$1(
|
||
type,
|
||
props,
|
||
true
|
||
/* mergeRef: true */
|
||
);
|
||
if (children) {
|
||
normalizeChildren$1(cloned, children);
|
||
}
|
||
if (!isBlockNode && currentBlock$1) {
|
||
if (cloned.shapeFlag & 6) {
|
||
currentBlock$1[currentBlock$1.indexOf(type)] = cloned;
|
||
} else {
|
||
currentBlock$1.push(cloned);
|
||
}
|
||
}
|
||
cloned.patchFlag |= -2;
|
||
return cloned;
|
||
}
|
||
if (isClassComponent$1(type)) {
|
||
type = type.__vccOpts;
|
||
}
|
||
if (props) {
|
||
props = guardReactiveProps$1(props);
|
||
let { class: klass, style } = props;
|
||
if (klass && !isString(klass)) {
|
||
props.class = normalizeClass(klass);
|
||
}
|
||
if (isObject(style)) {
|
||
if (isProxy$1(style) && !isArray(style)) {
|
||
style = extend({}, style);
|
||
}
|
||
props.style = normalizeStyle(style);
|
||
}
|
||
}
|
||
const shapeFlag = isString(type) ? 1 : isSuspense(type) ? 128 : isTeleport$1(type) ? 64 : isObject(type) ? 4 : isFunction(type) ? 2 : 0;
|
||
if (!!(process.env.NODE_ENV !== "production") && shapeFlag & 4 && isProxy$1(type)) {
|
||
type = toRaw$1(type);
|
||
warn$1$1(
|
||
`Vue received a Component that was made a reactive object. This can lead to unnecessary performance overhead and should be avoided by marking the component with \`markRaw\` or using \`shallowRef\` instead of \`ref\`.`,
|
||
`
|
||
Component that was made reactive: `,
|
||
type
|
||
);
|
||
}
|
||
return createBaseVNode$1(
|
||
type,
|
||
props,
|
||
children,
|
||
patchFlag,
|
||
dynamicProps,
|
||
shapeFlag,
|
||
isBlockNode,
|
||
true
|
||
);
|
||
}
|
||
function guardReactiveProps$1(props) {
|
||
if (!props)
|
||
return null;
|
||
return isProxy$1(props) || InternalObjectKey$1 in props ? extend({}, props) : props;
|
||
}
|
||
function cloneVNode$1(vnode, extraProps, mergeRef = false) {
|
||
const { props, ref, patchFlag, children } = vnode;
|
||
const mergedProps = extraProps ? mergeProps$1(props || {}, extraProps) : props;
|
||
const cloned = {
|
||
__v_isVNode: true,
|
||
__v_skip: true,
|
||
type: vnode.type,
|
||
props: mergedProps,
|
||
key: mergedProps && normalizeKey$1(mergedProps),
|
||
ref: extraProps && extraProps.ref ? (
|
||
// #2078 in the case of <component :is="vnode" ref="extra"/>
|
||
// if the vnode itself already has a ref, cloneVNode will need to merge
|
||
// the refs so the single vnode can be set on multiple refs
|
||
mergeRef && ref ? isArray(ref) ? ref.concat(normalizeRef$1(extraProps)) : [ref, normalizeRef$1(extraProps)] : normalizeRef$1(extraProps)
|
||
) : ref,
|
||
scopeId: vnode.scopeId,
|
||
slotScopeIds: vnode.slotScopeIds,
|
||
children: !!(process.env.NODE_ENV !== "production") && patchFlag === -1 && isArray(children) ? children.map(deepCloneVNode$1) : children,
|
||
target: vnode.target,
|
||
targetAnchor: vnode.targetAnchor,
|
||
staticCount: vnode.staticCount,
|
||
shapeFlag: vnode.shapeFlag,
|
||
// if the vnode is cloned with extra props, we can no longer assume its
|
||
// existing patch flag to be reliable and need to add the FULL_PROPS flag.
|
||
// note: preserve flag for fragments since they use the flag for children
|
||
// fast paths only.
|
||
patchFlag: extraProps && vnode.type !== Fragment$1 ? patchFlag === -1 ? 16 : patchFlag | 16 : patchFlag,
|
||
dynamicProps: vnode.dynamicProps,
|
||
dynamicChildren: vnode.dynamicChildren,
|
||
appContext: vnode.appContext,
|
||
dirs: vnode.dirs,
|
||
transition: vnode.transition,
|
||
// These should technically only be non-null on mounted VNodes. However,
|
||
// they *should* be copied for kept-alive vnodes. So we just always copy
|
||
// them since them being non-null during a mount doesn't affect the logic as
|
||
// they will simply be overwritten.
|
||
component: vnode.component,
|
||
suspense: vnode.suspense,
|
||
ssContent: vnode.ssContent && cloneVNode$1(vnode.ssContent),
|
||
ssFallback: vnode.ssFallback && cloneVNode$1(vnode.ssFallback),
|
||
el: vnode.el,
|
||
anchor: vnode.anchor,
|
||
ctx: vnode.ctx,
|
||
ce: vnode.ce
|
||
};
|
||
return cloned;
|
||
}
|
||
function deepCloneVNode$1(vnode) {
|
||
const cloned = cloneVNode$1(vnode);
|
||
if (isArray(vnode.children)) {
|
||
cloned.children = vnode.children.map(deepCloneVNode$1);
|
||
}
|
||
return cloned;
|
||
}
|
||
function createTextVNode$1(text = " ", flag = 0) {
|
||
return createVNode$2(Text$1, null, text, flag);
|
||
}
|
||
function normalizeChildren$1(vnode, children) {
|
||
let type = 0;
|
||
const { shapeFlag } = vnode;
|
||
if (children == null) {
|
||
children = null;
|
||
} else if (isArray(children)) {
|
||
type = 16;
|
||
} else if (typeof children === "object") {
|
||
if (shapeFlag & (1 | 64)) {
|
||
const slot = children.default;
|
||
if (slot) {
|
||
slot._c && (slot._d = false);
|
||
normalizeChildren$1(vnode, slot());
|
||
slot._c && (slot._d = true);
|
||
}
|
||
return;
|
||
} else {
|
||
type = 32;
|
||
const slotFlag = children._;
|
||
if (!slotFlag && !(InternalObjectKey$1 in children)) {
|
||
children._ctx = currentRenderingInstance$1;
|
||
} else if (slotFlag === 3 && currentRenderingInstance$1) {
|
||
if (currentRenderingInstance$1.slots._ === 1) {
|
||
children._ = 1;
|
||
} else {
|
||
children._ = 2;
|
||
vnode.patchFlag |= 1024;
|
||
}
|
||
}
|
||
}
|
||
} else if (isFunction(children)) {
|
||
children = { default: children, _ctx: currentRenderingInstance$1 };
|
||
type = 32;
|
||
} else {
|
||
children = String(children);
|
||
if (shapeFlag & 64) {
|
||
type = 16;
|
||
children = [createTextVNode$1(children)];
|
||
} else {
|
||
type = 8;
|
||
}
|
||
}
|
||
vnode.children = children;
|
||
vnode.shapeFlag |= type;
|
||
}
|
||
function mergeProps$1(...args) {
|
||
const ret = {};
|
||
for (let i = 0; i < args.length; i++) {
|
||
const toMerge = args[i];
|
||
for (const key in toMerge) {
|
||
if (key === "class") {
|
||
if (ret.class !== toMerge.class) {
|
||
ret.class = normalizeClass([ret.class, toMerge.class]);
|
||
}
|
||
} else if (key === "style") {
|
||
ret.style = normalizeStyle([ret.style, toMerge.style]);
|
||
} else if (isOn(key)) {
|
||
const existing = ret[key];
|
||
const incoming = toMerge[key];
|
||
if (incoming && existing !== incoming && !(isArray(existing) && existing.includes(incoming))) {
|
||
ret[key] = existing ? [].concat(existing, incoming) : incoming;
|
||
}
|
||
} else if (key !== "") {
|
||
ret[key] = toMerge[key];
|
||
}
|
||
}
|
||
}
|
||
return ret;
|
||
}
|
||
let currentInstance$1 = null;
|
||
const getCurrentInstance$1 = () => currentInstance$1 || currentRenderingInstance$1;
|
||
let internalSetCurrentInstance$1;
|
||
{
|
||
const g = getGlobalThis();
|
||
const registerGlobalSetter = (key, setter) => {
|
||
let setters;
|
||
if (!(setters = g[key]))
|
||
setters = g[key] = [];
|
||
setters.push(setter);
|
||
return (v) => {
|
||
if (setters.length > 1)
|
||
setters.forEach((set) => set(v));
|
||
else
|
||
setters[0](v);
|
||
};
|
||
};
|
||
internalSetCurrentInstance$1 = registerGlobalSetter(
|
||
`__VUE_INSTANCE_SETTERS__`,
|
||
(v) => currentInstance$1 = v
|
||
);
|
||
registerGlobalSetter(
|
||
`__VUE_SSR_SETTERS__`,
|
||
(v) => isInSSRComponentSetup$1 = v
|
||
);
|
||
}
|
||
const setCurrentInstance$1 = (instance) => {
|
||
const prev = currentInstance$1;
|
||
internalSetCurrentInstance$1(instance);
|
||
instance.scope.on();
|
||
return () => {
|
||
instance.scope.off();
|
||
internalSetCurrentInstance$1(prev);
|
||
};
|
||
};
|
||
function isStatefulComponent$1(instance) {
|
||
return instance.vnode.shapeFlag & 4;
|
||
}
|
||
let isInSSRComponentSetup$1 = false;
|
||
function getExposeProxy$1(instance) {
|
||
if (instance.exposed) {
|
||
return instance.exposeProxy || (instance.exposeProxy = new Proxy(proxyRefs$1(markRaw$1(instance.exposed)), {
|
||
get(target, key) {
|
||
if (key in target) {
|
||
return target[key];
|
||
} else if (key in publicPropertiesMap$1) {
|
||
return publicPropertiesMap$1[key](instance);
|
||
}
|
||
},
|
||
has(target, key) {
|
||
return key in target || key in publicPropertiesMap$1;
|
||
}
|
||
}));
|
||
}
|
||
}
|
||
const classifyRE$1 = /(?:^|[-_])(\w)/g;
|
||
const classify$1 = (str) => str.replace(classifyRE$1, (c) => c.toUpperCase()).replace(/[-_]/g, "");
|
||
function getComponentName$1(Component, includeInferred = true) {
|
||
return isFunction(Component) ? Component.displayName || Component.name : Component.name || includeInferred && Component.__name;
|
||
}
|
||
function formatComponentName$1(instance, Component, isRoot = false) {
|
||
let name = getComponentName$1(Component);
|
||
if (!name && Component.__file) {
|
||
const match = Component.__file.match(/([^/\\]+)\.\w+$/);
|
||
if (match) {
|
||
name = match[1];
|
||
}
|
||
}
|
||
if (!name && instance && instance.parent) {
|
||
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$1(name) : isRoot ? `App` : `Anonymous`;
|
||
}
|
||
function isClassComponent$1(value) {
|
||
return isFunction(value) && "__vccOpts" in value;
|
||
}
|
||
const warn$3 = !!(process.env.NODE_ENV !== "production") ? warn$1$1 : NOOP;
|
||
!!(process.env.NODE_ENV !== "production") || true ? devtools$1 : void 0;
|
||
!!(process.env.NODE_ENV !== "production") || true ? setDevtoolsHook$1 : NOOP;
|
||
|
||
/**
|
||
* @vue/runtime-dom v3.4.21
|
||
* (c) 2018-present Yuxi (Evan) You and Vue contributors
|
||
* @license MIT
|
||
**/
|
||
if (!!(process.env.NODE_ENV !== "production")) ;
|
||
|
||
Symbol(!!(process.env.NODE_ENV !== "production") ? "CSS_VAR_TEXT" : "");
|
||
|
||
function useCssModule(name = "$style") {
|
||
{
|
||
const instance = getCurrentInstance$1();
|
||
if (!instance) {
|
||
!!(process.env.NODE_ENV !== "production") && warn$3(`useCssModule must be called inside setup()`);
|
||
return EMPTY_OBJ;
|
||
}
|
||
const modules = instance.type.__cssModules;
|
||
if (!modules) {
|
||
!!(process.env.NODE_ENV !== "production") && warn$3(`Current instance does not have CSS modules injected.`);
|
||
return EMPTY_OBJ;
|
||
}
|
||
const mod = modules[name];
|
||
if (!mod) {
|
||
!!(process.env.NODE_ENV !== "production") && warn$3(`Current instance does not have CSS module named "${name}".`);
|
||
return EMPTY_OBJ;
|
||
}
|
||
return mod;
|
||
}
|
||
}
|
||
|
||
/**
|
||
* @dcloudio/uni-mp-vue v3.4.21
|
||
* (c) 2018-present Yuxi (Evan) You and Vue contributors
|
||
* @license MIT
|
||
**/
|
||
|
||
function warn$2(msg, ...args) {
|
||
console.warn(`[Vue warn] ${msg}`, ...args);
|
||
}
|
||
|
||
let activeEffectScope;
|
||
class EffectScope {
|
||
constructor(detached = false) {
|
||
this.detached = detached;
|
||
/**
|
||
* @internal
|
||
*/
|
||
this._active = true;
|
||
/**
|
||
* @internal
|
||
*/
|
||
this.effects = [];
|
||
/**
|
||
* @internal
|
||
*/
|
||
this.cleanups = [];
|
||
this.parent = activeEffectScope;
|
||
if (!detached && activeEffectScope) {
|
||
this.index = (activeEffectScope.scopes || (activeEffectScope.scopes = [])).push(
|
||
this
|
||
) - 1;
|
||
}
|
||
}
|
||
get active() {
|
||
return this._active;
|
||
}
|
||
run(fn) {
|
||
if (this._active) {
|
||
const currentEffectScope = activeEffectScope;
|
||
try {
|
||
activeEffectScope = this;
|
||
return fn();
|
||
} finally {
|
||
activeEffectScope = currentEffectScope;
|
||
}
|
||
} else if (!!(process.env.NODE_ENV !== "production")) {
|
||
warn$2(`cannot run an inactive effect scope.`);
|
||
}
|
||
}
|
||
/**
|
||
* This should only be called on non-detached scopes
|
||
* @internal
|
||
*/
|
||
on() {
|
||
activeEffectScope = this;
|
||
}
|
||
/**
|
||
* This should only be called on non-detached scopes
|
||
* @internal
|
||
*/
|
||
off() {
|
||
activeEffectScope = this.parent;
|
||
}
|
||
stop(fromParent) {
|
||
if (this._active) {
|
||
let i, l;
|
||
for (i = 0, l = this.effects.length; i < l; i++) {
|
||
this.effects[i].stop();
|
||
}
|
||
for (i = 0, l = this.cleanups.length; i < l; i++) {
|
||
this.cleanups[i]();
|
||
}
|
||
if (this.scopes) {
|
||
for (i = 0, l = this.scopes.length; i < l; i++) {
|
||
this.scopes[i].stop(true);
|
||
}
|
||
}
|
||
if (!this.detached && this.parent && !fromParent) {
|
||
const last = this.parent.scopes.pop();
|
||
if (last && last !== this) {
|
||
this.parent.scopes[this.index] = last;
|
||
last.index = this.index;
|
||
}
|
||
}
|
||
this.parent = void 0;
|
||
this._active = false;
|
||
}
|
||
}
|
||
}
|
||
function effectScope(detached) {
|
||
return new EffectScope(detached);
|
||
}
|
||
function recordEffectScope(effect, scope = activeEffectScope) {
|
||
if (scope && scope.active) {
|
||
scope.effects.push(effect);
|
||
}
|
||
}
|
||
function getCurrentScope() {
|
||
return activeEffectScope;
|
||
}
|
||
function onScopeDispose(fn) {
|
||
if (activeEffectScope) {
|
||
activeEffectScope.cleanups.push(fn);
|
||
} else if (!!(process.env.NODE_ENV !== "production")) {
|
||
warn$2(
|
||
`onScopeDispose() is called when there is no active effect scope to be associated with.`
|
||
);
|
||
}
|
||
}
|
||
|
||
let activeEffect;
|
||
class ReactiveEffect {
|
||
constructor(fn, trigger, scheduler, scope) {
|
||
this.fn = fn;
|
||
this.trigger = trigger;
|
||
this.scheduler = scheduler;
|
||
this.active = true;
|
||
this.deps = [];
|
||
/**
|
||
* @internal
|
||
*/
|
||
this._dirtyLevel = 4;
|
||
/**
|
||
* @internal
|
||
*/
|
||
this._trackId = 0;
|
||
/**
|
||
* @internal
|
||
*/
|
||
this._runnings = 0;
|
||
/**
|
||
* @internal
|
||
*/
|
||
this._shouldSchedule = false;
|
||
/**
|
||
* @internal
|
||
*/
|
||
this._depsLength = 0;
|
||
recordEffectScope(this, scope);
|
||
}
|
||
get dirty() {
|
||
if (this._dirtyLevel === 2 || this._dirtyLevel === 3) {
|
||
this._dirtyLevel = 1;
|
||
pauseTracking();
|
||
for (let i = 0; i < this._depsLength; i++) {
|
||
const dep = this.deps[i];
|
||
if (dep.computed) {
|
||
triggerComputed(dep.computed);
|
||
if (this._dirtyLevel >= 4) {
|
||
break;
|
||
}
|
||
}
|
||
}
|
||
if (this._dirtyLevel === 1) {
|
||
this._dirtyLevel = 0;
|
||
}
|
||
resetTracking();
|
||
}
|
||
return this._dirtyLevel >= 4;
|
||
}
|
||
set dirty(v) {
|
||
this._dirtyLevel = v ? 4 : 0;
|
||
}
|
||
run() {
|
||
this._dirtyLevel = 0;
|
||
if (!this.active) {
|
||
return this.fn();
|
||
}
|
||
let lastShouldTrack = shouldTrack;
|
||
let lastEffect = activeEffect;
|
||
try {
|
||
shouldTrack = true;
|
||
activeEffect = this;
|
||
this._runnings++;
|
||
preCleanupEffect(this);
|
||
return this.fn();
|
||
} finally {
|
||
postCleanupEffect(this);
|
||
this._runnings--;
|
||
activeEffect = lastEffect;
|
||
shouldTrack = lastShouldTrack;
|
||
}
|
||
}
|
||
stop() {
|
||
var _a;
|
||
if (this.active) {
|
||
preCleanupEffect(this);
|
||
postCleanupEffect(this);
|
||
(_a = this.onStop) == null ? void 0 : _a.call(this);
|
||
this.active = false;
|
||
}
|
||
}
|
||
}
|
||
function triggerComputed(computed) {
|
||
return computed.value;
|
||
}
|
||
function preCleanupEffect(effect2) {
|
||
effect2._trackId++;
|
||
effect2._depsLength = 0;
|
||
}
|
||
function postCleanupEffect(effect2) {
|
||
if (effect2.deps.length > effect2._depsLength) {
|
||
for (let i = effect2._depsLength; i < effect2.deps.length; i++) {
|
||
cleanupDepEffect(effect2.deps[i], effect2);
|
||
}
|
||
effect2.deps.length = effect2._depsLength;
|
||
}
|
||
}
|
||
function cleanupDepEffect(dep, effect2) {
|
||
const trackId = dep.get(effect2);
|
||
if (trackId !== void 0 && effect2._trackId !== trackId) {
|
||
dep.delete(effect2);
|
||
if (dep.size === 0) {
|
||
dep.cleanup();
|
||
}
|
||
}
|
||
}
|
||
function effect(fn, options) {
|
||
if (fn.effect instanceof ReactiveEffect) {
|
||
fn = fn.effect.fn;
|
||
}
|
||
const _effect = new ReactiveEffect(fn, NOOP, () => {
|
||
if (_effect.dirty) {
|
||
_effect.run();
|
||
}
|
||
});
|
||
if (options) {
|
||
extend(_effect, options);
|
||
if (options.scope)
|
||
recordEffectScope(_effect, options.scope);
|
||
}
|
||
if (!options || !options.lazy) {
|
||
_effect.run();
|
||
}
|
||
const runner = _effect.run.bind(_effect);
|
||
runner.effect = _effect;
|
||
return runner;
|
||
}
|
||
function stop(runner) {
|
||
runner.effect.stop();
|
||
}
|
||
let shouldTrack = true;
|
||
let pauseScheduleStack = 0;
|
||
const trackStack = [];
|
||
function pauseTracking() {
|
||
trackStack.push(shouldTrack);
|
||
shouldTrack = false;
|
||
}
|
||
function resetTracking() {
|
||
const last = trackStack.pop();
|
||
shouldTrack = last === void 0 ? true : last;
|
||
}
|
||
function pauseScheduling() {
|
||
pauseScheduleStack++;
|
||
}
|
||
function resetScheduling() {
|
||
pauseScheduleStack--;
|
||
while (!pauseScheduleStack && queueEffectSchedulers.length) {
|
||
queueEffectSchedulers.shift()();
|
||
}
|
||
}
|
||
function trackEffect(effect2, dep, debuggerEventExtraInfo) {
|
||
var _a;
|
||
if (dep.get(effect2) !== effect2._trackId) {
|
||
dep.set(effect2, effect2._trackId);
|
||
const oldDep = effect2.deps[effect2._depsLength];
|
||
if (oldDep !== dep) {
|
||
if (oldDep) {
|
||
cleanupDepEffect(oldDep, effect2);
|
||
}
|
||
effect2.deps[effect2._depsLength++] = dep;
|
||
} else {
|
||
effect2._depsLength++;
|
||
}
|
||
if (!!(process.env.NODE_ENV !== "production")) {
|
||
(_a = effect2.onTrack) == null ? void 0 : _a.call(effect2, extend({ effect: effect2 }, debuggerEventExtraInfo));
|
||
}
|
||
}
|
||
}
|
||
const queueEffectSchedulers = [];
|
||
function triggerEffects(dep, dirtyLevel, debuggerEventExtraInfo) {
|
||
var _a;
|
||
pauseScheduling();
|
||
for (const effect2 of dep.keys()) {
|
||
let tracking;
|
||
if (effect2._dirtyLevel < dirtyLevel && (tracking != null ? tracking : tracking = dep.get(effect2) === effect2._trackId)) {
|
||
effect2._shouldSchedule || (effect2._shouldSchedule = effect2._dirtyLevel === 0);
|
||
effect2._dirtyLevel = dirtyLevel;
|
||
}
|
||
if (effect2._shouldSchedule && (tracking != null ? tracking : tracking = dep.get(effect2) === effect2._trackId)) {
|
||
if (!!(process.env.NODE_ENV !== "production")) {
|
||
(_a = effect2.onTrigger) == null ? void 0 : _a.call(effect2, extend({ effect: effect2 }, debuggerEventExtraInfo));
|
||
}
|
||
effect2.trigger();
|
||
if ((!effect2._runnings || effect2.allowRecurse) && effect2._dirtyLevel !== 2) {
|
||
effect2._shouldSchedule = false;
|
||
if (effect2.scheduler) {
|
||
queueEffectSchedulers.push(effect2.scheduler);
|
||
}
|
||
}
|
||
}
|
||
}
|
||
resetScheduling();
|
||
}
|
||
|
||
const createDep = (cleanup, computed) => {
|
||
const dep = /* @__PURE__ */ new Map();
|
||
dep.cleanup = cleanup;
|
||
dep.computed = computed;
|
||
return dep;
|
||
};
|
||
|
||
const targetMap = /* @__PURE__ */ new WeakMap();
|
||
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 track(target, type, key) {
|
||
if (shouldTrack && activeEffect) {
|
||
let depsMap = targetMap.get(target);
|
||
if (!depsMap) {
|
||
targetMap.set(target, depsMap = /* @__PURE__ */ new Map());
|
||
}
|
||
let dep = depsMap.get(key);
|
||
if (!dep) {
|
||
depsMap.set(key, dep = createDep(() => depsMap.delete(key)));
|
||
}
|
||
trackEffect(
|
||
activeEffect,
|
||
dep,
|
||
!!(process.env.NODE_ENV !== "production") ? {
|
||
target,
|
||
type,
|
||
key
|
||
} : void 0
|
||
);
|
||
}
|
||
}
|
||
function trigger(target, type, key, newValue, oldValue, oldTarget) {
|
||
const depsMap = targetMap.get(target);
|
||
if (!depsMap) {
|
||
return;
|
||
}
|
||
let deps = [];
|
||
if (type === "clear") {
|
||
deps = [...depsMap.values()];
|
||
} else if (key === "length" && isArray(target)) {
|
||
const newLength = Number(newValue);
|
||
depsMap.forEach((dep, key2) => {
|
||
if (key2 === "length" || !isSymbol(key2) && key2 >= newLength) {
|
||
deps.push(dep);
|
||
}
|
||
});
|
||
} else {
|
||
if (key !== void 0) {
|
||
deps.push(depsMap.get(key));
|
||
}
|
||
switch (type) {
|
||
case "add":
|
||
if (!isArray(target)) {
|
||
deps.push(depsMap.get(ITERATE_KEY));
|
||
if (isMap(target)) {
|
||
deps.push(depsMap.get(MAP_KEY_ITERATE_KEY));
|
||
}
|
||
} else if (isIntegerKey(key)) {
|
||
deps.push(depsMap.get("length"));
|
||
}
|
||
break;
|
||
case "delete":
|
||
if (!isArray(target)) {
|
||
deps.push(depsMap.get(ITERATE_KEY));
|
||
if (isMap(target)) {
|
||
deps.push(depsMap.get(MAP_KEY_ITERATE_KEY));
|
||
}
|
||
}
|
||
break;
|
||
case "set":
|
||
if (isMap(target)) {
|
||
deps.push(depsMap.get(ITERATE_KEY));
|
||
}
|
||
break;
|
||
}
|
||
}
|
||
pauseScheduling();
|
||
for (const dep of deps) {
|
||
if (dep) {
|
||
triggerEffects(
|
||
dep,
|
||
4,
|
||
!!(process.env.NODE_ENV !== "production") ? {
|
||
target,
|
||
type,
|
||
key,
|
||
newValue,
|
||
oldValue,
|
||
oldTarget
|
||
} : void 0
|
||
);
|
||
}
|
||
}
|
||
resetScheduling();
|
||
}
|
||
function getDepFromReactive(object, key) {
|
||
var _a;
|
||
return (_a = targetMap.get(object)) == null ? void 0 : _a.get(key);
|
||
}
|
||
|
||
const isNonTrackableKeys = /* @__PURE__ */ makeMap(`__proto__,__v_isRef,__isVue`);
|
||
const builtInSymbols = new Set(
|
||
/* @__PURE__ */ Object.getOwnPropertyNames(Symbol).filter((key) => key !== "arguments" && key !== "caller").map((key) => Symbol[key]).filter(isSymbol)
|
||
);
|
||
const arrayInstrumentations = /* @__PURE__ */ createArrayInstrumentations();
|
||
function createArrayInstrumentations() {
|
||
const instrumentations = {};
|
||
["includes", "indexOf", "lastIndexOf"].forEach((key) => {
|
||
instrumentations[key] = function(...args) {
|
||
const arr = toRaw(this);
|
||
for (let i = 0, l = this.length; i < l; i++) {
|
||
track(arr, "get", i + "");
|
||
}
|
||
const res = arr[key](...args);
|
||
if (res === -1 || res === false) {
|
||
return arr[key](...args.map(toRaw));
|
||
} else {
|
||
return res;
|
||
}
|
||
};
|
||
});
|
||
["push", "pop", "shift", "unshift", "splice"].forEach((key) => {
|
||
instrumentations[key] = function(...args) {
|
||
pauseTracking();
|
||
pauseScheduling();
|
||
const res = toRaw(this)[key].apply(this, args);
|
||
resetScheduling();
|
||
resetTracking();
|
||
return res;
|
||
};
|
||
});
|
||
return instrumentations;
|
||
}
|
||
function hasOwnProperty(key) {
|
||
const obj = toRaw(this);
|
||
track(obj, "has", key);
|
||
return obj.hasOwnProperty(key);
|
||
}
|
||
class BaseReactiveHandler {
|
||
constructor(_isReadonly = false, _isShallow = false) {
|
||
this._isReadonly = _isReadonly;
|
||
this._isShallow = _isShallow;
|
||
}
|
||
get(target, key, receiver) {
|
||
const isReadonly2 = this._isReadonly, isShallow2 = this._isShallow;
|
||
if (key === "__v_isReactive") {
|
||
return !isReadonly2;
|
||
} else if (key === "__v_isReadonly") {
|
||
return isReadonly2;
|
||
} else if (key === "__v_isShallow") {
|
||
return isShallow2;
|
||
} else if (key === "__v_raw") {
|
||
if (receiver === (isReadonly2 ? isShallow2 ? shallowReadonlyMap : readonlyMap : isShallow2 ? shallowReactiveMap : reactiveMap).get(target) || // receiver is not the reactive proxy, but has the same prototype
|
||
// this means the reciever is a user proxy of the reactive proxy
|
||
Object.getPrototypeOf(target) === Object.getPrototypeOf(receiver)) {
|
||
return target;
|
||
}
|
||
return;
|
||
}
|
||
const targetIsArray = isArray(target);
|
||
if (!isReadonly2) {
|
||
if (targetIsArray && hasOwn(arrayInstrumentations, key)) {
|
||
return Reflect.get(arrayInstrumentations, key, receiver);
|
||
}
|
||
if (key === "hasOwnProperty") {
|
||
return hasOwnProperty;
|
||
}
|
||
}
|
||
const res = Reflect.get(target, key, receiver);
|
||
if (isSymbol(key) ? builtInSymbols.has(key) : isNonTrackableKeys(key)) {
|
||
return res;
|
||
}
|
||
if (!isReadonly2) {
|
||
track(target, "get", key);
|
||
}
|
||
if (isShallow2) {
|
||
return res;
|
||
}
|
||
if (isRef(res)) {
|
||
return targetIsArray && isIntegerKey(key) ? res : res.value;
|
||
}
|
||
if (isObject(res)) {
|
||
return isReadonly2 ? readonly(res) : reactive(res);
|
||
}
|
||
return res;
|
||
}
|
||
}
|
||
class MutableReactiveHandler extends BaseReactiveHandler {
|
||
constructor(isShallow2 = false) {
|
||
super(false, isShallow2);
|
||
}
|
||
set(target, key, value, receiver) {
|
||
let oldValue = target[key];
|
||
if (!this._isShallow) {
|
||
const isOldValueReadonly = isReadonly(oldValue);
|
||
if (!isShallow(value) && !isReadonly(value)) {
|
||
oldValue = toRaw(oldValue);
|
||
value = toRaw(value);
|
||
}
|
||
if (!isArray(target) && isRef(oldValue) && !isRef(value)) {
|
||
if (isOldValueReadonly) {
|
||
return false;
|
||
} else {
|
||
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);
|
||
if (target === toRaw(receiver)) {
|
||
if (!hadKey) {
|
||
trigger(target, "add", key, value);
|
||
} else if (hasChanged(value, oldValue)) {
|
||
trigger(target, "set", key, value, oldValue);
|
||
}
|
||
}
|
||
return result;
|
||
}
|
||
deleteProperty(target, key) {
|
||
const hadKey = hasOwn(target, key);
|
||
const oldValue = target[key];
|
||
const result = Reflect.deleteProperty(target, key);
|
||
if (result && hadKey) {
|
||
trigger(target, "delete", key, void 0, oldValue);
|
||
}
|
||
return result;
|
||
}
|
||
has(target, key) {
|
||
const result = Reflect.has(target, key);
|
||
if (!isSymbol(key) || !builtInSymbols.has(key)) {
|
||
track(target, "has", key);
|
||
}
|
||
return result;
|
||
}
|
||
ownKeys(target) {
|
||
track(
|
||
target,
|
||
"iterate",
|
||
isArray(target) ? "length" : ITERATE_KEY
|
||
);
|
||
return Reflect.ownKeys(target);
|
||
}
|
||
}
|
||
class ReadonlyReactiveHandler extends BaseReactiveHandler {
|
||
constructor(isShallow2 = false) {
|
||
super(true, isShallow2);
|
||
}
|
||
set(target, key) {
|
||
if (!!(process.env.NODE_ENV !== "production")) {
|
||
warn$2(
|
||
`Set operation on key "${String(key)}" failed: target is readonly.`,
|
||
target
|
||
);
|
||
}
|
||
return true;
|
||
}
|
||
deleteProperty(target, key) {
|
||
if (!!(process.env.NODE_ENV !== "production")) {
|
||
warn$2(
|
||
`Delete operation on key "${String(key)}" failed: target is readonly.`,
|
||
target
|
||
);
|
||
}
|
||
return true;
|
||
}
|
||
}
|
||
const mutableHandlers = /* @__PURE__ */ new MutableReactiveHandler();
|
||
const readonlyHandlers = /* @__PURE__ */ new ReadonlyReactiveHandler();
|
||
const shallowReactiveHandlers = /* @__PURE__ */ new MutableReactiveHandler(
|
||
true
|
||
);
|
||
const shallowReadonlyHandlers = /* @__PURE__ */ new ReadonlyReactiveHandler(true);
|
||
|
||
const toShallow = (value) => value;
|
||
const getProto = (v) => Reflect.getPrototypeOf(v);
|
||
function get(target, key, isReadonly = false, isShallow = false) {
|
||
target = target["__v_raw"];
|
||
const rawTarget = toRaw(target);
|
||
const rawKey = toRaw(key);
|
||
if (!isReadonly) {
|
||
if (hasChanged(key, rawKey)) {
|
||
track(rawTarget, "get", key);
|
||
}
|
||
track(rawTarget, "get", rawKey);
|
||
}
|
||
const { has: has2 } = getProto(rawTarget);
|
||
const wrap = isShallow ? toShallow : isReadonly ? toReadonly : toReactive;
|
||
if (has2.call(rawTarget, key)) {
|
||
return wrap(target.get(key));
|
||
} else if (has2.call(rawTarget, rawKey)) {
|
||
return wrap(target.get(rawKey));
|
||
} else if (target !== rawTarget) {
|
||
target.get(key);
|
||
}
|
||
}
|
||
function has(key, isReadonly = false) {
|
||
const target = this["__v_raw"];
|
||
const rawTarget = toRaw(target);
|
||
const rawKey = toRaw(key);
|
||
if (!isReadonly) {
|
||
if (hasChanged(key, rawKey)) {
|
||
track(rawTarget, "has", key);
|
||
}
|
||
track(rawTarget, "has", rawKey);
|
||
}
|
||
return key === rawKey ? target.has(key) : target.has(key) || target.has(rawKey);
|
||
}
|
||
function size(target, isReadonly = false) {
|
||
target = target["__v_raw"];
|
||
!isReadonly && track(toRaw(target), "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);
|
||
if (!hadKey) {
|
||
target.add(value);
|
||
trigger(target, "add", value, value);
|
||
}
|
||
return this;
|
||
}
|
||
function set$1(key, value) {
|
||
value = toRaw(value);
|
||
const target = toRaw(this);
|
||
const { has: has2, get: get2 } = getProto(target);
|
||
let hadKey = has2.call(target, key);
|
||
if (!hadKey) {
|
||
key = toRaw(key);
|
||
hadKey = has2.call(target, key);
|
||
} else if (!!(process.env.NODE_ENV !== "production")) {
|
||
checkIdentityKeys(target, has2, key);
|
||
}
|
||
const oldValue = get2.call(target, key);
|
||
target.set(key, value);
|
||
if (!hadKey) {
|
||
trigger(target, "add", key, value);
|
||
} else if (hasChanged(value, oldValue)) {
|
||
trigger(target, "set", key, value, oldValue);
|
||
}
|
||
return this;
|
||
}
|
||
function deleteEntry(key) {
|
||
const target = toRaw(this);
|
||
const { has: has2, get: get2 } = getProto(target);
|
||
let hadKey = has2.call(target, key);
|
||
if (!hadKey) {
|
||
key = toRaw(key);
|
||
hadKey = has2.call(target, key);
|
||
} else if (!!(process.env.NODE_ENV !== "production")) {
|
||
checkIdentityKeys(target, has2, key);
|
||
}
|
||
const oldValue = get2 ? get2.call(target, key) : void 0;
|
||
const result = target.delete(key);
|
||
if (hadKey) {
|
||
trigger(target, "delete", key, void 0, oldValue);
|
||
}
|
||
return result;
|
||
}
|
||
function clear() {
|
||
const target = toRaw(this);
|
||
const hadItems = target.size !== 0;
|
||
const oldTarget = !!(process.env.NODE_ENV !== "production") ? isMap(target) ? new Map(target) : new Set(target) : void 0;
|
||
const result = target.clear();
|
||
if (hadItems) {
|
||
trigger(target, "clear", void 0, void 0, oldTarget);
|
||
}
|
||
return result;
|
||
}
|
||
function createForEach(isReadonly, isShallow) {
|
||
return function forEach(callback, thisArg) {
|
||
const observed = this;
|
||
const target = observed["__v_raw"];
|
||
const rawTarget = toRaw(target);
|
||
const wrap = isShallow ? toShallow : isReadonly ? toReadonly : toReactive;
|
||
!isReadonly && track(rawTarget, "iterate", ITERATE_KEY);
|
||
return target.forEach((value, key) => {
|
||
return callback.call(thisArg, wrap(value), wrap(key), observed);
|
||
});
|
||
};
|
||
}
|
||
function createIterableMethod(method, isReadonly, isShallow) {
|
||
return function(...args) {
|
||
const target = this["__v_raw"];
|
||
const rawTarget = toRaw(target);
|
||
const targetIsMap = isMap(rawTarget);
|
||
const isPair = method === "entries" || method === Symbol.iterator && targetIsMap;
|
||
const isKeyOnly = method === "keys" && targetIsMap;
|
||
const innerIterator = target[method](...args);
|
||
const wrap = isShallow ? toShallow : isReadonly ? toReadonly : toReactive;
|
||
!isReadonly && track(
|
||
rawTarget,
|
||
"iterate",
|
||
isKeyOnly ? MAP_KEY_ITERATE_KEY : ITERATE_KEY
|
||
);
|
||
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]}" ` : ``;
|
||
warn$2(
|
||
`${capitalize(type)} operation ${key}failed: target is readonly.`,
|
||
toRaw(this)
|
||
);
|
||
}
|
||
return type === "delete" ? false : type === "clear" ? void 0 : this;
|
||
};
|
||
}
|
||
function createInstrumentations() {
|
||
const mutableInstrumentations2 = {
|
||
get(key) {
|
||
return get(this, key);
|
||
},
|
||
get size() {
|
||
return size(this);
|
||
},
|
||
has,
|
||
add,
|
||
set: set$1,
|
||
delete: deleteEntry,
|
||
clear,
|
||
forEach: createForEach(false, false)
|
||
};
|
||
const shallowInstrumentations2 = {
|
||
get(key) {
|
||
return get(this, key, false, true);
|
||
},
|
||
get size() {
|
||
return size(this);
|
||
},
|
||
has,
|
||
add,
|
||
set: set$1,
|
||
delete: deleteEntry,
|
||
clear,
|
||
forEach: createForEach(false, true)
|
||
};
|
||
const readonlyInstrumentations2 = {
|
||
get(key) {
|
||
return get(this, key, true);
|
||
},
|
||
get size() {
|
||
return size(this, true);
|
||
},
|
||
has(key) {
|
||
return has.call(this, key, true);
|
||
},
|
||
add: createReadonlyMethod("add"),
|
||
set: createReadonlyMethod("set"),
|
||
delete: createReadonlyMethod("delete"),
|
||
clear: createReadonlyMethod("clear"),
|
||
forEach: createForEach(true, false)
|
||
};
|
||
const shallowReadonlyInstrumentations2 = {
|
||
get(key) {
|
||
return get(this, key, true, true);
|
||
},
|
||
get size() {
|
||
return size(this, true);
|
||
},
|
||
has(key) {
|
||
return has.call(this, key, true);
|
||
},
|
||
add: createReadonlyMethod("add"),
|
||
set: createReadonlyMethod("set"),
|
||
delete: createReadonlyMethod("delete"),
|
||
clear: createReadonlyMethod("clear"),
|
||
forEach: createForEach(true, true)
|
||
};
|
||
const iteratorMethods = [
|
||
"keys",
|
||
"values",
|
||
"entries",
|
||
Symbol.iterator
|
||
];
|
||
iteratorMethods.forEach((method) => {
|
||
mutableInstrumentations2[method] = createIterableMethod(method, false, false);
|
||
readonlyInstrumentations2[method] = createIterableMethod(method, true, false);
|
||
shallowInstrumentations2[method] = createIterableMethod(method, false, true);
|
||
shallowReadonlyInstrumentations2[method] = createIterableMethod(
|
||
method,
|
||
true,
|
||
true
|
||
);
|
||
});
|
||
return [
|
||
mutableInstrumentations2,
|
||
readonlyInstrumentations2,
|
||
shallowInstrumentations2,
|
||
shallowReadonlyInstrumentations2
|
||
];
|
||
}
|
||
const [
|
||
mutableInstrumentations,
|
||
readonlyInstrumentations,
|
||
shallowInstrumentations,
|
||
shallowReadonlyInstrumentations
|
||
] = /* @__PURE__ */ createInstrumentations();
|
||
function createInstrumentationGetter(isReadonly, shallow) {
|
||
const instrumentations = shallow ? isReadonly ? shallowReadonlyInstrumentations : shallowInstrumentations : isReadonly ? readonlyInstrumentations : mutableInstrumentations;
|
||
return (target, key, receiver) => {
|
||
if (key === "__v_isReactive") {
|
||
return !isReadonly;
|
||
} else if (key === "__v_isReadonly") {
|
||
return isReadonly;
|
||
} else if (key === "__v_raw") {
|
||
return target;
|
||
}
|
||
return Reflect.get(
|
||
hasOwn(instrumentations, key) && key in target ? instrumentations : target,
|
||
key,
|
||
receiver
|
||
);
|
||
};
|
||
}
|
||
const mutableCollectionHandlers = {
|
||
get: /* @__PURE__ */ createInstrumentationGetter(false, false)
|
||
};
|
||
const shallowCollectionHandlers = {
|
||
get: /* @__PURE__ */ createInstrumentationGetter(false, true)
|
||
};
|
||
const readonlyCollectionHandlers = {
|
||
get: /* @__PURE__ */ createInstrumentationGetter(true, false)
|
||
};
|
||
const shallowReadonlyCollectionHandlers = {
|
||
get: /* @__PURE__ */ createInstrumentationGetter(true, true)
|
||
};
|
||
function checkIdentityKeys(target, has2, key) {
|
||
const rawKey = toRaw(key);
|
||
if (rawKey !== key && has2.call(target, rawKey)) {
|
||
const type = toRawType(target);
|
||
warn$2(
|
||
`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 = /* @__PURE__ */ new WeakMap();
|
||
const shallowReactiveMap = /* @__PURE__ */ new WeakMap();
|
||
const readonlyMap = /* @__PURE__ */ new WeakMap();
|
||
const shallowReadonlyMap = /* @__PURE__ */ 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"] || !Object.isExtensible(value) ? 0 /* INVALID */ : targetTypeMap(toRawType(value));
|
||
}
|
||
function reactive(target) {
|
||
if (isReadonly(target)) {
|
||
return target;
|
||
}
|
||
return createReactiveObject(
|
||
target,
|
||
false,
|
||
mutableHandlers,
|
||
mutableCollectionHandlers,
|
||
reactiveMap
|
||
);
|
||
}
|
||
function shallowReactive(target) {
|
||
return createReactiveObject(
|
||
target,
|
||
false,
|
||
shallowReactiveHandlers,
|
||
shallowCollectionHandlers,
|
||
shallowReactiveMap
|
||
);
|
||
}
|
||
function readonly(target) {
|
||
return createReactiveObject(
|
||
target,
|
||
true,
|
||
readonlyHandlers,
|
||
readonlyCollectionHandlers,
|
||
readonlyMap
|
||
);
|
||
}
|
||
function shallowReadonly(target) {
|
||
return createReactiveObject(
|
||
target,
|
||
true,
|
||
shallowReadonlyHandlers,
|
||
shallowReadonlyCollectionHandlers,
|
||
shallowReadonlyMap
|
||
);
|
||
}
|
||
function createReactiveObject(target, isReadonly2, baseHandlers, collectionHandlers, proxyMap) {
|
||
if (!isObject(target)) {
|
||
if (!!(process.env.NODE_ENV !== "production")) {
|
||
warn$2(`value cannot be made reactive: ${String(target)}`);
|
||
}
|
||
return target;
|
||
}
|
||
if (target["__v_raw"] && !(isReadonly2 && target["__v_isReactive"])) {
|
||
return target;
|
||
}
|
||
const existingProxy = proxyMap.get(target);
|
||
if (existingProxy) {
|
||
return existingProxy;
|
||
}
|
||
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"]);
|
||
}
|
||
return !!(value && value["__v_isReactive"]);
|
||
}
|
||
function isReadonly(value) {
|
||
return !!(value && value["__v_isReadonly"]);
|
||
}
|
||
function isShallow(value) {
|
||
return !!(value && value["__v_isShallow"]);
|
||
}
|
||
function isProxy(value) {
|
||
return isReactive(value) || isReadonly(value);
|
||
}
|
||
function toRaw(observed) {
|
||
const raw = observed && observed["__v_raw"];
|
||
return raw ? toRaw(raw) : observed;
|
||
}
|
||
function markRaw(value) {
|
||
if (Object.isExtensible(value)) {
|
||
def(value, "__v_skip", true);
|
||
}
|
||
return value;
|
||
}
|
||
const toReactive = (value) => isObject(value) ? reactive(value) : value;
|
||
const toReadonly = (value) => isObject(value) ? readonly(value) : value;
|
||
|
||
const COMPUTED_SIDE_EFFECT_WARN = `Computed is still dirty after getter evaluation, likely because a computed is mutating its own dependency in its getter. State mutations in computed getters should be avoided. Check the docs for more details: https://vuejs.org/guide/essentials/computed.html#getters-should-be-side-effect-free`;
|
||
class ComputedRefImpl {
|
||
constructor(getter, _setter, isReadonly, isSSR) {
|
||
this.getter = getter;
|
||
this._setter = _setter;
|
||
this.dep = void 0;
|
||
this.__v_isRef = true;
|
||
this["__v_isReadonly"] = false;
|
||
this.effect = new ReactiveEffect(
|
||
() => getter(this._value),
|
||
() => triggerRefValue(
|
||
this,
|
||
this.effect._dirtyLevel === 2 ? 2 : 3
|
||
)
|
||
);
|
||
this.effect.computed = this;
|
||
this.effect.active = this._cacheable = !isSSR;
|
||
this["__v_isReadonly"] = isReadonly;
|
||
}
|
||
get value() {
|
||
const self = toRaw(this);
|
||
if ((!self._cacheable || self.effect.dirty) && hasChanged(self._value, self._value = self.effect.run())) {
|
||
triggerRefValue(self, 4);
|
||
}
|
||
trackRefValue(self);
|
||
if (self.effect._dirtyLevel >= 2) {
|
||
if (!!(process.env.NODE_ENV !== "production") && this._warnRecursive) {
|
||
warn$2(COMPUTED_SIDE_EFFECT_WARN, `
|
||
|
||
getter: `, this.getter);
|
||
}
|
||
triggerRefValue(self, 2);
|
||
}
|
||
return self._value;
|
||
}
|
||
set value(newValue) {
|
||
this._setter(newValue);
|
||
}
|
||
// #region polyfill _dirty for backward compatibility third party code for Vue <= 3.3.x
|
||
get _dirty() {
|
||
return this.effect.dirty;
|
||
}
|
||
set _dirty(v) {
|
||
this.effect.dirty = v;
|
||
}
|
||
// #endregion
|
||
}
|
||
function computed$1(getterOrOptions, debugOptions, isSSR = false) {
|
||
let getter;
|
||
let setter;
|
||
const onlyGetter = isFunction(getterOrOptions);
|
||
if (onlyGetter) {
|
||
getter = getterOrOptions;
|
||
setter = !!(process.env.NODE_ENV !== "production") ? () => {
|
||
warn$2("Write operation failed: computed value is readonly");
|
||
} : NOOP;
|
||
} else {
|
||
getter = getterOrOptions.get;
|
||
setter = getterOrOptions.set;
|
||
}
|
||
const cRef = new ComputedRefImpl(getter, setter, onlyGetter || !setter, isSSR);
|
||
if (!!(process.env.NODE_ENV !== "production") && debugOptions && !isSSR) {
|
||
cRef.effect.onTrack = debugOptions.onTrack;
|
||
cRef.effect.onTrigger = debugOptions.onTrigger;
|
||
}
|
||
return cRef;
|
||
}
|
||
|
||
function trackRefValue(ref2) {
|
||
var _a;
|
||
if (shouldTrack && activeEffect) {
|
||
ref2 = toRaw(ref2);
|
||
trackEffect(
|
||
activeEffect,
|
||
(_a = ref2.dep) != null ? _a : ref2.dep = createDep(
|
||
() => ref2.dep = void 0,
|
||
ref2 instanceof ComputedRefImpl ? ref2 : void 0
|
||
),
|
||
!!(process.env.NODE_ENV !== "production") ? {
|
||
target: ref2,
|
||
type: "get",
|
||
key: "value"
|
||
} : void 0
|
||
);
|
||
}
|
||
}
|
||
function triggerRefValue(ref2, dirtyLevel = 4, newVal) {
|
||
ref2 = toRaw(ref2);
|
||
const dep = ref2.dep;
|
||
if (dep) {
|
||
triggerEffects(
|
||
dep,
|
||
dirtyLevel,
|
||
!!(process.env.NODE_ENV !== "production") ? {
|
||
target: ref2,
|
||
type: "set",
|
||
key: "value",
|
||
newValue: newVal
|
||
} : void 0
|
||
);
|
||
}
|
||
}
|
||
function isRef(r) {
|
||
return !!(r && r.__v_isRef === true);
|
||
}
|
||
function ref(value) {
|
||
return createRef(value, false);
|
||
}
|
||
function shallowRef(value) {
|
||
return createRef(value, true);
|
||
}
|
||
function createRef(rawValue, shallow) {
|
||
if (isRef(rawValue)) {
|
||
return rawValue;
|
||
}
|
||
return new RefImpl(rawValue, shallow);
|
||
}
|
||
class RefImpl {
|
||
constructor(value, __v_isShallow) {
|
||
this.__v_isShallow = __v_isShallow;
|
||
this.dep = void 0;
|
||
this.__v_isRef = true;
|
||
this._rawValue = __v_isShallow ? value : toRaw(value);
|
||
this._value = __v_isShallow ? value : toReactive(value);
|
||
}
|
||
get value() {
|
||
trackRefValue(this);
|
||
return this._value;
|
||
}
|
||
set value(newVal) {
|
||
const useDirectValue = this.__v_isShallow || isShallow(newVal) || isReadonly(newVal);
|
||
newVal = useDirectValue ? newVal : toRaw(newVal);
|
||
if (hasChanged(newVal, this._rawValue)) {
|
||
this._rawValue = newVal;
|
||
this._value = useDirectValue ? newVal : toReactive(newVal);
|
||
triggerRefValue(this, 4, newVal);
|
||
}
|
||
}
|
||
}
|
||
function triggerRef(ref2) {
|
||
triggerRefValue(ref2, 4, !!(process.env.NODE_ENV !== "production") ? ref2.value : void 0);
|
||
}
|
||
function unref(ref2) {
|
||
return isRef(ref2) ? ref2.value : ref2;
|
||
}
|
||
function toValue(source) {
|
||
return isFunction(source) ? source() : unref(source);
|
||
}
|
||
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.dep = void 0;
|
||
this.__v_isRef = true;
|
||
const { get, set } = factory(
|
||
() => trackRefValue(this),
|
||
() => triggerRefValue(this)
|
||
);
|
||
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)) {
|
||
warn$2(`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] = propertyToRef(object, key);
|
||
}
|
||
return ret;
|
||
}
|
||
class ObjectRefImpl {
|
||
constructor(_object, _key, _defaultValue) {
|
||
this._object = _object;
|
||
this._key = _key;
|
||
this._defaultValue = _defaultValue;
|
||
this.__v_isRef = true;
|
||
}
|
||
get value() {
|
||
const val = this._object[this._key];
|
||
return val === void 0 ? this._defaultValue : val;
|
||
}
|
||
set value(newVal) {
|
||
this._object[this._key] = newVal;
|
||
}
|
||
get dep() {
|
||
return getDepFromReactive(toRaw(this._object), this._key);
|
||
}
|
||
}
|
||
class GetterRefImpl {
|
||
constructor(_getter) {
|
||
this._getter = _getter;
|
||
this.__v_isRef = true;
|
||
this.__v_isReadonly = true;
|
||
}
|
||
get value() {
|
||
return this._getter();
|
||
}
|
||
}
|
||
function toRef(source, key, defaultValue) {
|
||
if (isRef(source)) {
|
||
return source;
|
||
} else if (isFunction(source)) {
|
||
return new GetterRefImpl(source);
|
||
} else if (isObject(source) && arguments.length > 1) {
|
||
return propertyToRef(source, key, defaultValue);
|
||
} else {
|
||
return ref(source);
|
||
}
|
||
}
|
||
function propertyToRef(source, key, defaultValue) {
|
||
const val = source[key];
|
||
return isRef(val) ? val : new ObjectRefImpl(source, key, defaultValue);
|
||
}
|
||
|
||
const stack = [];
|
||
function pushWarningContext(vnode) {
|
||
stack.push(vnode);
|
||
}
|
||
function popWarningContext() {
|
||
stack.pop();
|
||
}
|
||
function warn$1(msg, ...args) {
|
||
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,
|
||
[
|
||
msg + args.map((a) => {
|
||
var _a, _b;
|
||
return (_b = (_a = a.toString) == null ? void 0 : _a.call(a)) != null ? _b : JSON.stringify(a);
|
||
}).join(""),
|
||
instance && instance.proxy,
|
||
trace.map(
|
||
({ vnode }) => `at <${formatComponentName(instance, vnode.type)}>`
|
||
).join("\n"),
|
||
trace
|
||
]
|
||
);
|
||
} else {
|
||
const warnArgs = [`[Vue warn]: ${msg}`, ...args];
|
||
if (trace.length && // avoid spamming console during tests
|
||
true) {
|
||
warnArgs.push(`
|
||
`, ...formatTrace(trace));
|
||
}
|
||
console.warn(...warnArgs);
|
||
}
|
||
resetTracking();
|
||
}
|
||
function getComponentTrace() {
|
||
let currentVNode = stack[stack.length - 1];
|
||
if (!currentVNode) {
|
||
return [];
|
||
}
|
||
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;
|
||
}
|
||
function formatTrace(trace) {
|
||
const logs = [];
|
||
trace.forEach((entry, i) => {
|
||
logs.push(...i === 0 ? [] : [`
|
||
`], ...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];
|
||
}
|
||
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;
|
||
}
|
||
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 = {
|
||
["sp"]: "serverPrefetch hook",
|
||
["bc"]: "beforeCreate hook",
|
||
["c"]: "created hook",
|
||
["bm"]: "beforeMount hook",
|
||
["m"]: "mounted hook",
|
||
["bu"]: "beforeUpdate hook",
|
||
["u"]: "updated",
|
||
["bum"]: "beforeUnmount hook",
|
||
["um"]: "unmounted hook",
|
||
["a"]: "activated hook",
|
||
["da"]: "deactivated hook",
|
||
["ec"]: "errorCaptured hook",
|
||
["rtc"]: "renderTracked hook",
|
||
["rtg"]: "renderTriggered hook",
|
||
[0]: "setup function",
|
||
[1]: "render function",
|
||
[2]: "watcher getter",
|
||
[3]: "watcher callback",
|
||
[4]: "watcher cleanup function",
|
||
[5]: "native event handler",
|
||
[6]: "component event handler",
|
||
[7]: "vnode hook",
|
||
[8]: "directive hook",
|
||
[9]: "transition hook",
|
||
[10]: "app errorHandler",
|
||
[11]: "app warnHandler",
|
||
[12]: "ref function",
|
||
[13]: "async component loader",
|
||
[14]: "scheduler flush. This is likely a Vue internals bug. Please open an issue at https://github.com/vuejs/core ."
|
||
};
|
||
function callWithErrorHandling(fn, instance, type, args) {
|
||
try {
|
||
return args ? fn(...args) : fn();
|
||
} catch (err) {
|
||
handleError(err, instance, type);
|
||
}
|
||
}
|
||
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, throwInDev = true) {
|
||
const contextVNode = instance ? instance.vnode : null;
|
||
if (instance) {
|
||
let cur = instance.parent;
|
||
const exposedInstance = instance.proxy;
|
||
const errorInfo = !!(process.env.NODE_ENV !== "production") ? ErrorTypeStrings[type] || type : `https://vuejs.org/error-reference/#runtime-${type}`;
|
||
while (cur) {
|
||
const errorCapturedHooks = cur.ec;
|
||
if (errorCapturedHooks) {
|
||
for (let i = 0; i < errorCapturedHooks.length; i++) {
|
||
if (errorCapturedHooks[i](err, exposedInstance, errorInfo) === false) {
|
||
return;
|
||
}
|
||
}
|
||
}
|
||
cur = cur.parent;
|
||
}
|
||
const appErrorHandler = instance.appContext.config.errorHandler;
|
||
if (appErrorHandler) {
|
||
callWithErrorHandling(
|
||
appErrorHandler,
|
||
null,
|
||
10,
|
||
[err, exposedInstance, errorInfo]
|
||
);
|
||
return;
|
||
}
|
||
}
|
||
logError(err, type, contextVNode, throwInDev);
|
||
}
|
||
function logError(err, type, contextVNode, throwInDev = true) {
|
||
if (!!(process.env.NODE_ENV !== "production")) {
|
||
const info = ErrorTypeStrings[type] || type;
|
||
if (contextVNode) {
|
||
pushWarningContext(contextVNode);
|
||
}
|
||
warn$1(`Unhandled error${info ? ` during execution of ${info}` : ``}`);
|
||
if (contextVNode) {
|
||
popWarningContext();
|
||
}
|
||
if (throwInDev) {
|
||
console.error(err);
|
||
} else {
|
||
console.error(err);
|
||
}
|
||
} else {
|
||
console.error(err);
|
||
}
|
||
}
|
||
|
||
let isFlushing = false;
|
||
let isFlushPending = false;
|
||
const queue = [];
|
||
let flushIndex = 0;
|
||
const pendingPostFlushCbs = [];
|
||
let activePostFlushCbs = null;
|
||
let postFlushIndex = 0;
|
||
const resolvedPromise = /* @__PURE__ */ Promise.resolve();
|
||
let currentFlushPromise = null;
|
||
const RECURSION_LIMIT = 100;
|
||
function nextTick$1(fn) {
|
||
const p = currentFlushPromise || resolvedPromise;
|
||
return fn ? p.then(this ? fn.bind(this) : fn) : p;
|
||
}
|
||
function findInsertionIndex(id) {
|
||
let start = flushIndex + 1;
|
||
let end = queue.length;
|
||
while (start < end) {
|
||
const middle = start + end >>> 1;
|
||
const middleJob = queue[middle];
|
||
const middleJobId = getId(middleJob);
|
||
if (middleJobId < id || middleJobId === id && middleJob.pre) {
|
||
start = middle + 1;
|
||
} else {
|
||
end = middle;
|
||
}
|
||
}
|
||
return start;
|
||
}
|
||
function queueJob(job) {
|
||
if (!queue.length || !queue.includes(
|
||
job,
|
||
isFlushing && job.allowRecurse ? flushIndex + 1 : flushIndex
|
||
)) {
|
||
if (job.id == null) {
|
||
queue.push(job);
|
||
} else {
|
||
queue.splice(findInsertionIndex(job.id), 0, job);
|
||
}
|
||
queueFlush();
|
||
}
|
||
}
|
||
function queueFlush() {
|
||
if (!isFlushing && !isFlushPending) {
|
||
isFlushPending = true;
|
||
currentFlushPromise = resolvedPromise.then(flushJobs);
|
||
}
|
||
}
|
||
function hasQueueJob(job) {
|
||
return queue.indexOf(job) > -1;
|
||
}
|
||
function invalidateJob(job) {
|
||
const i = queue.indexOf(job);
|
||
if (i > flushIndex) {
|
||
queue.splice(i, 1);
|
||
}
|
||
}
|
||
function queuePostFlushCb(cb) {
|
||
if (!isArray(cb)) {
|
||
if (!activePostFlushCbs || !activePostFlushCbs.includes(
|
||
cb,
|
||
cb.allowRecurse ? postFlushIndex + 1 : postFlushIndex
|
||
)) {
|
||
pendingPostFlushCbs.push(cb);
|
||
}
|
||
} else {
|
||
pendingPostFlushCbs.push(...cb);
|
||
}
|
||
queueFlush();
|
||
}
|
||
function flushPreFlushCbs(instance, seen, i = isFlushing ? flushIndex + 1 : 0) {
|
||
if (!!(process.env.NODE_ENV !== "production")) {
|
||
seen = seen || /* @__PURE__ */ new Map();
|
||
}
|
||
for (; i < queue.length; i++) {
|
||
const cb = queue[i];
|
||
if (cb && cb.pre) {
|
||
if (!!(process.env.NODE_ENV !== "production") && checkRecursiveUpdates(seen, cb)) {
|
||
continue;
|
||
}
|
||
queue.splice(i, 1);
|
||
i--;
|
||
cb();
|
||
}
|
||
}
|
||
}
|
||
function flushPostFlushCbs(seen) {
|
||
if (pendingPostFlushCbs.length) {
|
||
const deduped = [...new Set(pendingPostFlushCbs)].sort(
|
||
(a, b) => getId(a) - getId(b)
|
||
);
|
||
pendingPostFlushCbs.length = 0;
|
||
if (activePostFlushCbs) {
|
||
activePostFlushCbs.push(...deduped);
|
||
return;
|
||
}
|
||
activePostFlushCbs = deduped;
|
||
if (!!(process.env.NODE_ENV !== "production")) {
|
||
seen = seen || /* @__PURE__ */ new Map();
|
||
}
|
||
for (postFlushIndex = 0; postFlushIndex < activePostFlushCbs.length; postFlushIndex++) {
|
||
if (!!(process.env.NODE_ENV !== "production") && checkRecursiveUpdates(seen, activePostFlushCbs[postFlushIndex])) {
|
||
continue;
|
||
}
|
||
activePostFlushCbs[postFlushIndex]();
|
||
}
|
||
activePostFlushCbs = null;
|
||
postFlushIndex = 0;
|
||
}
|
||
}
|
||
const getId = (job) => job.id == null ? Infinity : job.id;
|
||
const comparator = (a, b) => {
|
||
const diff = getId(a) - getId(b);
|
||
if (diff === 0) {
|
||
if (a.pre && !b.pre)
|
||
return -1;
|
||
if (b.pre && !a.pre)
|
||
return 1;
|
||
}
|
||
return diff;
|
||
};
|
||
function flushJobs(seen) {
|
||
isFlushPending = false;
|
||
isFlushing = true;
|
||
if (!!(process.env.NODE_ENV !== "production")) {
|
||
seen = seen || /* @__PURE__ */ new Map();
|
||
}
|
||
queue.sort(comparator);
|
||
const check = !!(process.env.NODE_ENV !== "production") ? (job) => checkRecursiveUpdates(seen, job) : NOOP;
|
||
try {
|
||
for (flushIndex = 0; flushIndex < queue.length; flushIndex++) {
|
||
const job = queue[flushIndex];
|
||
if (job && job.active !== false) {
|
||
if (!!(process.env.NODE_ENV !== "production") && check(job)) {
|
||
continue;
|
||
}
|
||
callWithErrorHandling(job, null, 14);
|
||
}
|
||
}
|
||
} finally {
|
||
flushIndex = 0;
|
||
queue.length = 0;
|
||
flushPostFlushCbs(seen);
|
||
isFlushing = false;
|
||
currentFlushPromise = null;
|
||
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) {
|
||
const instance = fn.ownerInstance;
|
||
const componentName = instance && getComponentName(instance.type);
|
||
handleError(
|
||
`Maximum recursive updates exceeded${componentName ? ` in component <${componentName}>` : ``}. 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.`,
|
||
null,
|
||
10
|
||
);
|
||
return true;
|
||
} else {
|
||
seen.set(fn, count + 1);
|
||
}
|
||
}
|
||
}
|
||
|
||
let devtools;
|
||
let buffer = [];
|
||
let devtoolsNotInstalled = false;
|
||
function emit$1(event, ...args) {
|
||
if (devtools) {
|
||
devtools.emit(event, ...args);
|
||
} else if (!devtoolsNotInstalled) {
|
||
buffer.push({ event, args });
|
||
}
|
||
}
|
||
function setDevtoolsHook(hook, target) {
|
||
var _a, _b;
|
||
devtools = hook;
|
||
if (devtools) {
|
||
devtools.enabled = true;
|
||
buffer.forEach(({ event, args }) => devtools.emit(event, ...args));
|
||
buffer = [];
|
||
} else if (
|
||
// handle late devtools injection - only do this if we are in an actual
|
||
// browser environment to avoid the timer handle stalling test runner exit
|
||
// (#4815)
|
||
typeof window !== "undefined" && // some envs mock window but not fully
|
||
window.HTMLElement && // also exclude jsdom
|
||
!((_b = (_a = window.navigator) == null ? void 0 : _a.userAgent) == null ? void 0 : _b.includes("jsdom"))
|
||
) {
|
||
const replay = target.__VUE_DEVTOOLS_HOOK_REPLAY__ = target.__VUE_DEVTOOLS_HOOK_REPLAY__ || [];
|
||
replay.push((newHook) => {
|
||
setDevtoolsHook(newHook, target);
|
||
});
|
||
setTimeout(() => {
|
||
if (!devtools) {
|
||
target.__VUE_DEVTOOLS_HOOK_REPLAY__ = null;
|
||
devtoolsNotInstalled = true;
|
||
buffer = [];
|
||
}
|
||
}, 3e3);
|
||
} else {
|
||
devtoolsNotInstalled = true;
|
||
buffer = [];
|
||
}
|
||
}
|
||
function devtoolsInitApp(app, version) {
|
||
emit$1("app:init" /* APP_INIT */, app, version, {
|
||
Fragment,
|
||
Text,
|
||
Comment,
|
||
Static
|
||
});
|
||
}
|
||
const devtoolsComponentAdded = /* @__PURE__ */ createDevtoolsComponentHook(
|
||
"component:added" /* COMPONENT_ADDED */
|
||
);
|
||
const devtoolsComponentUpdated = /* @__PURE__ */ createDevtoolsComponentHook("component:updated" /* COMPONENT_UPDATED */);
|
||
const _devtoolsComponentRemoved = /* @__PURE__ */ createDevtoolsComponentHook(
|
||
"component:removed" /* COMPONENT_REMOVED */
|
||
);
|
||
const devtoolsComponentRemoved = (component) => {
|
||
if (devtools && typeof devtools.cleanupBuffer === "function" && // remove the component if it wasn't buffered
|
||
!devtools.cleanupBuffer(component)) {
|
||
_devtoolsComponentRemoved(component);
|
||
}
|
||
};
|
||
/*! #__NO_SIDE_EFFECTS__ */
|
||
// @__NO_SIDE_EFFECTS__
|
||
function createDevtoolsComponentHook(hook) {
|
||
return (component) => {
|
||
emit$1(
|
||
hook,
|
||
component.appContext.app,
|
||
component.uid,
|
||
// fixed by xxxxxx
|
||
// 为 0 是 App，无 parent 是 Page 指向 App
|
||
component.uid === 0 ? void 0 : component.parent ? component.parent.uid : 0,
|
||
component
|
||
);
|
||
};
|
||
}
|
||
const devtoolsPerfStart = /* @__PURE__ */ createDevtoolsPerformanceHook(
|
||
"perf:start" /* PERFORMANCE_START */
|
||
);
|
||
const devtoolsPerfEnd = /* @__PURE__ */ createDevtoolsPerformanceHook(
|
||
"perf:end" /* PERFORMANCE_END */
|
||
);
|
||
function createDevtoolsPerformanceHook(hook) {
|
||
return (component, type, time) => {
|
||
emit$1(hook, component.appContext.app, component.uid, component, type, time);
|
||
};
|
||
}
|
||
function devtoolsComponentEmit(component, event, params) {
|
||
emit$1(
|
||
"component:emit" /* COMPONENT_EMIT */,
|
||
component.appContext.app,
|
||
component,
|
||
event,
|
||
params
|
||
);
|
||
}
|
||
|
||
function emit(instance, event, ...rawArgs) {
|
||
if (instance.isUnmounted)
|
||
return;
|
||
const props = instance.vnode.props || EMPTY_OBJ;
|
||
if (!!(process.env.NODE_ENV !== "production")) {
|
||
const {
|
||
emitsOptions,
|
||
propsOptions: [propsOptions]
|
||
} = instance;
|
||
if (emitsOptions) {
|
||
if (!(event in emitsOptions) && true) {
|
||
if (!propsOptions || !(toHandlerKey(event) in propsOptions)) {
|
||
warn$1(
|
||
`Component emitted event "${event}" but it is neither declared in the emits option nor as an "${toHandlerKey(event)}" prop.`
|
||
);
|
||
}
|
||
} else {
|
||
const validator = emitsOptions[event];
|
||
if (isFunction(validator)) {
|
||
const isValid = validator(...rawArgs);
|
||
if (!isValid) {
|
||
warn$1(
|
||
`Invalid event arguments: event validation failed for event "${event}".`
|
||
);
|
||
}
|
||
}
|
||
}
|
||
}
|
||
}
|
||
let args = rawArgs;
|
||
const isModelListener = event.startsWith("update:");
|
||
const modelArg = isModelListener && event.slice(7);
|
||
if (modelArg && modelArg in props) {
|
||
const modifiersKey = `${modelArg === "modelValue" ? "model" : modelArg}Modifiers`;
|
||
const { number, trim } = props[modifiersKey] || EMPTY_OBJ;
|
||
if (trim) {
|
||
args = rawArgs.map((a) => isString(a) ? a.trim() : a);
|
||
}
|
||
if (number) {
|
||
args = rawArgs.map(looseToNumber);
|
||
}
|
||
}
|
||
if (!!(process.env.NODE_ENV !== "production") || __VUE_PROD_DEVTOOLS__) {
|
||
devtoolsComponentEmit(instance, event, args);
|
||
}
|
||
if (!!(process.env.NODE_ENV !== "production")) {
|
||
const lowerCaseEvent = event.toLowerCase();
|
||
if (lowerCaseEvent !== event && props[toHandlerKey(lowerCaseEvent)]) {
|
||
warn$1(
|
||
`Event "${lowerCaseEvent}" is emitted in component ${formatComponentName(
|
||
instance,
|
||
instance.type
|
||
)} but the handler is registered for "${event}". Note that HTML attributes are case-insensitive and you cannot use v-on to listen to camelCase events when using in-DOM templates. You should probably use "${hyphenate(
|
||
event
|
||
)}" instead of "${event}".`
|
||
);
|
||
}
|
||
}
|
||
let handlerName;
|
||
let handler = props[handlerName = toHandlerKey(event)] || // also try camelCase event handler (#2249)
|
||
props[handlerName = toHandlerKey(camelize(event))];
|
||
if (!handler && isModelListener) {
|
||
handler = props[handlerName = toHandlerKey(hyphenate(event))];
|
||
}
|
||
if (handler) {
|
||
callWithAsyncErrorHandling(
|
||
handler,
|
||
instance,
|
||
6,
|
||
args
|
||
);
|
||
}
|
||
const onceHandler = props[handlerName + `Once`];
|
||
if (onceHandler) {
|
||
if (!instance.emitted) {
|
||
instance.emitted = {};
|
||
} else if (instance.emitted[handlerName]) {
|
||
return;
|
||
}
|
||
instance.emitted[handlerName] = true;
|
||
callWithAsyncErrorHandling(
|
||
onceHandler,
|
||
instance,
|
||
6,
|
||
args
|
||
);
|
||
}
|
||
}
|
||
function normalizeEmitsOptions(comp, appContext, asMixin = false) {
|
||
const cache = appContext.emitsCache;
|
||
const cached = cache.get(comp);
|
||
if (cached !== void 0) {
|
||
return cached;
|
||
}
|
||
const raw = comp.emits;
|
||
let normalized = {};
|
||
let hasExtends = false;
|
||
if (__VUE_OPTIONS_API__ && !isFunction(comp)) {
|
||
const extendEmits = (raw2) => {
|
||
const normalizedFromExtend = normalizeEmitsOptions(raw2, appContext, true);
|
||
if (normalizedFromExtend) {
|
||
hasExtends = true;
|
||
extend(normalized, normalizedFromExtend);
|
||
}
|
||
};
|
||
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) {
|
||
if (isObject(comp)) {
|
||
cache.set(comp, null);
|
||
}
|
||
return null;
|
||
}
|
||
if (isArray(raw)) {
|
||
raw.forEach((key) => normalized[key] = null);
|
||
} else {
|
||
extend(normalized, raw);
|
||
}
|
||
if (isObject(comp)) {
|
||
cache.set(comp, normalized);
|
||
}
|
||
return normalized;
|
||
}
|
||
function isEmitListener(options, key) {
|
||
if (!options || !isOn(key)) {
|
||
return false;
|
||
}
|
||
key = key.slice(2).replace(/Once$/, "");
|
||
return hasOwn(options, key[0].toLowerCase() + key.slice(1)) || hasOwn(options, hyphenate(key)) || hasOwn(options, key);
|
||
}
|
||
|
||
let currentRenderingInstance = null;
|
||
let currentScopeId = null;
|
||
function setCurrentRenderingInstance(instance) {
|
||
const prev = currentRenderingInstance;
|
||
currentRenderingInstance = instance;
|
||
currentScopeId = instance && instance.type.__scopeId || null;
|
||
return prev;
|
||
}
|
||
const withScopeId = (_id) => withCtx;
|
||
function withCtx(fn, ctx = currentRenderingInstance, isNonScopedSlot) {
|
||
if (!ctx)
|
||
return fn;
|
||
if (fn._n) {
|
||
return fn;
|
||
}
|
||
const renderFnWithContext = (...args) => {
|
||
if (renderFnWithContext._d) {
|
||
setBlockTracking(-1);
|
||
}
|
||
const prevInstance = setCurrentRenderingInstance(ctx);
|
||
let res;
|
||
try {
|
||
res = fn(...args);
|
||
} finally {
|
||
setCurrentRenderingInstance(prevInstance);
|
||
if (renderFnWithContext._d) {
|
||
setBlockTracking(1);
|
||
}
|
||
}
|
||
if (!!(process.env.NODE_ENV !== "production") || __VUE_PROD_DEVTOOLS__) {
|
||
devtoolsComponentUpdated(ctx);
|
||
}
|
||
return res;
|
||
};
|
||
renderFnWithContext._n = true;
|
||
renderFnWithContext._c = true;
|
||
renderFnWithContext._d = true;
|
||
return renderFnWithContext;
|
||
}
|
||
|
||
function markAttrsAccessed() {
|
||
}
|
||
|
||
const COMPONENTS = "components";
|
||
const DIRECTIVES = "directives";
|
||
function resolveComponent(name, maybeSelfReference) {
|
||
return resolveAsset(COMPONENTS, name, true, maybeSelfReference) || name;
|
||
}
|
||
const NULL_DYNAMIC_COMPONENT = Symbol.for("v-ndc");
|
||
function resolveDirective(name) {
|
||
return resolveAsset(DIRECTIVES, name);
|
||
}
|
||
function resolveAsset(type, name, warnMissing = true, maybeSelfReference = false) {
|
||
const instance = currentRenderingInstance || currentInstance;
|
||
if (instance) {
|
||
const Component = instance.type;
|
||
if (type === COMPONENTS) {
|
||
const selfName = getComponentName(
|
||
Component,
|
||
false
|
||
);
|
||
if (selfName && (selfName === name || selfName === camelize(name) || selfName === capitalize(camelize(name)))) {
|
||
return Component;
|
||
}
|
||
}
|
||
const res = (
|
||
// local registration
|
||
// check instance[type] first which is resolved for options API
|
||
resolve(instance[type] || Component[type], name) || // global registration
|
||
resolve(instance.appContext[type], name)
|
||
);
|
||
if (!res && maybeSelfReference) {
|
||
return Component;
|
||
}
|
||
if (!!(process.env.NODE_ENV !== "production") && warnMissing && !res) {
|
||
const extra = type === COMPONENTS ? `
|
||
If this is a native custom element, make sure to exclude it from component resolution via compilerOptions.isCustomElement.` : ``;
|
||
warn$1(`Failed to resolve ${type.slice(0, -1)}: ${name}${extra}`);
|
||
}
|
||
return res;
|
||
} else if (!!(process.env.NODE_ENV !== "production")) {
|
||
warn$1(
|
||
`resolve${capitalize(type.slice(0, -1))} can only be used in render() or setup().`
|
||
);
|
||
}
|
||
}
|
||
function resolve(registry, name) {
|
||
return registry && (registry[name] || registry[camelize(name)] || registry[capitalize(camelize(name))]);
|
||
}
|
||
|
||
const ssrContextKey = Symbol.for("v-scx");
|
||
const useSSRContext = () => {
|
||
{
|
||
const ctx = inject(ssrContextKey);
|
||
if (!ctx) {
|
||
!!(process.env.NODE_ENV !== "production") && warn$1(
|
||
`Server rendering context not provided. Make sure to only call useSSRContext() conditionally in the server build.`
|
||
);
|
||
}
|
||
return ctx;
|
||
}
|
||
};
|
||
|
||
function watchEffect(effect, options) {
|
||
return doWatch(effect, null, options);
|
||
}
|
||
function watchPostEffect(effect, options) {
|
||
return doWatch(
|
||
effect,
|
||
null,
|
||
!!(process.env.NODE_ENV !== "production") ? extend({}, options, { flush: "post" }) : { flush: "post" }
|
||
);
|
||
}
|
||
function watchSyncEffect(effect, options) {
|
||
return doWatch(
|
||
effect,
|
||
null,
|
||
!!(process.env.NODE_ENV !== "production") ? extend({}, options, { flush: "sync" }) : { flush: "sync" }
|
||
);
|
||
}
|
||
const INITIAL_WATCHER_VALUE = {};
|
||
function watch(source, cb, options) {
|
||
if (!!(process.env.NODE_ENV !== "production") && !isFunction(cb)) {
|
||
warn$1(
|
||
`\`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,
|
||
once,
|
||
onTrack,
|
||
onTrigger
|
||
} = EMPTY_OBJ) {
|
||
if (cb && once) {
|
||
const _cb = cb;
|
||
cb = (...args) => {
|
||
_cb(...args);
|
||
unwatch();
|
||
};
|
||
}
|
||
if (!!(process.env.NODE_ENV !== "production") && deep !== void 0 && typeof deep === "number") {
|
||
warn$1(
|
||
`watch() "deep" option with number value will be used as watch depth in future versions. Please use a boolean instead to avoid potential breakage.`
|
||
);
|
||
}
|
||
if (!!(process.env.NODE_ENV !== "production") && !cb) {
|
||
if (immediate !== void 0) {
|
||
warn$1(
|
||
`watch() "immediate" option is only respected when using the watch(source, callback, options?) signature.`
|
||
);
|
||
}
|
||
if (deep !== void 0) {
|
||
warn$1(
|
||
`watch() "deep" option is only respected when using the watch(source, callback, options?) signature.`
|
||
);
|
||
}
|
||
if (once !== void 0) {
|
||
warn$1(
|
||
`watch() "once" option is only respected when using the watch(source, callback, options?) signature.`
|
||
);
|
||
}
|
||
}
|
||
const warnInvalidSource = (s) => {
|
||
warn$1(
|
||
`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.`
|
||
);
|
||
};
|
||
const instance = currentInstance;
|
||
const reactiveGetter = (source2) => deep === true ? source2 : (
|
||
// for deep: false, only traverse root-level properties
|
||
traverse(source2, deep === false ? 1 : void 0)
|
||
);
|
||
let getter;
|
||
let forceTrigger = false;
|
||
let isMultiSource = false;
|
||
if (isRef(source)) {
|
||
getter = () => source.value;
|
||
forceTrigger = isShallow(source);
|
||
} else if (isReactive(source)) {
|
||
getter = () => reactiveGetter(source);
|
||
forceTrigger = true;
|
||
} else if (isArray(source)) {
|
||
isMultiSource = true;
|
||
forceTrigger = source.some((s) => isReactive(s) || isShallow(s));
|
||
getter = () => source.map((s) => {
|
||
if (isRef(s)) {
|
||
return s.value;
|
||
} else if (isReactive(s)) {
|
||
return reactiveGetter(s);
|
||
} else if (isFunction(s)) {
|
||
return callWithErrorHandling(s, instance, 2);
|
||
} else {
|
||
!!(process.env.NODE_ENV !== "production") && warnInvalidSource(s);
|
||
}
|
||
});
|
||
} else if (isFunction(source)) {
|
||
if (cb) {
|
||
getter = () => callWithErrorHandling(source, instance, 2);
|
||
} else {
|
||
getter = () => {
|
||
if (cleanup) {
|
||
cleanup();
|
||
}
|
||
return callWithAsyncErrorHandling(
|
||
source,
|
||
instance,
|
||
3,
|
||
[onCleanup]
|
||
);
|
||
};
|
||
}
|
||
} else {
|
||
getter = NOOP;
|
||
!!(process.env.NODE_ENV !== "production") && warnInvalidSource(source);
|
||
}
|
||
if (cb && deep) {
|
||
const baseGetter = getter;
|
||
getter = () => traverse(baseGetter());
|
||
}
|
||
let cleanup;
|
||
let onCleanup = (fn) => {
|
||
cleanup = effect.onStop = () => {
|
||
callWithErrorHandling(fn, instance, 4);
|
||
cleanup = effect.onStop = void 0;
|
||
};
|
||
};
|
||
let oldValue = isMultiSource ? new Array(source.length).fill(INITIAL_WATCHER_VALUE) : INITIAL_WATCHER_VALUE;
|
||
const job = () => {
|
||
if (!effect.active || !effect.dirty) {
|
||
return;
|
||
}
|
||
if (cb) {
|
||
const newValue = effect.run();
|
||
if (deep || forceTrigger || (isMultiSource ? newValue.some((v, i) => hasChanged(v, oldValue[i])) : hasChanged(newValue, oldValue)) || false) {
|
||
if (cleanup) {
|
||
cleanup();
|
||
}
|
||
callWithAsyncErrorHandling(cb, instance, 3, [
|
||
newValue,
|
||
// pass undefined as the old value when it's changed for the first time
|
||
oldValue === INITIAL_WATCHER_VALUE ? void 0 : isMultiSource && oldValue[0] === INITIAL_WATCHER_VALUE ? [] : oldValue,
|
||
onCleanup
|
||
]);
|
||
oldValue = newValue;
|
||
}
|
||
} else {
|
||
effect.run();
|
||
}
|
||
};
|
||
job.allowRecurse = !!cb;
|
||
let scheduler;
|
||
if (flush === "sync") {
|
||
scheduler = job;
|
||
} else if (flush === "post") {
|
||
scheduler = () => queuePostRenderEffect$1(job, instance && instance.suspense);
|
||
} else {
|
||
job.pre = true;
|
||
if (instance)
|
||
job.id = instance.uid;
|
||
scheduler = () => queueJob(job);
|
||
}
|
||
const effect = new ReactiveEffect(getter, NOOP, scheduler);
|
||
const scope = getCurrentScope();
|
||
const unwatch = () => {
|
||
effect.stop();
|
||
if (scope) {
|
||
remove(scope.effects, effect);
|
||
}
|
||
};
|
||
if (!!(process.env.NODE_ENV !== "production")) {
|
||
effect.onTrack = onTrack;
|
||
effect.onTrigger = onTrigger;
|
||
}
|
||
if (cb) {
|
||
if (immediate) {
|
||
job();
|
||
} else {
|
||
oldValue = effect.run();
|
||
}
|
||
} else if (flush === "post") {
|
||
queuePostRenderEffect$1(
|
||
effect.run.bind(effect),
|
||
instance && instance.suspense
|
||
);
|
||
} else {
|
||
effect.run();
|
||
}
|
||
return unwatch;
|
||
}
|
||
function instanceWatch(source, value, options) {
|
||
const publicThis = this.proxy;
|
||
const getter = isString(source) ? source.includes(".") ? createPathGetter(publicThis, source) : () => publicThis[source] : source.bind(publicThis, publicThis);
|
||
let cb;
|
||
if (isFunction(value)) {
|
||
cb = value;
|
||
} else {
|
||
cb = value.handler;
|
||
options = value;
|
||
}
|
||
const reset = setCurrentInstance(this);
|
||
const res = doWatch(getter, cb.bind(publicThis), options);
|
||
reset();
|
||
return res;
|
||
}
|
||
function createPathGetter(ctx, path) {
|
||
const segments = path.split(".");
|
||
return () => {
|
||
let cur = ctx;
|
||
for (let i = 0; i < segments.length && cur; i++) {
|
||
cur = cur[segments[i]];
|
||
}
|
||
return cur;
|
||
};
|
||
}
|
||
function traverse(value, depth, currentDepth = 0, seen) {
|
||
if (!isObject(value) || value["__v_skip"]) {
|
||
return value;
|
||
}
|
||
if (depth && depth > 0) {
|
||
if (currentDepth >= depth) {
|
||
return value;
|
||
}
|
||
currentDepth++;
|
||
}
|
||
seen = seen || /* @__PURE__ */ new Set();
|
||
if (seen.has(value)) {
|
||
return value;
|
||
}
|
||
seen.add(value);
|
||
if (isRef(value)) {
|
||
traverse(value.value, depth, currentDepth, seen);
|
||
} else if (isArray(value)) {
|
||
for (let i = 0; i < value.length; i++) {
|
||
traverse(value[i], depth, currentDepth, seen);
|
||
}
|
||
} else if (isSet(value) || isMap(value)) {
|
||
value.forEach((v) => {
|
||
traverse(v, depth, currentDepth, seen);
|
||
});
|
||
} else if (isPlainObject(value)) {
|
||
for (const key in value) {
|
||
traverse(value[key], depth, currentDepth, seen);
|
||
}
|
||
}
|
||
return value;
|
||
}
|
||
|
||
function validateDirectiveName(name) {
|
||
if (isBuiltInDirective(name)) {
|
||
warn$1("Do not use built-in directive ids as custom directive id: " + name);
|
||
}
|
||
}
|
||
function withDirectives(vnode, directives) {
|
||
if (currentRenderingInstance === null) {
|
||
!!(process.env.NODE_ENV !== "production") && warn$1(`withDirectives can only be used inside render functions.`);
|
||
return vnode;
|
||
}
|
||
const instance = getExposeProxy(currentRenderingInstance) || currentRenderingInstance.proxy;
|
||
const bindings = vnode.dirs || (vnode.dirs = []);
|
||
for (let i = 0; i < directives.length; i++) {
|
||
let [dir, value, arg, modifiers = EMPTY_OBJ] = directives[i];
|
||
if (dir) {
|
||
if (isFunction(dir)) {
|
||
dir = {
|
||
mounted: dir,
|
||
updated: dir
|
||
};
|
||
}
|
||
if (dir.deep) {
|
||
traverse(value);
|
||
}
|
||
bindings.push({
|
||
dir,
|
||
instance,
|
||
value,
|
||
oldValue: void 0,
|
||
arg,
|
||
modifiers
|
||
});
|
||
}
|
||
}
|
||
return vnode;
|
||
}
|
||
|
||
function createAppContext() {
|
||
return {
|
||
app: null,
|
||
config: {
|
||
isNativeTag: NO,
|
||
performance: false,
|
||
globalProperties: {},
|
||
optionMergeStrategies: {},
|
||
errorHandler: void 0,
|
||
warnHandler: void 0,
|
||
compilerOptions: {}
|
||
},
|
||
mixins: [],
|
||
components: {},
|
||
directives: {},
|
||
provides: /* @__PURE__ */ Object.create(null),
|
||
optionsCache: /* @__PURE__ */ new WeakMap(),
|
||
propsCache: /* @__PURE__ */ new WeakMap(),
|
||
emitsCache: /* @__PURE__ */ new WeakMap()
|
||
};
|
||
}
|
||
let uid$1 = 0;
|
||
function createAppAPI(render, hydrate) {
|
||
return function createApp(rootComponent, rootProps = null) {
|
||
if (!isFunction(rootComponent)) {
|
||
rootComponent = extend({}, rootComponent);
|
||
}
|
||
if (rootProps != null && !isObject(rootProps)) {
|
||
!!(process.env.NODE_ENV !== "production") && warn$1(`root props passed to app.mount() must be an object.`);
|
||
rootProps = null;
|
||
}
|
||
const context = createAppContext();
|
||
const installedPlugins = /* @__PURE__ */ new WeakSet();
|
||
const app = context.app = {
|
||
_uid: uid$1++,
|
||
_component: rootComponent,
|
||
_props: rootProps,
|
||
_container: null,
|
||
_context: context,
|
||
_instance: null,
|
||
version,
|
||
get config() {
|
||
return context.config;
|
||
},
|
||
set config(v) {
|
||
if (!!(process.env.NODE_ENV !== "production")) {
|
||
warn$1(
|
||
`app.config cannot be replaced. Modify individual options instead.`
|
||
);
|
||
}
|
||
},
|
||
use(plugin, ...options) {
|
||
if (installedPlugins.has(plugin)) {
|
||
!!(process.env.NODE_ENV !== "production") && warn$1(`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$1(
|
||
`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$1(
|
||
"Mixin has already been applied to target app" + (mixin.name ? `: ${mixin.name}` : "")
|
||
);
|
||
}
|
||
} else if (!!(process.env.NODE_ENV !== "production")) {
|
||
warn$1("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$1(`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$1(`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$1(
|
||
`App already provides property with key "${String(key)}". It will be overwritten with the new value.`
|
||
);
|
||
}
|
||
context.provides[key] = value;
|
||
return app;
|
||
},
|
||
runWithContext(fn) {
|
||
const lastApp = currentApp;
|
||
currentApp = app;
|
||
try {
|
||
return fn();
|
||
} finally {
|
||
currentApp = lastApp;
|
||
}
|
||
}
|
||
};
|
||
return app;
|
||
};
|
||
}
|
||
let currentApp = null;
|
||
|
||
function provide(key, value) {
|
||
if (!currentInstance) {
|
||
if (!!(process.env.NODE_ENV !== "production")) {
|
||
warn$1(`provide() can only be used inside setup().`);
|
||
}
|
||
} else {
|
||
let provides = currentInstance.provides;
|
||
const parentProvides = currentInstance.parent && currentInstance.parent.provides;
|
||
if (parentProvides === provides) {
|
||
provides = currentInstance.provides = Object.create(parentProvides);
|
||
}
|
||
provides[key] = value;
|
||
if (currentInstance.type.mpType === "app") {
|
||
currentInstance.appContext.app.provide(key, value);
|
||
}
|
||
}
|
||
}
|
||
function inject(key, defaultValue, treatDefaultAsFactory = false) {
|
||
const instance = currentInstance || currentRenderingInstance;
|
||
if (instance || currentApp) {
|
||
const provides = instance ? instance.parent == null ? instance.vnode.appContext && instance.vnode.appContext.provides : instance.parent.provides : currentApp._context.provides;
|
||
if (provides && key in provides) {
|
||
return provides[key];
|
||
} else if (arguments.length > 1) {
|
||
return treatDefaultAsFactory && isFunction(defaultValue) ? defaultValue.call(instance && instance.proxy) : defaultValue;
|
||
} else if (!!(process.env.NODE_ENV !== "production")) {
|
||
warn$1(`injection "${String(key)}" not found.`);
|
||
}
|
||
} else if (!!(process.env.NODE_ENV !== "production")) {
|
||
warn$1(`inject() can only be used inside setup() or functional components.`);
|
||
}
|
||
}
|
||
function hasInjectionContext() {
|
||
return !!(currentInstance || currentRenderingInstance || currentApp);
|
||
}
|
||
|
||
/*! #__NO_SIDE_EFFECTS__ */
|
||
// @__NO_SIDE_EFFECTS__
|
||
function defineComponent(options, extraOptions) {
|
||
return isFunction(options) ? (
|
||
// #8326: extend call and options.name access are considered side-effects
|
||
// by Rollup, so we have to wrap it in a pure-annotated IIFE.
|
||
/* @__PURE__ */ (() => extend({ name: options.name }, extraOptions, { setup: options }))()
|
||
) : options;
|
||
}
|
||
|
||
const isKeepAlive = (vnode) => vnode.type.__isKeepAlive;
|
||
function onActivated(hook, target) {
|
||
registerKeepAliveHook(hook, "a", target);
|
||
}
|
||
function onDeactivated(hook, target) {
|
||
registerKeepAliveHook(hook, "da", target);
|
||
}
|
||
function registerKeepAliveHook(hook, type, target = currentInstance) {
|
||
const wrappedHook = hook.__wdc || (hook.__wdc = () => {
|
||
let current = target;
|
||
while (current) {
|
||
if (current.isDeactivated) {
|
||
return;
|
||
}
|
||
current = current.parent;
|
||
}
|
||
return hook();
|
||
});
|
||
injectHook(type, wrappedHook, target);
|
||
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) {
|
||
const injected = injectHook(
|
||
type,
|
||
hook,
|
||
keepAliveRoot,
|
||
true
|
||
/* prepend */
|
||
);
|
||
onUnmounted(() => {
|
||
remove(keepAliveRoot[type], injected);
|
||
}, target);
|
||
}
|
||
|
||
function injectHook(type, hook, target = currentInstance, prepend = false) {
|
||
if (target) {
|
||
if (isRootHook(type)) {
|
||
target = target.root;
|
||
}
|
||
const hooks = target[type] || (target[type] = []);
|
||
const wrappedHook = hook.__weh || (hook.__weh = (...args) => {
|
||
if (target.isUnmounted) {
|
||
return;
|
||
}
|
||
pauseTracking();
|
||
const reset = setCurrentInstance(target);
|
||
const res = callWithAsyncErrorHandling(hook, target, type, args);
|
||
reset();
|
||
resetTracking();
|
||
return res;
|
||
});
|
||
if (prepend) {
|
||
hooks.unshift(wrappedHook);
|
||
} else {
|
||
hooks.push(wrappedHook);
|
||
}
|
||
return wrappedHook;
|
||
} else if (!!(process.env.NODE_ENV !== "production")) {
|
||
const apiName = toHandlerKey(
|
||
(ErrorTypeStrings[type] || type.replace(/^on/, "")).replace(/ hook$/, "")
|
||
);
|
||
warn$1(
|
||
`${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 (except for serverPrefetch)
|
||
(!isInSSRComponentSetup || lifecycle === "sp") && injectHook(lifecycle, (...args) => hook(...args), target)
|
||
);
|
||
const onBeforeMount = createHook("bm");
|
||
const onMounted = createHook("m");
|
||
const onBeforeUpdate = createHook("bu");
|
||
const onUpdated = createHook("u");
|
||
const onBeforeUnmount = createHook("bum");
|
||
const onUnmounted = createHook("um");
|
||
const onServerPrefetch = createHook("sp");
|
||
const onRenderTriggered = createHook(
|
||
"rtg"
|
||
);
|
||
const onRenderTracked = createHook(
|
||
"rtc"
|
||
);
|
||
function onErrorCaptured(hook, target = currentInstance) {
|
||
injectHook("ec", hook, target);
|
||
}
|
||
|
||
function toHandlers(obj, preserveCaseIfNecessary) {
|
||
const ret = {};
|
||
if (!!(process.env.NODE_ENV !== "production") && !isObject(obj)) {
|
||
warn$1(`v-on with no argument expects an object value.`);
|
||
return ret;
|
||
}
|
||
for (const key in obj) {
|
||
ret[preserveCaseIfNecessary && /[A-Z]/.test(key) ? `on:${key}` : toHandlerKey(key)] = obj[key];
|
||
}
|
||
return ret;
|
||
}
|
||
|
||
const getPublicInstance = (i) => {
|
||
if (!i)
|
||
return null;
|
||
if (isStatefulComponent(i))
|
||
return getExposeProxy(i) || i.proxy;
|
||
return getPublicInstance(i.parent);
|
||
};
|
||
const publicPropertiesMap = (
|
||
// Move PURE marker to new line to workaround compiler discarding it
|
||
// due to type annotation
|
||
/* @__PURE__ */ extend(/* @__PURE__ */ Object.create(null), {
|
||
$: (i) => i,
|
||
// fixed by xxxxxx vue-i18n 在 dev 模式，访问了 $el，故模拟一个假的
|
||
// $el: i => i.vnode.el,
|
||
$el: (i) => i.__$el || (i.__$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) => getPublicInstance(i.parent),
|
||
$root: (i) => getPublicInstance(i.root),
|
||
$emit: (i) => i.emit,
|
||
$options: (i) => __VUE_OPTIONS_API__ ? resolveMergedOptions(i) : i.type,
|
||
$forceUpdate: (i) => i.f || (i.f = () => {
|
||
i.effect.dirty = true;
|
||
queueJob(i.update);
|
||
}),
|
||
// $nextTick: i => i.n || (i.n = nextTick.bind(i.proxy!)),// fixed by xxxxxx
|
||
$watch: (i) => __VUE_OPTIONS_API__ ? instanceWatch.bind(i) : NOOP
|
||
})
|
||
);
|
||
const isReservedPrefix = (key) => key === "_" || key === "$";
|
||
const hasSetupBinding = (state, key) => state !== EMPTY_OBJ && !state.__isScriptSetup && hasOwn(state, key);
|
||
const PublicInstanceProxyHandlers = {
|
||
get({ _: instance }, key) {
|
||
const { ctx, setupState, data, props, accessCache, type, appContext } = instance;
|
||
if (!!(process.env.NODE_ENV !== "production") && key === "__isVue") {
|
||
return true;
|
||
}
|
||
let normalizedProps;
|
||
if (key[0] !== "$") {
|
||
const n = accessCache[key];
|
||
if (n !== void 0) {
|
||
switch (n) {
|
||
case 1 /* SETUP */:
|
||
return setupState[key];
|
||
case 2 /* DATA */:
|
||
return data[key];
|
||
case 4 /* CONTEXT */:
|
||
return ctx[key];
|
||
case 3 /* PROPS */:
|
||
return props[key];
|
||
}
|
||
} else if (hasSetupBinding(setupState, key)) {
|
||
accessCache[key] = 1 /* SETUP */;
|
||
return setupState[key];
|
||
} else if (data !== EMPTY_OBJ && hasOwn(data, key)) {
|
||
accessCache[key] = 2 /* 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] = 3 /* PROPS */;
|
||
return props[key];
|
||
} else if (ctx !== EMPTY_OBJ && hasOwn(ctx, key)) {
|
||
accessCache[key] = 4 /* CONTEXT */;
|
||
return ctx[key];
|
||
} else if (!__VUE_OPTIONS_API__ || shouldCacheAccess) {
|
||
accessCache[key] = 0 /* OTHER */;
|
||
}
|
||
}
|
||
const publicGetter = publicPropertiesMap[key];
|
||
let cssModule, globalProperties;
|
||
if (publicGetter) {
|
||
if (key === "$attrs") {
|
||
track(instance, "get", key);
|
||
!!(process.env.NODE_ENV !== "production") && markAttrsAccessed();
|
||
} else if (!!(process.env.NODE_ENV !== "production") && key === "$slots") {
|
||
track(instance, "get", key);
|
||
}
|
||
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)) {
|
||
accessCache[key] = 4 /* 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 && isReservedPrefix(key[0]) && hasOwn(data, key)) {
|
||
warn$1(
|
||
`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 if (instance === currentRenderingInstance) {
|
||
warn$1(
|
||
`Property ${JSON.stringify(key)} was accessed during render but is not defined on instance.`
|
||
);
|
||
}
|
||
}
|
||
},
|
||
set({ _: instance }, key, value) {
|
||
const { data, setupState, ctx } = instance;
|
||
if (hasSetupBinding(setupState, key)) {
|
||
setupState[key] = value;
|
||
return true;
|
||
} else if (!!(process.env.NODE_ENV !== "production") && setupState.__isScriptSetup && hasOwn(setupState, key)) {
|
||
warn$1(`Cannot mutate <script setup> binding "${key}" from Options API.`);
|
||
return false;
|
||
} else if (data !== EMPTY_OBJ && hasOwn(data, key)) {
|
||
data[key] = value;
|
||
return true;
|
||
} else if (hasOwn(instance.props, key)) {
|
||
!!(process.env.NODE_ENV !== "production") && warn$1(`Attempting to mutate prop "${key}". Props are readonly.`);
|
||
return false;
|
||
}
|
||
if (key[0] === "$" && key.slice(1) in instance) {
|
||
!!(process.env.NODE_ENV !== "production") && warn$1(
|
||
`Attempting to mutate public property "${key}". Properties starting with $ are reserved and readonly.`
|
||
);
|
||
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] || data !== EMPTY_OBJ && hasOwn(data, key) || hasSetupBinding(setupState, key) || (normalizedProps = propsOptions[0]) && hasOwn(normalizedProps, key) || hasOwn(ctx, key) || hasOwn(publicPropertiesMap, key) || hasOwn(appContext.config.globalProperties, key);
|
||
},
|
||
defineProperty(target, key, descriptor) {
|
||
if (descriptor.get != null) {
|
||
target._.accessCache[key] = 0;
|
||
} else if (hasOwn(descriptor, "value")) {
|
||
this.set(target, key, descriptor.value, null);
|
||
}
|
||
return Reflect.defineProperty(target, key, descriptor);
|
||
}
|
||
};
|
||
if (!!(process.env.NODE_ENV !== "production") && true) {
|
||
PublicInstanceProxyHandlers.ownKeys = (target) => {
|
||
warn$1(
|
||
`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);
|
||
};
|
||
}
|
||
function createDevRenderContext(instance) {
|
||
const target = {};
|
||
Object.defineProperty(target, `_`, {
|
||
configurable: true,
|
||
enumerable: false,
|
||
get: () => instance
|
||
});
|
||
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
|
||
});
|
||
});
|
||
return target;
|
||
}
|
||
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
|
||
});
|
||
});
|
||
}
|
||
}
|
||
function exposeSetupStateOnRenderContext(instance) {
|
||
const { ctx, setupState } = instance;
|
||
Object.keys(toRaw(setupState)).forEach((key) => {
|
||
if (!setupState.__isScriptSetup) {
|
||
if (isReservedPrefix(key[0])) {
|
||
warn$1(
|
||
`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 warnRuntimeUsage = (method) => warn$1(
|
||
`${method}() is a compiler-hint helper that is only usable inside <script setup> of a single file component. Its arguments should be compiled away and passing it at runtime has no effect.`
|
||
);
|
||
function defineProps() {
|
||
if (!!(process.env.NODE_ENV !== "production")) {
|
||
warnRuntimeUsage(`defineProps`);
|
||
}
|
||
return null;
|
||
}
|
||
function defineEmits() {
|
||
if (!!(process.env.NODE_ENV !== "production")) {
|
||
warnRuntimeUsage(`defineEmits`);
|
||
}
|
||
return null;
|
||
}
|
||
function defineExpose(exposed) {
|
||
if (!!(process.env.NODE_ENV !== "production")) {
|
||
warnRuntimeUsage(`defineExpose`);
|
||
}
|
||
}
|
||
function withDefaults(props, defaults) {
|
||
if (!!(process.env.NODE_ENV !== "production")) {
|
||
warnRuntimeUsage(`withDefaults`);
|
||
}
|
||
return null;
|
||
}
|
||
function useSlots() {
|
||
return getContext().slots;
|
||
}
|
||
function useAttrs() {
|
||
return getContext().attrs;
|
||
}
|
||
function getContext() {
|
||
const i = getCurrentInstance();
|
||
if (!!(process.env.NODE_ENV !== "production") && !i) {
|
||
warn$1(`useContext() called without active instance.`);
|
||
}
|
||
return i.setupContext || (i.setupContext = createSetupContext(i));
|
||
}
|
||
function normalizePropsOrEmits(props) {
|
||
return isArray(props) ? props.reduce(
|
||
(normalized, p) => (normalized[p] = null, normalized),
|
||
{}
|
||
) : props;
|
||
}
|
||
function mergeDefaults(raw, defaults) {
|
||
const props = normalizePropsOrEmits(raw);
|
||
for (const key in defaults) {
|
||
if (key.startsWith("__skip"))
|
||
continue;
|
||
let opt = props[key];
|
||
if (opt) {
|
||
if (isArray(opt) || isFunction(opt)) {
|
||
opt = props[key] = { type: opt, default: defaults[key] };
|
||
} else {
|
||
opt.default = defaults[key];
|
||
}
|
||
} else if (opt === null) {
|
||
opt = props[key] = { default: defaults[key] };
|
||
} else if (!!(process.env.NODE_ENV !== "production")) {
|
||
warn$1(`props default key "${key}" has no corresponding declaration.`);
|
||
}
|
||
if (opt && defaults[`__skip_${key}`]) {
|
||
opt.skipFactory = true;
|
||
}
|
||
}
|
||
return props;
|
||
}
|
||
function mergeModels(a, b) {
|
||
if (!a || !b)
|
||
return a || b;
|
||
if (isArray(a) && isArray(b))
|
||
return a.concat(b);
|
||
return extend({}, normalizePropsOrEmits(a), normalizePropsOrEmits(b));
|
||
}
|
||
function createPropsRestProxy(props, excludedKeys) {
|
||
const ret = {};
|
||
for (const key in props) {
|
||
if (!excludedKeys.includes(key)) {
|
||
Object.defineProperty(ret, key, {
|
||
enumerable: true,
|
||
get: () => props[key]
|
||
});
|
||
}
|
||
}
|
||
return ret;
|
||
}
|
||
function withAsyncContext(getAwaitable) {
|
||
const ctx = getCurrentInstance();
|
||
if (!!(process.env.NODE_ENV !== "production") && !ctx) {
|
||
warn$1(
|
||
`withAsyncContext called without active current instance. This is likely a bug.`
|
||
);
|
||
}
|
||
let awaitable = getAwaitable();
|
||
unsetCurrentInstance();
|
||
if (isPromise(awaitable)) {
|
||
awaitable = awaitable.catch((e) => {
|
||
setCurrentInstance(ctx);
|
||
throw e;
|
||
});
|
||
}
|
||
return [awaitable, () => setCurrentInstance(ctx)];
|
||
}
|
||
|
||
function createDuplicateChecker() {
|
||
const cache = /* @__PURE__ */ Object.create(null);
|
||
return (type, key) => {
|
||
if (cache[key]) {
|
||
warn$1(`${type} property "${key}" is already defined in ${cache[key]}.`);
|
||
} else {
|
||
cache[key] = type;
|
||
}
|
||
};
|
||
}
|
||
let shouldCacheAccess = true;
|
||
function applyOptions$1(instance) {
|
||
const options = resolveMergedOptions(instance);
|
||
const publicThis = instance.proxy;
|
||
const ctx = instance.ctx;
|
||
shouldCacheAccess = false;
|
||
if (options.beforeCreate) {
|
||
callHook(options.beforeCreate, instance, "bc");
|
||
}
|
||
const {
|
||
// state
|
||
data: dataOptions,
|
||
computed: computedOptions,
|
||
methods,
|
||
watch: watchOptions,
|
||
provide: provideOptions,
|
||
inject: injectOptions,
|
||
// lifecycle
|
||
created,
|
||
beforeMount,
|
||
mounted,
|
||
beforeUpdate,
|
||
updated,
|
||
activated,
|
||
deactivated,
|
||
beforeDestroy,
|
||
beforeUnmount,
|
||
destroyed,
|
||
unmounted,
|
||
render,
|
||
renderTracked,
|
||
renderTriggered,
|
||
errorCaptured,
|
||
serverPrefetch,
|
||
// public API
|
||
expose,
|
||
inheritAttrs,
|
||
// assets
|
||
components,
|
||
directives,
|
||
filters
|
||
} = options;
|
||
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);
|
||
}
|
||
}
|
||
}
|
||
function initInjections() {
|
||
if (injectOptions) {
|
||
resolveInjections(injectOptions, ctx, checkDuplicateProperties);
|
||
}
|
||
}
|
||
if (!__VUE_CREATED_DEFERRED__) {
|
||
initInjections();
|
||
}
|
||
if (methods) {
|
||
for (const key in methods) {
|
||
const methodHandler = methods[key];
|
||
if (isFunction(methodHandler)) {
|
||
if (!!(process.env.NODE_ENV !== "production")) {
|
||
Object.defineProperty(ctx, key, {
|
||
value: methodHandler.bind(publicThis),
|
||
configurable: true,
|
||
enumerable: true,
|
||
writable: true
|
||
});
|
||
} else {
|
||
ctx[key] = methodHandler.bind(publicThis);
|
||
}
|
||
if (!!(process.env.NODE_ENV !== "production")) {
|
||
checkDuplicateProperties("Methods" /* METHODS */, key);
|
||
}
|
||
} else if (!!(process.env.NODE_ENV !== "production")) {
|
||
warn$1(
|
||
`Method "${key}" has type "${typeof methodHandler}" in the component definition. Did you reference the function correctly?`
|
||
);
|
||
}
|
||
}
|
||
}
|
||
if (dataOptions) {
|
||
if (!!(process.env.NODE_ENV !== "production") && !isFunction(dataOptions)) {
|
||
warn$1(
|
||
`The data option must be a function. Plain object usage is no longer supported.`
|
||
);
|
||
}
|
||
const data = dataOptions.call(publicThis, publicThis);
|
||
if (!!(process.env.NODE_ENV !== "production") && isPromise(data)) {
|
||
warn$1(
|
||
`data() returned a Promise - note data() cannot be async; If you intend to perform data fetching before component renders, use async setup() + <Suspense>.`
|
||
);
|
||
}
|
||
if (!isObject(data)) {
|
||
!!(process.env.NODE_ENV !== "production") && warn$1(`data() should return an object.`);
|
||
} else {
|
||
instance.data = reactive(data);
|
||
if (!!(process.env.NODE_ENV !== "production")) {
|
||
for (const key in data) {
|
||
checkDuplicateProperties("Data" /* DATA */, key);
|
||
if (!isReservedPrefix(key[0])) {
|
||
Object.defineProperty(ctx, key, {
|
||
configurable: true,
|
||
enumerable: true,
|
||
get: () => data[key],
|
||
set: NOOP
|
||
});
|
||
}
|
||
}
|
||
}
|
||
}
|
||
}
|
||
shouldCacheAccess = true;
|
||
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$1(`Computed property "${key}" has no getter.`);
|
||
}
|
||
const set = !isFunction(opt) && isFunction(opt.set) ? opt.set.bind(publicThis) : !!(process.env.NODE_ENV !== "production") ? () => {
|
||
warn$1(
|
||
`Write operation failed: computed property "${key}" is readonly.`
|
||
);
|
||
} : NOOP;
|
||
const c = computed({
|
||
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) {
|
||
for (const key in watchOptions) {
|
||
createWatcher(watchOptions[key], ctx, publicThis, key);
|
||
}
|
||
}
|
||
function initProvides() {
|
||
if (provideOptions) {
|
||
const provides = isFunction(provideOptions) ? provideOptions.call(publicThis) : provideOptions;
|
||
Reflect.ownKeys(provides).forEach((key) => {
|
||
provide(key, provides[key]);
|
||
});
|
||
}
|
||
}
|
||
if (!__VUE_CREATED_DEFERRED__) {
|
||
initProvides();
|
||
}
|
||
if (__VUE_CREATED_DEFERRED__) {
|
||
let callCreatedHook2 = function() {
|
||
initInjections();
|
||
initProvides();
|
||
if (created) {
|
||
callHook(created, instance, "c");
|
||
}
|
||
instance.update();
|
||
};
|
||
ctx.$callCreatedHook = function(name) {
|
||
const reset = setCurrentInstance(instance);
|
||
pauseTracking();
|
||
try {
|
||
callCreatedHook2();
|
||
} finally {
|
||
resetTracking();
|
||
reset();
|
||
}
|
||
};
|
||
} else {
|
||
if (created) {
|
||
callHook(created, instance, "c");
|
||
}
|
||
}
|
||
function registerLifecycleHook(register, hook) {
|
||
if (isArray(hook)) {
|
||
hook.forEach((_hook) => register(_hook.bind(publicThis)));
|
||
} else if (hook) {
|
||
register(hook.bind(publicThis));
|
||
}
|
||
}
|
||
registerLifecycleHook(onBeforeMount, beforeMount);
|
||
registerLifecycleHook(onMounted, mounted);
|
||
registerLifecycleHook(onBeforeUpdate, beforeUpdate);
|
||
registerLifecycleHook(onUpdated, updated);
|
||
registerLifecycleHook(onActivated, activated);
|
||
registerLifecycleHook(onDeactivated, deactivated);
|
||
registerLifecycleHook(onErrorCaptured, errorCaptured);
|
||
registerLifecycleHook(onRenderTracked, renderTracked);
|
||
registerLifecycleHook(onRenderTriggered, renderTriggered);
|
||
registerLifecycleHook(onBeforeUnmount, beforeUnmount);
|
||
registerLifecycleHook(onUnmounted, unmounted);
|
||
registerLifecycleHook(onServerPrefetch, serverPrefetch);
|
||
if (isArray(expose)) {
|
||
if (expose.length) {
|
||
const exposed = instance.exposed || (instance.exposed = {});
|
||
expose.forEach((key) => {
|
||
Object.defineProperty(exposed, key, {
|
||
get: () => publicThis[key],
|
||
set: (val) => publicThis[key] = val
|
||
});
|
||
});
|
||
} else if (!instance.exposed) {
|
||
instance.exposed = {};
|
||
}
|
||
}
|
||
if (render && instance.render === NOOP) {
|
||
instance.render = render;
|
||
}
|
||
if (inheritAttrs != null) {
|
||
instance.inheritAttrs = inheritAttrs;
|
||
}
|
||
if (components)
|
||
instance.components = components;
|
||
if (directives)
|
||
instance.directives = directives;
|
||
if (instance.ctx.$onApplyOptions) {
|
||
instance.ctx.$onApplyOptions(options, instance, publicThis);
|
||
}
|
||
}
|
||
function resolveInjections(injectOptions, ctx, checkDuplicateProperties = NOOP) {
|
||
if (isArray(injectOptions)) {
|
||
injectOptions = normalizeInject(injectOptions);
|
||
}
|
||
for (const key in injectOptions) {
|
||
const opt = injectOptions[key];
|
||
let injected;
|
||
if (isObject(opt)) {
|
||
if ("default" in opt) {
|
||
injected = inject(
|
||
opt.from || key,
|
||
opt.default,
|
||
true
|
||
);
|
||
} else {
|
||
injected = inject(opt.from || key);
|
||
}
|
||
} else {
|
||
injected = inject(opt);
|
||
}
|
||
if (isRef(injected)) {
|
||
Object.defineProperty(ctx, key, {
|
||
enumerable: true,
|
||
configurable: true,
|
||
get: () => injected.value,
|
||
set: (v) => injected.value = v
|
||
});
|
||
} else {
|
||
ctx[key] = injected;
|
||
}
|
||
if (!!(process.env.NODE_ENV !== "production")) {
|
||
checkDuplicateProperties("Inject" /* INJECT */, key);
|
||
}
|
||
}
|
||
}
|
||
function callHook(hook, instance, type) {
|
||
callWithAsyncErrorHandling(
|
||
isArray(hook) ? hook.map((h) => h.bind(instance.proxy)) : hook.bind(instance.proxy),
|
||
instance,
|
||
type
|
||
);
|
||
}
|
||
function createWatcher(raw, ctx, publicThis, key) {
|
||
const getter = key.includes(".") ? createPathGetter(publicThis, key) : () => publicThis[key];
|
||
if (isString(raw)) {
|
||
const handler = ctx[raw];
|
||
if (isFunction(handler)) {
|
||
watch(getter, handler);
|
||
} else if (!!(process.env.NODE_ENV !== "production")) {
|
||
warn$1(`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$1(`Invalid watch handler specified by key "${raw.handler}"`, handler);
|
||
}
|
||
}
|
||
} else if (!!(process.env.NODE_ENV !== "production")) {
|
||
warn$1(`Invalid watch option: "${key}"`, raw);
|
||
}
|
||
}
|
||
function resolveMergedOptions(instance) {
|
||
const base = instance.type;
|
||
const { mixins, extends: extendsOptions } = base;
|
||
const {
|
||
mixins: globalMixins,
|
||
optionsCache: cache,
|
||
config: { optionMergeStrategies }
|
||
} = instance.appContext;
|
||
const cached = cache.get(base);
|
||
let resolved;
|
||
if (cached) {
|
||
resolved = cached;
|
||
} else if (!globalMixins.length && !mixins && !extendsOptions) {
|
||
{
|
||
resolved = base;
|
||
}
|
||
} else {
|
||
resolved = {};
|
||
if (globalMixins.length) {
|
||
globalMixins.forEach(
|
||
(m) => mergeOptions(resolved, m, optionMergeStrategies, true)
|
||
);
|
||
}
|
||
mergeOptions(resolved, base, optionMergeStrategies);
|
||
}
|
||
if (isObject(base)) {
|
||
cache.set(base, resolved);
|
||
}
|
||
return resolved;
|
||
}
|
||
function mergeOptions(to, from, strats, asMixin = false) {
|
||
const { mixins, extends: extendsOptions } = from;
|
||
if (extendsOptions) {
|
||
mergeOptions(to, extendsOptions, strats, true);
|
||
}
|
||
if (mixins) {
|
||
mixins.forEach(
|
||
(m) => mergeOptions(to, m, strats, true)
|
||
);
|
||
}
|
||
for (const key in from) {
|
||
if (asMixin && key === "expose") {
|
||
!!(process.env.NODE_ENV !== "production") && warn$1(
|
||
`"expose" option is ignored when declared in mixins or extends. It should only be declared in the base component itself.`
|
||
);
|
||
} else {
|
||
const strat = internalOptionMergeStrats[key] || strats && strats[key];
|
||
to[key] = strat ? strat(to[key], from[key]) : from[key];
|
||
}
|
||
}
|
||
return to;
|
||
}
|
||
const internalOptionMergeStrats = {
|
||
data: mergeDataFn,
|
||
props: mergeEmitsOrPropsOptions,
|
||
emits: mergeEmitsOrPropsOptions,
|
||
// objects
|
||
methods: mergeObjectOptions,
|
||
computed: mergeObjectOptions,
|
||
// lifecycle
|
||
beforeCreate: mergeAsArray$1,
|
||
created: mergeAsArray$1,
|
||
beforeMount: mergeAsArray$1,
|
||
mounted: mergeAsArray$1,
|
||
beforeUpdate: mergeAsArray$1,
|
||
updated: mergeAsArray$1,
|
||
beforeDestroy: mergeAsArray$1,
|
||
beforeUnmount: mergeAsArray$1,
|
||
destroyed: mergeAsArray$1,
|
||
unmounted: mergeAsArray$1,
|
||
activated: mergeAsArray$1,
|
||
deactivated: mergeAsArray$1,
|
||
errorCaptured: mergeAsArray$1,
|
||
serverPrefetch: mergeAsArray$1,
|
||
// assets
|
||
components: mergeObjectOptions,
|
||
directives: mergeObjectOptions,
|
||
// watch
|
||
watch: mergeWatchOptions,
|
||
// provide / inject
|
||
provide: mergeDataFn,
|
||
inject: mergeInject
|
||
};
|
||
function mergeDataFn(to, from) {
|
||
if (!from) {
|
||
return to;
|
||
}
|
||
if (!to) {
|
||
return from;
|
||
}
|
||
return function mergedDataFn() {
|
||
return (extend)(
|
||
isFunction(to) ? to.call(this, this) : to,
|
||
isFunction(from) ? from.call(this, this) : from
|
||
);
|
||
};
|
||
}
|
||
function mergeInject(to, from) {
|
||
return mergeObjectOptions(normalizeInject(to), normalizeInject(from));
|
||
}
|
||
function normalizeInject(raw) {
|
||
if (isArray(raw)) {
|
||
const res = {};
|
||
for (let i = 0; i < raw.length; i++) {
|
||
res[raw[i]] = raw[i];
|
||
}
|
||
return res;
|
||
}
|
||
return raw;
|
||
}
|
||
function mergeAsArray$1(to, from) {
|
||
return to ? [...new Set([].concat(to, from))] : from;
|
||
}
|
||
function mergeObjectOptions(to, from) {
|
||
return to ? extend(/* @__PURE__ */ Object.create(null), to, from) : from;
|
||
}
|
||
function mergeEmitsOrPropsOptions(to, from) {
|
||
if (to) {
|
||
if (isArray(to) && isArray(from)) {
|
||
return [.../* @__PURE__ */ new Set([...to, ...from])];
|
||
}
|
||
return extend(
|
||
/* @__PURE__ */ Object.create(null),
|
||
normalizePropsOrEmits(to),
|
||
normalizePropsOrEmits(from != null ? from : {})
|
||
);
|
||
} else {
|
||
return from;
|
||
}
|
||
}
|
||
function mergeWatchOptions(to, from) {
|
||
if (!to)
|
||
return from;
|
||
if (!from)
|
||
return to;
|
||
const merged = extend(/* @__PURE__ */ Object.create(null), to);
|
||
for (const key in from) {
|
||
merged[key] = mergeAsArray$1(to[key], from[key]);
|
||
}
|
||
return merged;
|
||
}
|
||
|
||
function initProps(instance, rawProps, isStateful, isSSR = false) {
|
||
const props = {};
|
||
const attrs = {};
|
||
instance.propsDefaults = /* @__PURE__ */ Object.create(null);
|
||
setFullProps(instance, rawProps, props, attrs);
|
||
for (const key in instance.propsOptions[0]) {
|
||
if (!(key in props)) {
|
||
props[key] = void 0;
|
||
}
|
||
}
|
||
if (!!(process.env.NODE_ENV !== "production")) {
|
||
validateProps(rawProps || {}, props, instance);
|
||
}
|
||
if (isStateful) {
|
||
instance.props = isSSR ? props : shallowReactive(props);
|
||
} else {
|
||
if (!instance.type.props) {
|
||
instance.props = attrs;
|
||
} else {
|
||
instance.props = props;
|
||
}
|
||
}
|
||
instance.attrs = attrs;
|
||
}
|
||
function isInHmrContext(instance) {
|
||
}
|
||
function updateProps(instance, rawProps, rawPrevProps, optimized) {
|
||
const {
|
||
props,
|
||
attrs,
|
||
vnode: { patchFlag }
|
||
} = instance;
|
||
const rawCurrentProps = toRaw(props);
|
||
const [options] = instance.propsOptions;
|
||
let hasAttrsChanged = false;
|
||
if (
|
||
// always force full diff in dev
|
||
// - #1942 if hmr is enabled with sfc component
|
||
// - vite#872 non-sfc component used by sfc component
|
||
!(!!(process.env.NODE_ENV !== "production") && isInHmrContext()) && (optimized || patchFlag > 0) && !(patchFlag & 16)
|
||
) {
|
||
if (patchFlag & 8) {
|
||
const propsToUpdate = instance.vnode.dynamicProps;
|
||
for (let i = 0; i < propsToUpdate.length; i++) {
|
||
let key = propsToUpdate[i];
|
||
if (isEmitListener(instance.emitsOptions, key)) {
|
||
continue;
|
||
}
|
||
const value = rawProps[key];
|
||
if (options) {
|
||
if (hasOwn(attrs, key)) {
|
||
if (value !== attrs[key]) {
|
||
attrs[key] = value;
|
||
hasAttrsChanged = true;
|
||
}
|
||
} else {
|
||
const camelizedKey = camelize(key);
|
||
props[camelizedKey] = resolvePropValue(
|
||
options,
|
||
rawCurrentProps,
|
||
camelizedKey,
|
||
value,
|
||
instance,
|
||
false
|
||
);
|
||
}
|
||
} else {
|
||
if (value !== attrs[key]) {
|
||
attrs[key] = value;
|
||
hasAttrsChanged = true;
|
||
}
|
||
}
|
||
}
|
||
}
|
||
} else {
|
||
if (setFullProps(instance, rawProps, props, attrs)) {
|
||
hasAttrsChanged = true;
|
||
}
|
||
let kebabKey;
|
||
for (const key in rawCurrentProps) {
|
||
if (!rawProps || // for camelCase
|
||
!hasOwn(rawProps, key) && // it's possible the original props was passed in as kebab-case
|
||
// and converted to camelCase (#955)
|
||
((kebabKey = hyphenate(key)) === key || !hasOwn(rawProps, kebabKey))) {
|
||
if (options) {
|
||
if (rawPrevProps && // for camelCase
|
||
(rawPrevProps[key] !== void 0 || // for kebab-case
|
||
rawPrevProps[kebabKey] !== void 0)) {
|
||
props[key] = resolvePropValue(
|
||
options,
|
||
rawCurrentProps,
|
||
key,
|
||
void 0,
|
||
instance,
|
||
true
|
||
);
|
||
}
|
||
} else {
|
||
delete props[key];
|
||
}
|
||
}
|
||
}
|
||
if (attrs !== rawCurrentProps) {
|
||
for (const key in attrs) {
|
||
if (!rawProps || !hasOwn(rawProps, key) && true) {
|
||
delete attrs[key];
|
||
hasAttrsChanged = true;
|
||
}
|
||
}
|
||
}
|
||
}
|
||
if (hasAttrsChanged) {
|
||
trigger(instance, "set", "$attrs");
|
||
}
|
||
if (!!(process.env.NODE_ENV !== "production")) {
|
||
validateProps(rawProps || {}, props, instance);
|
||
}
|
||
}
|
||
function setFullProps(instance, rawProps, props, attrs) {
|
||
const [options, needCastKeys] = instance.propsOptions;
|
||
let hasAttrsChanged = false;
|
||
let rawCastValues;
|
||
if (rawProps) {
|
||
for (let key in rawProps) {
|
||
if (isReservedProp(key)) {
|
||
continue;
|
||
}
|
||
const value = rawProps[key];
|
||
let camelKey;
|
||
if (options && hasOwn(options, camelKey = camelize(key))) {
|
||
if (!needCastKeys || !needCastKeys.includes(camelKey)) {
|
||
props[camelKey] = value;
|
||
} else {
|
||
(rawCastValues || (rawCastValues = {}))[camelKey] = value;
|
||
}
|
||
} else if (!isEmitListener(instance.emitsOptions, key)) {
|
||
if (!(key in attrs) || value !== attrs[key]) {
|
||
attrs[key] = value;
|
||
hasAttrsChanged = true;
|
||
}
|
||
}
|
||
}
|
||
}
|
||
if (needCastKeys) {
|
||
const rawCurrentProps = toRaw(props);
|
||
const castValues = rawCastValues || EMPTY_OBJ;
|
||
for (let i = 0; i < needCastKeys.length; i++) {
|
||
const key = needCastKeys[i];
|
||
props[key] = resolvePropValue(
|
||
options,
|
||
rawCurrentProps,
|
||
key,
|
||
castValues[key],
|
||
instance,
|
||
!hasOwn(castValues, key)
|
||
);
|
||
}
|
||
}
|
||
return hasAttrsChanged;
|
||
}
|
||
function resolvePropValue(options, props, key, value, instance, isAbsent) {
|
||
const opt = options[key];
|
||
if (opt != null) {
|
||
const hasDefault = hasOwn(opt, "default");
|
||
if (hasDefault && value === void 0) {
|
||
const defaultValue = opt.default;
|
||
if (opt.type !== Function && !opt.skipFactory && isFunction(defaultValue)) {
|
||
const { propsDefaults } = instance;
|
||
if (key in propsDefaults) {
|
||
value = propsDefaults[key];
|
||
} else {
|
||
const reset = setCurrentInstance(instance);
|
||
value = propsDefaults[key] = defaultValue.call(
|
||
null,
|
||
props
|
||
);
|
||
reset();
|
||
}
|
||
} else {
|
||
value = defaultValue;
|
||
}
|
||
}
|
||
if (opt[0 /* shouldCast */]) {
|
||
if (isAbsent && !hasDefault) {
|
||
value = false;
|
||
} else if (opt[1 /* shouldCastTrue */] && (value === "" || value === hyphenate(key))) {
|
||
value = true;
|
||
}
|
||
}
|
||
}
|
||
return value;
|
||
}
|
||
function normalizePropsOptions(comp, appContext, asMixin = false) {
|
||
const cache = appContext.propsCache;
|
||
const cached = cache.get(comp);
|
||
if (cached) {
|
||
return cached;
|
||
}
|
||
const raw = comp.props;
|
||
const normalized = {};
|
||
const needCastKeys = [];
|
||
let hasExtends = false;
|
||
if (__VUE_OPTIONS_API__ && !isFunction(comp)) {
|
||
const extendProps = (raw2) => {
|
||
hasExtends = true;
|
||
const [props, keys] = normalizePropsOptions(raw2, 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) {
|
||
if (isObject(comp)) {
|
||
cache.set(comp, EMPTY_ARR);
|
||
}
|
||
return EMPTY_ARR;
|
||
}
|
||
if (isArray(raw)) {
|
||
for (let i = 0; i < raw.length; i++) {
|
||
if (!!(process.env.NODE_ENV !== "production") && !isString(raw[i])) {
|
||
warn$1(`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$1(`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 } : extend({}, 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 (booleanIndex > -1 || hasOwn(prop, "default")) {
|
||
needCastKeys.push(normalizedKey);
|
||
}
|
||
}
|
||
}
|
||
}
|
||
}
|
||
const res = [normalized, needCastKeys];
|
||
if (isObject(comp)) {
|
||
cache.set(comp, res);
|
||
}
|
||
return res;
|
||
}
|
||
function validatePropName(key) {
|
||
if (key[0] !== "$" && !isReservedProp(key)) {
|
||
return true;
|
||
} else if (!!(process.env.NODE_ENV !== "production")) {
|
||
warn$1(`Invalid prop name: "${key}" is a reserved property.`);
|
||
}
|
||
return false;
|
||
}
|
||
function getType(ctor) {
|
||
if (ctor === null) {
|
||
return "null";
|
||
}
|
||
if (typeof ctor === "function") {
|
||
return ctor.name || "";
|
||
} else if (typeof ctor === "object") {
|
||
const name = ctor.constructor && ctor.constructor.name;
|
||
return name || "";
|
||
}
|
||
return "";
|
||
}
|
||
function isSameType(a, b) {
|
||
return getType(a) === getType(b);
|
||
}
|
||
function getTypeIndex(type, expectedTypes) {
|
||
if (isArray(expectedTypes)) {
|
||
return expectedTypes.findIndex((t) => isSameType(t, type));
|
||
} else if (isFunction(expectedTypes)) {
|
||
return isSameType(expectedTypes, type) ? 0 : -1;
|
||
}
|
||
return -1;
|
||
}
|
||
function validateProps(rawProps, props, instance) {
|
||
const resolvedValues = toRaw(props);
|
||
const options = instance.propsOptions[0];
|
||
for (const key in options) {
|
||
let opt = options[key];
|
||
if (opt == null)
|
||
continue;
|
||
validateProp(
|
||
key,
|
||
resolvedValues[key],
|
||
opt,
|
||
!!(process.env.NODE_ENV !== "production") ? shallowReadonly(resolvedValues) : resolvedValues,
|
||
!hasOwn(rawProps, key) && !hasOwn(rawProps, hyphenate(key))
|
||
);
|
||
}
|
||
}
|
||
function validateProp(name, value, prop, props, isAbsent) {
|
||
const { type, required, validator, skipCheck } = prop;
|
||
if (required && isAbsent) {
|
||
warn$1('Missing required prop: "' + name + '"');
|
||
return;
|
||
}
|
||
if (value == null && !required) {
|
||
return;
|
||
}
|
||
if (type != null && type !== true && !skipCheck) {
|
||
let isValid = false;
|
||
const types = isArray(type) ? type : [type];
|
||
const expectedTypes = [];
|
||
for (let i = 0; i < types.length && !isValid; i++) {
|
||
const { valid, expectedType } = assertType(value, types[i]);
|
||
expectedTypes.push(expectedType || "");
|
||
isValid = valid;
|
||
}
|
||
if (!isValid) {
|
||
warn$1(getInvalidTypeMessage(name, value, expectedTypes));
|
||
return;
|
||
}
|
||
}
|
||
if (validator && !validator(value, props)) {
|
||
warn$1('Invalid prop: custom validator check failed for prop "' + name + '".');
|
||
}
|
||
}
|
||
const isSimpleType = /* @__PURE__ */ makeMap(
|
||
"String,Number,Boolean,Function,Symbol,BigInt"
|
||
);
|
||
function assertType(value, type) {
|
||
let valid;
|
||
const expectedType = getType(type);
|
||
if (isSimpleType(expectedType)) {
|
||
const t = typeof value;
|
||
valid = t === expectedType.toLowerCase();
|
||
if (!valid && t === "object") {
|
||
valid = value instanceof type;
|
||
}
|
||
} else if (expectedType === "Object") {
|
||
valid = isObject(value);
|
||
} else if (expectedType === "Array") {
|
||
valid = isArray(value);
|
||
} else if (expectedType === "null") {
|
||
valid = value === null;
|
||
} else {
|
||
valid = value instanceof type;
|
||
}
|
||
return {
|
||
valid,
|
||
expectedType
|
||
};
|
||
}
|
||
function getInvalidTypeMessage(name, value, expectedTypes) {
|
||
if (expectedTypes.length === 0) {
|
||
return `Prop type [] for prop "${name}" won't match anything. Did you mean to use type Array instead?`;
|
||
}
|
||
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);
|
||
if (expectedTypes.length === 1 && isExplicable(expectedType) && !isBoolean(expectedType, receivedType)) {
|
||
message += ` with value ${expectedValue}`;
|
||
}
|
||
message += `, got ${receivedType} `;
|
||
if (isExplicable(receivedType)) {
|
||
message += `with value ${receivedValue}.`;
|
||
}
|
||
return message;
|
||
}
|
||
function styleValue(value, type) {
|
||
if (type === "String") {
|
||
return `"${value}"`;
|
||
} else if (type === "Number") {
|
||
return `${Number(value)}`;
|
||
} else {
|
||
return `${value}`;
|
||
}
|
||
}
|
||
function isExplicable(type) {
|
||
const explicitTypes = ["string", "number", "boolean"];
|
||
return explicitTypes.some((elem) => type.toLowerCase() === elem);
|
||
}
|
||
function isBoolean(...args) {
|
||
return args.some((elem) => elem.toLowerCase() === "boolean");
|
||
}
|
||
|
||
let supported;
|
||
let perf;
|
||
function startMeasure(instance, type) {
|
||
if (instance.appContext.config.performance && isSupported()) {
|
||
perf.mark(`vue-${type}-${instance.uid}`);
|
||
}
|
||
if (!!(process.env.NODE_ENV !== "production") || __VUE_PROD_DEVTOOLS__) {
|
||
devtoolsPerfStart(instance, type, isSupported() ? perf.now() : Date.now());
|
||
}
|
||
}
|
||
function endMeasure(instance, type) {
|
||
if (instance.appContext.config.performance && isSupported()) {
|
||
const startTag = `vue-${type}-${instance.uid}`;
|
||
const endTag = startTag + `:end`;
|
||
perf.mark(endTag);
|
||
perf.measure(
|
||
`<${formatComponentName(instance, instance.type)}> ${type}`,
|
||
startTag,
|
||
endTag
|
||
);
|
||
perf.clearMarks(startTag);
|
||
perf.clearMarks(endTag);
|
||
}
|
||
if (!!(process.env.NODE_ENV !== "production") || __VUE_PROD_DEVTOOLS__) {
|
||
devtoolsPerfEnd(instance, type, isSupported() ? perf.now() : Date.now());
|
||
}
|
||
}
|
||
function isSupported() {
|
||
if (supported !== void 0) {
|
||
return supported;
|
||
}
|
||
if (typeof window !== "undefined" && window.performance) {
|
||
supported = true;
|
||
perf = window.performance;
|
||
} else {
|
||
supported = false;
|
||
}
|
||
return supported;
|
||
}
|
||
|
||
const queuePostRenderEffect$1 = queuePostFlushCb;
|
||
|
||
const isTeleport = (type) => type.__isTeleport;
|
||
|
||
const Fragment = Symbol.for("v-fgt");
|
||
const Text = Symbol.for("v-txt");
|
||
const Comment = Symbol.for("v-cmt");
|
||
const Static = Symbol.for("v-stc");
|
||
let currentBlock = null;
|
||
let isBlockTreeEnabled = 1;
|
||
function setBlockTracking(value) {
|
||
isBlockTreeEnabled += value;
|
||
}
|
||
function isVNode(value) {
|
||
return value ? value.__v_isVNode === true : false;
|
||
}
|
||
const createVNodeWithArgsTransform = (...args) => {
|
||
return _createVNode(
|
||
...args
|
||
);
|
||
};
|
||
const InternalObjectKey = `__vInternal`;
|
||
const normalizeKey = ({ key }) => key != null ? key : null;
|
||
const normalizeRef = ({
|
||
ref,
|
||
ref_key,
|
||
ref_for
|
||
}) => {
|
||
if (typeof ref === "number") {
|
||
ref = "" + ref;
|
||
}
|
||
return ref != null ? isString(ref) || isRef(ref) || isFunction(ref) ? { i: currentRenderingInstance, r: ref, k: ref_key, f: !!ref_for } : ref : null;
|
||
};
|
||
function createBaseVNode(type, props = null, children = null, patchFlag = 0, dynamicProps = null, shapeFlag = type === Fragment ? 0 : 1, isBlockNode = false, needFullChildrenNormalization = false) {
|
||
const vnode = {
|
||
__v_isVNode: true,
|
||
__v_skip: true,
|
||
type,
|
||
props,
|
||
key: props && normalizeKey(props),
|
||
ref: props && normalizeRef(props),
|
||
scopeId: currentScopeId,
|
||
slotScopeIds: null,
|
||
children,
|
||
component: null,
|
||
suspense: null,
|
||
ssContent: null,
|
||
ssFallback: null,
|
||
dirs: null,
|
||
transition: null,
|
||
el: null,
|
||
anchor: null,
|
||
target: null,
|
||
targetAnchor: null,
|
||
staticCount: 0,
|
||
shapeFlag,
|
||
patchFlag,
|
||
dynamicProps,
|
||
dynamicChildren: null,
|
||
appContext: null,
|
||
ctx: currentRenderingInstance
|
||
};
|
||
if (needFullChildrenNormalization) {
|
||
normalizeChildren(vnode, children);
|
||
} else if (children) {
|
||
vnode.shapeFlag |= isString(children) ? 8 : 16;
|
||
}
|
||
if (!!(process.env.NODE_ENV !== "production") && vnode.key !== vnode.key) {
|
||
warn$1(`VNode created with invalid key (NaN). VNode type:`, vnode.type);
|
||
}
|
||
if (isBlockTreeEnabled > 0 && // avoid a block node from tracking itself
|
||
!isBlockNode && // has current parent block
|
||
currentBlock && // presence of a patch flag indicates this node needs patching on updates.
|
||
// component nodes also should always be patched, because even if the
|
||
// component doesn't need to update, it needs to persist the instance on to
|
||
// the next vnode so that it can be properly unmounted later.
|
||
(vnode.patchFlag > 0 || shapeFlag & 6) && // the EVENTS flag is only for hydration and if it is the only flag, the
|
||
// vnode should not be considered dynamic due to handler caching.
|
||
vnode.patchFlag !== 32) {
|
||
currentBlock.push(vnode);
|
||
}
|
||
return vnode;
|
||
}
|
||
const createVNode$1 = !!(process.env.NODE_ENV !== "production") ? createVNodeWithArgsTransform : _createVNode;
|
||
function _createVNode(type, props = null, children = null, patchFlag = 0, dynamicProps = null, isBlockNode = false) {
|
||
if (!type || type === NULL_DYNAMIC_COMPONENT) {
|
||
if (!!(process.env.NODE_ENV !== "production") && !type) {
|
||
warn$1(`Invalid vnode type when creating vnode: ${type}.`);
|
||
}
|
||
type = Comment;
|
||
}
|
||
if (isVNode(type)) {
|
||
const cloned = cloneVNode(
|
||
type,
|
||
props,
|
||
true
|
||
/* mergeRef: true */
|
||
);
|
||
if (children) {
|
||
normalizeChildren(cloned, children);
|
||
}
|
||
if (isBlockTreeEnabled > 0 && !isBlockNode && currentBlock) {
|
||
if (cloned.shapeFlag & 6) {
|
||
currentBlock[currentBlock.indexOf(type)] = cloned;
|
||
} else {
|
||
currentBlock.push(cloned);
|
||
}
|
||
}
|
||
cloned.patchFlag |= -2;
|
||
return cloned;
|
||
}
|
||
if (isClassComponent(type)) {
|
||
type = type.__vccOpts;
|
||
}
|
||
if (props) {
|
||
props = guardReactiveProps(props);
|
||
let { class: klass, style } = props;
|
||
if (klass && !isString(klass)) {
|
||
props.class = normalizeClass(klass);
|
||
}
|
||
if (isObject(style)) {
|
||
if (isProxy(style) && !isArray(style)) {
|
||
style = extend({}, style);
|
||
}
|
||
props.style = normalizeStyle(style);
|
||
}
|
||
}
|
||
const shapeFlag = isString(type) ? 1 : isTeleport(type) ? 64 : isObject(type) ? 4 : isFunction(type) ? 2 : 0;
|
||
if (!!(process.env.NODE_ENV !== "production") && shapeFlag & 4 && isProxy(type)) {
|
||
type = toRaw(type);
|
||
warn$1(
|
||
`Vue received a Component that was made a reactive object. This can lead to unnecessary performance overhead and should be avoided by marking the component with \`markRaw\` or using \`shallowRef\` instead of \`ref\`.`,
|
||
`
|
||
Component that was made reactive: `,
|
||
type
|
||
);
|
||
}
|
||
return createBaseVNode(
|
||
type,
|
||
props,
|
||
children,
|
||
patchFlag,
|
||
dynamicProps,
|
||
shapeFlag,
|
||
isBlockNode,
|
||
true
|
||
);
|
||
}
|
||
function guardReactiveProps(props) {
|
||
if (!props)
|
||
return null;
|
||
return isProxy(props) || InternalObjectKey in props ? extend({}, props) : props;
|
||
}
|
||
function cloneVNode(vnode, extraProps, mergeRef = false) {
|
||
const { props, ref, patchFlag, children } = vnode;
|
||
const mergedProps = extraProps ? mergeProps(props || {}, extraProps) : props;
|
||
const cloned = {
|
||
__v_isVNode: true,
|
||
__v_skip: true,
|
||
type: vnode.type,
|
||
props: mergedProps,
|
||
key: mergedProps && normalizeKey(mergedProps),
|
||
ref: extraProps && extraProps.ref ? (
|
||
// #2078 in the case of <component :is="vnode" ref="extra"/>
|
||
// if the vnode itself already has a ref, cloneVNode will need to merge
|
||
// the refs so the single vnode can be set on multiple refs
|
||
mergeRef && ref ? isArray(ref) ? ref.concat(normalizeRef(extraProps)) : [ref, normalizeRef(extraProps)] : normalizeRef(extraProps)
|
||
) : ref,
|
||
scopeId: vnode.scopeId,
|
||
slotScopeIds: vnode.slotScopeIds,
|
||
children: !!(process.env.NODE_ENV !== "production") && patchFlag === -1 && isArray(children) ? children.map(deepCloneVNode) : children,
|
||
target: vnode.target,
|
||
targetAnchor: vnode.targetAnchor,
|
||
staticCount: vnode.staticCount,
|
||
shapeFlag: vnode.shapeFlag,
|
||
// if the vnode is cloned with extra props, we can no longer assume its
|
||
// existing patch flag to be reliable and need to add the FULL_PROPS flag.
|
||
// note: preserve flag for fragments since they use the flag for children
|
||
// fast paths only.
|
||
patchFlag: extraProps && vnode.type !== Fragment ? patchFlag === -1 ? 16 : patchFlag | 16 : patchFlag,
|
||
dynamicProps: vnode.dynamicProps,
|
||
dynamicChildren: vnode.dynamicChildren,
|
||
appContext: vnode.appContext,
|
||
dirs: vnode.dirs,
|
||
transition: vnode.transition,
|
||
// These should technically only be non-null on mounted VNodes. However,
|
||
// they *should* be copied for kept-alive vnodes. So we just always copy
|
||
// them since them being non-null during a mount doesn't affect the logic as
|
||
// they will simply be overwritten.
|
||
component: vnode.component,
|
||
suspense: vnode.suspense,
|
||
ssContent: vnode.ssContent && cloneVNode(vnode.ssContent),
|
||
ssFallback: vnode.ssFallback && cloneVNode(vnode.ssFallback),
|
||
el: vnode.el,
|
||
anchor: vnode.anchor,
|
||
ctx: vnode.ctx,
|
||
ce: vnode.ce
|
||
};
|
||
return cloned;
|
||
}
|
||
function deepCloneVNode(vnode) {
|
||
const cloned = cloneVNode(vnode);
|
||
if (isArray(vnode.children)) {
|
||
cloned.children = vnode.children.map(deepCloneVNode);
|
||
}
|
||
return cloned;
|
||
}
|
||
function createTextVNode(text = " ", flag = 0) {
|
||
return createVNode$1(Text, null, text, flag);
|
||
}
|
||
function normalizeChildren(vnode, children) {
|
||
let type = 0;
|
||
const { shapeFlag } = vnode;
|
||
if (children == null) {
|
||
children = null;
|
||
} else if (isArray(children)) {
|
||
type = 16;
|
||
} else if (typeof children === "object") {
|
||
if (shapeFlag & (1 | 64)) {
|
||
const slot = children.default;
|
||
if (slot) {
|
||
slot._c && (slot._d = false);
|
||
normalizeChildren(vnode, slot());
|
||
slot._c && (slot._d = true);
|
||
}
|
||
return;
|
||
} else {
|
||
type = 32;
|
||
const slotFlag = children._;
|
||
if (!slotFlag && !(InternalObjectKey in children)) {
|
||
children._ctx = currentRenderingInstance;
|
||
} else if (slotFlag === 3 && currentRenderingInstance) {
|
||
if (currentRenderingInstance.slots._ === 1) {
|
||
children._ = 1;
|
||
} else {
|
||
children._ = 2;
|
||
vnode.patchFlag |= 1024;
|
||
}
|
||
}
|
||
}
|
||
} else if (isFunction(children)) {
|
||
children = { default: children, _ctx: currentRenderingInstance };
|
||
type = 32;
|
||
} else {
|
||
children = String(children);
|
||
if (shapeFlag & 64) {
|
||
type = 16;
|
||
children = [createTextVNode(children)];
|
||
} else {
|
||
type = 8;
|
||
}
|
||
}
|
||
vnode.children = children;
|
||
vnode.shapeFlag |= type;
|
||
}
|
||
function mergeProps(...args) {
|
||
const ret = {};
|
||
for (let i = 0; i < args.length; i++) {
|
||
const toMerge = args[i];
|
||
for (const key in toMerge) {
|
||
if (key === "class") {
|
||
if (ret.class !== toMerge.class) {
|
||
ret.class = normalizeClass([ret.class, toMerge.class]);
|
||
}
|
||
} else if (key === "style") {
|
||
ret.style = normalizeStyle([ret.style, toMerge.style]);
|
||
} else if (isOn(key)) {
|
||
const existing = ret[key];
|
||
const incoming = toMerge[key];
|
||
if (incoming && existing !== incoming && !(isArray(existing) && existing.includes(incoming))) {
|
||
ret[key] = existing ? [].concat(existing, incoming) : incoming;
|
||
}
|
||
} else if (key !== "") {
|
||
ret[key] = toMerge[key];
|
||
}
|
||
}
|
||
}
|
||
return ret;
|
||
}
|
||
|
||
const emptyAppContext = createAppContext();
|
||
let uid = 0;
|
||
function createComponentInstance(vnode, parent, suspense) {
|
||
const type = vnode.type;
|
||
const appContext = (parent ? parent.appContext : vnode.appContext) || emptyAppContext;
|
||
const instance = {
|
||
uid: uid++,
|
||
vnode,
|
||
type,
|
||
parent,
|
||
appContext,
|
||
root: null,
|
||
// to be immediately set
|
||
next: null,
|
||
subTree: null,
|
||
// will be set synchronously right after creation
|
||
effect: null,
|
||
update: null,
|
||
// will be set synchronously right after creation
|
||
scope: new EffectScope(
|
||
true
|
||
/* detached */
|
||
),
|
||
render: null,
|
||
proxy: null,
|
||
exposed: null,
|
||
exposeProxy: null,
|
||
withProxy: null,
|
||
provides: parent ? parent.provides : Object.create(appContext.provides),
|
||
accessCache: null,
|
||
renderCache: [],
|
||
// local resolved assets
|
||
components: null,
|
||
directives: null,
|
||
// resolved props and emits options
|
||
propsOptions: normalizePropsOptions(type, appContext),
|
||
emitsOptions: normalizeEmitsOptions(type, appContext),
|
||
// emit
|
||
emit: null,
|
||
// to be set immediately
|
||
emitted: null,
|
||
// props default value
|
||
propsDefaults: EMPTY_OBJ,
|
||
// inheritAttrs
|
||
inheritAttrs: type.inheritAttrs,
|
||
// state
|
||
ctx: EMPTY_OBJ,
|
||
data: EMPTY_OBJ,
|
||
props: EMPTY_OBJ,
|
||
attrs: EMPTY_OBJ,
|
||
slots: EMPTY_OBJ,
|
||
refs: EMPTY_OBJ,
|
||
setupState: EMPTY_OBJ,
|
||
setupContext: null,
|
||
attrsProxy: null,
|
||
slotsProxy: null,
|
||
// suspense related
|
||
suspense,
|
||
suspenseId: suspense ? suspense.pendingId : 0,
|
||
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,
|
||
sp: null,
|
||
// fixed by xxxxxx 用于存储uni-app的元素缓存
|
||
$uniElements: /* @__PURE__ */ new Map(),
|
||
$templateUniElementRefs: [],
|
||
$templateUniElementStyles: {},
|
||
$eS: {}
|
||
};
|
||
if (!!(process.env.NODE_ENV !== "production")) {
|
||
instance.ctx = createDevRenderContext(instance);
|
||
} else {
|
||
instance.ctx = { _: instance };
|
||
}
|
||
instance.root = parent ? parent.root : instance;
|
||
instance.emit = emit.bind(null, instance);
|
||
if (vnode.ce) {
|
||
vnode.ce(instance);
|
||
}
|
||
return instance;
|
||
}
|
||
let currentInstance = null;
|
||
const getCurrentInstance = () => currentInstance || currentRenderingInstance;
|
||
let internalSetCurrentInstance;
|
||
let setInSSRSetupState;
|
||
{
|
||
internalSetCurrentInstance = (i) => {
|
||
currentInstance = i;
|
||
};
|
||
setInSSRSetupState = (v) => {
|
||
isInSSRComponentSetup = v;
|
||
};
|
||
}
|
||
const setCurrentInstance = (instance) => {
|
||
const prev = currentInstance;
|
||
internalSetCurrentInstance(instance);
|
||
instance.scope.on();
|
||
return () => {
|
||
instance.scope.off();
|
||
internalSetCurrentInstance(prev);
|
||
};
|
||
};
|
||
const unsetCurrentInstance = () => {
|
||
currentInstance && currentInstance.scope.off();
|
||
internalSetCurrentInstance(null);
|
||
};
|
||
const isBuiltInTag = /* @__PURE__ */ makeMap("slot,component");
|
||
function validateComponentName(name, { isNativeTag }) {
|
||
if (isBuiltInTag(name) || isNativeTag(name)) {
|
||
warn$1(
|
||
"Do not use built-in or reserved HTML elements as component id: " + name
|
||
);
|
||
}
|
||
}
|
||
function isStatefulComponent(instance) {
|
||
return instance.vnode.shapeFlag & 4;
|
||
}
|
||
let isInSSRComponentSetup = false;
|
||
function setupComponent(instance, isSSR = false) {
|
||
isSSR && setInSSRSetupState(isSSR);
|
||
const {
|
||
props
|
||
/*, children*/
|
||
} = instance.vnode;
|
||
const isStateful = isStatefulComponent(instance);
|
||
initProps(instance, props, isStateful, isSSR);
|
||
const setupResult = isStateful ? setupStatefulComponent(instance, isSSR) : void 0;
|
||
isSSR && setInSSRSetupState(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]);
|
||
}
|
||
}
|
||
if (Component.compilerOptions && isRuntimeOnly()) {
|
||
warn$1(
|
||
`"compilerOptions" is only supported when using a build of Vue that includes the runtime compiler. Since you are using a runtime-only build, the options should be passed via your build tool config instead.`
|
||
);
|
||
}
|
||
}
|
||
instance.accessCache = /* @__PURE__ */ Object.create(null);
|
||
instance.proxy = markRaw(new Proxy(instance.ctx, PublicInstanceProxyHandlers));
|
||
if (!!(process.env.NODE_ENV !== "production")) {
|
||
exposePropsOnRenderContext(instance);
|
||
}
|
||
const { setup } = Component;
|
||
if (setup) {
|
||
const setupContext = instance.setupContext = setup.length > 1 ? createSetupContext(instance) : null;
|
||
const reset = setCurrentInstance(instance);
|
||
pauseTracking();
|
||
const setupResult = callWithErrorHandling(
|
||
setup,
|
||
instance,
|
||
0,
|
||
[
|
||
!!(process.env.NODE_ENV !== "production") ? shallowReadonly(instance.props) : instance.props,
|
||
setupContext
|
||
]
|
||
);
|
||
resetTracking();
|
||
reset();
|
||
if (isPromise(setupResult)) {
|
||
setupResult.then(unsetCurrentInstance, unsetCurrentInstance);
|
||
if (!!(process.env.NODE_ENV !== "production")) {
|
||
warn$1(
|
||
`setup() returned a Promise, but the version of Vue you are using does not support it yet.`
|
||
);
|
||
}
|
||
} else {
|
||
handleSetupResult(instance, setupResult, isSSR);
|
||
}
|
||
} else {
|
||
finishComponentSetup(instance, isSSR);
|
||
}
|
||
}
|
||
function handleSetupResult(instance, setupResult, isSSR) {
|
||
if (isFunction(setupResult)) {
|
||
{
|
||
instance.render = setupResult;
|
||
}
|
||
} else if (isObject(setupResult)) {
|
||
if (!!(process.env.NODE_ENV !== "production") && isVNode(setupResult)) {
|
||
warn$1(
|
||
`setup() should not return VNodes directly - return a render function instead.`
|
||
);
|
||
}
|
||
if (!!(process.env.NODE_ENV !== "production") || __VUE_PROD_DEVTOOLS__) {
|
||
instance.devtoolsRawSetupState = setupResult;
|
||
}
|
||
instance.setupState = proxyRefs(setupResult);
|
||
if (!!(process.env.NODE_ENV !== "production")) {
|
||
exposeSetupStateOnRenderContext(instance);
|
||
}
|
||
} else if (!!(process.env.NODE_ENV !== "production") && setupResult !== void 0) {
|
||
warn$1(
|
||
`setup() should return an object. Received: ${setupResult === null ? "null" : typeof setupResult}`
|
||
);
|
||
}
|
||
finishComponentSetup(instance, isSSR);
|
||
}
|
||
let compile;
|
||
const isRuntimeOnly = () => !compile;
|
||
function finishComponentSetup(instance, isSSR, skipOptions) {
|
||
const Component = instance.type;
|
||
if (!instance.render) {
|
||
instance.render = Component.render || NOOP;
|
||
}
|
||
if (__VUE_OPTIONS_API__ && true) {
|
||
const reset = setCurrentInstance(instance);
|
||
pauseTracking();
|
||
try {
|
||
applyOptions$1(instance);
|
||
} finally {
|
||
resetTracking();
|
||
reset();
|
||
}
|
||
}
|
||
if (!!(process.env.NODE_ENV !== "production") && !Component.render && instance.render === NOOP && !isSSR) {
|
||
if (Component.template) {
|
||
warn$1(
|
||
`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".` )
|
||
);
|
||
} else {
|
||
warn$1(`Component is missing template or render function.`);
|
||
}
|
||
}
|
||
}
|
||
function getAttrsProxy(instance) {
|
||
return instance.attrsProxy || (instance.attrsProxy = new Proxy(
|
||
instance.attrs,
|
||
!!(process.env.NODE_ENV !== "production") ? {
|
||
get(target, key) {
|
||
track(instance, "get", "$attrs");
|
||
return target[key];
|
||
},
|
||
set() {
|
||
warn$1(`setupContext.attrs is readonly.`);
|
||
return false;
|
||
},
|
||
deleteProperty() {
|
||
warn$1(`setupContext.attrs is readonly.`);
|
||
return false;
|
||
}
|
||
} : {
|
||
get(target, key) {
|
||
track(instance, "get", "$attrs");
|
||
return target[key];
|
||
}
|
||
}
|
||
));
|
||
}
|
||
function getSlotsProxy(instance) {
|
||
return instance.slotsProxy || (instance.slotsProxy = new Proxy(instance.slots, {
|
||
get(target, key) {
|
||
track(instance, "get", "$slots");
|
||
return target[key];
|
||
}
|
||
}));
|
||
}
|
||
function createSetupContext(instance) {
|
||
const expose = (exposed) => {
|
||
if (!!(process.env.NODE_ENV !== "production")) {
|
||
if (instance.exposed) {
|
||
warn$1(`expose() should be called only once per setup().`);
|
||
}
|
||
if (exposed != null) {
|
||
let exposedType = typeof exposed;
|
||
if (exposedType === "object") {
|
||
if (isArray(exposed)) {
|
||
exposedType = "array";
|
||
} else if (isRef(exposed)) {
|
||
exposedType = "ref";
|
||
}
|
||
}
|
||
if (exposedType !== "object") {
|
||
warn$1(
|
||
`expose() should be passed a plain object, received ${exposedType}.`
|
||
);
|
||
}
|
||
}
|
||
}
|
||
instance.exposed = exposed || {};
|
||
};
|
||
if (!!(process.env.NODE_ENV !== "production")) {
|
||
return Object.freeze({
|
||
get attrs() {
|
||
return getAttrsProxy(instance);
|
||
},
|
||
get slots() {
|
||
return getSlotsProxy(instance);
|
||
},
|
||
get emit() {
|
||
return (event, ...args) => instance.emit(event, ...args);
|
||
},
|
||
expose
|
||
});
|
||
} else {
|
||
return {
|
||
get attrs() {
|
||
return getAttrsProxy(instance);
|
||
},
|
||
slots: instance.slots,
|
||
emit: instance.emit,
|
||
expose
|
||
};
|
||
}
|
||
}
|
||
function getExposeProxy(instance) {
|
||
if (instance.exposed) {
|
||
return instance.exposeProxy || (instance.exposeProxy = new Proxy(proxyRefs(markRaw(instance.exposed)), {
|
||
get(target, key) {
|
||
if (key in target) {
|
||
return target[key];
|
||
}
|
||
return instance.proxy[key];
|
||
},
|
||
has(target, key) {
|
||
return key in target || key in publicPropertiesMap;
|
||
}
|
||
}));
|
||
}
|
||
}
|
||
const classifyRE = /(?:^|[-_])(\w)/g;
|
||
const classify = (str) => str.replace(classifyRE, (c) => c.toUpperCase()).replace(/[-_]/g, "");
|
||
function getComponentName(Component, includeInferred = true) {
|
||
return isFunction(Component) ? Component.displayName || Component.name : Component.name || includeInferred && Component.__name;
|
||
}
|
||
function formatComponentName(instance, Component, isRoot = false) {
|
||
let name = getComponentName(Component);
|
||
if (!name && Component.__file) {
|
||
const match = Component.__file.match(/([^/\\]+)\.\w+$/);
|
||
if (match) {
|
||
name = match[1];
|
||
}
|
||
}
|
||
if (!name && instance && instance.parent) {
|
||
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 isClassComponent(value) {
|
||
return isFunction(value) && "__vccOpts" in value;
|
||
}
|
||
|
||
const computed = (getterOrOptions, debugOptions) => {
|
||
const c = computed$1(getterOrOptions, debugOptions, isInSSRComponentSetup);
|
||
if (!!(process.env.NODE_ENV !== "production")) {
|
||
const i = getCurrentInstance();
|
||
if (i && i.appContext.config.warnRecursiveComputed) {
|
||
c._warnRecursive = true;
|
||
}
|
||
}
|
||
return c;
|
||
};
|
||
|
||
function useModel(props, name, options = EMPTY_OBJ) {
|
||
const i = getCurrentInstance();
|
||
if (!!(process.env.NODE_ENV !== "production") && !i) {
|
||
warn$1(`useModel() called without active instance.`);
|
||
return ref();
|
||
}
|
||
if (!!(process.env.NODE_ENV !== "production") && !i.propsOptions[0][name]) {
|
||
warn$1(`useModel() called with prop "${name}" which is not declared.`);
|
||
return ref();
|
||
}
|
||
const camelizedName = camelize(name);
|
||
const hyphenatedName = hyphenate(name);
|
||
const res = customRef((track, trigger) => {
|
||
let localValue;
|
||
watchSyncEffect(() => {
|
||
const propValue = props[name];
|
||
if (hasChanged(localValue, propValue)) {
|
||
localValue = propValue;
|
||
trigger();
|
||
}
|
||
});
|
||
return {
|
||
get() {
|
||
track();
|
||
return options.get ? options.get(localValue) : localValue;
|
||
},
|
||
set(value) {
|
||
const rawProps = i.vnode.props;
|
||
if (!(rawProps && // check if parent has passed v-model
|
||
(name in rawProps || camelizedName in rawProps || hyphenatedName in rawProps) && (`onUpdate:${name}` in rawProps || `onUpdate:${camelizedName}` in rawProps || `onUpdate:${hyphenatedName}` in rawProps)) && hasChanged(value, localValue)) {
|
||
localValue = value;
|
||
trigger();
|
||
}
|
||
i.emit(`update:${name}`, options.set ? options.set(value) : value);
|
||
}
|
||
};
|
||
});
|
||
const modifierKey = name === "modelValue" ? "modelModifiers" : `${name}Modifiers`;
|
||
res[Symbol.iterator] = () => {
|
||
let i2 = 0;
|
||
return {
|
||
next() {
|
||
if (i2 < 2) {
|
||
return { value: i2++ ? props[modifierKey] || {} : res, done: false };
|
||
} else {
|
||
return { done: true };
|
||
}
|
||
}
|
||
};
|
||
};
|
||
return res;
|
||
}
|
||
|
||
const version = "3.4.21";
|
||
const warn = !!(process.env.NODE_ENV !== "production") ? warn$1 : NOOP;
|
||
const resolveFilter = null;
|
||
|
||
function unwrapper(target) {
|
||
return unref(target);
|
||
}
|
||
function defineAsyncComponent(source) {
|
||
console.error("defineAsyncComponent is unsupported");
|
||
}
|
||
|
||
const ARRAYTYPE = "[object Array]";
|
||
const OBJECTTYPE = "[object Object]";
|
||
function diff(current, pre) {
|
||
const result = {};
|
||
syncKeys(current, pre);
|
||
_diff(current, pre, "", result);
|
||
return result;
|
||
}
|
||
function syncKeys(current, pre) {
|
||
current = unwrapper(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 === void 0) {
|
||
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 = unwrapper(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 = unwrapper(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;
|
||
}
|
||
|
||
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.UNI_DEBUG) {
|
||
const mpInstance = ctx.$scope;
|
||
console.log(
|
||
"uni-app:[" + +/* @__PURE__ */ 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(instance, fn) {
|
||
const ctx = instance.ctx;
|
||
if (!ctx.__next_tick_pending && !hasComponentEffect(instance)) {
|
||
if (process.env.UNI_DEBUG) {
|
||
const mpInstance = ctx.$scope;
|
||
console.log(
|
||
"uni-app:[" + +/* @__PURE__ */ new Date() + "][" + (mpInstance.is || mpInstance.route) + "][" + instance.uid + "]:nextVueTick"
|
||
);
|
||
}
|
||
return nextTick$1(fn && fn.bind(instance.proxy));
|
||
}
|
||
if (process.env.UNI_DEBUG) {
|
||
const mpInstance = ctx.$scope;
|
||
console.log(
|
||
"uni-app:[" + +/* @__PURE__ */ 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
|
||
);
|
||
} else if (_resolve) {
|
||
_resolve(instance.proxy);
|
||
}
|
||
});
|
||
return new Promise((resolve) => {
|
||
_resolve = resolve;
|
||
});
|
||
}
|
||
|
||
function clone(src, seen) {
|
||
src = unwrapper(src);
|
||
const type = typeof src;
|
||
if (type === "object" && src !== null) {
|
||
let copy = seen.get(src);
|
||
if (typeof copy !== "undefined") {
|
||
return copy;
|
||
}
|
||
if (isArray(src)) {
|
||
const len = src.length;
|
||
copy = new Array(len);
|
||
seen.set(src, copy);
|
||
for (let i = 0; i < len; i++) {
|
||
copy[i] = clone(src[i], seen);
|
||
}
|
||
} else {
|
||
copy = {};
|
||
seen.set(src, copy);
|
||
for (const name in src) {
|
||
if (hasOwn(src, name)) {
|
||
copy[name] = clone(src[name], seen);
|
||
}
|
||
}
|
||
}
|
||
return copy;
|
||
}
|
||
if (type !== "symbol") {
|
||
return src;
|
||
}
|
||
}
|
||
function deepCopy(src) {
|
||
return clone(src, typeof WeakMap !== "undefined" ? /* @__PURE__ */ new WeakMap() : /* @__PURE__ */ new Map());
|
||
}
|
||
|
||
function getMPInstanceData(instance, keys) {
|
||
const data = instance.data;
|
||
const ret = /* @__PURE__ */ Object.create(null);
|
||
keys.forEach((key) => {
|
||
ret[key] = data[key];
|
||
});
|
||
return ret;
|
||
}
|
||
function patch(instance, data, oldData) {
|
||
if (!data) {
|
||
return;
|
||
}
|
||
data = deepCopy(data);
|
||
data.$eS = instance.$eS || {};
|
||
const ctx = instance.ctx;
|
||
const mpType = ctx.mpType;
|
||
if (mpType === "page" || mpType === "component") {
|
||
data.r0 = 1;
|
||
const start = Date.now();
|
||
const mpInstance = ctx.$scope;
|
||
const keys = Object.keys(data);
|
||
const diffData = diff(data, oldData || getMPInstanceData(mpInstance, keys));
|
||
if (Object.keys(diffData).length) {
|
||
if (process.env.UNI_DEBUG) {
|
||
console.log(
|
||
"uni-app:[" + +/* @__PURE__ */ new Date() + "][" + (mpInstance.is || mpInstance.route) + "][" + instance.uid + "][\u8017\u65F6" + (Date.now() - start) + "]\u5DEE\u91CF\u66F4\u65B0",
|
||
JSON.stringify(diffData)
|
||
);
|
||
}
|
||
ctx.__next_tick_pending = true;
|
||
mpInstance.setData(diffData, () => {
|
||
ctx.__next_tick_pending = false;
|
||
flushCallbacks(instance);
|
||
});
|
||
flushPreFlushCbs();
|
||
} else {
|
||
flushCallbacks(instance);
|
||
}
|
||
}
|
||
}
|
||
|
||
function initAppConfig(appConfig) {
|
||
appConfig.globalProperties.$nextTick = function $nextTick(fn) {
|
||
return nextTick(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);
|
||
}
|
||
}
|
||
delete instance.ctx.$onApplyOptions;
|
||
}
|
||
|
||
function setRef$1(instance, isUnmount = false) {
|
||
const {
|
||
setupState,
|
||
$templateRefs,
|
||
$templateUniElementRefs,
|
||
ctx: { $scope, $mpPlatform }
|
||
} = instance;
|
||
if ($mpPlatform === "mp-alipay") {
|
||
return;
|
||
}
|
||
if (!$scope || !$templateRefs && !$templateUniElementRefs) {
|
||
return;
|
||
}
|
||
if (isUnmount) {
|
||
$templateRefs && $templateRefs.forEach(
|
||
(templateRef) => setTemplateRef(templateRef, null, setupState)
|
||
);
|
||
$templateUniElementRefs && $templateUniElementRefs.forEach(
|
||
(templateRef) => setTemplateRef(templateRef, null, setupState)
|
||
);
|
||
return;
|
||
}
|
||
const check = $mpPlatform === "mp-baidu" || $mpPlatform === "mp-toutiao";
|
||
const doSetByRefs = (refs) => {
|
||
if (refs.length === 0) {
|
||
return [];
|
||
}
|
||
const mpComponents = (
|
||
// 字节小程序 selectAllComponents 可能返回 null
|
||
// https://github.com/dcloudio/uni-app/issues/3954
|
||
($scope.selectAllComponents(".r") || []).concat(
|
||
$scope.selectAllComponents(".r-i-f") || []
|
||
)
|
||
);
|
||
return refs.filter((templateRef) => {
|
||
const refValue = findComponentPublicInstance(mpComponents, templateRef.i);
|
||
if (check && refValue === null) {
|
||
return true;
|
||
}
|
||
setTemplateRef(templateRef, refValue, setupState);
|
||
return false;
|
||
});
|
||
};
|
||
const doSet = () => {
|
||
if ($templateRefs) {
|
||
const refs = doSetByRefs($templateRefs);
|
||
if (refs.length && instance.proxy && instance.proxy.$scope) {
|
||
instance.proxy.$scope.setData({ r1: 1 }, () => {
|
||
doSetByRefs(refs);
|
||
});
|
||
}
|
||
}
|
||
};
|
||
if ($templateUniElementRefs && $templateUniElementRefs.length) {
|
||
nextTick(instance, () => {
|
||
$templateUniElementRefs.forEach((templateRef) => {
|
||
if (isArray(templateRef.v)) {
|
||
templateRef.v.forEach((v) => {
|
||
setTemplateRef(templateRef, v, setupState);
|
||
});
|
||
} else {
|
||
setTemplateRef(templateRef, templateRef.v, setupState);
|
||
}
|
||
});
|
||
});
|
||
}
|
||
if ($scope._$setRef) {
|
||
$scope._$setRef(doSet);
|
||
} else {
|
||
nextTick(instance, doSet);
|
||
}
|
||
}
|
||
function toSkip(value) {
|
||
if (isObject(value)) {
|
||
markRaw(value);
|
||
}
|
||
return value;
|
||
}
|
||
function findComponentPublicInstance(mpComponents, id) {
|
||
const mpInstance = mpComponents.find(
|
||
(com) => com && (com.properties || com.props).uI === id
|
||
);
|
||
if (mpInstance) {
|
||
const vm = mpInstance.$vm;
|
||
if (vm) {
|
||
return getExposeProxy(vm.$) || vm;
|
||
}
|
||
return toSkip(mpInstance);
|
||
}
|
||
return null;
|
||
}
|
||
function setTemplateRef({ r, f }, refValue, setupState) {
|
||
if (isFunction(r)) {
|
||
r(refValue, {});
|
||
} else {
|
||
const _isString = isString(r);
|
||
const _isRef = isRef(r);
|
||
if (_isString || _isRef) {
|
||
if (f) {
|
||
if (!_isRef) {
|
||
return;
|
||
}
|
||
if (!isArray(r.value)) {
|
||
r.value = [];
|
||
}
|
||
const existing = r.value;
|
||
if (existing.indexOf(refValue) === -1) {
|
||
existing.push(refValue);
|
||
if (!refValue) {
|
||
return;
|
||
}
|
||
if (refValue.$) {
|
||
onBeforeUnmount(() => remove(existing, refValue), refValue.$);
|
||
}
|
||
}
|
||
} else if (_isString) {
|
||
if (hasOwn(setupState, r)) {
|
||
setupState[r] = refValue;
|
||
}
|
||
} else if (isRef(r)) {
|
||
r.value = refValue;
|
||
} else if (!!(process.env.NODE_ENV !== "production")) {
|
||
warnRef(r);
|
||
}
|
||
} else if (!!(process.env.NODE_ENV !== "production")) {
|
||
warnRef(r);
|
||
}
|
||
}
|
||
}
|
||
function warnRef(ref) {
|
||
warn("Invalid template ref type:", ref, `(${typeof ref})`);
|
||
}
|
||
|
||
const queuePostRenderEffect = 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);
|
||
startMeasure(instance, `mount`);
|
||
}
|
||
if (!!(process.env.NODE_ENV !== "production")) {
|
||
startMeasure(instance, `init`);
|
||
}
|
||
setupComponent(instance);
|
||
if (!!(process.env.NODE_ENV !== "production")) {
|
||
endMeasure(instance, `init`);
|
||
}
|
||
if (__VUE_OPTIONS_API__) {
|
||
if (options.parentComponent && instance.proxy) {
|
||
options.parentComponent.ctx.$children.push(getExposeProxy(instance) || instance.proxy);
|
||
}
|
||
}
|
||
setupRenderEffect(instance);
|
||
if (!!(process.env.NODE_ENV !== "production")) {
|
||
popWarningContext();
|
||
endMeasure(instance, `mount`);
|
||
}
|
||
return instance.proxy;
|
||
}
|
||
const getFunctionalFallthrough = (attrs) => {
|
||
let res;
|
||
for (const key in attrs) {
|
||
if (key === "class" || key === "style" || isOn(key)) {
|
||
(res || (res = {}))[key] = attrs[key];
|
||
}
|
||
}
|
||
return res;
|
||
};
|
||
function renderComponentRoot(instance) {
|
||
const {
|
||
type: Component,
|
||
vnode,
|
||
proxy,
|
||
withProxy,
|
||
props,
|
||
propsOptions: [propsOptions],
|
||
slots,
|
||
attrs,
|
||
emit,
|
||
render,
|
||
renderCache,
|
||
data,
|
||
setupState,
|
||
ctx,
|
||
uid,
|
||
appContext: {
|
||
app: {
|
||
config: {
|
||
globalProperties: { pruneComponentPropsCache }
|
||
}
|
||
}
|
||
},
|
||
inheritAttrs
|
||
} = instance;
|
||
instance.$uniElementIds = /* @__PURE__ */ new Map();
|
||
instance.$templateRefs = [];
|
||
instance.$templateUniElementRefs = [];
|
||
instance.$templateUniElementStyles = {};
|
||
instance.$ei = 0;
|
||
pruneComponentPropsCache(uid);
|
||
instance.__counter = instance.__counter === 0 ? 1 : 0;
|
||
let result;
|
||
const prev = setCurrentRenderingInstance(instance);
|
||
try {
|
||
if (vnode.shapeFlag & 4) {
|
||
fallthroughAttrs(inheritAttrs, props, propsOptions, attrs);
|
||
const proxyToUse = withProxy || proxy;
|
||
result = render.call(
|
||
proxyToUse,
|
||
proxyToUse,
|
||
renderCache,
|
||
props,
|
||
setupState,
|
||
data,
|
||
ctx
|
||
);
|
||
} else {
|
||
fallthroughAttrs(
|
||
inheritAttrs,
|
||
props,
|
||
propsOptions,
|
||
Component.props ? attrs : getFunctionalFallthrough(attrs)
|
||
);
|
||
const render2 = Component;
|
||
result = render2.length > 1 ? render2(props, { attrs, slots, emit }) : render2(
|
||
props,
|
||
null
|
||
/* we know it doesn't need it */
|
||
);
|
||
}
|
||
} catch (err) {
|
||
handleError(err, instance, 1);
|
||
result = false;
|
||
}
|
||
setRef$1(instance);
|
||
setCurrentRenderingInstance(prev);
|
||
return result;
|
||
}
|
||
function fallthroughAttrs(inheritAttrs, props, propsOptions, fallthroughAttrs2) {
|
||
if (props && fallthroughAttrs2 && inheritAttrs !== false) {
|
||
const keys = Object.keys(fallthroughAttrs2).filter(
|
||
(key) => key !== "class" && key !== "style"
|
||
);
|
||
if (!keys.length) {
|
||
return;
|
||
}
|
||
if (propsOptions && keys.some(isModelListener)) {
|
||
keys.forEach((key) => {
|
||
if (!isModelListener(key) || !(key.slice(9) in propsOptions)) {
|
||
props[key] = fallthroughAttrs2[key];
|
||
}
|
||
});
|
||
} else {
|
||
keys.forEach((key) => props[key] = fallthroughAttrs2[key]);
|
||
}
|
||
}
|
||
}
|
||
const updateComponentPreRender = (instance) => {
|
||
pauseTracking();
|
||
flushPreFlushCbs();
|
||
resetTracking();
|
||
};
|
||
function componentUpdateScopedSlotsFn() {
|
||
const scopedSlotsData = this.$scopedSlotsData;
|
||
if (!scopedSlotsData || scopedSlotsData.length === 0) {
|
||
return;
|
||
}
|
||
const start = Date.now();
|
||
const mpInstance = this.ctx.$scope;
|
||
const oldData = mpInstance.data;
|
||
const diffData = /* @__PURE__ */ Object.create(null);
|
||
scopedSlotsData.forEach(({ path, index, data }) => {
|
||
const oldScopedSlotData = getValueByDataPath(oldData, path);
|
||
const diffPath = isString(index) ? `${path}.${index}` : `${path}[${index}]`;
|
||
if (typeof oldScopedSlotData === "undefined" || typeof oldScopedSlotData[index] === "undefined") {
|
||
diffData[diffPath] = data;
|
||
} else {
|
||
const diffScopedSlotData = diff(
|
||
data,
|
||
oldScopedSlotData[index]
|
||
);
|
||
Object.keys(diffScopedSlotData).forEach((name) => {
|
||
diffData[diffPath + "." + name] = diffScopedSlotData[name];
|
||
});
|
||
}
|
||
});
|
||
scopedSlotsData.length = 0;
|
||
if (Object.keys(diffData).length) {
|
||
if (process.env.UNI_DEBUG) {
|
||
console.log(
|
||
"uni-app:[" + +/* @__PURE__ */ new Date() + "][" + (mpInstance.is || mpInstance.route) + "][" + this.uid + "][\u8017\u65F6" + (Date.now() - start) + "]\u4F5C\u7528\u57DF\u63D2\u69FD\u5DEE\u91CF\u66F4\u65B0",
|
||
JSON.stringify(diffData)
|
||
);
|
||
}
|
||
mpInstance.setData(diffData);
|
||
}
|
||
}
|
||
function toggleRecurse({ effect, update }, allowed) {
|
||
effect.allowRecurse = update.allowRecurse = allowed;
|
||
}
|
||
function setupRenderEffect(instance) {
|
||
const updateScopedSlots = componentUpdateScopedSlotsFn.bind(
|
||
instance
|
||
);
|
||
instance.$updateScopedSlots = () => nextTick$1(() => queueJob(updateScopedSlots));
|
||
const componentUpdateFn = () => {
|
||
if (!instance.isMounted) {
|
||
onBeforeUnmount(() => {
|
||
setRef$1(instance, true);
|
||
}, instance);
|
||
if (!!(process.env.NODE_ENV !== "production")) {
|
||
startMeasure(instance, `patch`);
|
||
}
|
||
patch(instance, renderComponentRoot(instance));
|
||
if (!!(process.env.NODE_ENV !== "production")) {
|
||
endMeasure(instance, `patch`);
|
||
}
|
||
if (!!(process.env.NODE_ENV !== "production") || __VUE_PROD_DEVTOOLS__) {
|
||
devtoolsComponentAdded(instance);
|
||
}
|
||
} else {
|
||
const { next, bu, u } = instance;
|
||
if (!!(process.env.NODE_ENV !== "production")) {
|
||
pushWarningContext(next || instance.vnode);
|
||
}
|
||
toggleRecurse(instance, false);
|
||
updateComponentPreRender();
|
||
if (bu) {
|
||
invokeArrayFns(bu);
|
||
}
|
||
toggleRecurse(instance, true);
|
||
if (!!(process.env.NODE_ENV !== "production")) {
|
||
startMeasure(instance, `patch`);
|
||
}
|
||
patch(instance, renderComponentRoot(instance));
|
||
if (!!(process.env.NODE_ENV !== "production")) {
|
||
endMeasure(instance, `patch`);
|
||
}
|
||
if (u) {
|
||
queuePostRenderEffect(u);
|
||
}
|
||
if (!!(process.env.NODE_ENV !== "production") || __VUE_PROD_DEVTOOLS__) {
|
||
devtoolsComponentUpdated(instance);
|
||
}
|
||
if (!!(process.env.NODE_ENV !== "production")) {
|
||
popWarningContext();
|
||
}
|
||
}
|
||
};
|
||
const effect = instance.effect = new ReactiveEffect(
|
||
componentUpdateFn,
|
||
NOOP,
|
||
() => queueJob(update),
|
||
instance.scope
|
||
// track it in component's effect scope
|
||
);
|
||
const update = instance.update = () => {
|
||
if (effect.dirty) {
|
||
effect.run();
|
||
}
|
||
};
|
||
update.id = instance.uid;
|
||
toggleRecurse(instance, true);
|
||
if (!!(process.env.NODE_ENV !== "production")) {
|
||
effect.onTrack = instance.rtc ? (e) => invokeArrayFns(instance.rtc, e) : void 0;
|
||
effect.onTrigger = instance.rtg ? (e) => invokeArrayFns(instance.rtg, e) : void 0;
|
||
update.ownerInstance = instance;
|
||
}
|
||
if (!__VUE_CREATED_DEFERRED__) {
|
||
update();
|
||
}
|
||
}
|
||
function unmountComponent(instance) {
|
||
const { bum, scope, update, um } = instance;
|
||
if (bum) {
|
||
invokeArrayFns(bum);
|
||
}
|
||
if (__VUE_OPTIONS_API__) {
|
||
const parentInstance = instance.parent;
|
||
if (parentInstance) {
|
||
const $children = parentInstance.ctx.$children;
|
||
const target = getExposeProxy(instance) || instance.proxy;
|
||
const index = $children.indexOf(target);
|
||
if (index > -1) {
|
||
$children.splice(index, 1);
|
||
}
|
||
}
|
||
}
|
||
scope.stop();
|
||
if (update) {
|
||
update.active = false;
|
||
}
|
||
if (um) {
|
||
queuePostRenderEffect(um);
|
||
}
|
||
queuePostRenderEffect(() => {
|
||
instance.isUnmounted = true;
|
||
});
|
||
if (!!(process.env.NODE_ENV !== "production") || __VUE_PROD_DEVTOOLS__) {
|
||
devtoolsComponentRemoved(instance);
|
||
}
|
||
}
|
||
const oldCreateApp = createAppAPI();
|
||
function getTarget() {
|
||
if (typeof window !== "undefined") {
|
||
return window;
|
||
}
|
||
if (typeof globalThis !== "undefined") {
|
||
return globalThis;
|
||
}
|
||
if (typeof global !== "undefined") {
|
||
return global;
|
||
}
|
||
if (typeof my !== "undefined") {
|
||
return my;
|
||
}
|
||
}
|
||
function createVueApp(rootComponent, rootProps = null) {
|
||
const target = getTarget();
|
||
target.__VUE__ = true;
|
||
if (!!(process.env.NODE_ENV !== "production") || __VUE_PROD_DEVTOOLS__) {
|
||
setDevtoolsHook(target.__VUE_DEVTOOLS_GLOBAL_HOOK__, target);
|
||
}
|
||
const app = oldCreateApp(rootComponent, rootProps);
|
||
const appContext = app._context;
|
||
initAppConfig(appContext.config);
|
||
const createVNode = (initialVNode) => {
|
||
initialVNode.appContext = appContext;
|
||
initialVNode.shapeFlag = 6;
|
||
return initialVNode;
|
||
};
|
||
const createComponent = function createComponent2(initialVNode, options) {
|
||
return mountComponent(createVNode(initialVNode), options);
|
||
};
|
||
const destroyComponent = function destroyComponent2(component) {
|
||
return component && unmountComponent(component.$);
|
||
};
|
||
app.mount = function mount() {
|
||
rootComponent.render = NOOP;
|
||
const instance = mountComponent(
|
||
createVNode({ type: rootComponent }),
|
||
{
|
||
mpType: "app",
|
||
mpInstance: null,
|
||
parentComponent: null,
|
||
slots: [],
|
||
props: null
|
||
}
|
||
);
|
||
app._instance = instance.$;
|
||
if (!!(process.env.NODE_ENV !== "production") || __VUE_PROD_DEVTOOLS__) {
|
||
devtoolsInitApp(app, version);
|
||
}
|
||
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;
|
||
}
|
||
|
||
function useCssVars(getter) {
|
||
const instance = getCurrentInstance();
|
||
if (!instance) {
|
||
!!(process.env.NODE_ENV !== "production") && warn(`useCssVars is called without current active component instance.`);
|
||
return;
|
||
}
|
||
initCssVarsRender(instance, getter);
|
||
}
|
||
function initCssVarsRender(instance, getter) {
|
||
instance.ctx.__cssVars = () => {
|
||
const vars = getter(instance.proxy);
|
||
const cssVars = {};
|
||
for (const key in vars) {
|
||
cssVars[`--${key}`] = vars[key];
|
||
}
|
||
return cssVars;
|
||
};
|
||
}
|
||
|
||
function withModifiers() {
|
||
}
|
||
function createVNode() {
|
||
}
|
||
|
||
function injectLifecycleHook(name, hook, publicThis, instance) {
|
||
if (isFunction(hook)) {
|
||
injectHook(name, hook.bind(publicThis), instance);
|
||
}
|
||
}
|
||
function initHooks(options, instance, publicThis) {
|
||
const mpType = options.mpType || publicThis.$mpType;
|
||
if (!mpType || mpType === 'component') {
|
||
// 仅 App,Page 类型支持在 options 中配置 on 生命周期，组件可以使用组合式 API 定义页面生命周期
|
||
return;
|
||
}
|
||
Object.keys(options).forEach((name) => {
|
||
if (isUniLifecycleHook(name, options[name], false)) {
|
||
const hooks = options[name];
|
||
if (isArray(hooks)) {
|
||
hooks.forEach((hook) => injectLifecycleHook(name, hook, publicThis, instance));
|
||
}
|
||
else {
|
||
injectLifecycleHook(name, hooks, publicThis, instance);
|
||
}
|
||
}
|
||
});
|
||
}
|
||
|
||
function applyOptions(options, instance, publicThis) {
|
||
initHooks(options, instance, publicThis);
|
||
}
|
||
|
||
function set(target, key, val) {
|
||
return (target[key] = val);
|
||
}
|
||
function $callMethod(method, ...args) {
|
||
const fn = this[method];
|
||
if (fn) {
|
||
return fn(...args);
|
||
}
|
||
console.error(`method ${method} not found`);
|
||
return null;
|
||
}
|
||
|
||
function createErrorHandler(app) {
|
||
return function errorHandler(err, instance, _info) {
|
||
if (!instance) {
|
||
throw err;
|
||
}
|
||
const appInstance = app._instance;
|
||
if (!appInstance || !appInstance.proxy) {
|
||
throw err;
|
||
}
|
||
{
|
||
appInstance.proxy.$callHook(ON_ERROR, err);
|
||
}
|
||
};
|
||
}
|
||
function mergeAsArray(to, from) {
|
||
return to ? [...new Set([].concat(to, from))] : from;
|
||
}
|
||
function initOptionMergeStrategies(optionMergeStrategies) {
|
||
UniLifecycleHooks.forEach((name) => {
|
||
optionMergeStrategies[name] = mergeAsArray;
|
||
});
|
||
}
|
||
|
||
let realAtob;
|
||
const b64 = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/=';
|
||
const b64re = /^(?:[A-Za-z\d+/]{4})*?(?:[A-Za-z\d+/]{2}(?:==)?|[A-Za-z\d+/]{3}=?)?$/;
|
||
if (typeof atob !== 'function') {
|
||
realAtob = function (str) {
|
||
str = String(str).replace(/[\t\n\f\r ]+/g, '');
|
||
if (!b64re.test(str)) {
|
||
throw new Error("Failed to execute 'atob' on 'Window': The string to be decoded is not correctly encoded.");
|
||
}
|
||
// Adding the padding if missing, for semplicity
|
||
str += '=='.slice(2 - (str.length & 3));
|
||
var bitmap;
|
||
var result = '';
|
||
var r1;
|
||
var r2;
|
||
var i = 0;
|
||
for (; i < str.length;) {
|
||
bitmap =
|
||
(b64.indexOf(str.charAt(i++)) << 18) |
|
||
(b64.indexOf(str.charAt(i++)) << 12) |
|
||
((r1 = b64.indexOf(str.charAt(i++))) << 6) |
|
||
(r2 = b64.indexOf(str.charAt(i++)));
|
||
result +=
|
||
r1 === 64
|
||
? String.fromCharCode((bitmap >> 16) & 255)
|
||
: r2 === 64
|
||
? String.fromCharCode((bitmap >> 16) & 255, (bitmap >> 8) & 255)
|
||
: String.fromCharCode((bitmap >> 16) & 255, (bitmap >> 8) & 255, bitmap & 255);
|
||
}
|
||
return result;
|
||
};
|
||
}
|
||
else {
|
||
// 注意atob只能在全局对象上调用，例如：`const Base64 = {atob};Base64.atob('xxxx')`是错误的用法
|
||
realAtob = atob;
|
||
}
|
||
function b64DecodeUnicode(str) {
|
||
return decodeURIComponent(realAtob(str)
|
||
.split('')
|
||
.map(function (c) {
|
||
return '%' + ('00' + c.charCodeAt(0).toString(16)).slice(-2);
|
||
})
|
||
.join(''));
|
||
}
|
||
function getCurrentUserInfo() {
|
||
const token = uni.getStorageSync('uni_id_token') || '';
|
||
const tokenArr = token.split('.');
|
||
if (!token || tokenArr.length !== 3) {
|
||
return {
|
||
uid: null,
|
||
role: [],
|
||
permission: [],
|
||
tokenExpired: 0,
|
||
};
|
||
}
|
||
let userInfo;
|
||
try {
|
||
userInfo = JSON.parse(b64DecodeUnicode(tokenArr[1]));
|
||
}
|
||
catch (error) {
|
||
throw new Error('获取当前用户信息出错，详细错误信息为：' + error.message);
|
||
}
|
||
userInfo.tokenExpired = userInfo.exp * 1000;
|
||
delete userInfo.exp;
|
||
delete userInfo.iat;
|
||
return userInfo;
|
||
}
|
||
function uniIdMixin(globalProperties) {
|
||
globalProperties.uniIDHasRole = function (roleId) {
|
||
const { role } = getCurrentUserInfo();
|
||
return role.indexOf(roleId) > -1;
|
||
};
|
||
globalProperties.uniIDHasPermission = function (permissionId) {
|
||
const { permission } = getCurrentUserInfo();
|
||
return this.uniIDHasRole('admin') || permission.indexOf(permissionId) > -1;
|
||
};
|
||
globalProperties.uniIDTokenValid = function () {
|
||
const { tokenExpired } = getCurrentUserInfo();
|
||
return tokenExpired > Date.now();
|
||
};
|
||
}
|
||
|
||
function initApp(app) {
|
||
const appConfig = app._context.config;
|
||
appConfig.errorHandler = invokeCreateErrorHandler(app, createErrorHandler);
|
||
initOptionMergeStrategies(appConfig.optionMergeStrategies);
|
||
const globalProperties = appConfig.globalProperties;
|
||
{
|
||
uniIdMixin(globalProperties);
|
||
}
|
||
if (__VUE_OPTIONS_API__) {
|
||
globalProperties.$set = set;
|
||
globalProperties.$applyOptions = applyOptions;
|
||
globalProperties.$callMethod = $callMethod;
|
||
}
|
||
{
|
||
uni.invokeCreateVueAppHook(app);
|
||
}
|
||
}
|
||
|
||
const propsCaches = Object.create(null);
|
||
function renderProps(props) {
|
||
const { uid, __counter } = getCurrentInstance();
|
||
const propsId = (propsCaches[uid] || (propsCaches[uid] = [])).push(guardReactiveProps(props)) - 1;
|
||
// 强制每次更新
|
||
return uid + ',' + propsId + ',' + __counter;
|
||
}
|
||
function pruneComponentPropsCache(uid) {
|
||
delete propsCaches[uid];
|
||
}
|
||
function findComponentPropsData(up) {
|
||
if (!up) {
|
||
return;
|
||
}
|
||
const [uid, propsId] = up.split(',');
|
||
if (!propsCaches[uid]) {
|
||
return;
|
||
}
|
||
return propsCaches[uid][parseInt(propsId)];
|
||
}
|
||
|
||
var plugin = {
|
||
install(app) {
|
||
initApp(app);
|
||
app.config.globalProperties.pruneComponentPropsCache =
|
||
pruneComponentPropsCache;
|
||
const oldMount = app.mount;
|
||
app.mount = function mount(rootContainer) {
|
||
const instance = oldMount.call(app, rootContainer);
|
||
const createApp = getCreateApp();
|
||
if (createApp) {
|
||
createApp(instance);
|
||
}
|
||
else {
|
||
// @ts-expect-error 旧编译器
|
||
if (typeof createMiniProgramApp !== 'undefined') {
|
||
// @ts-expect-error
|
||
createMiniProgramApp(instance);
|
||
}
|
||
}
|
||
return instance;
|
||
};
|
||
},
|
||
};
|
||
function getCreateApp() {
|
||
const method = process.env.UNI_MP_PLUGIN
|
||
? 'createPluginApp'
|
||
: process.env.UNI_SUBPACKAGE
|
||
? 'createSubpackageApp'
|
||
: 'createApp';
|
||
if (typeof global !== 'undefined' &&
|
||
typeof global[method] !== 'undefined') {
|
||
return global[method];
|
||
}
|
||
else if (typeof my !== 'undefined') {
|
||
// 支付宝小程序开启globalObjectMode配置后才会有global
|
||
return my[method];
|
||
}
|
||
}
|
||
|
||
function vOn(value, key) {
|
||
const instance = getCurrentInstance();
|
||
const ctx = instance.ctx;
|
||
// 微信小程序，QQ小程序，当 setData diff 的时候，若事件不主动同步过去，会导致事件绑定不更新，（question/137217）
|
||
const extraKey = typeof key !== 'undefined' &&
|
||
(ctx.$mpPlatform === 'mp-weixin' ||
|
||
ctx.$mpPlatform === 'mp-qq' ||
|
||
ctx.$mpPlatform === 'mp-xhs') &&
|
||
(isString(key) || typeof key === 'number')
|
||
? '_' + key
|
||
: '';
|
||
const name = 'e' + instance.$ei++ + extraKey;
|
||
const mpInstance = ctx.$scope;
|
||
if (!value) {
|
||
// remove
|
||
delete mpInstance[name];
|
||
return name;
|
||
}
|
||
const existingInvoker = mpInstance[name];
|
||
if (existingInvoker) {
|
||
// patch
|
||
existingInvoker.value = value;
|
||
}
|
||
else {
|
||
// add
|
||
mpInstance[name] = createInvoker(value, instance);
|
||
}
|
||
return name;
|
||
}
|
||
function createInvoker(initialValue, instance) {
|
||
const invoker = (e) => {
|
||
patchMPEvent(e);
|
||
let args = [e];
|
||
if (instance && instance.ctx.$getTriggerEventDetail) {
|
||
if (typeof e.detail === 'number') {
|
||
e.detail = instance.ctx.$getTriggerEventDetail(e.detail);
|
||
}
|
||
}
|
||
if (e.detail && e.detail.__args__) {
|
||
args = e.detail.__args__;
|
||
}
|
||
const eventValue = invoker.value;
|
||
const invoke = () => callWithAsyncErrorHandling(patchStopImmediatePropagation(e, eventValue), instance, 5 /* ErrorCodes.NATIVE_EVENT_HANDLER */, args);
|
||
// 冒泡事件触发时，启用延迟策略，避免同一批次的事件执行时机不正确，对性能可能有略微影响 https://github.com/dcloudio/uni-app/issues/3228
|
||
const eventTarget = e.target;
|
||
const eventSync = eventTarget
|
||
? eventTarget.dataset
|
||
? String(eventTarget.dataset.eventsync) === 'true'
|
||
: false
|
||
: false;
|
||
if (bubbles.includes(e.type) && !eventSync) {
|
||
setTimeout(invoke);
|
||
}
|
||
else {
|
||
const res = invoke();
|
||
if (e.type === 'input' && (isArray(res) || isPromise(res))) {
|
||
return;
|
||
}
|
||
return res;
|
||
}
|
||
};
|
||
invoker.value = initialValue;
|
||
return invoker;
|
||
}
|
||
// 冒泡事件列表
|
||
const bubbles = [
|
||
// touch事件暂不做延迟，否则在 Android 上会影响性能，比如一些拖拽跟手手势等
|
||
// 'touchstart',
|
||
// 'touchmove',
|
||
// 'touchcancel',
|
||
// 'touchend',
|
||
'tap',
|
||
'longpress',
|
||
'longtap',
|
||
'transitionend',
|
||
'animationstart',
|
||
'animationiteration',
|
||
'animationend',
|
||
'touchforcechange',
|
||
];
|
||
function isMPTapEvent(event) {
|
||
return event.type === 'tap';
|
||
}
|
||
function normalizeXEvent(event) {
|
||
if (isMPTapEvent(event)) {
|
||
event.x = event.detail.x;
|
||
event.y = event.detail.y;
|
||
event.clientX = event.detail.x;
|
||
event.clientY = event.detail.y;
|
||
const touch0 = event.touches && event.touches[0];
|
||
if (touch0) {
|
||
event.pageX = touch0.pageX;
|
||
event.pageY = touch0.pageY;
|
||
event.screenX = touch0.screenX;
|
||
event.screenY = touch0.screenY;
|
||
}
|
||
}
|
||
}
|
||
function patchMPEvent(event) {
|
||
if (event.type && event.target) {
|
||
event.preventDefault = NOOP;
|
||
event.stopPropagation = NOOP;
|
||
event.stopImmediatePropagation = NOOP;
|
||
if (!hasOwn(event, 'detail')) {
|
||
event.detail = {};
|
||
}
|
||
if (hasOwn(event, 'markerId')) {
|
||
event.detail = typeof event.detail === 'object' ? event.detail : {};
|
||
event.detail.markerId = event.markerId;
|
||
}
|
||
// mp-baidu，checked=>value
|
||
if (isPlainObject(event.detail) &&
|
||
hasOwn(event.detail, 'checked') &&
|
||
!hasOwn(event.detail, 'value')) {
|
||
event.detail.value = event.detail.checked;
|
||
}
|
||
if (isPlainObject(event.detail)) {
|
||
event.target = extend({}, event.target, event.detail);
|
||
}
|
||
{
|
||
normalizeXEvent(event);
|
||
}
|
||
}
|
||
}
|
||
function patchStopImmediatePropagation(e, value) {
|
||
if (isArray(value)) {
|
||
const originalStop = e.stopImmediatePropagation;
|
||
e.stopImmediatePropagation = () => {
|
||
originalStop && originalStop.call(e);
|
||
e._stopped = true;
|
||
};
|
||
return value.map((fn) => (e) => !e._stopped && fn(e));
|
||
}
|
||
else {
|
||
return value;
|
||
}
|
||
}
|
||
|
||
/**
|
||
* Actual implementation
|
||
*/
|
||
function vFor(source, renderItem) {
|
||
let ret;
|
||
if (isArray(source) || isString(source)) {
|
||
ret = new Array(source.length);
|
||
for (let i = 0, l = source.length; i < l; i++) {
|
||
ret[i] = renderItem(source[i], i, i);
|
||
}
|
||
}
|
||
else if (typeof source === 'number') {
|
||
if ((process.env.NODE_ENV !== 'production') && !Number.isInteger(source)) {
|
||
warn(`The v-for range expect an integer value but got ${source}.`);
|
||
return [];
|
||
}
|
||
ret = new Array(source);
|
||
for (let i = 0; i < source; i++) {
|
||
ret[i] = renderItem(i + 1, i, i);
|
||
}
|
||
}
|
||
else if (isObject(source)) {
|
||
if (source[Symbol.iterator]) {
|
||
ret = Array.from(source, (item, i) => renderItem(item, i, i));
|
||
}
|
||
else {
|
||
const keys = Object.keys(source);
|
||
ret = new Array(keys.length);
|
||
for (let i = 0, l = keys.length; i < l; i++) {
|
||
const key = keys[i];
|
||
ret[i] = renderItem(source[key], key, i);
|
||
}
|
||
}
|
||
}
|
||
else {
|
||
ret = [];
|
||
}
|
||
return ret;
|
||
}
|
||
|
||
function renderSlot(name, props = {}, key) {
|
||
const instance = getCurrentInstance();
|
||
const { parent, isMounted, ctx: { $scope }, } = instance;
|
||
// mp-alipay 为 props
|
||
const vueIds = ($scope.properties || $scope.props).uI;
|
||
if (!vueIds) {
|
||
return;
|
||
}
|
||
if (!parent && !isMounted) {
|
||
// 头条小程序首次 render 时，还没有 parent
|
||
onMounted(() => {
|
||
renderSlot(name, props, key);
|
||
}, instance);
|
||
return;
|
||
}
|
||
const invoker = findScopedSlotInvoker(vueIds, instance);
|
||
// 可能不存在，因为插槽不是必需的
|
||
if (invoker) {
|
||
invoker(name, props, key);
|
||
}
|
||
}
|
||
function findScopedSlotInvoker(vueId, instance) {
|
||
let parent = instance.parent;
|
||
while (parent) {
|
||
const invokers = parent.$ssi;
|
||
if (invokers && invokers[vueId]) {
|
||
return invokers[vueId];
|
||
}
|
||
parent = parent.parent;
|
||
}
|
||
}
|
||
|
||
function withScopedSlot(fn, { name, path, vueId, }) {
|
||
const instance = getCurrentInstance();
|
||
fn.path = path;
|
||
const scopedSlots = (instance.$ssi ||
|
||
(instance.$ssi = {}));
|
||
const invoker = scopedSlots[vueId] ||
|
||
(scopedSlots[vueId] = createScopedSlotInvoker(instance));
|
||
if (!invoker.slots[name]) {
|
||
invoker.slots[name] = {
|
||
fn,
|
||
};
|
||
}
|
||
else {
|
||
invoker.slots[name].fn = fn;
|
||
}
|
||
return getValueByDataPath(instance.ctx.$scope.data, path);
|
||
}
|
||
function createScopedSlotInvoker(instance) {
|
||
const invoker = (slotName, args, index) => {
|
||
const slot = invoker.slots[slotName];
|
||
if (!slot) {
|
||
// slot 可能不存在 https://github.com/dcloudio/uni-app/issues/3346
|
||
return;
|
||
}
|
||
const hasIndex = typeof index !== 'undefined';
|
||
index = index || 0;
|
||
// 确保当前 slot 的上下文，类似 withCtx
|
||
const prevInstance = setCurrentRenderingInstance(instance);
|
||
const data = slot.fn(args, slotName + (hasIndex ? '-' + index : ''), index);
|
||
const path = slot.fn.path;
|
||
setCurrentRenderingInstance(prevInstance);
|
||
(instance.$scopedSlotsData || (instance.$scopedSlotsData = [])).push({
|
||
path,
|
||
index,
|
||
data,
|
||
});
|
||
instance.$updateScopedSlots();
|
||
};
|
||
invoker.slots = {};
|
||
return invoker;
|
||
}
|
||
|
||
function stringifyStyle(value) {
|
||
if (isString(value)) {
|
||
return value;
|
||
}
|
||
return stringify(normalizeStyle$1(value) );
|
||
}
|
||
// 不使用 @vue/shared 中的 stringifyStyle (#3456)
|
||
function stringify(styles) {
|
||
let ret = '';
|
||
if (!styles || isString(styles)) {
|
||
return ret;
|
||
}
|
||
for (const key in styles) {
|
||
ret += `${key.startsWith(`--`) ? key : hyphenate(key)}:${styles[key]};`;
|
||
}
|
||
return ret;
|
||
}
|
||
|
||
/**
|
||
* quickapp-webview 不能使用 default 作为插槽名称，故统一转换 default 为 d
|
||
* @param names
|
||
* @returns
|
||
*/
|
||
function dynamicSlot(names) {
|
||
if (isString(names)) {
|
||
return dynamicSlotName(names);
|
||
}
|
||
return names.map((name) => dynamicSlotName(name));
|
||
}
|
||
|
||
function setRef(ref, id, opts = {}) {
|
||
const { $templateRefs } = getCurrentInstance();
|
||
$templateRefs.push({ i: id, r: ref, k: opts.k, f: opts.f });
|
||
}
|
||
|
||
function withModelModifiers(fn, { number, trim }, isComponent = false) {
|
||
if (isComponent) {
|
||
return (...args) => {
|
||
if (trim) {
|
||
args = args.map((a) => a.trim());
|
||
}
|
||
else if (number) {
|
||
args = args.map(toNumber);
|
||
}
|
||
return fn(...args);
|
||
};
|
||
}
|
||
return (event) => {
|
||
const value = event.detail.value;
|
||
if (trim) {
|
||
event.detail.value = value.trim();
|
||
}
|
||
else if (number) {
|
||
event.detail.value = toNumber(value);
|
||
}
|
||
return fn(event);
|
||
};
|
||
}
|
||
|
||
class UniCSSStyleDeclaration {
|
||
constructor() {
|
||
// 跳过vue的响应式
|
||
this.__v_skip = true;
|
||
this.$styles = {};
|
||
this.$onChangeCallbacks = [];
|
||
}
|
||
setProperty(name, value) {
|
||
const oldValue = this.$styles[name];
|
||
if (oldValue === value) {
|
||
return;
|
||
}
|
||
this.$styles[name] = value;
|
||
this.$onChangeCallbacks.forEach((callback) => callback(this.$styles));
|
||
}
|
||
getPropertyValue(property) {
|
||
return this.$styles[property] || '';
|
||
}
|
||
get cssText() {
|
||
return Object.entries(this.$styles)
|
||
.map(([key, value]) => `${key}:${value}`)
|
||
.join(';');
|
||
}
|
||
$onChange(callback) {
|
||
this.$onChangeCallbacks.push(callback);
|
||
}
|
||
$destroy() {
|
||
this.$onChangeCallbacks = [];
|
||
}
|
||
}
|
||
|
||
class UniElement {
|
||
constructor(id, name) {
|
||
// 跳过vue的响应式
|
||
this.__v_skip = true;
|
||
this.style = new UniCSSStyleDeclaration();
|
||
this.id = id;
|
||
this.tagName = name.toUpperCase();
|
||
this.nodeName = this.tagName;
|
||
}
|
||
getBoundingClientRectAsync(callback) {
|
||
// TODO defineAsyncApi?
|
||
if (callback) {
|
||
this._getBoundingClientRectAsync((domRect) => {
|
||
var _a, _b;
|
||
(_a = callback.success) === null || _a === void 0 ? void 0 : _a.call(callback, domRect);
|
||
(_b = callback.complate) === null || _b === void 0 ? void 0 : _b.call(callback);
|
||
});
|
||
return;
|
||
}
|
||
return new Promise((resolve, reject) => {
|
||
this._getBoundingClientRectAsync(resolve);
|
||
});
|
||
}
|
||
_getBoundingClientRectAsync(callback) {
|
||
const query = uni.createSelectorQuery().in(this.$vm);
|
||
query.select('#' + this.id).boundingClientRect();
|
||
query.exec(function (res) {
|
||
callback(res[0]);
|
||
});
|
||
}
|
||
$onStyleChange(callback) {
|
||
this.style.$onChange(callback);
|
||
}
|
||
getAttribute(name) {
|
||
switch (name) {
|
||
case 'id':
|
||
return this.id;
|
||
case 'style':
|
||
return this.style.cssText;
|
||
default:
|
||
console.warn(`Miniprogram does not support UniElement.getAttribute(${name})`);
|
||
return null;
|
||
}
|
||
}
|
||
setAttribute(name, value) {
|
||
console.warn(`Miniprogram does not support UniElement.setAttribute(${name}, value)`);
|
||
}
|
||
$destroy() {
|
||
this.style.$destroy();
|
||
// @ts-expect-error
|
||
this.style = null;
|
||
}
|
||
}
|
||
|
||
/**
|
||
* 每次 render 完成，删除不在 $uniElementIds 中的元素
|
||
* @param ins
|
||
*/
|
||
function pruneUniElements(ins) {
|
||
// 如果 $uniElements 不在 $uniElementIds 中，则删除
|
||
ins.$uniElements.forEach((uniElement, id) => {
|
||
const options = ins.$uniElementIds.get(id);
|
||
if (!options) {
|
||
uniElement.$destroy();
|
||
ins.$uniElements.delete(id);
|
||
}
|
||
});
|
||
}
|
||
/**
|
||
* 销毁所有元素
|
||
* @param ins
|
||
*/
|
||
function destroyUniElements(ins) {
|
||
ins.$uniElements.forEach((uniElement, id) => {
|
||
uniElement.$destroy();
|
||
});
|
||
ins.$uniElements.clear();
|
||
ins.$templateUniElementRefs = [];
|
||
}
|
||
const customElements = new Map();
|
||
function registerCustomElement(tagName, elementClass) {
|
||
customElements.set(tagName, elementClass);
|
||
}
|
||
function createUniElement(id, tagName, ins) {
|
||
if (!ins || !ins.proxy) {
|
||
return null;
|
||
}
|
||
const uniElement = new (customElements.get(tagName) || UniElement)(id, tagName);
|
||
uniElement.$vm = ins.proxy;
|
||
uniElement.$onStyleChange((styles) => {
|
||
var _a;
|
||
let cssText = '';
|
||
// 如果不支持 wxs setStyle，需要合并模板绑定的 style
|
||
const templateStyle = ins.$templateUniElementStyles[id];
|
||
if (templateStyle) {
|
||
cssText = `${templateStyle};${stringifyStyle(styles)}`;
|
||
}
|
||
else {
|
||
cssText = stringifyStyle(styles);
|
||
}
|
||
const mpInstance = (_a = ins.proxy) === null || _a === void 0 ? void 0 : _a.$scope;
|
||
if (mpInstance) {
|
||
if (process.env.UNI_DEBUG) {
|
||
console.log('uni-app:[' +
|
||
Date.now() +
|
||
'][' +
|
||
(mpInstance.is || mpInstance.route) +
|
||
'][' +
|
||
ins.uid +
|
||
'][' +
|
||
id +
|
||
']setStyle', cssText);
|
||
}
|
||
mpInstance.setData({
|
||
[`$eS.${id}`]: cssText,
|
||
});
|
||
}
|
||
});
|
||
return uniElement;
|
||
}
|
||
/**
|
||
* 根据指定 id 查找元素
|
||
* @param id
|
||
* @param ins
|
||
* @returns
|
||
*/
|
||
function findUniElement(id, ins = getCurrentInstance()) {
|
||
if (!ins) {
|
||
return null;
|
||
}
|
||
// 缓存
|
||
const element = ins.$uniElements.get(id);
|
||
if (element) {
|
||
return element;
|
||
}
|
||
const options = ins.$uniElementIds.get(id);
|
||
if (options) {
|
||
const element = createUniElement(id, options.name, ins);
|
||
// @ts-expect-error
|
||
ins.$uniElements.set(id, element);
|
||
return element;
|
||
}
|
||
// 递归查找
|
||
if (ins.proxy) {
|
||
const children = ins.proxy.$children;
|
||
for (const child of children) {
|
||
const element = findUniElement(id, child.$);
|
||
if (element) {
|
||
return element;
|
||
}
|
||
}
|
||
}
|
||
return null;
|
||
}
|
||
|
||
function setUniElementId(id, options, ref, refOpts) {
|
||
const ins = getCurrentInstance();
|
||
if (ins) {
|
||
let tagName;
|
||
let tagType;
|
||
if (isString(options)) {
|
||
tagName = options;
|
||
}
|
||
else {
|
||
tagName = options.name;
|
||
tagType = options.type;
|
||
}
|
||
const { $uniElementIds } = ins;
|
||
id = toRaw(id);
|
||
// 仅保留第一个，其他忽略
|
||
if (!$uniElementIds.has(id)) {
|
||
$uniElementIds.set(id, { name: tagName });
|
||
}
|
||
if (ref) {
|
||
// 指定了ref，则需要存储ref，使得 this.$refs 和 setup 的 ref 生效
|
||
setUniElementRef(ins, ref, id, {
|
||
k: refOpts === null || refOpts === void 0 ? void 0 : refOpts.k,
|
||
f: refOpts === null || refOpts === void 0 ? void 0 : refOpts.f,
|
||
n: tagName,
|
||
}, tagType);
|
||
}
|
||
if (tagType === 2 /* SetUniElementIdTagType.BuiltInRootElement */ && ins.props.id) {
|
||
const parent = ins.parent;
|
||
if (parent) {
|
||
// 从当前实例中找到元素，并设置到父实例中
|
||
const uniElement = findUniElement(id, ins);
|
||
if (uniElement) {
|
||
parent.$uniElements.set(ins.props.id, uniElement);
|
||
const existTemplateRef = parent.$templateUniElementRefs.find((t) => t.i === ins.props.id);
|
||
if (existTemplateRef) {
|
||
existTemplateRef.v = uniElement;
|
||
}
|
||
}
|
||
}
|
||
}
|
||
}
|
||
return id;
|
||
}
|
||
function setUniElementStyle(id, style = '') {
|
||
const ins = getCurrentInstance();
|
||
if (!ins) {
|
||
return '';
|
||
}
|
||
if (style) {
|
||
style = stringifyStyle(style);
|
||
}
|
||
if (style) {
|
||
ins.$templateUniElementStyles[id] = style;
|
||
}
|
||
// 当 patch 的时候，需要增加 $eS 的更新，而 element 的 style 是直接更新到 mp 的 $eS 上
|
||
// 从缓存中获取元素，作用域插槽？
|
||
const el = ins.$uniElements.get(id);
|
||
if (!el) {
|
||
ins.$eS[id] = style;
|
||
}
|
||
else {
|
||
const cssText = el.style.cssText;
|
||
ins.$eS[id] = style ? `${style};${cssText}` : cssText;
|
||
}
|
||
return '';
|
||
}
|
||
function setUniElementRef(ins, ref, id, opts, tagType) {
|
||
const { $templateUniElementRefs } = ins;
|
||
if (tagType === 1 /* SetUniElementIdTagType.BuiltInComponent */) {
|
||
const existTemplateRef = $templateUniElementRefs.find((t) => t.r === ref);
|
||
if (!existTemplateRef) {
|
||
$templateUniElementRefs.push({
|
||
i: id,
|
||
r: ref,
|
||
k: opts.k,
|
||
f: opts.f,
|
||
v: null,
|
||
});
|
||
}
|
||
// 不需要处理后续逻辑，交给BuiltInRootElement处理
|
||
return;
|
||
}
|
||
const uniElement = findUniElement(id, ins);
|
||
const existTemplateRef = $templateUniElementRefs.find((t) => t.r === ref);
|
||
if (existTemplateRef) {
|
||
if (opts.f) {
|
||
existTemplateRef.v.push(uniElement);
|
||
}
|
||
else {
|
||
existTemplateRef.v = uniElement;
|
||
}
|
||
}
|
||
else {
|
||
$templateUniElementRefs.push({
|
||
i: id,
|
||
r: ref,
|
||
k: opts.k,
|
||
f: opts.f,
|
||
v: opts.f ? [uniElement] : uniElement,
|
||
});
|
||
}
|
||
}
|
||
|
||
function setupDevtoolsPlugin() {
|
||
// noop
|
||
}
|
||
|
||
const o = (value, key) => vOn(value, key);
|
||
const f = (source, renderItem) => vFor(source, renderItem);
|
||
const d = (names) => dynamicSlot(names);
|
||
const r = (name, props, key) => renderSlot(name, props, key);
|
||
const w = (fn, options) => withScopedSlot(fn, options);
|
||
const s = (value) => stringifyStyle(value);
|
||
const c = (str) => camelize(str);
|
||
const e = (target, ...sources) => extend(target, ...sources);
|
||
const h = (str) => hyphenate(str);
|
||
const n = (value) => normalizeClass$1(value) ;
|
||
const t = (val) => toDisplayString(val);
|
||
const p = (props) => renderProps(props);
|
||
const sr = (ref, id, opts) => setRef(ref, id, opts);
|
||
const m = (fn, modifiers, isComponent = false) => withModelModifiers(fn, modifiers, isComponent);
|
||
const j = (obj) => JSON.stringify(obj);
|
||
const sei = setUniElementId;
|
||
const ses = setUniElementStyle;
|
||
|
||
function createApp(rootComponent, rootProps = null) {
|
||
rootComponent && (rootComponent.mpType = 'app');
|
||
return createVueApp(rootComponent, rootProps).use(plugin);
|
||
}
|
||
const createSSRApp = createApp;
|
||
|
||
export { EffectScope, Fragment, ReactiveEffect, Text, UniElement, UniElement as UniElementImpl, c, callWithAsyncErrorHandling, callWithErrorHandling, computed, createApp, createPropsRestProxy, createSSRApp, createVNode, createVueApp, customRef, d, defineAsyncComponent, defineComponent, defineEmits, defineExpose, defineProps, destroyUniElements, devtoolsComponentAdded, devtoolsComponentRemoved, devtoolsComponentUpdated, diff, e, effect, effectScope, f, findComponentPropsData, findUniElement, getCurrentInstance, getCurrentScope, getExposeProxy, guardReactiveProps, h, hasInjectionContext, hasQueueJob, inject, injectHook, invalidateJob, isInSSRComponentSetup, isProxy, isReactive, isReadonly, isRef, isShallow, j, logError, m, markRaw, mergeDefaults, mergeModels, mergeProps, n, nextTick$1 as nextTick, o, onActivated, onBeforeMount, onBeforeUnmount, onBeforeUpdate, onDeactivated, onErrorCaptured, onMounted, onRenderTracked, onRenderTriggered, onScopeDispose, onServerPrefetch, onUnmounted, onUpdated, p, patch, provide, proxyRefs, pruneComponentPropsCache, pruneUniElements, queuePostFlushCb, r, reactive, readonly, ref, registerCustomElement, resolveComponent, resolveDirective, resolveFilter, s, sei, ses, setCurrentRenderingInstance, setTemplateRef, setupDevtoolsPlugin, shallowReactive, shallowReadonly, shallowRef, sr, stop, t, toHandlers, toRaw, toRef, toRefs, toValue, triggerRef, unref, updateProps, useAttrs, useCssModule, useCssVars, useModel, useSSRContext, useSlots, version, w, warn, watch, watchEffect, watchPostEffect, watchSyncEffect, withAsyncContext, withCtx, withDefaults, withDirectives, withModifiers, withScopeId };
|