You can not select more than 25 topics
Topics must start with a letter or number, can include dashes ('-') and can be up to 35 characters long.
7588 lines
212 KiB
7588 lines
212 KiB
"use strict"; |
|
const _export_sfc = (sfc, props) => { |
|
const target = sfc.__vccOpts || sfc; |
|
for (const [key, val] of props) { |
|
target[key] = val; |
|
} |
|
return target; |
|
}; |
|
/** |
|
* @vue/shared v3.4.21 |
|
* (c) 2018-present Yuxi (Evan) You and Vue contributors |
|
* @license MIT |
|
**/ |
|
function makeMap(str, expectsLowerCase) { |
|
const set2 = new Set(str.split(",")); |
|
return expectsLowerCase ? (val) => set2.has(val.toLowerCase()) : (val) => set2.has(val); |
|
} |
|
const EMPTY_OBJ = Object.freeze({}); |
|
const EMPTY_ARR = Object.freeze([]); |
|
const NOOP = () => { |
|
}; |
|
const NO = () => false; |
|
const isOn = (key) => key.charCodeAt(0) === 111 && key.charCodeAt(1) === 110 && // uppercase letter |
|
(key.charCodeAt(2) > 122 || key.charCodeAt(2) < 97); |
|
const isModelListener = (key) => key.startsWith("onUpdate:"); |
|
const extend = Object.assign; |
|
const remove = (arr, el) => { |
|
const i = arr.indexOf(el); |
|
if (i > -1) { |
|
arr.splice(i, 1); |
|
} |
|
}; |
|
const hasOwnProperty$1 = Object.prototype.hasOwnProperty; |
|
const hasOwn = (val, key) => hasOwnProperty$1.call(val, key); |
|
const isArray = Array.isArray; |
|
const isMap = (val) => toTypeString(val) === "[object Map]"; |
|
const isSet = (val) => toTypeString(val) === "[object Set]"; |
|
const isFunction = (val) => typeof val === "function"; |
|
const isString = (val) => typeof val === "string"; |
|
const isSymbol = (val) => typeof val === "symbol"; |
|
const isObject = (val) => val !== null && typeof val === "object"; |
|
const isPromise = (val) => { |
|
return (isObject(val) || isFunction(val)) && isFunction(val.then) && isFunction(val.catch); |
|
}; |
|
const objectToString = Object.prototype.toString; |
|
const toTypeString = (value) => objectToString.call(value); |
|
const toRawType = (value) => { |
|
return toTypeString(value).slice(8, -1); |
|
}; |
|
const isPlainObject = (val) => toTypeString(val) === "[object Object]"; |
|
const isIntegerKey = (key) => isString(key) && key !== "NaN" && key[0] !== "-" && "" + parseInt(key, 10) === key; |
|
const isReservedProp = /* @__PURE__ */ makeMap( |
|
// the leading comma is intentional so empty string "" is also included |
|
",key,ref,ref_for,ref_key,onVnodeBeforeMount,onVnodeMounted,onVnodeBeforeUpdate,onVnodeUpdated,onVnodeBeforeUnmount,onVnodeUnmounted" |
|
); |
|
const isBuiltInDirective = /* @__PURE__ */ makeMap( |
|
"bind,cloak,else-if,else,for,html,if,model,on,once,pre,show,slot,text,memo" |
|
); |
|
const cacheStringFunction = (fn) => { |
|
const cache = /* @__PURE__ */ Object.create(null); |
|
return (str) => { |
|
const hit = cache[str]; |
|
return hit || (cache[str] = fn(str)); |
|
}; |
|
}; |
|
const camelizeRE = /-(\w)/g; |
|
const camelize = cacheStringFunction((str) => { |
|
return str.replace(camelizeRE, (_, c) => c ? c.toUpperCase() : ""); |
|
}); |
|
const hyphenateRE = /\B([A-Z])/g; |
|
const hyphenate = cacheStringFunction( |
|
(str) => str.replace(hyphenateRE, "-$1").toLowerCase() |
|
); |
|
const capitalize = cacheStringFunction((str) => { |
|
return str.charAt(0).toUpperCase() + str.slice(1); |
|
}); |
|
const toHandlerKey = cacheStringFunction((str) => { |
|
const s2 = str ? `on${capitalize(str)}` : ``; |
|
return s2; |
|
}); |
|
const hasChanged = (value, oldValue) => !Object.is(value, oldValue); |
|
const invokeArrayFns$1 = (fns, arg) => { |
|
for (let i = 0; i < fns.length; i++) { |
|
fns[i](arg); |
|
} |
|
}; |
|
const def = (obj, key, value) => { |
|
Object.defineProperty(obj, key, { |
|
configurable: true, |
|
enumerable: false, |
|
value |
|
}); |
|
}; |
|
const looseToNumber = (val) => { |
|
const n = parseFloat(val); |
|
return isNaN(n) ? val : n; |
|
}; |
|
let _globalThis; |
|
const getGlobalThis = () => { |
|
return _globalThis || (_globalThis = typeof globalThis !== "undefined" ? globalThis : typeof self !== "undefined" ? self : typeof window !== "undefined" ? window : typeof global !== "undefined" ? global : {}); |
|
}; |
|
function normalizeStyle(value) { |
|
if (isArray(value)) { |
|
const res = {}; |
|
for (let i = 0; i < value.length; i++) { |
|
const item = value[i]; |
|
const normalized = isString(item) ? parseStringStyle(item) : normalizeStyle(item); |
|
if (normalized) { |
|
for (const key in normalized) { |
|
res[key] = normalized[key]; |
|
} |
|
} |
|
} |
|
return res; |
|
} else if (isString(value) || isObject(value)) { |
|
return value; |
|
} |
|
} |
|
const listDelimiterRE = /;(?![^(]*\))/g; |
|
const propertyDelimiterRE = /:([^]+)/; |
|
const styleCommentRE = /\/\*[^]*?\*\//g; |
|
function parseStringStyle(cssText) { |
|
const ret = {}; |
|
cssText.replace(styleCommentRE, "").split(listDelimiterRE).forEach((item) => { |
|
if (item) { |
|
const tmp = item.split(propertyDelimiterRE); |
|
tmp.length > 1 && (ret[tmp[0].trim()] = tmp[1].trim()); |
|
} |
|
}); |
|
return ret; |
|
} |
|
const SLOT_DEFAULT_NAME = "d"; |
|
const ON_SHOW = "onShow"; |
|
const ON_HIDE = "onHide"; |
|
const ON_LAUNCH = "onLaunch"; |
|
const ON_ERROR = "onError"; |
|
const ON_THEME_CHANGE = "onThemeChange"; |
|
const ON_PAGE_NOT_FOUND = "onPageNotFound"; |
|
const ON_UNHANDLE_REJECTION = "onUnhandledRejection"; |
|
const ON_EXIT = "onExit"; |
|
const ON_LOAD = "onLoad"; |
|
const ON_READY = "onReady"; |
|
const ON_UNLOAD = "onUnload"; |
|
const ON_INIT = "onInit"; |
|
const ON_SAVE_EXIT_STATE = "onSaveExitState"; |
|
const ON_RESIZE = "onResize"; |
|
const ON_BACK_PRESS = "onBackPress"; |
|
const ON_PAGE_SCROLL = "onPageScroll"; |
|
const ON_TAB_ITEM_TAP = "onTabItemTap"; |
|
const ON_REACH_BOTTOM = "onReachBottom"; |
|
const ON_PULL_DOWN_REFRESH = "onPullDownRefresh"; |
|
const ON_SHARE_TIMELINE = "onShareTimeline"; |
|
const ON_ADD_TO_FAVORITES = "onAddToFavorites"; |
|
const ON_SHARE_APP_MESSAGE = "onShareAppMessage"; |
|
const ON_NAVIGATION_BAR_BUTTON_TAP = "onNavigationBarButtonTap"; |
|
const ON_NAVIGATION_BAR_SEARCH_INPUT_CLICKED = "onNavigationBarSearchInputClicked"; |
|
const ON_NAVIGATION_BAR_SEARCH_INPUT_CHANGED = "onNavigationBarSearchInputChanged"; |
|
const ON_NAVIGATION_BAR_SEARCH_INPUT_CONFIRMED = "onNavigationBarSearchInputConfirmed"; |
|
const ON_NAVIGATION_BAR_SEARCH_INPUT_FOCUS_CHANGED = "onNavigationBarSearchInputFocusChanged"; |
|
const customizeRE = /:/g; |
|
function customizeEvent(str) { |
|
return camelize(str.replace(customizeRE, "-")); |
|
} |
|
function hasLeadingSlash(str) { |
|
return str.indexOf("/") === 0; |
|
} |
|
function addLeadingSlash(str) { |
|
return hasLeadingSlash(str) ? str : "/" + str; |
|
} |
|
const invokeArrayFns = (fns, arg) => { |
|
let ret; |
|
for (let i = 0; i < fns.length; i++) { |
|
ret = fns[i](arg); |
|
} |
|
return ret; |
|
}; |
|
function once(fn, ctx = null) { |
|
let res; |
|
return (...args) => { |
|
if (fn) { |
|
res = fn.apply(ctx, args); |
|
fn = null; |
|
} |
|
return res; |
|
}; |
|
} |
|
function getValueByDataPath(obj, path) { |
|
if (!isString(path)) { |
|
return; |
|
} |
|
path = path.replace(/\[(\d+)\]/g, ".$1"); |
|
const parts = path.split("."); |
|
let key = parts[0]; |
|
if (!obj) { |
|
obj = {}; |
|
} |
|
if (parts.length === 1) { |
|
return obj[key]; |
|
} |
|
return getValueByDataPath(obj[key], parts.slice(1).join(".")); |
|
} |
|
function sortObject(obj) { |
|
let sortObj = {}; |
|
if (isPlainObject(obj)) { |
|
Object.keys(obj).sort().forEach((key) => { |
|
const _key = key; |
|
sortObj[_key] = obj[_key]; |
|
}); |
|
} |
|
return !Object.keys(sortObj) ? obj : sortObj; |
|
} |
|
const encode = encodeURIComponent; |
|
function stringifyQuery(obj, encodeStr = encode) { |
|
const res = obj ? Object.keys(obj).map((key) => { |
|
let val = obj[key]; |
|
if (typeof val === void 0 || val === null) { |
|
val = ""; |
|
} else if (isPlainObject(val)) { |
|
val = JSON.stringify(val); |
|
} |
|
return encodeStr(key) + "=" + encodeStr(val); |
|
}).filter((x) => x.length > 0).join("&") : null; |
|
return res ? `?${res}` : ""; |
|
} |
|
const PAGE_HOOKS = [ |
|
ON_INIT, |
|
ON_LOAD, |
|
ON_SHOW, |
|
ON_HIDE, |
|
ON_UNLOAD, |
|
ON_BACK_PRESS, |
|
ON_PAGE_SCROLL, |
|
ON_TAB_ITEM_TAP, |
|
ON_REACH_BOTTOM, |
|
ON_PULL_DOWN_REFRESH, |
|
ON_SHARE_TIMELINE, |
|
ON_SHARE_APP_MESSAGE, |
|
ON_ADD_TO_FAVORITES, |
|
ON_SAVE_EXIT_STATE, |
|
ON_NAVIGATION_BAR_BUTTON_TAP, |
|
ON_NAVIGATION_BAR_SEARCH_INPUT_CLICKED, |
|
ON_NAVIGATION_BAR_SEARCH_INPUT_CHANGED, |
|
ON_NAVIGATION_BAR_SEARCH_INPUT_CONFIRMED, |
|
ON_NAVIGATION_BAR_SEARCH_INPUT_FOCUS_CHANGED |
|
]; |
|
function isRootHook(name) { |
|
return PAGE_HOOKS.indexOf(name) > -1; |
|
} |
|
const UniLifecycleHooks = [ |
|
ON_SHOW, |
|
ON_HIDE, |
|
ON_LAUNCH, |
|
ON_ERROR, |
|
ON_THEME_CHANGE, |
|
ON_PAGE_NOT_FOUND, |
|
ON_UNHANDLE_REJECTION, |
|
ON_EXIT, |
|
ON_INIT, |
|
ON_LOAD, |
|
ON_READY, |
|
ON_UNLOAD, |
|
ON_RESIZE, |
|
ON_BACK_PRESS, |
|
ON_PAGE_SCROLL, |
|
ON_TAB_ITEM_TAP, |
|
ON_REACH_BOTTOM, |
|
ON_PULL_DOWN_REFRESH, |
|
ON_SHARE_TIMELINE, |
|
ON_ADD_TO_FAVORITES, |
|
ON_SHARE_APP_MESSAGE, |
|
ON_SAVE_EXIT_STATE, |
|
ON_NAVIGATION_BAR_BUTTON_TAP, |
|
ON_NAVIGATION_BAR_SEARCH_INPUT_CLICKED, |
|
ON_NAVIGATION_BAR_SEARCH_INPUT_CHANGED, |
|
ON_NAVIGATION_BAR_SEARCH_INPUT_CONFIRMED, |
|
ON_NAVIGATION_BAR_SEARCH_INPUT_FOCUS_CHANGED |
|
]; |
|
const MINI_PROGRAM_PAGE_RUNTIME_HOOKS = /* @__PURE__ */ (() => { |
|
return { |
|
onPageScroll: 1, |
|
onShareAppMessage: 1 << 1, |
|
onShareTimeline: 1 << 2 |
|
}; |
|
})(); |
|
function isUniLifecycleHook(name, value, checkType = true) { |
|
if (checkType && !isFunction(value)) { |
|
return false; |
|
} |
|
if (UniLifecycleHooks.indexOf(name) > -1) { |
|
return true; |
|
} else if (name.indexOf("on") === 0) { |
|
return true; |
|
} |
|
return false; |
|
} |
|
let vueApp; |
|
const createVueAppHooks = []; |
|
function onCreateVueApp(hook) { |
|
if (vueApp) { |
|
return hook(vueApp); |
|
} |
|
createVueAppHooks.push(hook); |
|
} |
|
function invokeCreateVueAppHook(app) { |
|
vueApp = app; |
|
createVueAppHooks.forEach((hook) => hook(app)); |
|
} |
|
const invokeCreateErrorHandler = once((app, createErrorHandler2) => { |
|
if (isFunction(app._component.onError)) { |
|
return createErrorHandler2(app); |
|
} |
|
}); |
|
const E = function() { |
|
}; |
|
E.prototype = { |
|
on: function(name, callback, ctx) { |
|
var e = this.e || (this.e = {}); |
|
(e[name] || (e[name] = [])).push({ |
|
fn: callback, |
|
ctx |
|
}); |
|
return this; |
|
}, |
|
once: function(name, callback, ctx) { |
|
var self2 = this; |
|
function listener() { |
|
self2.off(name, listener); |
|
callback.apply(ctx, arguments); |
|
} |
|
listener._ = callback; |
|
return this.on(name, listener, ctx); |
|
}, |
|
emit: function(name) { |
|
var data = [].slice.call(arguments, 1); |
|
var evtArr = ((this.e || (this.e = {}))[name] || []).slice(); |
|
var i = 0; |
|
var len = evtArr.length; |
|
for (i; i < len; i++) { |
|
evtArr[i].fn.apply(evtArr[i].ctx, data); |
|
} |
|
return this; |
|
}, |
|
off: function(name, callback) { |
|
var e = this.e || (this.e = {}); |
|
var evts = e[name]; |
|
var liveEvents = []; |
|
if (evts && callback) { |
|
for (var i = evts.length - 1; i >= 0; i--) { |
|
if (evts[i].fn === callback || evts[i].fn._ === callback) { |
|
evts.splice(i, 1); |
|
break; |
|
} |
|
} |
|
liveEvents = evts; |
|
} |
|
liveEvents.length ? e[name] = liveEvents : delete e[name]; |
|
return this; |
|
} |
|
}; |
|
var E$1 = E; |
|
const LOCALE_ZH_HANS = "zh-Hans"; |
|
const LOCALE_ZH_HANT = "zh-Hant"; |
|
const LOCALE_EN = "en"; |
|
const LOCALE_FR = "fr"; |
|
const LOCALE_ES = "es"; |
|
function include(str, parts) { |
|
return !!parts.find((part) => str.indexOf(part) !== -1); |
|
} |
|
function startsWith(str, parts) { |
|
return parts.find((part) => str.indexOf(part) === 0); |
|
} |
|
function normalizeLocale(locale, messages) { |
|
if (!locale) { |
|
return; |
|
} |
|
locale = locale.trim().replace(/_/g, "-"); |
|
if (messages && messages[locale]) { |
|
return locale; |
|
} |
|
locale = locale.toLowerCase(); |
|
if (locale === "chinese") { |
|
return LOCALE_ZH_HANS; |
|
} |
|
if (locale.indexOf("zh") === 0) { |
|
if (locale.indexOf("-hans") > -1) { |
|
return LOCALE_ZH_HANS; |
|
} |
|
if (locale.indexOf("-hant") > -1) { |
|
return LOCALE_ZH_HANT; |
|
} |
|
if (include(locale, ["-tw", "-hk", "-mo", "-cht"])) { |
|
return LOCALE_ZH_HANT; |
|
} |
|
return LOCALE_ZH_HANS; |
|
} |
|
let locales = [LOCALE_EN, LOCALE_FR, LOCALE_ES]; |
|
if (messages && Object.keys(messages).length > 0) { |
|
locales = Object.keys(messages); |
|
} |
|
const lang = startsWith(locale, locales); |
|
if (lang) { |
|
return lang; |
|
} |
|
} |
|
function getBaseSystemInfo() { |
|
return wx.getSystemInfoSync(); |
|
} |
|
function validateProtocolFail(name, msg) { |
|
console.warn(`${name}: ${msg}`); |
|
} |
|
function validateProtocol(name, data, protocol, onFail) { |
|
if (!onFail) { |
|
onFail = validateProtocolFail; |
|
} |
|
for (const key in protocol) { |
|
const errMsg = validateProp$1(key, data[key], protocol[key], !hasOwn(data, key)); |
|
if (isString(errMsg)) { |
|
onFail(name, errMsg); |
|
} |
|
} |
|
} |
|
function validateProtocols(name, args, protocol, onFail) { |
|
if (!protocol) { |
|
return; |
|
} |
|
if (!isArray(protocol)) { |
|
return validateProtocol(name, args[0] || /* @__PURE__ */ Object.create(null), protocol, onFail); |
|
} |
|
const len = protocol.length; |
|
const argsLen = args.length; |
|
for (let i = 0; i < len; i++) { |
|
const opts = protocol[i]; |
|
const data = /* @__PURE__ */ Object.create(null); |
|
if (argsLen > i) { |
|
data[opts.name] = args[i]; |
|
} |
|
validateProtocol(name, data, { [opts.name]: opts }, onFail); |
|
} |
|
} |
|
function validateProp$1(name, value, prop, isAbsent) { |
|
if (!isPlainObject(prop)) { |
|
prop = { type: prop }; |
|
} |
|
const { type, required, validator } = prop; |
|
if (required && isAbsent) { |
|
return 'Missing required args: "' + name + '"'; |
|
} |
|
if (value == null && !required) { |
|
return; |
|
} |
|
if (type != null) { |
|
let isValid = false; |
|
const types = isArray(type) ? type : [type]; |
|
const expectedTypes = []; |
|
for (let i = 0; i < types.length && !isValid; i++) { |
|
const { valid, expectedType } = assertType$1(value, types[i]); |
|
expectedTypes.push(expectedType || ""); |
|
isValid = valid; |
|
} |
|
if (!isValid) { |
|
return getInvalidTypeMessage$1(name, value, expectedTypes); |
|
} |
|
} |
|
if (validator) { |
|
return validator(value); |
|
} |
|
} |
|
const isSimpleType$1 = /* @__PURE__ */ makeMap("String,Number,Boolean,Function,Symbol"); |
|
function assertType$1(value, type) { |
|
let valid; |
|
const expectedType = getType$1(type); |
|
if (isSimpleType$1(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 { |
|
{ |
|
valid = value instanceof type; |
|
} |
|
} |
|
return { |
|
valid, |
|
expectedType |
|
}; |
|
} |
|
function getInvalidTypeMessage$1(name, value, expectedTypes) { |
|
let message = `Invalid args: type check failed for args "${name}". Expected ${expectedTypes.map(capitalize).join(", ")}`; |
|
const expectedType = expectedTypes[0]; |
|
const receivedType = toRawType(value); |
|
const expectedValue = styleValue$1(value, expectedType); |
|
const receivedValue = styleValue$1(value, receivedType); |
|
if (expectedTypes.length === 1 && isExplicable$1(expectedType) && !isBoolean$1(expectedType, receivedType)) { |
|
message += ` with value ${expectedValue}`; |
|
} |
|
message += `, got ${receivedType} `; |
|
if (isExplicable$1(receivedType)) { |
|
message += `with value ${receivedValue}.`; |
|
} |
|
return message; |
|
} |
|
function getType$1(ctor) { |
|
const match = ctor && ctor.toString().match(/^\s*function (\w+)/); |
|
return match ? match[1] : ""; |
|
} |
|
function styleValue$1(value, type) { |
|
if (type === "String") { |
|
return `"${value}"`; |
|
} else if (type === "Number") { |
|
return `${Number(value)}`; |
|
} else { |
|
return `${value}`; |
|
} |
|
} |
|
function isExplicable$1(type) { |
|
const explicitTypes = ["string", "number", "boolean"]; |
|
return explicitTypes.some((elem) => type.toLowerCase() === elem); |
|
} |
|
function isBoolean$1(...args) { |
|
return args.some((elem) => elem.toLowerCase() === "boolean"); |
|
} |
|
function tryCatch(fn) { |
|
return function() { |
|
try { |
|
return fn.apply(fn, arguments); |
|
} catch (e) { |
|
console.error(e); |
|
} |
|
}; |
|
} |
|
let invokeCallbackId = 1; |
|
const invokeCallbacks = {}; |
|
function addInvokeCallback(id, name, callback, keepAlive = false) { |
|
invokeCallbacks[id] = { |
|
name, |
|
keepAlive, |
|
callback |
|
}; |
|
return id; |
|
} |
|
function invokeCallback(id, res, extras) { |
|
if (typeof id === "number") { |
|
const opts = invokeCallbacks[id]; |
|
if (opts) { |
|
if (!opts.keepAlive) { |
|
delete invokeCallbacks[id]; |
|
} |
|
return opts.callback(res, extras); |
|
} |
|
} |
|
return res; |
|
} |
|
const API_SUCCESS = "success"; |
|
const API_FAIL = "fail"; |
|
const API_COMPLETE = "complete"; |
|
function getApiCallbacks(args) { |
|
const apiCallbacks = {}; |
|
for (const name in args) { |
|
const fn = args[name]; |
|
if (isFunction(fn)) { |
|
apiCallbacks[name] = tryCatch(fn); |
|
delete args[name]; |
|
} |
|
} |
|
return apiCallbacks; |
|
} |
|
function normalizeErrMsg(errMsg, name) { |
|
if (!errMsg || errMsg.indexOf(":fail") === -1) { |
|
return name + ":ok"; |
|
} |
|
return name + errMsg.substring(errMsg.indexOf(":fail")); |
|
} |
|
function createAsyncApiCallback(name, args = {}, { beforeAll, beforeSuccess } = {}) { |
|
if (!isPlainObject(args)) { |
|
args = {}; |
|
} |
|
const { success, fail, complete } = getApiCallbacks(args); |
|
const hasSuccess = isFunction(success); |
|
const hasFail = isFunction(fail); |
|
const hasComplete = isFunction(complete); |
|
const callbackId = invokeCallbackId++; |
|
addInvokeCallback(callbackId, name, (res) => { |
|
res = res || {}; |
|
res.errMsg = normalizeErrMsg(res.errMsg, name); |
|
isFunction(beforeAll) && beforeAll(res); |
|
if (res.errMsg === name + ":ok") { |
|
isFunction(beforeSuccess) && beforeSuccess(res, args); |
|
hasSuccess && success(res); |
|
} else { |
|
hasFail && fail(res); |
|
} |
|
hasComplete && complete(res); |
|
}); |
|
return callbackId; |
|
} |
|
const HOOK_SUCCESS = "success"; |
|
const HOOK_FAIL = "fail"; |
|
const HOOK_COMPLETE = "complete"; |
|
const globalInterceptors = {}; |
|
const scopedInterceptors = {}; |
|
function wrapperHook(hook, params) { |
|
return function(data) { |
|
return hook(data, params) || data; |
|
}; |
|
} |
|
function queue$2(hooks, data, params) { |
|
let promise = false; |
|
for (let i = 0; i < hooks.length; i++) { |
|
const hook = hooks[i]; |
|
if (promise) { |
|
promise = Promise.resolve(wrapperHook(hook, params)); |
|
} else { |
|
const res = hook(data, params); |
|
if (isPromise(res)) { |
|
promise = Promise.resolve(res); |
|
} |
|
if (res === false) { |
|
return { |
|
then() { |
|
}, |
|
catch() { |
|
} |
|
}; |
|
} |
|
} |
|
} |
|
return promise || { |
|
then(callback) { |
|
return callback(data); |
|
}, |
|
catch() { |
|
} |
|
}; |
|
} |
|
function wrapperOptions(interceptors2, options = {}) { |
|
[HOOK_SUCCESS, HOOK_FAIL, HOOK_COMPLETE].forEach((name) => { |
|
const hooks = interceptors2[name]; |
|
if (!isArray(hooks)) { |
|
return; |
|
} |
|
const oldCallback = options[name]; |
|
options[name] = function callbackInterceptor(res) { |
|
queue$2(hooks, res, options).then((res2) => { |
|
return isFunction(oldCallback) && oldCallback(res2) || res2; |
|
}); |
|
}; |
|
}); |
|
return options; |
|
} |
|
function wrapperReturnValue(method, returnValue) { |
|
const returnValueHooks = []; |
|
if (isArray(globalInterceptors.returnValue)) { |
|
returnValueHooks.push(...globalInterceptors.returnValue); |
|
} |
|
const interceptor = scopedInterceptors[method]; |
|
if (interceptor && isArray(interceptor.returnValue)) { |
|
returnValueHooks.push(...interceptor.returnValue); |
|
} |
|
returnValueHooks.forEach((hook) => { |
|
returnValue = hook(returnValue) || returnValue; |
|
}); |
|
return returnValue; |
|
} |
|
function getApiInterceptorHooks(method) { |
|
const interceptor = /* @__PURE__ */ Object.create(null); |
|
Object.keys(globalInterceptors).forEach((hook) => { |
|
if (hook !== "returnValue") { |
|
interceptor[hook] = globalInterceptors[hook].slice(); |
|
} |
|
}); |
|
const scopedInterceptor = scopedInterceptors[method]; |
|
if (scopedInterceptor) { |
|
Object.keys(scopedInterceptor).forEach((hook) => { |
|
if (hook !== "returnValue") { |
|
interceptor[hook] = (interceptor[hook] || []).concat(scopedInterceptor[hook]); |
|
} |
|
}); |
|
} |
|
return interceptor; |
|
} |
|
function invokeApi(method, api, options, params) { |
|
const interceptor = getApiInterceptorHooks(method); |
|
if (interceptor && Object.keys(interceptor).length) { |
|
if (isArray(interceptor.invoke)) { |
|
const res = queue$2(interceptor.invoke, options); |
|
return res.then((options2) => { |
|
return api(wrapperOptions(getApiInterceptorHooks(method), options2), ...params); |
|
}); |
|
} else { |
|
return api(wrapperOptions(interceptor, options), ...params); |
|
} |
|
} |
|
return api(options, ...params); |
|
} |
|
function hasCallback(args) { |
|
if (isPlainObject(args) && [API_SUCCESS, API_FAIL, API_COMPLETE].find((cb) => isFunction(args[cb]))) { |
|
return true; |
|
} |
|
return false; |
|
} |
|
function handlePromise(promise) { |
|
return promise; |
|
} |
|
function promisify$1(name, fn) { |
|
return (args = {}, ...rest) => { |
|
if (hasCallback(args)) { |
|
return wrapperReturnValue(name, invokeApi(name, fn, args, rest)); |
|
} |
|
return wrapperReturnValue(name, handlePromise(new Promise((resolve2, reject) => { |
|
invokeApi(name, fn, extend(args, { success: resolve2, fail: reject }), rest); |
|
}))); |
|
}; |
|
} |
|
function formatApiArgs(args, options) { |
|
const params = args[0]; |
|
if (!options || !options.formatArgs || !isPlainObject(options.formatArgs) && isPlainObject(params)) { |
|
return; |
|
} |
|
const formatArgs = options.formatArgs; |
|
const keys = Object.keys(formatArgs); |
|
for (let i = 0; i < keys.length; i++) { |
|
const name = keys[i]; |
|
const formatterOrDefaultValue = formatArgs[name]; |
|
if (isFunction(formatterOrDefaultValue)) { |
|
const errMsg = formatterOrDefaultValue(args[0][name], params); |
|
if (isString(errMsg)) { |
|
return errMsg; |
|
} |
|
} else { |
|
if (!hasOwn(params, name)) { |
|
params[name] = formatterOrDefaultValue; |
|
} |
|
} |
|
} |
|
} |
|
function invokeSuccess(id, name, res) { |
|
const result = { |
|
errMsg: name + ":ok" |
|
}; |
|
return invokeCallback(id, extend(res || {}, result)); |
|
} |
|
function invokeFail(id, name, errMsg, errRes = {}) { |
|
const apiErrMsg = name + ":fail" + (errMsg ? " " + errMsg : ""); |
|
delete errRes.errCode; |
|
let res = extend({ errMsg: apiErrMsg }, errRes); |
|
return invokeCallback(id, res); |
|
} |
|
function beforeInvokeApi(name, args, protocol, options) { |
|
{ |
|
validateProtocols(name, args, protocol); |
|
} |
|
if (options && options.beforeInvoke) { |
|
const errMsg2 = options.beforeInvoke(args); |
|
if (isString(errMsg2)) { |
|
return errMsg2; |
|
} |
|
} |
|
const errMsg = formatApiArgs(args, options); |
|
if (errMsg) { |
|
return errMsg; |
|
} |
|
} |
|
function parseErrMsg(errMsg) { |
|
if (!errMsg || isString(errMsg)) { |
|
return errMsg; |
|
} |
|
if (errMsg.stack) { |
|
console.error(errMsg.message + "\n" + errMsg.stack); |
|
return errMsg.message; |
|
} |
|
return errMsg; |
|
} |
|
function wrapperTaskApi(name, fn, protocol, options) { |
|
return (args) => { |
|
const id = createAsyncApiCallback(name, args, options); |
|
const errMsg = beforeInvokeApi(name, [args], protocol, options); |
|
if (errMsg) { |
|
return invokeFail(id, name, errMsg); |
|
} |
|
return fn(args, { |
|
resolve: (res) => invokeSuccess(id, name, res), |
|
reject: (errMsg2, errRes) => invokeFail(id, name, parseErrMsg(errMsg2), errRes) |
|
}); |
|
}; |
|
} |
|
function wrapperSyncApi(name, fn, protocol, options) { |
|
return (...args) => { |
|
const errMsg = beforeInvokeApi(name, args, protocol, options); |
|
if (errMsg) { |
|
throw new Error(errMsg); |
|
} |
|
return fn.apply(null, args); |
|
}; |
|
} |
|
function wrapperAsyncApi(name, fn, protocol, options) { |
|
return wrapperTaskApi(name, fn, protocol, options); |
|
} |
|
function defineSyncApi(name, fn, protocol, options) { |
|
return wrapperSyncApi(name, fn, protocol, options); |
|
} |
|
function defineAsyncApi(name, fn, protocol, options) { |
|
return promisify$1(name, wrapperAsyncApi(name, fn, protocol, options)); |
|
} |
|
const API_UPX2PX = "upx2px"; |
|
const Upx2pxProtocol = [ |
|
{ |
|
name: "upx", |
|
type: [Number, String], |
|
required: true |
|
} |
|
]; |
|
const EPS = 1e-4; |
|
const BASE_DEVICE_WIDTH = 750; |
|
let isIOS = false; |
|
let deviceWidth = 0; |
|
let deviceDPR = 0; |
|
function checkDeviceWidth() { |
|
const { platform, pixelRatio, windowWidth } = getBaseSystemInfo(); |
|
deviceWidth = windowWidth; |
|
deviceDPR = pixelRatio; |
|
isIOS = platform === "ios"; |
|
} |
|
const upx2px = defineSyncApi(API_UPX2PX, (number, newDeviceWidth) => { |
|
if (deviceWidth === 0) { |
|
checkDeviceWidth(); |
|
} |
|
number = Number(number); |
|
if (number === 0) { |
|
return 0; |
|
} |
|
let width = newDeviceWidth || deviceWidth; |
|
let result = number / BASE_DEVICE_WIDTH * width; |
|
if (result < 0) { |
|
result = -result; |
|
} |
|
result = Math.floor(result + EPS); |
|
if (result === 0) { |
|
if (deviceDPR === 1 || !isIOS) { |
|
result = 1; |
|
} else { |
|
result = 0.5; |
|
} |
|
} |
|
return number < 0 ? -result : result; |
|
}, Upx2pxProtocol); |
|
const API_ADD_INTERCEPTOR = "addInterceptor"; |
|
const API_REMOVE_INTERCEPTOR = "removeInterceptor"; |
|
const AddInterceptorProtocol = [ |
|
{ |
|
name: "method", |
|
type: [String, Object], |
|
required: true |
|
} |
|
]; |
|
const RemoveInterceptorProtocol = AddInterceptorProtocol; |
|
function mergeInterceptorHook(interceptors2, interceptor) { |
|
Object.keys(interceptor).forEach((hook) => { |
|
if (isFunction(interceptor[hook])) { |
|
interceptors2[hook] = mergeHook(interceptors2[hook], interceptor[hook]); |
|
} |
|
}); |
|
} |
|
function removeInterceptorHook(interceptors2, interceptor) { |
|
if (!interceptors2 || !interceptor) { |
|
return; |
|
} |
|
Object.keys(interceptor).forEach((name) => { |
|
const hooks = interceptors2[name]; |
|
const hook = interceptor[name]; |
|
if (isArray(hooks) && isFunction(hook)) { |
|
remove(hooks, hook); |
|
} |
|
}); |
|
} |
|
function mergeHook(parentVal, childVal) { |
|
const res = childVal ? parentVal ? parentVal.concat(childVal) : isArray(childVal) ? childVal : [childVal] : parentVal; |
|
return res ? dedupeHooks(res) : res; |
|
} |
|
function dedupeHooks(hooks) { |
|
const res = []; |
|
for (let i = 0; i < hooks.length; i++) { |
|
if (res.indexOf(hooks[i]) === -1) { |
|
res.push(hooks[i]); |
|
} |
|
} |
|
return res; |
|
} |
|
const addInterceptor = defineSyncApi(API_ADD_INTERCEPTOR, (method, interceptor) => { |
|
if (isString(method) && isPlainObject(interceptor)) { |
|
mergeInterceptorHook(scopedInterceptors[method] || (scopedInterceptors[method] = {}), interceptor); |
|
} else if (isPlainObject(method)) { |
|
mergeInterceptorHook(globalInterceptors, method); |
|
} |
|
}, AddInterceptorProtocol); |
|
const removeInterceptor = defineSyncApi(API_REMOVE_INTERCEPTOR, (method, interceptor) => { |
|
if (isString(method)) { |
|
if (isPlainObject(interceptor)) { |
|
removeInterceptorHook(scopedInterceptors[method], interceptor); |
|
} else { |
|
delete scopedInterceptors[method]; |
|
} |
|
} else if (isPlainObject(method)) { |
|
removeInterceptorHook(globalInterceptors, method); |
|
} |
|
}, RemoveInterceptorProtocol); |
|
const interceptors = {}; |
|
const API_ON = "$on"; |
|
const OnProtocol = [ |
|
{ |
|
name: "event", |
|
type: String, |
|
required: true |
|
}, |
|
{ |
|
name: "callback", |
|
type: Function, |
|
required: true |
|
} |
|
]; |
|
const API_ONCE = "$once"; |
|
const OnceProtocol = OnProtocol; |
|
const API_OFF = "$off"; |
|
const OffProtocol = [ |
|
{ |
|
name: "event", |
|
type: [String, Array] |
|
}, |
|
{ |
|
name: "callback", |
|
type: Function |
|
} |
|
]; |
|
const API_EMIT = "$emit"; |
|
const EmitProtocol = [ |
|
{ |
|
name: "event", |
|
type: String, |
|
required: true |
|
} |
|
]; |
|
const emitter = new E$1(); |
|
const $on = defineSyncApi(API_ON, (name, callback) => { |
|
emitter.on(name, callback); |
|
return () => emitter.off(name, callback); |
|
}, OnProtocol); |
|
const $once = defineSyncApi(API_ONCE, (name, callback) => { |
|
emitter.once(name, callback); |
|
return () => emitter.off(name, callback); |
|
}, OnceProtocol); |
|
const $off = defineSyncApi(API_OFF, (name, callback) => { |
|
if (!name) { |
|
emitter.e = {}; |
|
return; |
|
} |
|
if (!isArray(name)) |
|
name = [name]; |
|
name.forEach((n) => emitter.off(n, callback)); |
|
}, OffProtocol); |
|
const $emit = defineSyncApi(API_EMIT, (name, ...args) => { |
|
emitter.emit(name, ...args); |
|
}, EmitProtocol); |
|
let cid; |
|
let cidErrMsg; |
|
let enabled; |
|
function normalizePushMessage(message) { |
|
try { |
|
return JSON.parse(message); |
|
} catch (e) { |
|
} |
|
return message; |
|
} |
|
function invokePushCallback(args) { |
|
if (args.type === "enabled") { |
|
enabled = true; |
|
} else if (args.type === "clientId") { |
|
cid = args.cid; |
|
cidErrMsg = args.errMsg; |
|
invokeGetPushCidCallbacks(cid, args.errMsg); |
|
} else if (args.type === "pushMsg") { |
|
const message = { |
|
type: "receive", |
|
data: normalizePushMessage(args.message) |
|
}; |
|
for (let i = 0; i < onPushMessageCallbacks.length; i++) { |
|
const callback = onPushMessageCallbacks[i]; |
|
callback(message); |
|
if (message.stopped) { |
|
break; |
|
} |
|
} |
|
} else if (args.type === "click") { |
|
onPushMessageCallbacks.forEach((callback) => { |
|
callback({ |
|
type: "click", |
|
data: normalizePushMessage(args.message) |
|
}); |
|
}); |
|
} |
|
} |
|
const getPushCidCallbacks = []; |
|
function invokeGetPushCidCallbacks(cid2, errMsg) { |
|
getPushCidCallbacks.forEach((callback) => { |
|
callback(cid2, errMsg); |
|
}); |
|
getPushCidCallbacks.length = 0; |
|
} |
|
const API_GET_PUSH_CLIENT_ID = "getPushClientId"; |
|
const getPushClientId = defineAsyncApi(API_GET_PUSH_CLIENT_ID, (_, { resolve: resolve2, reject }) => { |
|
Promise.resolve().then(() => { |
|
if (typeof enabled === "undefined") { |
|
enabled = false; |
|
cid = ""; |
|
cidErrMsg = "uniPush is not enabled"; |
|
} |
|
getPushCidCallbacks.push((cid2, errMsg) => { |
|
if (cid2) { |
|
resolve2({ cid: cid2 }); |
|
} else { |
|
reject(errMsg); |
|
} |
|
}); |
|
if (typeof cid !== "undefined") { |
|
invokeGetPushCidCallbacks(cid, cidErrMsg); |
|
} |
|
}); |
|
}); |
|
const onPushMessageCallbacks = []; |
|
const onPushMessage = (fn) => { |
|
if (onPushMessageCallbacks.indexOf(fn) === -1) { |
|
onPushMessageCallbacks.push(fn); |
|
} |
|
}; |
|
const offPushMessage = (fn) => { |
|
if (!fn) { |
|
onPushMessageCallbacks.length = 0; |
|
} else { |
|
const index2 = onPushMessageCallbacks.indexOf(fn); |
|
if (index2 > -1) { |
|
onPushMessageCallbacks.splice(index2, 1); |
|
} |
|
} |
|
}; |
|
const SYNC_API_RE = /^\$|getLocale|setLocale|sendNativeEvent|restoreGlobal|requireGlobal|getCurrentSubNVue|getMenuButtonBoundingClientRect|^report|interceptors|Interceptor$|getSubNVueById|requireNativePlugin|upx2px|hideKeyboard|canIUse|^create|Sync$|Manager$|base64ToArrayBuffer|arrayBufferToBase64|getDeviceInfo|getAppBaseInfo|getWindowInfo|getSystemSetting|getAppAuthorizeSetting/; |
|
const CONTEXT_API_RE = /^create|Manager$/; |
|
const CONTEXT_API_RE_EXC = ["createBLEConnection"]; |
|
const ASYNC_API = ["createBLEConnection"]; |
|
const CALLBACK_API_RE = /^on|^off/; |
|
function isContextApi(name) { |
|
return CONTEXT_API_RE.test(name) && CONTEXT_API_RE_EXC.indexOf(name) === -1; |
|
} |
|
function isSyncApi(name) { |
|
return SYNC_API_RE.test(name) && ASYNC_API.indexOf(name) === -1; |
|
} |
|
function isCallbackApi(name) { |
|
return CALLBACK_API_RE.test(name) && name !== "onPush"; |
|
} |
|
function shouldPromise(name) { |
|
if (isContextApi(name) || isSyncApi(name) || isCallbackApi(name)) { |
|
return false; |
|
} |
|
return true; |
|
} |
|
if (!Promise.prototype.finally) { |
|
Promise.prototype.finally = function(onfinally) { |
|
const promise = this.constructor; |
|
return this.then((value) => promise.resolve(onfinally && onfinally()).then(() => value), (reason) => promise.resolve(onfinally && onfinally()).then(() => { |
|
throw reason; |
|
})); |
|
}; |
|
} |
|
function promisify(name, api) { |
|
if (!shouldPromise(name)) { |
|
return api; |
|
} |
|
if (!isFunction(api)) { |
|
return api; |
|
} |
|
return function promiseApi(options = {}, ...rest) { |
|
if (isFunction(options.success) || isFunction(options.fail) || isFunction(options.complete)) { |
|
return wrapperReturnValue(name, invokeApi(name, api, options, rest)); |
|
} |
|
return wrapperReturnValue(name, handlePromise(new Promise((resolve2, reject) => { |
|
invokeApi(name, api, extend({}, options, { |
|
success: resolve2, |
|
fail: reject |
|
}), rest); |
|
}))); |
|
}; |
|
} |
|
const CALLBACKS = ["success", "fail", "cancel", "complete"]; |
|
function initWrapper(protocols2) { |
|
function processCallback(methodName, method, returnValue) { |
|
return function(res) { |
|
return method(processReturnValue(methodName, res, returnValue)); |
|
}; |
|
} |
|
function processArgs(methodName, fromArgs, argsOption = {}, returnValue = {}, keepFromArgs = false) { |
|
if (isPlainObject(fromArgs)) { |
|
const toArgs = keepFromArgs === true ? fromArgs : {}; |
|
if (isFunction(argsOption)) { |
|
argsOption = argsOption(fromArgs, toArgs) || {}; |
|
} |
|
for (const key in fromArgs) { |
|
if (hasOwn(argsOption, key)) { |
|
let keyOption = argsOption[key]; |
|
if (isFunction(keyOption)) { |
|
keyOption = keyOption(fromArgs[key], fromArgs, toArgs); |
|
} |
|
if (!keyOption) { |
|
console.warn(`微信小程序 ${methodName} 暂不支持 ${key}`); |
|
} else if (isString(keyOption)) { |
|
toArgs[keyOption] = fromArgs[key]; |
|
} else if (isPlainObject(keyOption)) { |
|
toArgs[keyOption.name ? keyOption.name : key] = keyOption.value; |
|
} |
|
} else if (CALLBACKS.indexOf(key) !== -1) { |
|
const callback = fromArgs[key]; |
|
if (isFunction(callback)) { |
|
toArgs[key] = processCallback(methodName, callback, returnValue); |
|
} |
|
} else { |
|
if (!keepFromArgs && !hasOwn(toArgs, key)) { |
|
toArgs[key] = fromArgs[key]; |
|
} |
|
} |
|
} |
|
return toArgs; |
|
} else if (isFunction(fromArgs)) { |
|
fromArgs = processCallback(methodName, fromArgs, returnValue); |
|
} |
|
return fromArgs; |
|
} |
|
function processReturnValue(methodName, res, returnValue, keepReturnValue = false) { |
|
if (isFunction(protocols2.returnValue)) { |
|
res = protocols2.returnValue(methodName, res); |
|
} |
|
return processArgs(methodName, res, returnValue, {}, keepReturnValue); |
|
} |
|
return function wrapper(methodName, method) { |
|
if (!hasOwn(protocols2, methodName)) { |
|
return method; |
|
} |
|
const protocol = protocols2[methodName]; |
|
if (!protocol) { |
|
return function() { |
|
console.error(`微信小程序 暂不支持${methodName}`); |
|
}; |
|
} |
|
return function(arg1, arg2) { |
|
let options = protocol; |
|
if (isFunction(protocol)) { |
|
options = protocol(arg1); |
|
} |
|
arg1 = processArgs(methodName, arg1, options.args, options.returnValue); |
|
const args = [arg1]; |
|
if (typeof arg2 !== "undefined") { |
|
args.push(arg2); |
|
} |
|
const returnValue = wx[options.name || methodName].apply(wx, args); |
|
if (isSyncApi(methodName)) { |
|
return processReturnValue(methodName, returnValue, options.returnValue, isContextApi(methodName)); |
|
} |
|
return returnValue; |
|
}; |
|
}; |
|
} |
|
const getLocale = () => { |
|
const app = isFunction(getApp) && getApp({ allowDefault: true }); |
|
if (app && app.$vm) { |
|
return app.$vm.$locale; |
|
} |
|
return normalizeLocale(wx.getSystemInfoSync().language) || LOCALE_EN; |
|
}; |
|
const setLocale = (locale) => { |
|
const app = isFunction(getApp) && getApp(); |
|
if (!app) { |
|
return false; |
|
} |
|
const oldLocale = app.$vm.$locale; |
|
if (oldLocale !== locale) { |
|
app.$vm.$locale = locale; |
|
onLocaleChangeCallbacks.forEach((fn) => fn({ locale })); |
|
return true; |
|
} |
|
return false; |
|
}; |
|
const onLocaleChangeCallbacks = []; |
|
const onLocaleChange = (fn) => { |
|
if (onLocaleChangeCallbacks.indexOf(fn) === -1) { |
|
onLocaleChangeCallbacks.push(fn); |
|
} |
|
}; |
|
if (typeof global !== "undefined") { |
|
global.getLocale = getLocale; |
|
} |
|
const UUID_KEY = "__DC_STAT_UUID"; |
|
let deviceId; |
|
function useDeviceId(global2 = wx) { |
|
return function addDeviceId(_, toRes) { |
|
deviceId = deviceId || global2.getStorageSync(UUID_KEY); |
|
if (!deviceId) { |
|
deviceId = Date.now() + "" + Math.floor(Math.random() * 1e7); |
|
wx.setStorage({ |
|
key: UUID_KEY, |
|
data: deviceId |
|
}); |
|
} |
|
toRes.deviceId = deviceId; |
|
}; |
|
} |
|
function addSafeAreaInsets(fromRes, toRes) { |
|
if (fromRes.safeArea) { |
|
const safeArea = fromRes.safeArea; |
|
toRes.safeAreaInsets = { |
|
top: safeArea.top, |
|
left: safeArea.left, |
|
right: fromRes.windowWidth - safeArea.right, |
|
bottom: fromRes.screenHeight - safeArea.bottom |
|
}; |
|
} |
|
} |
|
function populateParameters(fromRes, toRes) { |
|
const { brand = "", model = "", system = "", language = "", theme, version: version2, platform, fontSizeSetting, SDKVersion, pixelRatio, deviceOrientation } = fromRes; |
|
let osName = ""; |
|
let osVersion = ""; |
|
{ |
|
osName = system.split(" ")[0] || ""; |
|
osVersion = system.split(" ")[1] || ""; |
|
} |
|
let hostVersion = version2; |
|
let deviceType = getGetDeviceType(fromRes, model); |
|
let deviceBrand = getDeviceBrand(brand); |
|
let _hostName = getHostName(fromRes); |
|
let _deviceOrientation = deviceOrientation; |
|
let _devicePixelRatio = pixelRatio; |
|
let _SDKVersion = SDKVersion; |
|
const hostLanguage = language.replace(/_/g, "-"); |
|
const parameters = { |
|
appId: "__UNI__F085E81", |
|
appName: "gateway", |
|
appVersion: "1.0.0", |
|
appVersionCode: "100", |
|
appLanguage: getAppLanguage(hostLanguage), |
|
uniCompileVersion: "4.29", |
|
uniRuntimeVersion: "4.29", |
|
uniPlatform: "mp-weixin", |
|
deviceBrand, |
|
deviceModel: model, |
|
deviceType, |
|
devicePixelRatio: _devicePixelRatio, |
|
deviceOrientation: _deviceOrientation, |
|
osName: osName.toLocaleLowerCase(), |
|
osVersion, |
|
hostTheme: theme, |
|
hostVersion, |
|
hostLanguage, |
|
hostName: _hostName, |
|
hostSDKVersion: _SDKVersion, |
|
hostFontSizeSetting: fontSizeSetting, |
|
windowTop: 0, |
|
windowBottom: 0, |
|
// TODO |
|
osLanguage: void 0, |
|
osTheme: void 0, |
|
ua: void 0, |
|
hostPackageName: void 0, |
|
browserName: void 0, |
|
browserVersion: void 0 |
|
}; |
|
extend(toRes, parameters); |
|
} |
|
function getGetDeviceType(fromRes, model) { |
|
let deviceType = fromRes.deviceType || "phone"; |
|
{ |
|
const deviceTypeMaps = { |
|
ipad: "pad", |
|
windows: "pc", |
|
mac: "pc" |
|
}; |
|
const deviceTypeMapsKeys = Object.keys(deviceTypeMaps); |
|
const _model = model.toLocaleLowerCase(); |
|
for (let index2 = 0; index2 < deviceTypeMapsKeys.length; index2++) { |
|
const _m = deviceTypeMapsKeys[index2]; |
|
if (_model.indexOf(_m) !== -1) { |
|
deviceType = deviceTypeMaps[_m]; |
|
break; |
|
} |
|
} |
|
} |
|
return deviceType; |
|
} |
|
function getDeviceBrand(brand) { |
|
let deviceBrand = brand; |
|
if (deviceBrand) { |
|
deviceBrand = deviceBrand.toLocaleLowerCase(); |
|
} |
|
return deviceBrand; |
|
} |
|
function getAppLanguage(defaultLanguage) { |
|
return getLocale ? getLocale() : defaultLanguage; |
|
} |
|
function getHostName(fromRes) { |
|
const _platform = "WeChat"; |
|
let _hostName = fromRes.hostName || _platform; |
|
{ |
|
if (fromRes.environment) { |
|
_hostName = fromRes.environment; |
|
} else if (fromRes.host && fromRes.host.env) { |
|
_hostName = fromRes.host.env; |
|
} |
|
} |
|
return _hostName; |
|
} |
|
const getSystemInfo = { |
|
returnValue: (fromRes, toRes) => { |
|
addSafeAreaInsets(fromRes, toRes); |
|
useDeviceId()(fromRes, toRes); |
|
populateParameters(fromRes, toRes); |
|
} |
|
}; |
|
const getSystemInfoSync = getSystemInfo; |
|
const redirectTo = {}; |
|
const previewImage = { |
|
args(fromArgs, toArgs) { |
|
let currentIndex = parseInt(fromArgs.current); |
|
if (isNaN(currentIndex)) { |
|
return; |
|
} |
|
const urls = fromArgs.urls; |
|
if (!isArray(urls)) { |
|
return; |
|
} |
|
const len = urls.length; |
|
if (!len) { |
|
return; |
|
} |
|
if (currentIndex < 0) { |
|
currentIndex = 0; |
|
} else if (currentIndex >= len) { |
|
currentIndex = len - 1; |
|
} |
|
if (currentIndex > 0) { |
|
toArgs.current = urls[currentIndex]; |
|
toArgs.urls = urls.filter((item, index2) => index2 < currentIndex ? item !== urls[currentIndex] : true); |
|
} else { |
|
toArgs.current = urls[0]; |
|
} |
|
return { |
|
indicator: false, |
|
loop: false |
|
}; |
|
} |
|
}; |
|
const showActionSheet = { |
|
args(fromArgs, toArgs) { |
|
toArgs.alertText = fromArgs.title; |
|
} |
|
}; |
|
const getDeviceInfo = { |
|
returnValue: (fromRes, toRes) => { |
|
const { brand, model } = fromRes; |
|
let deviceType = getGetDeviceType(fromRes, model); |
|
let deviceBrand = getDeviceBrand(brand); |
|
useDeviceId()(fromRes, toRes); |
|
toRes = sortObject(extend(toRes, { |
|
deviceType, |
|
deviceBrand, |
|
deviceModel: model |
|
})); |
|
} |
|
}; |
|
const getAppBaseInfo = { |
|
returnValue: (fromRes, toRes) => { |
|
const { version: version2, language, SDKVersion, theme } = fromRes; |
|
let _hostName = getHostName(fromRes); |
|
let hostLanguage = language.replace(/_/g, "-"); |
|
toRes = sortObject(extend(toRes, { |
|
hostVersion: version2, |
|
hostLanguage, |
|
hostName: _hostName, |
|
hostSDKVersion: SDKVersion, |
|
hostTheme: theme, |
|
appId: "__UNI__F085E81", |
|
appName: "gateway", |
|
appVersion: "1.0.0", |
|
appVersionCode: "100", |
|
appLanguage: getAppLanguage(hostLanguage) |
|
})); |
|
} |
|
}; |
|
const getWindowInfo = { |
|
returnValue: (fromRes, toRes) => { |
|
addSafeAreaInsets(fromRes, toRes); |
|
toRes = sortObject(extend(toRes, { |
|
windowTop: 0, |
|
windowBottom: 0 |
|
})); |
|
} |
|
}; |
|
const getAppAuthorizeSetting = { |
|
returnValue: function(fromRes, toRes) { |
|
const { locationReducedAccuracy } = fromRes; |
|
toRes.locationAccuracy = "unsupported"; |
|
if (locationReducedAccuracy === true) { |
|
toRes.locationAccuracy = "reduced"; |
|
} else if (locationReducedAccuracy === false) { |
|
toRes.locationAccuracy = "full"; |
|
} |
|
} |
|
}; |
|
const baseApis = { |
|
$on, |
|
$off, |
|
$once, |
|
$emit, |
|
upx2px, |
|
interceptors, |
|
addInterceptor, |
|
removeInterceptor, |
|
onCreateVueApp, |
|
invokeCreateVueAppHook, |
|
getLocale, |
|
setLocale, |
|
onLocaleChange, |
|
getPushClientId, |
|
onPushMessage, |
|
offPushMessage, |
|
invokePushCallback |
|
}; |
|
function initUni(api, protocols2, platform = wx) { |
|
const wrapper = initWrapper(protocols2); |
|
const UniProxyHandlers = { |
|
get(target, key) { |
|
if (hasOwn(target, key)) { |
|
return target[key]; |
|
} |
|
if (hasOwn(api, key)) { |
|
return promisify(key, api[key]); |
|
} |
|
if (hasOwn(baseApis, key)) { |
|
return promisify(key, baseApis[key]); |
|
} |
|
return promisify(key, wrapper(key, platform[key])); |
|
} |
|
}; |
|
return new Proxy({}, UniProxyHandlers); |
|
} |
|
function initGetProvider(providers) { |
|
return function getProvider2({ service, success, fail, complete }) { |
|
let res; |
|
if (providers[service]) { |
|
res = { |
|
errMsg: "getProvider:ok", |
|
service, |
|
provider: providers[service] |
|
}; |
|
isFunction(success) && success(res); |
|
} else { |
|
res = { |
|
errMsg: "getProvider:fail:服务[" + service + "]不存在" |
|
}; |
|
isFunction(fail) && fail(res); |
|
} |
|
isFunction(complete) && complete(res); |
|
}; |
|
} |
|
const objectKeys = [ |
|
"qy", |
|
"env", |
|
"error", |
|
"version", |
|
"lanDebug", |
|
"cloud", |
|
"serviceMarket", |
|
"router", |
|
"worklet", |
|
"__webpack_require_UNI_MP_PLUGIN__" |
|
]; |
|
const singlePageDisableKey = ["lanDebug", "router", "worklet"]; |
|
const launchOption = wx.getLaunchOptionsSync ? wx.getLaunchOptionsSync() : null; |
|
function isWxKey(key) { |
|
if (launchOption && launchOption.scene === 1154 && singlePageDisableKey.includes(key)) { |
|
return false; |
|
} |
|
return objectKeys.indexOf(key) > -1 || typeof wx[key] === "function"; |
|
} |
|
function initWx() { |
|
const newWx = {}; |
|
for (const key in wx) { |
|
if (isWxKey(key)) { |
|
newWx[key] = wx[key]; |
|
} |
|
} |
|
if (typeof globalThis !== "undefined" && typeof requireMiniProgram === "undefined") { |
|
globalThis.wx = newWx; |
|
} |
|
return newWx; |
|
} |
|
const mocks$1 = ["__route__", "__wxExparserNodeId__", "__wxWebviewId__"]; |
|
const getProvider = initGetProvider({ |
|
oauth: ["weixin"], |
|
share: ["weixin"], |
|
payment: ["wxpay"], |
|
push: ["weixin"] |
|
}); |
|
function initComponentMocks(component) { |
|
const res = /* @__PURE__ */ Object.create(null); |
|
mocks$1.forEach((name) => { |
|
res[name] = component[name]; |
|
}); |
|
return res; |
|
} |
|
function createSelectorQuery() { |
|
const query = wx$2.createSelectorQuery(); |
|
const oldIn = query.in; |
|
query.in = function newIn(component) { |
|
return oldIn.call(this, initComponentMocks(component)); |
|
}; |
|
return query; |
|
} |
|
const wx$2 = initWx(); |
|
let baseInfo = wx$2.getAppBaseInfo && wx$2.getAppBaseInfo(); |
|
if (!baseInfo) { |
|
baseInfo = wx$2.getSystemInfoSync(); |
|
} |
|
const host = baseInfo ? baseInfo.host : null; |
|
const shareVideoMessage = host && host.env === "SAAASDK" ? wx$2.miniapp.shareVideoMessage : wx$2.shareVideoMessage; |
|
var shims = /* @__PURE__ */ Object.freeze({ |
|
__proto__: null, |
|
createSelectorQuery, |
|
getProvider, |
|
shareVideoMessage |
|
}); |
|
const compressImage = { |
|
args(fromArgs, toArgs) { |
|
if (fromArgs.compressedHeight && !toArgs.compressHeight) { |
|
toArgs.compressHeight = fromArgs.compressedHeight; |
|
} |
|
if (fromArgs.compressedWidth && !toArgs.compressWidth) { |
|
toArgs.compressWidth = fromArgs.compressedWidth; |
|
} |
|
} |
|
}; |
|
var protocols = /* @__PURE__ */ Object.freeze({ |
|
__proto__: null, |
|
compressImage, |
|
getAppAuthorizeSetting, |
|
getAppBaseInfo, |
|
getDeviceInfo, |
|
getSystemInfo, |
|
getSystemInfoSync, |
|
getWindowInfo, |
|
previewImage, |
|
redirectTo, |
|
showActionSheet |
|
}); |
|
const wx$1 = initWx(); |
|
var index = initUni(shims, protocols, wx$1); |
|
new Set( |
|
/* @__PURE__ */ Object.getOwnPropertyNames(Symbol).filter((key) => key !== "arguments" && key !== "caller").map((key) => Symbol[key]).filter(isSymbol) |
|
); |
|
function toRaw$1(observed) { |
|
const raw = observed && observed["__v_raw"]; |
|
return raw ? toRaw$1(raw) : observed; |
|
} |
|
function isRef$1(r2) { |
|
return !!(r2 && r2.__v_isRef === true); |
|
} |
|
/** |
|
* @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) { |
|
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); |
|
} |
|
} |
|
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 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 = ErrorTypeStrings$1[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) { |
|
{ |
|
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); |
|
} |
|
} |
|
} |
|
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(); |
|
const RECURSION_LIMIT$1 = 100; |
|
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; |
|
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; |
|
{ |
|
seen = seen || /* @__PURE__ */ new Map(); |
|
} |
|
for (postFlushIndex$1 = 0; postFlushIndex$1 < activePostFlushCbs$1.length; postFlushIndex$1++) { |
|
if (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 diff2 = getId$1(a) - getId$1(b); |
|
if (diff2 === 0) { |
|
if (a.pre && !b.pre) |
|
return -1; |
|
if (b.pre && !a.pre) |
|
return 1; |
|
} |
|
return diff2; |
|
}; |
|
function flushJobs$1(seen) { |
|
isFlushPending$1 = false; |
|
isFlushing$1 = true; |
|
{ |
|
seen = seen || /* @__PURE__ */ new Map(); |
|
} |
|
queue$1.sort(comparator$1); |
|
const check = (job) => checkRecursiveUpdates$1(seen, job); |
|
try { |
|
for (flushIndex$1 = 0; flushIndex$1 < queue$1.length; flushIndex$1++) { |
|
const job = queue$1[flushIndex$1]; |
|
if (job && job.active !== false) { |
|
if (check(job)) { |
|
continue; |
|
} |
|
callWithErrorHandling$1(job, null, 14); |
|
} |
|
} |
|
} finally { |
|
flushIndex$1 = 0; |
|
queue$1.length = 0; |
|
flushPostFlushCbs$1(seen); |
|
isFlushing$1 = false; |
|
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(); |
|
{ |
|
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 (e2) { |
|
console.error(e2); |
|
console.warn( |
|
`[HMR] Something went wrong during Vue component hot-reload. Full reload required.` |
|
); |
|
} |
|
}; |
|
} |
|
{ |
|
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((set2) => set2(v)); |
|
else |
|
setters[0](v); |
|
}; |
|
}; |
|
registerGlobalSetter( |
|
`__VUE_INSTANCE_SETTERS__`, |
|
(v) => v |
|
); |
|
registerGlobalSetter( |
|
`__VUE_SSR_SETTERS__`, |
|
(v) => v |
|
); |
|
} |
|
const classifyRE$1 = /(?:^|[-_])(\w)/g; |
|
const classify$1 = (str) => str.replace(classifyRE$1, (c2) => c2.toUpperCase()).replace(/[-_]/g, ""); |
|
function getComponentName$1(Component2, includeInferred = true) { |
|
return isFunction(Component2) ? Component2.displayName || Component2.name : Component2.name || includeInferred && Component2.__name; |
|
} |
|
function formatComponentName$1(instance, Component2, isRoot = false) { |
|
let name = getComponentName$1(Component2); |
|
if (!name && Component2.__file) { |
|
const match = Component2.__file.match(/([^/\\]+)\.\w+$/); |
|
if (match) { |
|
name = match[1]; |
|
} |
|
} |
|
if (!name && instance && instance.parent) { |
|
const inferFromRegistry = (registry) => { |
|
for (const key in registry) { |
|
if (registry[key] === Component2) { |
|
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; |
|
} |
|
/** |
|
* @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; |
|
this._active = true; |
|
this.effects = []; |
|
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 { |
|
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 recordEffectScope(effect2, scope = activeEffectScope) { |
|
if (scope && scope.active) { |
|
scope.effects.push(effect2); |
|
} |
|
} |
|
function getCurrentScope() { |
|
return activeEffectScope; |
|
} |
|
let activeEffect; |
|
class ReactiveEffect2 { |
|
constructor(fn, trigger2, scheduler, scope) { |
|
this.fn = fn; |
|
this.trigger = trigger2; |
|
this.scheduler = scheduler; |
|
this.active = true; |
|
this.deps = []; |
|
this._dirtyLevel = 4; |
|
this._trackId = 0; |
|
this._runnings = 0; |
|
this._shouldSchedule = false; |
|
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(computed2) { |
|
return computed2.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(); |
|
} |
|
} |
|
} |
|
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++; |
|
} |
|
{ |
|
(_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)) { |
|
{ |
|
(_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, computed2) => { |
|
const dep = /* @__PURE__ */ new Map(); |
|
dep.cleanup = cleanup; |
|
dep.computed = computed2; |
|
return dep; |
|
}; |
|
const targetMap = /* @__PURE__ */ new WeakMap(); |
|
const ITERATE_KEY = Symbol("iterate"); |
|
const MAP_KEY_ITERATE_KEY = Symbol("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, |
|
{ |
|
target, |
|
type, |
|
key |
|
} |
|
); |
|
} |
|
} |
|
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, |
|
{ |
|
target, |
|
type, |
|
key, |
|
newValue, |
|
oldValue, |
|
oldTarget |
|
} |
|
); |
|
} |
|
} |
|
resetScheduling(); |
|
} |
|
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 BaseReactiveHandler2 { |
|
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 MutableReactiveHandler2 extends BaseReactiveHandler2 { |
|
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 ReadonlyReactiveHandler2 extends BaseReactiveHandler2 { |
|
constructor(isShallow2 = false) { |
|
super(true, isShallow2); |
|
} |
|
set(target, key) { |
|
{ |
|
warn$2( |
|
`Set operation on key "${String(key)}" failed: target is readonly.`, |
|
target |
|
); |
|
} |
|
return true; |
|
} |
|
deleteProperty(target, key) { |
|
{ |
|
warn$2( |
|
`Delete operation on key "${String(key)}" failed: target is readonly.`, |
|
target |
|
); |
|
} |
|
return true; |
|
} |
|
} |
|
const mutableHandlers = /* @__PURE__ */ new MutableReactiveHandler2(); |
|
const readonlyHandlers = /* @__PURE__ */ new ReadonlyReactiveHandler2(); |
|
const shallowReactiveHandlers = /* @__PURE__ */ new MutableReactiveHandler2( |
|
true |
|
); |
|
const shallowReadonlyHandlers = /* @__PURE__ */ new ReadonlyReactiveHandler2(true); |
|
const toShallow = (value) => value; |
|
const getProto = (v) => Reflect.getPrototypeOf(v); |
|
function get(target, key, isReadonly2 = false, isShallow2 = false) { |
|
target = target["__v_raw"]; |
|
const rawTarget = toRaw(target); |
|
const rawKey = toRaw(key); |
|
if (!isReadonly2) { |
|
if (hasChanged(key, rawKey)) { |
|
track(rawTarget, "get", key); |
|
} |
|
track(rawTarget, "get", rawKey); |
|
} |
|
const { has: has2 } = getProto(rawTarget); |
|
const wrap = isShallow2 ? toShallow : isReadonly2 ? 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, isReadonly2 = false) { |
|
const target = this["__v_raw"]; |
|
const rawTarget = toRaw(target); |
|
const rawKey = toRaw(key); |
|
if (!isReadonly2) { |
|
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, isReadonly2 = false) { |
|
target = target["__v_raw"]; |
|
!isReadonly2 && 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 { |
|
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 { |
|
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 = isMap(target) ? new Map(target) : new Set(target); |
|
const result = target.clear(); |
|
if (hadItems) { |
|
trigger(target, "clear", void 0, void 0, oldTarget); |
|
} |
|
return result; |
|
} |
|
function createForEach(isReadonly2, isShallow2) { |
|
return function forEach(callback, thisArg) { |
|
const observed = this; |
|
const target = observed["__v_raw"]; |
|
const rawTarget = toRaw(target); |
|
const wrap = isShallow2 ? toShallow : isReadonly2 ? toReadonly : toReactive; |
|
!isReadonly2 && track(rawTarget, "iterate", ITERATE_KEY); |
|
return target.forEach((value, key) => { |
|
return callback.call(thisArg, wrap(value), wrap(key), observed); |
|
}); |
|
}; |
|
} |
|
function createIterableMethod(method, isReadonly2, isShallow2) { |
|
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 = isShallow2 ? toShallow : isReadonly2 ? toReadonly : toReactive; |
|
!isReadonly2 && 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) { |
|
{ |
|
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(isReadonly2, shallow) { |
|
const instrumentations = shallow ? isReadonly2 ? shallowReadonlyInstrumentations : shallowInstrumentations : isReadonly2 ? readonlyInstrumentations : mutableInstrumentations; |
|
return (target, key, receiver) => { |
|
if (key === "__v_isReactive") { |
|
return !isReadonly2; |
|
} else if (key === "__v_isReadonly") { |
|
return isReadonly2; |
|
} 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; |
|
case "Map": |
|
case "Set": |
|
case "WeakMap": |
|
case "WeakSet": |
|
return 2; |
|
default: |
|
return 0; |
|
} |
|
} |
|
function getTargetType(value) { |
|
return value["__v_skip"] || !Object.isExtensible(value) ? 0 : 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)) { |
|
{ |
|
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) { |
|
return target; |
|
} |
|
const proxy = new Proxy( |
|
target, |
|
targetType === 2 ? 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 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, isReadonly2, isSSR) { |
|
this.getter = getter; |
|
this._setter = _setter; |
|
this.dep = void 0; |
|
this.__v_isRef = true; |
|
this["__v_isReadonly"] = false; |
|
this.effect = new ReactiveEffect2( |
|
() => getter(this._value), |
|
() => triggerRefValue( |
|
this, |
|
this.effect._dirtyLevel === 2 ? 2 : 3 |
|
) |
|
); |
|
this.effect.computed = this; |
|
this.effect.active = this._cacheable = !isSSR; |
|
this["__v_isReadonly"] = isReadonly2; |
|
} |
|
get value() { |
|
const self2 = toRaw(this); |
|
if ((!self2._cacheable || self2.effect.dirty) && hasChanged(self2._value, self2._value = self2.effect.run())) { |
|
triggerRefValue(self2, 4); |
|
} |
|
trackRefValue(self2); |
|
if (self2.effect._dirtyLevel >= 2) { |
|
if (this._warnRecursive) { |
|
warn$2(COMPUTED_SIDE_EFFECT_WARN, ` |
|
|
|
getter: `, this.getter); |
|
} |
|
triggerRefValue(self2, 2); |
|
} |
|
return self2._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 = () => { |
|
warn$2("Write operation failed: computed value is readonly"); |
|
}; |
|
} else { |
|
getter = getterOrOptions.get; |
|
setter = getterOrOptions.set; |
|
} |
|
const cRef = new ComputedRefImpl(getter, setter, onlyGetter || !setter, isSSR); |
|
if (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 |
|
), |
|
{ |
|
target: ref2, |
|
type: "get", |
|
key: "value" |
|
} |
|
); |
|
} |
|
} |
|
function triggerRefValue(ref2, dirtyLevel = 4, newVal) { |
|
ref2 = toRaw(ref2); |
|
const dep = ref2.dep; |
|
if (dep) { |
|
triggerEffects( |
|
dep, |
|
dirtyLevel, |
|
{ |
|
target: ref2, |
|
type: "set", |
|
key: "value", |
|
newValue: newVal |
|
} |
|
); |
|
} |
|
} |
|
function isRef(r2) { |
|
return !!(r2 && r2.__v_isRef === true); |
|
} |
|
function ref(value) { |
|
return createRef(value, false); |
|
} |
|
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 unref(ref2) { |
|
return isRef(ref2) ? ref2.value : ref2; |
|
} |
|
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); |
|
} |
|
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 = ErrorTypeStrings[type] || 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) { |
|
{ |
|
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); |
|
} |
|
} |
|
} |
|
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 p2 = currentFlushPromise || resolvedPromise; |
|
return fn ? p2.then(this ? fn.bind(this) : fn) : p2; |
|
} |
|
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) { |
|
{ |
|
seen = seen || /* @__PURE__ */ new Map(); |
|
} |
|
for (; i < queue.length; i++) { |
|
const cb = queue[i]; |
|
if (cb && cb.pre) { |
|
if (instance && cb.id !== instance.uid) { |
|
continue; |
|
} |
|
if (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; |
|
{ |
|
seen = seen || /* @__PURE__ */ new Map(); |
|
} |
|
for (postFlushIndex = 0; postFlushIndex < activePostFlushCbs.length; postFlushIndex++) { |
|
if (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 diff2 = getId(a) - getId(b); |
|
if (diff2 === 0) { |
|
if (a.pre && !b.pre) |
|
return -1; |
|
if (b.pre && !a.pre) |
|
return 1; |
|
} |
|
return diff2; |
|
}; |
|
function flushJobs(seen) { |
|
isFlushPending = false; |
|
isFlushing = true; |
|
{ |
|
seen = seen || /* @__PURE__ */ new Map(); |
|
} |
|
queue.sort(comparator); |
|
const check = (job) => checkRecursiveUpdates(seen, job); |
|
try { |
|
for (flushIndex = 0; flushIndex < queue.length; flushIndex++) { |
|
const job = queue[flushIndex]; |
|
if (job && job.active !== false) { |
|
if (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, version2) { |
|
emit$1("app:init", app, version2, { |
|
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.appContext.app, |
|
component, |
|
event, |
|
params |
|
); |
|
} |
|
function emit(instance, event, ...rawArgs) { |
|
if (instance.isUnmounted) |
|
return; |
|
const props = instance.vnode.props || EMPTY_OBJ; |
|
{ |
|
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 isModelListener2 = event.startsWith("update:"); |
|
const modelArg = isModelListener2 && 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); |
|
} |
|
} |
|
{ |
|
devtoolsComponentEmit(instance, event, args); |
|
} |
|
{ |
|
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 && isModelListener2) { |
|
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 (!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; |
|
function setCurrentRenderingInstance(instance) { |
|
const prev = currentRenderingInstance; |
|
currentRenderingInstance = instance; |
|
instance && instance.type.__scopeId || null; |
|
return prev; |
|
} |
|
const COMPONENTS = "components"; |
|
function resolveComponent(name, maybeSelfReference) { |
|
return resolveAsset(COMPONENTS, name, true, maybeSelfReference) || name; |
|
} |
|
function resolveAsset(type, name, warnMissing = true, maybeSelfReference = false) { |
|
const instance = currentRenderingInstance || currentInstance; |
|
if (instance) { |
|
const Component2 = instance.type; |
|
if (type === COMPONENTS) { |
|
const selfName = getComponentName( |
|
Component2, |
|
false |
|
); |
|
if (selfName && (selfName === name || selfName === camelize(name) || selfName === capitalize(camelize(name)))) { |
|
return Component2; |
|
} |
|
} |
|
const res = ( |
|
// local registration |
|
// check instance[type] first which is resolved for options API |
|
resolve(instance[type] || Component2[type], name) || // global registration |
|
resolve(instance.appContext[type], name) |
|
); |
|
if (!res && maybeSelfReference) { |
|
return Component2; |
|
} |
|
if (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 { |
|
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 INITIAL_WATCHER_VALUE = {}; |
|
function watch(source, cb, options) { |
|
if (!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: once2, |
|
onTrack, |
|
onTrigger |
|
} = EMPTY_OBJ) { |
|
if (cb && once2) { |
|
const _cb = cb; |
|
cb = (...args) => { |
|
_cb(...args); |
|
unwatch(); |
|
}; |
|
} |
|
if (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 (!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 (once2 !== void 0) { |
|
warn$1( |
|
`watch() "once" option is only respected when using the watch(source, callback, options?) signature.` |
|
); |
|
} |
|
} |
|
const warnInvalidSource = (s2) => { |
|
warn$1( |
|
`Invalid watch source: `, |
|
s2, |
|
`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((s2) => isReactive(s2) || isShallow(s2)); |
|
getter = () => source.map((s2) => { |
|
if (isRef(s2)) { |
|
return s2.value; |
|
} else if (isReactive(s2)) { |
|
return reactiveGetter(s2); |
|
} else if (isFunction(s2)) { |
|
return callWithErrorHandling(s2, instance, 2); |
|
} else { |
|
warnInvalidSource(s2); |
|
} |
|
}); |
|
} 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; |
|
warnInvalidSource(source); |
|
} |
|
if (cb && deep) { |
|
const baseGetter = getter; |
|
getter = () => traverse(baseGetter()); |
|
} |
|
let cleanup; |
|
let onCleanup = (fn) => { |
|
cleanup = effect2.onStop = () => { |
|
callWithErrorHandling(fn, instance, 4); |
|
cleanup = effect2.onStop = void 0; |
|
}; |
|
}; |
|
let oldValue = isMultiSource ? new Array(source.length).fill(INITIAL_WATCHER_VALUE) : INITIAL_WATCHER_VALUE; |
|
const job = () => { |
|
if (!effect2.active || !effect2.dirty) { |
|
return; |
|
} |
|
if (cb) { |
|
const newValue = effect2.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 { |
|
effect2.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 effect2 = new ReactiveEffect2(getter, NOOP, scheduler); |
|
const scope = getCurrentScope(); |
|
const unwatch = () => { |
|
effect2.stop(); |
|
if (scope) { |
|
remove(scope.effects, effect2); |
|
} |
|
}; |
|
{ |
|
effect2.onTrack = onTrack; |
|
effect2.onTrigger = onTrigger; |
|
} |
|
if (cb) { |
|
if (immediate) { |
|
job(); |
|
} else { |
|
oldValue = effect2.run(); |
|
} |
|
} else if (flush === "post") { |
|
queuePostRenderEffect$1( |
|
effect2.run.bind(effect2), |
|
instance && instance.suspense |
|
); |
|
} else { |
|
effect2.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 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 createApp2(rootComponent, rootProps = null) { |
|
if (!isFunction(rootComponent)) { |
|
rootComponent = extend({}, rootComponent); |
|
} |
|
if (rootProps != null && !isObject(rootProps)) { |
|
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) { |
|
{ |
|
warn$1( |
|
`app.config cannot be replaced. Modify individual options instead.` |
|
); |
|
} |
|
}, |
|
use(plugin2, ...options) { |
|
if (installedPlugins.has(plugin2)) { |
|
warn$1(`Plugin has already been applied to target app.`); |
|
} else if (plugin2 && isFunction(plugin2.install)) { |
|
installedPlugins.add(plugin2); |
|
plugin2.install(app, ...options); |
|
} else if (isFunction(plugin2)) { |
|
installedPlugins.add(plugin2); |
|
plugin2(app, ...options); |
|
} else { |
|
warn$1( |
|
`A plugin must either be a function or an object with an "install" function.` |
|
); |
|
} |
|
return app; |
|
}, |
|
mixin(mixin) { |
|
{ |
|
if (!context.mixins.includes(mixin)) { |
|
context.mixins.push(mixin); |
|
} else { |
|
warn$1( |
|
"Mixin has already been applied to target app" + (mixin.name ? `: ${mixin.name}` : "") |
|
); |
|
} |
|
} |
|
return app; |
|
}, |
|
component(name, component) { |
|
{ |
|
validateComponentName(name, context.config); |
|
} |
|
if (!component) { |
|
return context.components[name]; |
|
} |
|
if (context.components[name]) { |
|
warn$1(`Component "${name}" has already been registered in target app.`); |
|
} |
|
context.components[name] = component; |
|
return app; |
|
}, |
|
directive(name, directive) { |
|
{ |
|
validateDirectiveName(name); |
|
} |
|
if (!directive) { |
|
return context.directives[name]; |
|
} |
|
if (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 (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) { |
|
{ |
|
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 { |
|
warn$1(`injection "${String(key)}" not found.`); |
|
} |
|
} else { |
|
warn$1(`inject() can only be used inside setup() or functional components.`); |
|
} |
|
} |
|
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 { |
|
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); |
|
} |
|
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) => shallowReadonly(i.props), |
|
$attrs: (i) => shallowReadonly(i.attrs), |
|
$slots: (i) => shallowReadonly(i.slots), |
|
$refs: (i) => shallowReadonly(i.refs), |
|
$parent: (i) => getPublicInstance(i.parent), |
|
$root: (i) => getPublicInstance(i.root), |
|
$emit: (i) => i.emit, |
|
$options: (i) => resolveMergedOptions(i), |
|
$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) => instanceWatch.bind(i) |
|
}) |
|
); |
|
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 (key === "__isVue") { |
|
return true; |
|
} |
|
let normalizedProps; |
|
if (key[0] !== "$") { |
|
const n2 = accessCache[key]; |
|
if (n2 !== void 0) { |
|
switch (n2) { |
|
case 1: |
|
return setupState[key]; |
|
case 2: |
|
return data[key]; |
|
case 4: |
|
return ctx[key]; |
|
case 3: |
|
return props[key]; |
|
} |
|
} else if (hasSetupBinding(setupState, key)) { |
|
accessCache[key] = 1; |
|
return setupState[key]; |
|
} else if (data !== EMPTY_OBJ && hasOwn(data, key)) { |
|
accessCache[key] = 2; |
|
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; |
|
return props[key]; |
|
} else if (ctx !== EMPTY_OBJ && hasOwn(ctx, key)) { |
|
accessCache[key] = 4; |
|
return ctx[key]; |
|
} else if (shouldCacheAccess) { |
|
accessCache[key] = 0; |
|
} |
|
} |
|
const publicGetter = publicPropertiesMap[key]; |
|
let cssModule, globalProperties; |
|
if (publicGetter) { |
|
if (key === "$attrs") { |
|
track(instance, "get", key); |
|
} else if (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; |
|
return ctx[key]; |
|
} else if ( |
|
// global properties |
|
globalProperties = appContext.config.globalProperties, hasOwn(globalProperties, key) |
|
) { |
|
{ |
|
return globalProperties[key]; |
|
} |
|
} else if (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 (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)) { |
|
warn$1(`Attempting to mutate prop "${key}". Props are readonly.`); |
|
return false; |
|
} |
|
if (key[0] === "$" && key.slice(1) in instance) { |
|
warn$1( |
|
`Attempting to mutate public property "${key}". Properties starting with $ are reserved and readonly.` |
|
); |
|
return false; |
|
} else { |
|
if (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); |
|
} |
|
}; |
|
{ |
|
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 |
|
}); |
|
} |
|
}); |
|
} |
|
function normalizePropsOrEmits(props) { |
|
return isArray(props) ? props.reduce( |
|
(normalized, p2) => (normalized[p2] = null, normalized), |
|
{} |
|
) : props; |
|
} |
|
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$1(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 = createDuplicateChecker(); |
|
{ |
|
const [propsOptions] = instance.propsOptions; |
|
if (propsOptions) { |
|
for (const key in propsOptions) { |
|
checkDuplicateProperties("Props", key); |
|
} |
|
} |
|
} |
|
if (injectOptions) { |
|
resolveInjections(injectOptions, ctx, checkDuplicateProperties); |
|
} |
|
if (methods) { |
|
for (const key in methods) { |
|
const methodHandler = methods[key]; |
|
if (isFunction(methodHandler)) { |
|
{ |
|
Object.defineProperty(ctx, key, { |
|
value: methodHandler.bind(publicThis), |
|
configurable: true, |
|
enumerable: true, |
|
writable: true |
|
}); |
|
} |
|
{ |
|
checkDuplicateProperties("Methods", key); |
|
} |
|
} else { |
|
warn$1( |
|
`Method "${key}" has type "${typeof methodHandler}" in the component definition. Did you reference the function correctly?` |
|
); |
|
} |
|
} |
|
} |
|
if (dataOptions) { |
|
if (!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 (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)) { |
|
warn$1(`data() should return an object.`); |
|
} else { |
|
instance.data = reactive(data); |
|
{ |
|
for (const key in data) { |
|
checkDuplicateProperties("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 get2 = isFunction(opt) ? opt.bind(publicThis, publicThis) : isFunction(opt.get) ? opt.get.bind(publicThis, publicThis) : NOOP; |
|
if (get2 === NOOP) { |
|
warn$1(`Computed property "${key}" has no getter.`); |
|
} |
|
const set2 = !isFunction(opt) && isFunction(opt.set) ? opt.set.bind(publicThis) : () => { |
|
warn$1( |
|
`Write operation failed: computed property "${key}" is readonly.` |
|
); |
|
}; |
|
const c2 = computed({ |
|
get: get2, |
|
set: set2 |
|
}); |
|
Object.defineProperty(ctx, key, { |
|
enumerable: true, |
|
configurable: true, |
|
get: () => c2.value, |
|
set: (v) => c2.value = v |
|
}); |
|
{ |
|
checkDuplicateProperties("Computed", key); |
|
} |
|
} |
|
} |
|
if (watchOptions) { |
|
for (const key in watchOptions) { |
|
createWatcher(watchOptions[key], ctx, publicThis, key); |
|
} |
|
} |
|
{ |
|
if (provideOptions) { |
|
const provides = isFunction(provideOptions) ? provideOptions.call(publicThis) : provideOptions; |
|
Reflect.ownKeys(provides).forEach((key) => { |
|
provide(key, provides[key]); |
|
}); |
|
} |
|
} |
|
{ |
|
if (created) { |
|
callHook$1(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; |
|
} |
|
{ |
|
checkDuplicateProperties("Inject", key); |
|
} |
|
} |
|
} |
|
function callHook$1(hook, instance, type) { |
|
callWithAsyncErrorHandling( |
|
isArray(hook) ? hook.map((h2) => h2.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 { |
|
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((r2) => createWatcher(r2, ctx, publicThis, key)); |
|
} else { |
|
const handler = isFunction(raw.handler) ? raw.handler.bind(publicThis) : ctx[raw.handler]; |
|
if (isFunction(handler)) { |
|
watch(getter, handler, raw); |
|
} else { |
|
warn$1(`Invalid watch handler specified by key "${raw.handler}"`, handler); |
|
} |
|
} |
|
} else { |
|
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( |
|
(m2) => mergeOptions(resolved, m2, 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( |
|
(m2) => mergeOptions(to, m2, strats, true) |
|
); |
|
} |
|
for (const key in from) { |
|
if (asMixin && key === "expose") { |
|
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$1(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; |
|
} |
|
} |
|
{ |
|
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) { |
|
while (instance) { |
|
if (instance.type.__hmrId) |
|
return true; |
|
instance = instance.parent; |
|
} |
|
} |
|
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 |
|
!isInHmrContext(instance) && (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"); |
|
} |
|
{ |
|
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 (!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 (!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 (!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 { |
|
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((t2) => isSameType(t2, 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, |
|
shallowReadonly(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 t2 = typeof value; |
|
valid = t2 === expectedType.toLowerCase(); |
|
if (!valid && t2 === "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}`); |
|
} |
|
{ |
|
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); |
|
} |
|
{ |
|
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 Fragment = Symbol.for("v-fgt"); |
|
const Text = Symbol.for("v-txt"); |
|
const Comment = Symbol.for("v-cmt"); |
|
const Static = Symbol.for("v-stc"); |
|
function isVNode(value) { |
|
return value ? value.__v_isVNode === true : false; |
|
} |
|
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 |
|
}; |
|
{ |
|
instance.ctx = createDevRenderContext(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$1(instance, props, isStateful, isSSR); |
|
const setupResult = isStateful ? setupStatefulComponent(instance, isSSR) : void 0; |
|
isSSR && setInSSRSetupState(false); |
|
return setupResult; |
|
} |
|
function setupStatefulComponent(instance, isSSR) { |
|
const Component2 = instance.type; |
|
{ |
|
if (Component2.name) { |
|
validateComponentName(Component2.name, instance.appContext.config); |
|
} |
|
if (Component2.components) { |
|
const names = Object.keys(Component2.components); |
|
for (let i = 0; i < names.length; i++) { |
|
validateComponentName(names[i], instance.appContext.config); |
|
} |
|
} |
|
if (Component2.directives) { |
|
const names = Object.keys(Component2.directives); |
|
for (let i = 0; i < names.length; i++) { |
|
validateDirectiveName(names[i]); |
|
} |
|
} |
|
if (Component2.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)); |
|
{ |
|
exposePropsOnRenderContext(instance); |
|
} |
|
const { setup } = Component2; |
|
if (setup) { |
|
const setupContext = instance.setupContext = setup.length > 1 ? createSetupContext(instance) : null; |
|
const reset = setCurrentInstance(instance); |
|
pauseTracking(); |
|
const setupResult = callWithErrorHandling( |
|
setup, |
|
instance, |
|
0, |
|
[ |
|
shallowReadonly(instance.props), |
|
setupContext |
|
] |
|
); |
|
resetTracking(); |
|
reset(); |
|
if (isPromise(setupResult)) { |
|
setupResult.then(unsetCurrentInstance, unsetCurrentInstance); |
|
{ |
|
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 (isVNode(setupResult)) { |
|
warn$1( |
|
`setup() should not return VNodes directly - return a render function instead.` |
|
); |
|
} |
|
{ |
|
instance.devtoolsRawSetupState = setupResult; |
|
} |
|
instance.setupState = proxyRefs(setupResult); |
|
{ |
|
exposeSetupStateOnRenderContext(instance); |
|
} |
|
} else if (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 Component2 = instance.type; |
|
if (!instance.render) { |
|
instance.render = Component2.render || NOOP; |
|
} |
|
{ |
|
const reset = setCurrentInstance(instance); |
|
pauseTracking(); |
|
try { |
|
applyOptions$1(instance); |
|
} finally { |
|
resetTracking(); |
|
reset(); |
|
} |
|
} |
|
if (!Component2.render && instance.render === NOOP && !isSSR) { |
|
if (Component2.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, |
|
{ |
|
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; |
|
} |
|
} |
|
)); |
|
} |
|
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 (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 || {}; |
|
}; |
|
{ |
|
return Object.freeze({ |
|
get attrs() { |
|
return getAttrsProxy(instance); |
|
}, |
|
get slots() { |
|
return getSlotsProxy(instance); |
|
}, |
|
get emit() { |
|
return (event, ...args) => instance.emit(event, ...args); |
|
}, |
|
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, (c2) => c2.toUpperCase()).replace(/[-_]/g, ""); |
|
function getComponentName(Component2, includeInferred = true) { |
|
return isFunction(Component2) ? Component2.displayName || Component2.name : Component2.name || includeInferred && Component2.__name; |
|
} |
|
function formatComponentName(instance, Component2, isRoot = false) { |
|
let name = getComponentName(Component2); |
|
if (!name && Component2.__file) { |
|
const match = Component2.__file.match(/([^/\\]+)\.\w+$/); |
|
if (match) { |
|
name = match[1]; |
|
} |
|
} |
|
if (!name && instance && instance.parent) { |
|
const inferFromRegistry = (registry) => { |
|
for (const key in registry) { |
|
if (registry[key] === Component2) { |
|
return key; |
|
} |
|
} |
|
}; |
|
name = inferFromRegistry( |
|
instance.components || instance.parent.type.components |
|
) || inferFromRegistry(instance.appContext.components); |
|
} |
|
return name ? classify(name) : isRoot ? `App` : `Anonymous`; |
|
} |
|
const computed = (getterOrOptions, debugOptions) => { |
|
const c2 = computed$1(getterOrOptions, debugOptions, isInSSRComponentSetup); |
|
{ |
|
const i = getCurrentInstance(); |
|
if (i && i.appContext.config.warnRecursiveComputed) { |
|
c2._warnRecursive = true; |
|
} |
|
} |
|
return c2; |
|
}; |
|
const version = "3.4.21"; |
|
const warn = warn$1; |
|
function unwrapper(target) { |
|
return unref(target); |
|
} |
|
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, index2) => { |
|
syncKeys(current[index2], 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, index2) => { |
|
_diff( |
|
item, |
|
preValue[index2], |
|
(path == "" ? "" : path + ".") + key + "[" + index2 + "]", |
|
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, index2) => { |
|
_diff(item, pre[index2], path + "[" + index2 + "]", 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) { |
|
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)) { |
|
return nextTick$1(fn && fn.bind(instance.proxy)); |
|
} |
|
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((resolve2) => { |
|
_resolve = resolve2; |
|
}); |
|
} |
|
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); |
|
const ctx = instance.ctx; |
|
const mpType = ctx.mpType; |
|
if (mpType === "page" || mpType === "component") { |
|
data.r0 = 1; |
|
const mpInstance = ctx.$scope; |
|
const keys = Object.keys(data); |
|
const diffData = diff(data, oldData || getMPInstanceData(mpInstance, keys)); |
|
if (Object.keys(diffData).length) { |
|
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, |
|
ctx: { $scope, $mpPlatform } |
|
} = instance; |
|
if ($mpPlatform === "mp-alipay") { |
|
return; |
|
} |
|
if (!$templateRefs || !$scope) { |
|
return; |
|
} |
|
if (isUnmount) { |
|
return $templateRefs.forEach( |
|
(templateRef) => setTemplateRef(templateRef, null, setupState) |
|
); |
|
} |
|
const check = $mpPlatform === "mp-baidu" || $mpPlatform === "mp-toutiao"; |
|
const doSetByRefs = (refs) => { |
|
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 = () => { |
|
const refs = doSetByRefs($templateRefs); |
|
if (refs.length && instance.proxy && instance.proxy.$scope) { |
|
instance.proxy.$scope.setData({ r1: 1 }, () => { |
|
doSetByRefs(refs); |
|
}); |
|
} |
|
}; |
|
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: r2, f: f2 }, refValue, setupState) { |
|
if (isFunction(r2)) { |
|
r2(refValue, {}); |
|
} else { |
|
const _isString = isString(r2); |
|
const _isRef = isRef(r2); |
|
if (_isString || _isRef) { |
|
if (f2) { |
|
if (!_isRef) { |
|
return; |
|
} |
|
if (!isArray(r2.value)) { |
|
r2.value = []; |
|
} |
|
const existing = r2.value; |
|
if (existing.indexOf(refValue) === -1) { |
|
existing.push(refValue); |
|
if (!refValue) { |
|
return; |
|
} |
|
onBeforeUnmount(() => remove(existing, refValue), refValue.$); |
|
} |
|
} else if (_isString) { |
|
if (hasOwn(setupState, r2)) { |
|
setupState[r2] = refValue; |
|
} |
|
} else if (isRef(r2)) { |
|
r2.value = refValue; |
|
} else { |
|
warnRef(r2); |
|
} |
|
} else { |
|
warnRef(r2); |
|
} |
|
} |
|
} |
|
function warnRef(ref2) { |
|
warn("Invalid template ref type:", ref2, `(${typeof ref2})`); |
|
} |
|
const queuePostRenderEffect = queuePostFlushCb; |
|
function mountComponent(initialVNode, options) { |
|
const instance = initialVNode.component = createComponentInstance(initialVNode, options.parentComponent, null); |
|
{ |
|
instance.ctx.$onApplyOptions = onApplyOptions; |
|
instance.ctx.$children = []; |
|
} |
|
if (options.mpType === "app") { |
|
instance.render = NOOP; |
|
} |
|
if (options.onBeforeSetup) { |
|
options.onBeforeSetup(instance, options); |
|
} |
|
{ |
|
pushWarningContext(initialVNode); |
|
startMeasure(instance, `mount`); |
|
} |
|
{ |
|
startMeasure(instance, `init`); |
|
} |
|
setupComponent(instance); |
|
{ |
|
endMeasure(instance, `init`); |
|
} |
|
{ |
|
if (options.parentComponent && instance.proxy) { |
|
options.parentComponent.ctx.$children.push(getExposeProxy(instance) || instance.proxy); |
|
} |
|
} |
|
setupRenderEffect(instance); |
|
{ |
|
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: Component2, |
|
vnode, |
|
proxy, |
|
withProxy, |
|
props, |
|
propsOptions: [propsOptions], |
|
slots, |
|
attrs, |
|
emit: emit2, |
|
render, |
|
renderCache, |
|
data, |
|
setupState, |
|
ctx, |
|
uid: uid2, |
|
appContext: { |
|
app: { |
|
config: { |
|
globalProperties: { pruneComponentPropsCache: pruneComponentPropsCache2 } |
|
} |
|
} |
|
}, |
|
inheritAttrs |
|
} = instance; |
|
instance.$templateRefs = []; |
|
instance.$ei = 0; |
|
pruneComponentPropsCache2(uid2); |
|
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, |
|
Component2.props ? attrs : getFunctionalFallthrough(attrs) |
|
); |
|
const render2 = Component2; |
|
result = render2.length > 1 ? render2(props, { attrs, slots, emit: emit2 }) : 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 mpInstance = this.ctx.$scope; |
|
const oldData = mpInstance.data; |
|
const diffData = /* @__PURE__ */ Object.create(null); |
|
scopedSlotsData.forEach(({ path, index: index2, data }) => { |
|
const oldScopedSlotData = getValueByDataPath(oldData, path); |
|
const diffPath = isString(index2) ? `${path}.${index2}` : `${path}[${index2}]`; |
|
if (typeof oldScopedSlotData === "undefined" || typeof oldScopedSlotData[index2] === "undefined") { |
|
diffData[diffPath] = data; |
|
} else { |
|
const diffScopedSlotData = diff( |
|
data, |
|
oldScopedSlotData[index2] |
|
); |
|
Object.keys(diffScopedSlotData).forEach((name) => { |
|
diffData[diffPath + "." + name] = diffScopedSlotData[name]; |
|
}); |
|
} |
|
}); |
|
scopedSlotsData.length = 0; |
|
if (Object.keys(diffData).length) { |
|
mpInstance.setData(diffData); |
|
} |
|
} |
|
function toggleRecurse({ effect: effect2, update }, allowed) { |
|
effect2.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); |
|
{ |
|
startMeasure(instance, `patch`); |
|
} |
|
patch(instance, renderComponentRoot(instance)); |
|
{ |
|
endMeasure(instance, `patch`); |
|
} |
|
{ |
|
devtoolsComponentAdded(instance); |
|
} |
|
} else { |
|
const { next, bu, u } = instance; |
|
{ |
|
pushWarningContext(next || instance.vnode); |
|
} |
|
toggleRecurse(instance, false); |
|
updateComponentPreRender(); |
|
if (bu) { |
|
invokeArrayFns$1(bu); |
|
} |
|
toggleRecurse(instance, true); |
|
{ |
|
startMeasure(instance, `patch`); |
|
} |
|
patch(instance, renderComponentRoot(instance)); |
|
{ |
|
endMeasure(instance, `patch`); |
|
} |
|
if (u) { |
|
queuePostRenderEffect(u); |
|
} |
|
{ |
|
devtoolsComponentUpdated(instance); |
|
} |
|
{ |
|
popWarningContext(); |
|
} |
|
} |
|
}; |
|
const effect2 = instance.effect = new ReactiveEffect2( |
|
componentUpdateFn, |
|
NOOP, |
|
() => queueJob(update), |
|
instance.scope |
|
// track it in component's effect scope |
|
); |
|
const update = instance.update = () => { |
|
if (effect2.dirty) { |
|
effect2.run(); |
|
} |
|
}; |
|
update.id = instance.uid; |
|
toggleRecurse(instance, true); |
|
{ |
|
effect2.onTrack = instance.rtc ? (e2) => invokeArrayFns$1(instance.rtc, e2) : void 0; |
|
effect2.onTrigger = instance.rtg ? (e2) => invokeArrayFns$1(instance.rtg, e2) : void 0; |
|
update.ownerInstance = instance; |
|
} |
|
update(); |
|
} |
|
function unmountComponent(instance) { |
|
const { bum, scope, update, um } = instance; |
|
if (bum) { |
|
invokeArrayFns$1(bum); |
|
} |
|
scope.stop(); |
|
if (update) { |
|
update.active = false; |
|
} |
|
if (um) { |
|
queuePostRenderEffect(um); |
|
} |
|
queuePostRenderEffect(() => { |
|
instance.isUnmounted = true; |
|
}); |
|
{ |
|
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; |
|
{ |
|
setDevtoolsHook(target.__VUE_DEVTOOLS_GLOBAL_HOOK__, target); |
|
} |
|
const app = oldCreateApp(rootComponent, rootProps); |
|
const appContext = app._context; |
|
initAppConfig(appContext.config); |
|
const createVNode2 = (initialVNode) => { |
|
initialVNode.appContext = appContext; |
|
initialVNode.shapeFlag = 6; |
|
return initialVNode; |
|
}; |
|
const createComponent2 = function createComponent22(initialVNode, options) { |
|
return mountComponent(createVNode2(initialVNode), options); |
|
}; |
|
const destroyComponent = function destroyComponent2(component) { |
|
return component && unmountComponent(component.$); |
|
}; |
|
app.mount = function mount() { |
|
rootComponent.render = NOOP; |
|
const instance = mountComponent( |
|
createVNode2({ type: rootComponent }), |
|
{ |
|
mpType: "app", |
|
mpInstance: null, |
|
parentComponent: null, |
|
slots: [], |
|
props: null |
|
} |
|
); |
|
app._instance = instance.$; |
|
{ |
|
devtoolsInitApp(app, version); |
|
} |
|
instance.$app = app; |
|
instance.$createComponent = createComponent2; |
|
instance.$destroyComponent = destroyComponent; |
|
appContext.$appInstance = instance; |
|
return instance; |
|
}; |
|
app.unmount = function unmount() { |
|
warn(`Cannot unmount an app.`); |
|
}; |
|
return app; |
|
} |
|
function injectLifecycleHook(name, hook, publicThis, instance) { |
|
if (isFunction(hook)) { |
|
injectHook(name, hook.bind(publicThis), instance); |
|
} |
|
} |
|
function initHooks$1(options, instance, publicThis) { |
|
const mpType = options.mpType || publicThis.$mpType; |
|
if (!mpType || mpType === "component") { |
|
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$2(options, instance, publicThis) { |
|
initHooks$1(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."); |
|
} |
|
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 { |
|
realAtob = atob; |
|
} |
|
function b64DecodeUnicode(str) { |
|
return decodeURIComponent(realAtob(str).split("").map(function(c2) { |
|
return "%" + ("00" + c2.charCodeAt(0).toString(16)).slice(-2); |
|
}).join("")); |
|
} |
|
function getCurrentUserInfo() { |
|
const token = index.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 * 1e3; |
|
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); |
|
} |
|
{ |
|
globalProperties.$set = set; |
|
globalProperties.$applyOptions = applyOptions$2; |
|
globalProperties.$callMethod = $callMethod; |
|
} |
|
{ |
|
index.invokeCreateVueAppHook(app); |
|
} |
|
} |
|
const propsCaches = /* @__PURE__ */ Object.create(null); |
|
function pruneComponentPropsCache(uid2) { |
|
delete propsCaches[uid2]; |
|
} |
|
function findComponentPropsData(up) { |
|
if (!up) { |
|
return; |
|
} |
|
const [uid2, propsId] = up.split(","); |
|
if (!propsCaches[uid2]) { |
|
return; |
|
} |
|
return propsCaches[uid2][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 createApp2 = getCreateApp(); |
|
if (createApp2) { |
|
createApp2(instance); |
|
} else { |
|
if (typeof createMiniProgramApp !== "undefined") { |
|
createMiniProgramApp(instance); |
|
} |
|
} |
|
return instance; |
|
}; |
|
} |
|
}; |
|
function getCreateApp() { |
|
const method = "createApp"; |
|
if (typeof global !== "undefined" && typeof global[method] !== "undefined") { |
|
return global[method]; |
|
} else if (typeof my !== "undefined") { |
|
return my[method]; |
|
} |
|
} |
|
function vOn(value, key) { |
|
const instance = getCurrentInstance(); |
|
const ctx = instance.ctx; |
|
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) { |
|
delete mpInstance[name]; |
|
return name; |
|
} |
|
const existingInvoker = mpInstance[name]; |
|
if (existingInvoker) { |
|
existingInvoker.value = value; |
|
} else { |
|
mpInstance[name] = createInvoker(value, instance); |
|
} |
|
return name; |
|
} |
|
function createInvoker(initialValue, instance) { |
|
const invoker = (e2) => { |
|
patchMPEvent(e2); |
|
let args = [e2]; |
|
if (e2.detail && e2.detail.__args__) { |
|
args = e2.detail.__args__; |
|
} |
|
const eventValue = invoker.value; |
|
const invoke = () => callWithAsyncErrorHandling(patchStopImmediatePropagation(e2, eventValue), instance, 5, args); |
|
const eventTarget = e2.target; |
|
const eventSync = eventTarget ? eventTarget.dataset ? String(eventTarget.dataset.eventsync) === "true" : false : false; |
|
if (bubbles.includes(e2.type) && !eventSync) { |
|
setTimeout(invoke); |
|
} else { |
|
const res = invoke(); |
|
if (e2.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 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; |
|
} |
|
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); |
|
} |
|
} |
|
} |
|
function patchStopImmediatePropagation(e2, value) { |
|
if (isArray(value)) { |
|
const originalStop = e2.stopImmediatePropagation; |
|
e2.stopImmediatePropagation = () => { |
|
originalStop && originalStop.call(e2); |
|
e2._stopped = true; |
|
}; |
|
return value.map((fn) => (e3) => !e3._stopped && fn(e3)); |
|
} else { |
|
return value; |
|
} |
|
} |
|
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 (!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 stringifyStyle(value) { |
|
if (isString(value)) { |
|
return value; |
|
} |
|
return stringify(normalizeStyle(value)); |
|
} |
|
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; |
|
} |
|
const o = (value, key) => vOn(value, key); |
|
const f = (source, renderItem) => vFor(source, renderItem); |
|
const s = (value) => stringifyStyle(value); |
|
function createApp$1(rootComponent, rootProps = null) { |
|
rootComponent && (rootComponent.mpType = "app"); |
|
return createVueApp(rootComponent, rootProps).use(plugin); |
|
} |
|
const createSSRApp = createApp$1; |
|
const MP_METHODS = [ |
|
"createSelectorQuery", |
|
"createIntersectionObserver", |
|
"selectAllComponents", |
|
"selectComponent" |
|
]; |
|
function createEmitFn(oldEmit, ctx) { |
|
return function emit2(event, ...args) { |
|
const scope = ctx.$scope; |
|
if (scope && event) { |
|
const detail = { __args__: args }; |
|
{ |
|
scope.triggerEvent(event, detail); |
|
} |
|
} |
|
return oldEmit.apply(this, [event, ...args]); |
|
}; |
|
} |
|
function initBaseInstance(instance, options) { |
|
const ctx = instance.ctx; |
|
ctx.mpType = options.mpType; |
|
ctx.$mpType = options.mpType; |
|
ctx.$mpPlatform = "mp-weixin"; |
|
ctx.$scope = options.mpInstance; |
|
ctx.$mp = {}; |
|
{ |
|
ctx._self = {}; |
|
} |
|
instance.slots = {}; |
|
if (isArray(options.slots) && options.slots.length) { |
|
options.slots.forEach((name) => { |
|
instance.slots[name] = true; |
|
}); |
|
if (instance.slots[SLOT_DEFAULT_NAME]) { |
|
instance.slots.default = true; |
|
} |
|
} |
|
ctx.getOpenerEventChannel = function() { |
|
{ |
|
return options.mpInstance.getOpenerEventChannel(); |
|
} |
|
}; |
|
ctx.$hasHook = hasHook; |
|
ctx.$callHook = callHook; |
|
instance.emit = createEmitFn(instance.emit, ctx); |
|
} |
|
function initComponentInstance(instance, options) { |
|
initBaseInstance(instance, options); |
|
const ctx = instance.ctx; |
|
MP_METHODS.forEach((method) => { |
|
ctx[method] = function(...args) { |
|
const mpInstance = ctx.$scope; |
|
if (mpInstance && mpInstance[method]) { |
|
return mpInstance[method].apply(mpInstance, args); |
|
} |
|
}; |
|
}); |
|
} |
|
function initMocks(instance, mpInstance, mocks2) { |
|
const ctx = instance.ctx; |
|
mocks2.forEach((mock) => { |
|
if (hasOwn(mpInstance, mock)) { |
|
instance[mock] = ctx[mock] = mpInstance[mock]; |
|
} |
|
}); |
|
} |
|
function hasHook(name) { |
|
const hooks = this.$[name]; |
|
if (hooks && hooks.length) { |
|
return true; |
|
} |
|
return false; |
|
} |
|
function callHook(name, args) { |
|
if (name === "mounted") { |
|
callHook.call(this, "bm"); |
|
this.$.isMounted = true; |
|
name = "m"; |
|
} |
|
const hooks = this.$[name]; |
|
return hooks && invokeArrayFns(hooks, args); |
|
} |
|
const PAGE_INIT_HOOKS = [ |
|
ON_LOAD, |
|
ON_SHOW, |
|
ON_HIDE, |
|
ON_UNLOAD, |
|
ON_RESIZE, |
|
ON_TAB_ITEM_TAP, |
|
ON_REACH_BOTTOM, |
|
ON_PULL_DOWN_REFRESH, |
|
ON_ADD_TO_FAVORITES |
|
// 'onReady', // lifetimes.ready |
|
// 'onPageScroll', // 影响性能，开发者手动注册 |
|
// 'onShareTimeline', // 右上角菜单，开发者手动注册 |
|
// 'onShareAppMessage' // 右上角菜单，开发者手动注册 |
|
]; |
|
function findHooks(vueOptions, hooks = /* @__PURE__ */ new Set()) { |
|
if (vueOptions) { |
|
Object.keys(vueOptions).forEach((name) => { |
|
if (isUniLifecycleHook(name, vueOptions[name])) { |
|
hooks.add(name); |
|
} |
|
}); |
|
{ |
|
const { extends: extendsOptions, mixins } = vueOptions; |
|
if (mixins) { |
|
mixins.forEach((mixin) => findHooks(mixin, hooks)); |
|
} |
|
if (extendsOptions) { |
|
findHooks(extendsOptions, hooks); |
|
} |
|
} |
|
} |
|
return hooks; |
|
} |
|
function initHook(mpOptions, hook, excludes) { |
|
if (excludes.indexOf(hook) === -1 && !hasOwn(mpOptions, hook)) { |
|
mpOptions[hook] = function(args) { |
|
return this.$vm && this.$vm.$callHook(hook, args); |
|
}; |
|
} |
|
} |
|
const EXCLUDE_HOOKS = [ON_READY]; |
|
function initHooks(mpOptions, hooks, excludes = EXCLUDE_HOOKS) { |
|
hooks.forEach((hook) => initHook(mpOptions, hook, excludes)); |
|
} |
|
function initUnknownHooks(mpOptions, vueOptions, excludes = EXCLUDE_HOOKS) { |
|
findHooks(vueOptions).forEach((hook) => initHook(mpOptions, hook, excludes)); |
|
} |
|
function initRuntimeHooks(mpOptions, runtimeHooks) { |
|
if (!runtimeHooks) { |
|
return; |
|
} |
|
const hooks = Object.keys(MINI_PROGRAM_PAGE_RUNTIME_HOOKS); |
|
hooks.forEach((hook) => { |
|
if (runtimeHooks & MINI_PROGRAM_PAGE_RUNTIME_HOOKS[hook]) { |
|
initHook(mpOptions, hook, []); |
|
} |
|
}); |
|
} |
|
const findMixinRuntimeHooks = /* @__PURE__ */ once(() => { |
|
const runtimeHooks = []; |
|
const app = isFunction(getApp) && getApp({ allowDefault: true }); |
|
if (app && app.$vm && app.$vm.$) { |
|
const mixins = app.$vm.$.appContext.mixins; |
|
if (isArray(mixins)) { |
|
const hooks = Object.keys(MINI_PROGRAM_PAGE_RUNTIME_HOOKS); |
|
mixins.forEach((mixin) => { |
|
hooks.forEach((hook) => { |
|
if (hasOwn(mixin, hook) && !runtimeHooks.includes(hook)) { |
|
runtimeHooks.push(hook); |
|
} |
|
}); |
|
}); |
|
} |
|
} |
|
return runtimeHooks; |
|
}); |
|
function initMixinRuntimeHooks(mpOptions) { |
|
initHooks(mpOptions, findMixinRuntimeHooks()); |
|
} |
|
const HOOKS = [ |
|
ON_SHOW, |
|
ON_HIDE, |
|
ON_ERROR, |
|
ON_THEME_CHANGE, |
|
ON_PAGE_NOT_FOUND, |
|
ON_UNHANDLE_REJECTION |
|
]; |
|
function parseApp(instance, parseAppOptions) { |
|
const internalInstance = instance.$; |
|
const appOptions = { |
|
globalData: instance.$options && instance.$options.globalData || {}, |
|
$vm: instance, |
|
// mp-alipay 组件 data 初始化比 onLaunch 早，提前挂载 |
|
onLaunch(options) { |
|
this.$vm = instance; |
|
const ctx = internalInstance.ctx; |
|
if (this.$vm && ctx.$scope) { |
|
return; |
|
} |
|
initBaseInstance(internalInstance, { |
|
mpType: "app", |
|
mpInstance: this, |
|
slots: [] |
|
}); |
|
ctx.globalData = this.globalData; |
|
instance.$callHook(ON_LAUNCH, options); |
|
} |
|
}; |
|
const { onError } = internalInstance; |
|
if (onError) { |
|
internalInstance.appContext.config.errorHandler = (err) => { |
|
instance.$callHook(ON_ERROR, err); |
|
}; |
|
} |
|
initLocale(instance); |
|
const vueOptions = instance.$.type; |
|
initHooks(appOptions, HOOKS); |
|
initUnknownHooks(appOptions, vueOptions); |
|
{ |
|
const methods = vueOptions.methods; |
|
methods && extend(appOptions, methods); |
|
} |
|
if (parseAppOptions) { |
|
parseAppOptions.parse(appOptions); |
|
} |
|
return appOptions; |
|
} |
|
function initCreateApp(parseAppOptions) { |
|
return function createApp2(vm) { |
|
return App(parseApp(vm, parseAppOptions)); |
|
}; |
|
} |
|
function initCreateSubpackageApp(parseAppOptions) { |
|
return function createApp2(vm) { |
|
const appOptions = parseApp(vm, parseAppOptions); |
|
const app = isFunction(getApp) && getApp({ |
|
allowDefault: true |
|
}); |
|
if (!app) |
|
return; |
|
vm.$.ctx.$scope = app; |
|
const globalData = app.globalData; |
|
if (globalData) { |
|
Object.keys(appOptions.globalData).forEach((name) => { |
|
if (!hasOwn(globalData, name)) { |
|
globalData[name] = appOptions.globalData[name]; |
|
} |
|
}); |
|
} |
|
Object.keys(appOptions).forEach((name) => { |
|
if (!hasOwn(app, name)) { |
|
app[name] = appOptions[name]; |
|
} |
|
}); |
|
initAppLifecycle(appOptions, vm); |
|
}; |
|
} |
|
function initAppLifecycle(appOptions, vm) { |
|
if (isFunction(appOptions.onLaunch)) { |
|
const args = wx.getLaunchOptionsSync && wx.getLaunchOptionsSync(); |
|
appOptions.onLaunch(args); |
|
} |
|
if (isFunction(appOptions.onShow) && wx.onAppShow) { |
|
wx.onAppShow((args) => { |
|
vm.$callHook("onShow", args); |
|
}); |
|
} |
|
if (isFunction(appOptions.onHide) && wx.onAppHide) { |
|
wx.onAppHide((args) => { |
|
vm.$callHook("onHide", args); |
|
}); |
|
} |
|
} |
|
function initLocale(appVm) { |
|
const locale = ref(normalizeLocale(wx.getSystemInfoSync().language) || LOCALE_EN); |
|
Object.defineProperty(appVm, "$locale", { |
|
get() { |
|
return locale.value; |
|
}, |
|
set(v) { |
|
locale.value = v; |
|
} |
|
}); |
|
} |
|
function initVueIds(vueIds, mpInstance) { |
|
if (!vueIds) { |
|
return; |
|
} |
|
const ids = vueIds.split(","); |
|
const len = ids.length; |
|
if (len === 1) { |
|
mpInstance._$vueId = ids[0]; |
|
} else if (len === 2) { |
|
mpInstance._$vueId = ids[0]; |
|
mpInstance._$vuePid = ids[1]; |
|
} |
|
} |
|
const EXTRAS = ["externalClasses"]; |
|
function initExtraOptions(miniProgramComponentOptions, vueOptions) { |
|
EXTRAS.forEach((name) => { |
|
if (hasOwn(vueOptions, name)) { |
|
miniProgramComponentOptions[name] = vueOptions[name]; |
|
} |
|
}); |
|
} |
|
const WORKLET_RE = /_(.*)_worklet_factory_/; |
|
function initWorkletMethods(mpMethods, vueMethods) { |
|
if (vueMethods) { |
|
Object.keys(vueMethods).forEach((name) => { |
|
const matches = name.match(WORKLET_RE); |
|
if (matches) { |
|
const workletName = matches[1]; |
|
mpMethods[name] = vueMethods[name]; |
|
mpMethods[workletName] = vueMethods[workletName]; |
|
} |
|
}); |
|
} |
|
} |
|
function initWxsCallMethods(methods, wxsCallMethods) { |
|
if (!isArray(wxsCallMethods)) { |
|
return; |
|
} |
|
wxsCallMethods.forEach((callMethod) => { |
|
methods[callMethod] = function(args) { |
|
return this.$vm[callMethod](args); |
|
}; |
|
}); |
|
} |
|
function selectAllComponents(mpInstance, selector, $refs) { |
|
const components = mpInstance.selectAllComponents(selector); |
|
components.forEach((component) => { |
|
const ref2 = component.properties.uR; |
|
$refs[ref2] = component.$vm || component; |
|
}); |
|
} |
|
function initRefs(instance, mpInstance) { |
|
Object.defineProperty(instance, "refs", { |
|
get() { |
|
const $refs = {}; |
|
selectAllComponents(mpInstance, ".r", $refs); |
|
const forComponents = mpInstance.selectAllComponents(".r-i-f"); |
|
forComponents.forEach((component) => { |
|
const ref2 = component.properties.uR; |
|
if (!ref2) { |
|
return; |
|
} |
|
if (!$refs[ref2]) { |
|
$refs[ref2] = []; |
|
} |
|
$refs[ref2].push(component.$vm || component); |
|
}); |
|
return $refs; |
|
} |
|
}); |
|
} |
|
function findVmByVueId(instance, vuePid) { |
|
const $children = instance.$children; |
|
for (let i = $children.length - 1; i >= 0; i--) { |
|
const childVm = $children[i]; |
|
if (childVm.$scope._$vueId === vuePid) { |
|
return childVm; |
|
} |
|
} |
|
let parentVm; |
|
for (let i = $children.length - 1; i >= 0; i--) { |
|
parentVm = findVmByVueId($children[i], vuePid); |
|
if (parentVm) { |
|
return parentVm; |
|
} |
|
} |
|
} |
|
const builtInProps = [ |
|
// 百度小程序,快手小程序自定义组件不支持绑定动态事件，动态dataset，故通过props传递事件信息 |
|
// event-opts |
|
"eO", |
|
// 组件 ref |
|
"uR", |
|
// 组件 ref-in-for |
|
"uRIF", |
|
// 组件 id |
|
"uI", |
|
// 组件类型 m: 小程序组件 |
|
"uT", |
|
// 组件 props |
|
"uP", |
|
// 小程序不能直接定义 $slots 的 props，所以通过 vueSlots 转换到 $slots |
|
"uS" |
|
]; |
|
function initDefaultProps(options, isBehavior = false) { |
|
const properties = {}; |
|
if (!isBehavior) { |
|
builtInProps.forEach((name) => { |
|
properties[name] = { |
|
type: null, |
|
value: "" |
|
}; |
|
}); |
|
properties.uS = { |
|
type: null, |
|
value: [], |
|
observer: function(newVal) { |
|
const $slots = /* @__PURE__ */ Object.create(null); |
|
newVal && newVal.forEach((slotName) => { |
|
$slots[slotName] = true; |
|
}); |
|
this.setData({ |
|
$slots |
|
}); |
|
} |
|
}; |
|
} |
|
if (options.behaviors) { |
|
if (options.behaviors.includes("wx://form-field")) { |
|
if (!options.properties || !options.properties.name) { |
|
properties.name = { |
|
type: null, |
|
value: "" |
|
}; |
|
} |
|
if (!options.properties || !options.properties.value) { |
|
properties.value = { |
|
type: null, |
|
value: "" |
|
}; |
|
} |
|
} |
|
} |
|
return properties; |
|
} |
|
function initVirtualHostProps(options) { |
|
const properties = {}; |
|
{ |
|
if (options && options.virtualHost) { |
|
properties.virtualHostStyle = { |
|
type: null, |
|
value: "" |
|
}; |
|
properties.virtualHostClass = { |
|
type: null, |
|
value: "" |
|
}; |
|
} |
|
} |
|
return properties; |
|
} |
|
function initProps(mpComponentOptions) { |
|
if (!mpComponentOptions.properties) { |
|
mpComponentOptions.properties = {}; |
|
} |
|
extend(mpComponentOptions.properties, initDefaultProps(mpComponentOptions), initVirtualHostProps(mpComponentOptions.options)); |
|
} |
|
const PROP_TYPES = [String, Number, Boolean, Object, Array, null]; |
|
function parsePropType(type, defaultValue) { |
|
if (isArray(type) && type.length === 1) { |
|
return type[0]; |
|
} |
|
return type; |
|
} |
|
function normalizePropType(type, defaultValue) { |
|
const res = parsePropType(type); |
|
return PROP_TYPES.indexOf(res) !== -1 ? res : null; |
|
} |
|
function initPageProps({ properties }, rawProps) { |
|
if (isArray(rawProps)) { |
|
rawProps.forEach((key) => { |
|
properties[key] = { |
|
type: String, |
|
value: "" |
|
}; |
|
}); |
|
} else if (isPlainObject(rawProps)) { |
|
Object.keys(rawProps).forEach((key) => { |
|
const opts = rawProps[key]; |
|
if (isPlainObject(opts)) { |
|
let value = opts.default; |
|
if (isFunction(value)) { |
|
value = value(); |
|
} |
|
const type = opts.type; |
|
opts.type = normalizePropType(type); |
|
properties[key] = { |
|
type: opts.type, |
|
value |
|
}; |
|
} else { |
|
properties[key] = { |
|
type: normalizePropType(opts) |
|
}; |
|
} |
|
}); |
|
} |
|
} |
|
function findPropsData(properties, isPage2) { |
|
return (isPage2 ? findPagePropsData(properties) : findComponentPropsData(properties.uP)) || {}; |
|
} |
|
function findPagePropsData(properties) { |
|
const propsData = {}; |
|
if (isPlainObject(properties)) { |
|
Object.keys(properties).forEach((name) => { |
|
if (builtInProps.indexOf(name) === -1) { |
|
propsData[name] = properties[name]; |
|
} |
|
}); |
|
} |
|
return propsData; |
|
} |
|
function initFormField(vm) { |
|
const vueOptions = vm.$options; |
|
if (isArray(vueOptions.behaviors) && vueOptions.behaviors.includes("uni://form-field")) { |
|
vm.$watch("modelValue", () => { |
|
vm.$scope && vm.$scope.setData({ |
|
name: vm.name, |
|
value: vm.modelValue |
|
}); |
|
}, { |
|
immediate: true |
|
}); |
|
} |
|
} |
|
function initData(_) { |
|
return {}; |
|
} |
|
function initPropsObserver(componentOptions) { |
|
const observe = function observe2() { |
|
const up = this.properties.uP; |
|
if (!up) { |
|
return; |
|
} |
|
if (this.$vm) { |
|
updateComponentProps(up, this.$vm.$); |
|
} else if (this.properties.uT === "m") { |
|
updateMiniProgramComponentProperties(up, this); |
|
} |
|
}; |
|
{ |
|
if (!componentOptions.observers) { |
|
componentOptions.observers = {}; |
|
} |
|
componentOptions.observers.uP = observe; |
|
} |
|
} |
|
function updateMiniProgramComponentProperties(up, mpInstance) { |
|
const prevProps = mpInstance.properties; |
|
const nextProps = findComponentPropsData(up) || {}; |
|
if (hasPropsChanged(prevProps, nextProps, false)) { |
|
mpInstance.setData(nextProps); |
|
} |
|
} |
|
function updateComponentProps(up, instance) { |
|
const prevProps = toRaw(instance.props); |
|
const nextProps = findComponentPropsData(up) || {}; |
|
if (hasPropsChanged(prevProps, nextProps)) { |
|
updateProps(instance, nextProps, prevProps, false); |
|
if (hasQueueJob(instance.update)) { |
|
invalidateJob(instance.update); |
|
} |
|
{ |
|
instance.update(); |
|
} |
|
} |
|
} |
|
function hasPropsChanged(prevProps, nextProps, checkLen = true) { |
|
const nextKeys = Object.keys(nextProps); |
|
if (checkLen && nextKeys.length !== Object.keys(prevProps).length) { |
|
return true; |
|
} |
|
for (let i = 0; i < nextKeys.length; i++) { |
|
const key = nextKeys[i]; |
|
if (nextProps[key] !== prevProps[key]) { |
|
return true; |
|
} |
|
} |
|
return false; |
|
} |
|
function initBehaviors(vueOptions) { |
|
const vueBehaviors = vueOptions.behaviors; |
|
let vueProps = vueOptions.props; |
|
if (!vueProps) { |
|
vueOptions.props = vueProps = []; |
|
} |
|
const behaviors = []; |
|
if (isArray(vueBehaviors)) { |
|
vueBehaviors.forEach((behavior) => { |
|
behaviors.push(behavior.replace("uni://", "wx://")); |
|
if (behavior === "uni://form-field") { |
|
if (isArray(vueProps)) { |
|
vueProps.push("name"); |
|
vueProps.push("modelValue"); |
|
} else { |
|
vueProps.name = { |
|
type: String, |
|
default: "" |
|
}; |
|
vueProps.modelValue = { |
|
type: [String, Number, Boolean, Array, Object, Date], |
|
default: "" |
|
}; |
|
} |
|
} |
|
}); |
|
} |
|
return behaviors; |
|
} |
|
function applyOptions(componentOptions, vueOptions) { |
|
componentOptions.data = initData(); |
|
componentOptions.behaviors = initBehaviors(vueOptions); |
|
} |
|
function parseComponent(vueOptions, { parse, mocks: mocks2, isPage: isPage2, initRelation: initRelation2, handleLink: handleLink2, initLifetimes: initLifetimes2 }) { |
|
vueOptions = vueOptions.default || vueOptions; |
|
const options = { |
|
multipleSlots: true, |
|
// styleIsolation: 'apply-shared', |
|
addGlobalClass: true, |
|
pureDataPattern: /^uP$/ |
|
}; |
|
if (isArray(vueOptions.mixins)) { |
|
vueOptions.mixins.forEach((item) => { |
|
if (isObject(item.options)) { |
|
extend(options, item.options); |
|
} |
|
}); |
|
} |
|
if (vueOptions.options) { |
|
extend(options, vueOptions.options); |
|
} |
|
const mpComponentOptions = { |
|
options, |
|
lifetimes: initLifetimes2({ mocks: mocks2, isPage: isPage2, initRelation: initRelation2, vueOptions }), |
|
pageLifetimes: { |
|
show() { |
|
this.$vm && this.$vm.$callHook("onPageShow"); |
|
}, |
|
hide() { |
|
this.$vm && this.$vm.$callHook("onPageHide"); |
|
}, |
|
resize(size2) { |
|
this.$vm && this.$vm.$callHook("onPageResize", size2); |
|
} |
|
}, |
|
methods: { |
|
__l: handleLink2 |
|
} |
|
}; |
|
{ |
|
applyOptions(mpComponentOptions, vueOptions); |
|
} |
|
initProps(mpComponentOptions); |
|
initPropsObserver(mpComponentOptions); |
|
initExtraOptions(mpComponentOptions, vueOptions); |
|
initWxsCallMethods(mpComponentOptions.methods, vueOptions.wxsCallMethods); |
|
{ |
|
initWorkletMethods(mpComponentOptions.methods, vueOptions.methods); |
|
} |
|
if (parse) { |
|
parse(mpComponentOptions, { handleLink: handleLink2 }); |
|
} |
|
return mpComponentOptions; |
|
} |
|
function initCreateComponent(parseOptions2) { |
|
return function createComponent2(vueComponentOptions) { |
|
return Component(parseComponent(vueComponentOptions, parseOptions2)); |
|
}; |
|
} |
|
let $createComponentFn; |
|
let $destroyComponentFn; |
|
function getAppVm() { |
|
return getApp().$vm; |
|
} |
|
function $createComponent(initialVNode, options) { |
|
if (!$createComponentFn) { |
|
$createComponentFn = getAppVm().$createComponent; |
|
} |
|
const proxy = $createComponentFn(initialVNode, options); |
|
return getExposeProxy(proxy.$) || proxy; |
|
} |
|
function $destroyComponent(instance) { |
|
if (!$destroyComponentFn) { |
|
$destroyComponentFn = getAppVm().$destroyComponent; |
|
} |
|
return $destroyComponentFn(instance); |
|
} |
|
function parsePage(vueOptions, parseOptions2) { |
|
const { parse, mocks: mocks2, isPage: isPage2, initRelation: initRelation2, handleLink: handleLink2, initLifetimes: initLifetimes2 } = parseOptions2; |
|
const miniProgramPageOptions = parseComponent(vueOptions, { |
|
mocks: mocks2, |
|
isPage: isPage2, |
|
initRelation: initRelation2, |
|
handleLink: handleLink2, |
|
initLifetimes: initLifetimes2 |
|
}); |
|
initPageProps(miniProgramPageOptions, (vueOptions.default || vueOptions).props); |
|
const methods = miniProgramPageOptions.methods; |
|
methods.onLoad = function(query) { |
|
this.options = query; |
|
this.$page = { |
|
fullPath: addLeadingSlash(this.route + stringifyQuery(query)) |
|
}; |
|
return this.$vm && this.$vm.$callHook(ON_LOAD, query); |
|
}; |
|
initHooks(methods, PAGE_INIT_HOOKS); |
|
{ |
|
initUnknownHooks(methods, vueOptions); |
|
} |
|
initRuntimeHooks(methods, vueOptions.__runtimeHooks); |
|
initMixinRuntimeHooks(methods); |
|
parse && parse(miniProgramPageOptions, { handleLink: handleLink2 }); |
|
return miniProgramPageOptions; |
|
} |
|
function initCreatePage(parseOptions2) { |
|
return function createPage2(vuePageOptions) { |
|
return Component(parsePage(vuePageOptions, parseOptions2)); |
|
}; |
|
} |
|
function initCreatePluginApp(parseAppOptions) { |
|
return function createApp2(vm) { |
|
initAppLifecycle(parseApp(vm, parseAppOptions), vm); |
|
}; |
|
} |
|
const MPPage = Page; |
|
const MPComponent = Component; |
|
function initTriggerEvent(mpInstance) { |
|
const oldTriggerEvent = mpInstance.triggerEvent; |
|
const newTriggerEvent = function(event, ...args) { |
|
return oldTriggerEvent.apply(mpInstance, [customizeEvent(event), ...args]); |
|
}; |
|
try { |
|
mpInstance.triggerEvent = newTriggerEvent; |
|
} catch (error) { |
|
mpInstance._triggerEvent = newTriggerEvent; |
|
} |
|
} |
|
function initMiniProgramHook(name, options, isComponent) { |
|
const oldHook = options[name]; |
|
if (!oldHook) { |
|
options[name] = function() { |
|
initTriggerEvent(this); |
|
}; |
|
} else { |
|
options[name] = function(...args) { |
|
initTriggerEvent(this); |
|
return oldHook.apply(this, args); |
|
}; |
|
} |
|
} |
|
Page = function(options) { |
|
initMiniProgramHook(ON_LOAD, options); |
|
return MPPage(options); |
|
}; |
|
Component = function(options) { |
|
initMiniProgramHook("created", options); |
|
const isVueComponent = options.properties && options.properties.uP; |
|
if (!isVueComponent) { |
|
initProps(options); |
|
initPropsObserver(options); |
|
} |
|
return MPComponent(options); |
|
}; |
|
function initLifetimes({ mocks: mocks2, isPage: isPage2, initRelation: initRelation2, vueOptions }) { |
|
return { |
|
attached() { |
|
let properties = this.properties; |
|
initVueIds(properties.uI, this); |
|
const relationOptions = { |
|
vuePid: this._$vuePid |
|
}; |
|
initRelation2(this, relationOptions); |
|
const mpInstance = this; |
|
const isMiniProgramPage = isPage2(mpInstance); |
|
let propsData = properties; |
|
this.$vm = $createComponent({ |
|
type: vueOptions, |
|
props: findPropsData(propsData, isMiniProgramPage) |
|
}, { |
|
mpType: isMiniProgramPage ? "page" : "component", |
|
mpInstance, |
|
slots: properties.uS || {}, |
|
// vueSlots |
|
parentComponent: relationOptions.parent && relationOptions.parent.$, |
|
onBeforeSetup(instance, options) { |
|
initRefs(instance, mpInstance); |
|
initMocks(instance, mpInstance, mocks2); |
|
initComponentInstance(instance, options); |
|
} |
|
}); |
|
if (!isMiniProgramPage) { |
|
initFormField(this.$vm); |
|
} |
|
}, |
|
ready() { |
|
if (this.$vm) { |
|
{ |
|
this.$vm.$callHook("mounted"); |
|
this.$vm.$callHook(ON_READY); |
|
} |
|
} |
|
}, |
|
detached() { |
|
if (this.$vm) { |
|
pruneComponentPropsCache(this.$vm.$.uid); |
|
$destroyComponent(this.$vm); |
|
} |
|
} |
|
}; |
|
} |
|
const mocks = ["__route__", "__wxExparserNodeId__", "__wxWebviewId__"]; |
|
function isPage(mpInstance) { |
|
return !!mpInstance.route; |
|
} |
|
function initRelation(mpInstance, detail) { |
|
mpInstance.triggerEvent("__l", detail); |
|
} |
|
function handleLink(event) { |
|
const detail = event.detail || event.value; |
|
const vuePid = detail.vuePid; |
|
let parentVm; |
|
if (vuePid) { |
|
parentVm = findVmByVueId(this.$vm, vuePid); |
|
} |
|
if (!parentVm) { |
|
parentVm = this.$vm; |
|
} |
|
detail.parent = parentVm; |
|
} |
|
var parseOptions = /* @__PURE__ */ Object.freeze({ |
|
__proto__: null, |
|
handleLink, |
|
initLifetimes, |
|
initRelation, |
|
isPage, |
|
mocks |
|
}); |
|
const createApp = initCreateApp(); |
|
const createPage = initCreatePage(parseOptions); |
|
const createComponent = initCreateComponent(parseOptions); |
|
const createPluginApp = initCreatePluginApp(); |
|
const createSubpackageApp = initCreateSubpackageApp(); |
|
{ |
|
wx.createApp = global.createApp = createApp; |
|
wx.createPage = createPage; |
|
wx.createComponent = createComponent; |
|
wx.createPluginApp = global.createPluginApp = createPluginApp; |
|
wx.createSubpackageApp = global.createSubpackageApp = createSubpackageApp; |
|
} |
|
exports._export_sfc = _export_sfc; |
|
exports.createSSRApp = createSSRApp; |
|
exports.f = f; |
|
exports.index = index; |
|
exports.o = o; |
|
exports.resolveComponent = resolveComponent; |
|
exports.s = s;
|
|
|