|
|
@@ -30,17 +30,17 @@ const remove = (arr, el) => {
|
|
|
arr.splice(i, 1);
|
|
|
}
|
|
|
};
|
|
|
-const hasOwnProperty$1 = Object.prototype.hasOwnProperty;
|
|
|
-const hasOwn = (val, key) => hasOwnProperty$1.call(val, key);
|
|
|
+const hasOwnProperty$2 = Object.prototype.hasOwnProperty;
|
|
|
+const hasOwn$1 = (val, key) => hasOwnProperty$2.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 isObject$1 = (val) => val !== null && typeof val === "object";
|
|
|
const isPromise = (val) => {
|
|
|
- return (isObject(val) || isFunction(val)) && isFunction(val.then) && isFunction(val.catch);
|
|
|
+ return (isObject$1(val) || isFunction(val)) && isFunction(val.then) && isFunction(val.catch);
|
|
|
};
|
|
|
const objectToString = Object.prototype.toString;
|
|
|
const toTypeString = (value) => objectToString.call(value);
|
|
|
@@ -112,7 +112,7 @@ function normalizeStyle(value) {
|
|
|
}
|
|
|
}
|
|
|
return res;
|
|
|
- } else if (isString(value) || isObject(value)) {
|
|
|
+ } else if (isString(value) || isObject$1(value)) {
|
|
|
return value;
|
|
|
}
|
|
|
}
|
|
|
@@ -140,7 +140,7 @@ function normalizeClass(value) {
|
|
|
res += normalized + " ";
|
|
|
}
|
|
|
}
|
|
|
- } else if (isObject(value)) {
|
|
|
+ } else if (isObject$1(value)) {
|
|
|
for (const name in value) {
|
|
|
if (value[name]) {
|
|
|
res += name + " ";
|
|
|
@@ -150,7 +150,7 @@ function normalizeClass(value) {
|
|
|
return res.trim();
|
|
|
}
|
|
|
const toDisplayString = (val) => {
|
|
|
- return isString(val) ? val : val == null ? "" : isArray(val) || isObject(val) && (val.toString === objectToString || !isFunction(val.toString)) ? JSON.stringify(val, replacer, 2) : String(val);
|
|
|
+ return isString(val) ? val : val == null ? "" : isArray(val) || isObject$1(val) && (val.toString === objectToString || !isFunction(val.toString)) ? JSON.stringify(val, replacer, 2) : String(val);
|
|
|
};
|
|
|
const replacer = (_key, val) => {
|
|
|
if (val && val.__v_isRef) {
|
|
|
@@ -171,7 +171,7 @@ const replacer = (_key, val) => {
|
|
|
};
|
|
|
} else if (isSymbol(val)) {
|
|
|
return stringifySymbol(val);
|
|
|
- } else if (isObject(val) && !isArray(val) && !isPlainObject(val)) {
|
|
|
+ } else if (isObject$1(val) && !isArray(val) && !isPlainObject(val)) {
|
|
|
return String(val);
|
|
|
}
|
|
|
return val;
|
|
|
@@ -409,11 +409,96 @@ E.prototype = {
|
|
|
}
|
|
|
};
|
|
|
var E$1 = E;
|
|
|
+const isObject = (val) => val !== null && typeof val === "object";
|
|
|
+const defaultDelimiters = ["{", "}"];
|
|
|
+class BaseFormatter {
|
|
|
+ constructor() {
|
|
|
+ this._caches = /* @__PURE__ */ Object.create(null);
|
|
|
+ }
|
|
|
+ interpolate(message, values, delimiters = defaultDelimiters) {
|
|
|
+ if (!values) {
|
|
|
+ return [message];
|
|
|
+ }
|
|
|
+ let tokens = this._caches[message];
|
|
|
+ if (!tokens) {
|
|
|
+ tokens = parse(message, delimiters);
|
|
|
+ this._caches[message] = tokens;
|
|
|
+ }
|
|
|
+ return compile$1(tokens, values);
|
|
|
+ }
|
|
|
+}
|
|
|
+const RE_TOKEN_LIST_VALUE = /^(?:\d)+/;
|
|
|
+const RE_TOKEN_NAMED_VALUE = /^(?:\w)+/;
|
|
|
+function parse(format, [startDelimiter, endDelimiter]) {
|
|
|
+ const tokens = [];
|
|
|
+ let position = 0;
|
|
|
+ let text = "";
|
|
|
+ while (position < format.length) {
|
|
|
+ let char = format[position++];
|
|
|
+ if (char === startDelimiter) {
|
|
|
+ if (text) {
|
|
|
+ tokens.push({ type: "text", value: text });
|
|
|
+ }
|
|
|
+ text = "";
|
|
|
+ let sub = "";
|
|
|
+ char = format[position++];
|
|
|
+ while (char !== void 0 && char !== endDelimiter) {
|
|
|
+ sub += char;
|
|
|
+ char = format[position++];
|
|
|
+ }
|
|
|
+ const isClosed = char === endDelimiter;
|
|
|
+ const type = RE_TOKEN_LIST_VALUE.test(sub) ? "list" : isClosed && RE_TOKEN_NAMED_VALUE.test(sub) ? "named" : "unknown";
|
|
|
+ tokens.push({ value: sub, type });
|
|
|
+ } else {
|
|
|
+ text += char;
|
|
|
+ }
|
|
|
+ }
|
|
|
+ text && tokens.push({ type: "text", value: text });
|
|
|
+ return tokens;
|
|
|
+}
|
|
|
+function compile$1(tokens, values) {
|
|
|
+ const compiled = [];
|
|
|
+ let index2 = 0;
|
|
|
+ const mode = Array.isArray(values) ? "list" : isObject(values) ? "named" : "unknown";
|
|
|
+ if (mode === "unknown") {
|
|
|
+ return compiled;
|
|
|
+ }
|
|
|
+ while (index2 < tokens.length) {
|
|
|
+ const token = tokens[index2];
|
|
|
+ switch (token.type) {
|
|
|
+ case "text":
|
|
|
+ compiled.push(token.value);
|
|
|
+ break;
|
|
|
+ case "list":
|
|
|
+ compiled.push(values[parseInt(token.value, 10)]);
|
|
|
+ break;
|
|
|
+ case "named":
|
|
|
+ if (mode === "named") {
|
|
|
+ compiled.push(values[token.value]);
|
|
|
+ } else {
|
|
|
+ {
|
|
|
+ console.warn(`Type of token '${token.type}' and format of value '${mode}' don't match!`);
|
|
|
+ }
|
|
|
+ }
|
|
|
+ break;
|
|
|
+ case "unknown":
|
|
|
+ {
|
|
|
+ console.warn(`Detect 'unknown' type of token!`);
|
|
|
+ }
|
|
|
+ break;
|
|
|
+ }
|
|
|
+ index2++;
|
|
|
+ }
|
|
|
+ return compiled;
|
|
|
+}
|
|
|
const LOCALE_ZH_HANS = "zh-Hans";
|
|
|
const LOCALE_ZH_HANT = "zh-Hant";
|
|
|
const LOCALE_EN = "en";
|
|
|
const LOCALE_FR = "fr";
|
|
|
const LOCALE_ES = "es";
|
|
|
+const hasOwnProperty$1 = Object.prototype.hasOwnProperty;
|
|
|
+const hasOwn = (val, key) => hasOwnProperty$1.call(val, key);
|
|
|
+const defaultFormatter = new BaseFormatter();
|
|
|
function include(str, parts) {
|
|
|
return !!parts.find((part) => str.indexOf(part) !== -1);
|
|
|
}
|
|
|
@@ -453,6 +538,163 @@ function normalizeLocale(locale, messages) {
|
|
|
return lang;
|
|
|
}
|
|
|
}
|
|
|
+class I18n {
|
|
|
+ constructor({ locale, fallbackLocale, messages, watcher, formater: formater2 }) {
|
|
|
+ this.locale = LOCALE_EN;
|
|
|
+ this.fallbackLocale = LOCALE_EN;
|
|
|
+ this.message = {};
|
|
|
+ this.messages = {};
|
|
|
+ this.watchers = [];
|
|
|
+ if (fallbackLocale) {
|
|
|
+ this.fallbackLocale = fallbackLocale;
|
|
|
+ }
|
|
|
+ this.formater = formater2 || defaultFormatter;
|
|
|
+ this.messages = messages || {};
|
|
|
+ this.setLocale(locale || LOCALE_EN);
|
|
|
+ if (watcher) {
|
|
|
+ this.watchLocale(watcher);
|
|
|
+ }
|
|
|
+ }
|
|
|
+ setLocale(locale) {
|
|
|
+ const oldLocale = this.locale;
|
|
|
+ this.locale = normalizeLocale(locale, this.messages) || this.fallbackLocale;
|
|
|
+ if (!this.messages[this.locale]) {
|
|
|
+ this.messages[this.locale] = {};
|
|
|
+ }
|
|
|
+ this.message = this.messages[this.locale];
|
|
|
+ if (oldLocale !== this.locale) {
|
|
|
+ this.watchers.forEach((watcher) => {
|
|
|
+ watcher(this.locale, oldLocale);
|
|
|
+ });
|
|
|
+ }
|
|
|
+ }
|
|
|
+ getLocale() {
|
|
|
+ return this.locale;
|
|
|
+ }
|
|
|
+ watchLocale(fn) {
|
|
|
+ const index2 = this.watchers.push(fn) - 1;
|
|
|
+ return () => {
|
|
|
+ this.watchers.splice(index2, 1);
|
|
|
+ };
|
|
|
+ }
|
|
|
+ add(locale, message, override = true) {
|
|
|
+ const curMessages = this.messages[locale];
|
|
|
+ if (curMessages) {
|
|
|
+ if (override) {
|
|
|
+ Object.assign(curMessages, message);
|
|
|
+ } else {
|
|
|
+ Object.keys(message).forEach((key) => {
|
|
|
+ if (!hasOwn(curMessages, key)) {
|
|
|
+ curMessages[key] = message[key];
|
|
|
+ }
|
|
|
+ });
|
|
|
+ }
|
|
|
+ } else {
|
|
|
+ this.messages[locale] = message;
|
|
|
+ }
|
|
|
+ }
|
|
|
+ f(message, values, delimiters) {
|
|
|
+ return this.formater.interpolate(message, values, delimiters).join("");
|
|
|
+ }
|
|
|
+ t(key, locale, values) {
|
|
|
+ let message = this.message;
|
|
|
+ if (typeof locale === "string") {
|
|
|
+ locale = normalizeLocale(locale, this.messages);
|
|
|
+ locale && (message = this.messages[locale]);
|
|
|
+ } else {
|
|
|
+ values = locale;
|
|
|
+ }
|
|
|
+ if (!hasOwn(message, key)) {
|
|
|
+ console.warn(`Cannot translate the value of keypath ${key}. Use the value of keypath as default.`);
|
|
|
+ return key;
|
|
|
+ }
|
|
|
+ return this.formater.interpolate(message[key], values).join("");
|
|
|
+ }
|
|
|
+}
|
|
|
+function watchAppLocale(appVm, i18n) {
|
|
|
+ if (appVm.$watchLocale) {
|
|
|
+ appVm.$watchLocale((newLocale) => {
|
|
|
+ i18n.setLocale(newLocale);
|
|
|
+ });
|
|
|
+ } else {
|
|
|
+ appVm.$watch(() => appVm.$locale, (newLocale) => {
|
|
|
+ i18n.setLocale(newLocale);
|
|
|
+ });
|
|
|
+ }
|
|
|
+}
|
|
|
+function getDefaultLocale() {
|
|
|
+ if (typeof index !== "undefined" && index.getLocale) {
|
|
|
+ return index.getLocale();
|
|
|
+ }
|
|
|
+ if (typeof global !== "undefined" && global.getLocale) {
|
|
|
+ return global.getLocale();
|
|
|
+ }
|
|
|
+ return LOCALE_EN;
|
|
|
+}
|
|
|
+function initVueI18n(locale, messages = {}, fallbackLocale, watcher) {
|
|
|
+ if (typeof locale !== "string") {
|
|
|
+ const options = [
|
|
|
+ messages,
|
|
|
+ locale
|
|
|
+ ];
|
|
|
+ locale = options[0];
|
|
|
+ messages = options[1];
|
|
|
+ }
|
|
|
+ if (typeof locale !== "string") {
|
|
|
+ locale = getDefaultLocale();
|
|
|
+ }
|
|
|
+ if (typeof fallbackLocale !== "string") {
|
|
|
+ fallbackLocale = typeof __uniConfig !== "undefined" && __uniConfig.fallbackLocale || LOCALE_EN;
|
|
|
+ }
|
|
|
+ const i18n = new I18n({
|
|
|
+ locale,
|
|
|
+ fallbackLocale,
|
|
|
+ messages,
|
|
|
+ watcher
|
|
|
+ });
|
|
|
+ let t2 = (key, values) => {
|
|
|
+ if (typeof getApp !== "function") {
|
|
|
+ t2 = function(key2, values2) {
|
|
|
+ return i18n.t(key2, values2);
|
|
|
+ };
|
|
|
+ } else {
|
|
|
+ let isWatchedAppLocale = false;
|
|
|
+ t2 = function(key2, values2) {
|
|
|
+ const appVm = getApp().$vm;
|
|
|
+ if (appVm) {
|
|
|
+ appVm.$locale;
|
|
|
+ if (!isWatchedAppLocale) {
|
|
|
+ isWatchedAppLocale = true;
|
|
|
+ watchAppLocale(appVm, i18n);
|
|
|
+ }
|
|
|
+ }
|
|
|
+ return i18n.t(key2, values2);
|
|
|
+ };
|
|
|
+ }
|
|
|
+ return t2(key, values);
|
|
|
+ };
|
|
|
+ return {
|
|
|
+ i18n,
|
|
|
+ f(message, values, delimiters) {
|
|
|
+ return i18n.f(message, values, delimiters);
|
|
|
+ },
|
|
|
+ t(key, values) {
|
|
|
+ return t2(key, values);
|
|
|
+ },
|
|
|
+ add(locale2, message, override = true) {
|
|
|
+ return i18n.add(locale2, message, override);
|
|
|
+ },
|
|
|
+ watch(fn) {
|
|
|
+ return i18n.watchLocale(fn);
|
|
|
+ },
|
|
|
+ getLocale() {
|
|
|
+ return i18n.getLocale();
|
|
|
+ },
|
|
|
+ setLocale(newLocale) {
|
|
|
+ return i18n.setLocale(newLocale);
|
|
|
+ }
|
|
|
+ };
|
|
|
+}
|
|
|
function getBaseSystemInfo() {
|
|
|
return wx.getSystemInfoSync();
|
|
|
}
|
|
|
@@ -464,7 +706,7 @@ function validateProtocol(name, data, protocol, onFail) {
|
|
|
onFail = validateProtocolFail;
|
|
|
}
|
|
|
for (const key in protocol) {
|
|
|
- const errMsg = validateProp$1(key, data[key], protocol[key], !hasOwn(data, key));
|
|
|
+ const errMsg = validateProp$1(key, data[key], protocol[key], !hasOwn$1(data, key));
|
|
|
if (isString(errMsg)) {
|
|
|
onFail(name, errMsg);
|
|
|
}
|
|
|
@@ -527,7 +769,7 @@ function assertType$1(value, type) {
|
|
|
valid = value instanceof type;
|
|
|
}
|
|
|
} else if (expectedType === "Object") {
|
|
|
- valid = isObject(value);
|
|
|
+ valid = isObject$1(value);
|
|
|
} else if (expectedType === "Array") {
|
|
|
valid = isArray(value);
|
|
|
} else {
|
|
|
@@ -783,7 +1025,7 @@ function formatApiArgs(args, options) {
|
|
|
return errMsg;
|
|
|
}
|
|
|
} else {
|
|
|
- if (!hasOwn(params, name)) {
|
|
|
+ if (!hasOwn$1(params, name)) {
|
|
|
params[name] = formatterOrDefaultValue;
|
|
|
}
|
|
|
}
|
|
|
@@ -1157,7 +1399,7 @@ function initWrapper(protocols2) {
|
|
|
argsOption = argsOption(fromArgs, toArgs) || {};
|
|
|
}
|
|
|
for (const key in fromArgs) {
|
|
|
- if (hasOwn(argsOption, key)) {
|
|
|
+ if (hasOwn$1(argsOption, key)) {
|
|
|
let keyOption = argsOption[key];
|
|
|
if (isFunction(keyOption)) {
|
|
|
keyOption = keyOption(fromArgs[key], fromArgs, toArgs);
|
|
|
@@ -1175,7 +1417,7 @@ function initWrapper(protocols2) {
|
|
|
toArgs[key] = processCallback(methodName, callback, returnValue);
|
|
|
}
|
|
|
} else {
|
|
|
- if (!keepFromArgs && !hasOwn(toArgs, key)) {
|
|
|
+ if (!keepFromArgs && !hasOwn$1(toArgs, key)) {
|
|
|
toArgs[key] = fromArgs[key];
|
|
|
}
|
|
|
}
|
|
|
@@ -1193,7 +1435,7 @@ function initWrapper(protocols2) {
|
|
|
return processArgs(methodName, res, returnValue, {}, keepReturnValue);
|
|
|
}
|
|
|
return function wrapper(methodName, method) {
|
|
|
- if (!hasOwn(protocols2, methodName)) {
|
|
|
+ if (!hasOwn$1(protocols2, methodName)) {
|
|
|
return method;
|
|
|
}
|
|
|
const protocol = protocols2[methodName];
|
|
|
@@ -1487,13 +1729,13 @@ function initUni(api, protocols2, platform = wx) {
|
|
|
const wrapper = initWrapper(protocols2);
|
|
|
const UniProxyHandlers = {
|
|
|
get(target, key) {
|
|
|
- if (hasOwn(target, key)) {
|
|
|
+ if (hasOwn$1(target, key)) {
|
|
|
return target[key];
|
|
|
}
|
|
|
- if (hasOwn(api, key)) {
|
|
|
+ if (hasOwn$1(api, key)) {
|
|
|
return promisify(key, api[key]);
|
|
|
}
|
|
|
- if (hasOwn(baseApis, key)) {
|
|
|
+ if (hasOwn$1(baseApis, key)) {
|
|
|
return promisify(key, baseApis[key]);
|
|
|
}
|
|
|
return promisify(key, wrapper(key, platform[key]));
|
|
|
@@ -2505,7 +2747,7 @@ class BaseReactiveHandler2 {
|
|
|
}
|
|
|
const targetIsArray = isArray(target);
|
|
|
if (!isReadonly2) {
|
|
|
- if (targetIsArray && hasOwn(arrayInstrumentations, key)) {
|
|
|
+ if (targetIsArray && hasOwn$1(arrayInstrumentations, key)) {
|
|
|
return Reflect.get(arrayInstrumentations, key, receiver);
|
|
|
}
|
|
|
if (key === "hasOwnProperty") {
|
|
|
@@ -2525,7 +2767,7 @@ class BaseReactiveHandler2 {
|
|
|
if (isRef(res)) {
|
|
|
return targetIsArray && isIntegerKey(key) ? res : res.value;
|
|
|
}
|
|
|
- if (isObject(res)) {
|
|
|
+ if (isObject$1(res)) {
|
|
|
return isReadonly2 ? readonly(res) : reactive(res);
|
|
|
}
|
|
|
return res;
|
|
|
@@ -2552,7 +2794,7 @@ class MutableReactiveHandler2 extends BaseReactiveHandler2 {
|
|
|
}
|
|
|
}
|
|
|
}
|
|
|
- const hadKey = isArray(target) && isIntegerKey(key) ? Number(key) < target.length : hasOwn(target, key);
|
|
|
+ const hadKey = isArray(target) && isIntegerKey(key) ? Number(key) < target.length : hasOwn$1(target, key);
|
|
|
const result = Reflect.set(target, key, value, receiver);
|
|
|
if (target === toRaw(receiver)) {
|
|
|
if (!hadKey) {
|
|
|
@@ -2564,7 +2806,7 @@ class MutableReactiveHandler2 extends BaseReactiveHandler2 {
|
|
|
return result;
|
|
|
}
|
|
|
deleteProperty(target, key) {
|
|
|
- const hadKey = hasOwn(target, key);
|
|
|
+ const hadKey = hasOwn$1(target, key);
|
|
|
const oldValue = target[key];
|
|
|
const result = Reflect.deleteProperty(target, key);
|
|
|
if (result && hadKey) {
|
|
|
@@ -2869,7 +3111,7 @@ function createInstrumentationGetter(isReadonly2, shallow) {
|
|
|
return target;
|
|
|
}
|
|
|
return Reflect.get(
|
|
|
- hasOwn(instrumentations, key) && key in target ? instrumentations : target,
|
|
|
+ hasOwn$1(instrumentations, key) && key in target ? instrumentations : target,
|
|
|
key,
|
|
|
receiver
|
|
|
);
|
|
|
@@ -2957,7 +3199,7 @@ function shallowReadonly(target) {
|
|
|
);
|
|
|
}
|
|
|
function createReactiveObject(target, isReadonly2, baseHandlers, collectionHandlers, proxyMap) {
|
|
|
- if (!isObject(target)) {
|
|
|
+ if (!isObject$1(target)) {
|
|
|
{
|
|
|
warn$2(`value cannot be made reactive: ${String(target)}`);
|
|
|
}
|
|
|
@@ -3006,8 +3248,8 @@ function markRaw(value) {
|
|
|
}
|
|
|
return value;
|
|
|
}
|
|
|
-const toReactive = (value) => isObject(value) ? reactive(value) : value;
|
|
|
-const toReadonly = (value) => isObject(value) ? readonly(value) : value;
|
|
|
+const toReactive = (value) => isObject$1(value) ? reactive(value) : value;
|
|
|
+const toReadonly = (value) => isObject$1(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) {
|
|
|
@@ -3761,7 +4003,7 @@ function normalizeEmitsOptions(comp, appContext, asMixin = false) {
|
|
|
}
|
|
|
}
|
|
|
if (!raw && !hasExtends) {
|
|
|
- if (isObject(comp)) {
|
|
|
+ if (isObject$1(comp)) {
|
|
|
cache.set(comp, null);
|
|
|
}
|
|
|
return null;
|
|
|
@@ -3771,7 +4013,7 @@ function normalizeEmitsOptions(comp, appContext, asMixin = false) {
|
|
|
} else {
|
|
|
extend(normalized, raw);
|
|
|
}
|
|
|
- if (isObject(comp)) {
|
|
|
+ if (isObject$1(comp)) {
|
|
|
cache.set(comp, normalized);
|
|
|
}
|
|
|
return normalized;
|
|
|
@@ -3781,7 +4023,7 @@ function isEmitListener(options, 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);
|
|
|
+ return hasOwn$1(options, key[0].toLowerCase() + key.slice(1)) || hasOwn$1(options, hyphenate(key)) || hasOwn$1(options, key);
|
|
|
}
|
|
|
let currentRenderingInstance = null;
|
|
|
function setCurrentRenderingInstance(instance) {
|
|
|
@@ -4032,7 +4274,7 @@ function createPathGetter(ctx, path) {
|
|
|
};
|
|
|
}
|
|
|
function traverse(value, depth, currentDepth = 0, seen) {
|
|
|
- if (!isObject(value) || value["__v_skip"]) {
|
|
|
+ if (!isObject$1(value) || value["__v_skip"]) {
|
|
|
return value;
|
|
|
}
|
|
|
if (depth && depth > 0) {
|
|
|
@@ -4095,7 +4337,7 @@ function createAppAPI(render, hydrate) {
|
|
|
if (!isFunction(rootComponent)) {
|
|
|
rootComponent = extend({}, rootComponent);
|
|
|
}
|
|
|
- if (rootProps != null && !isObject(rootProps)) {
|
|
|
+ if (rootProps != null && !isObject$1(rootProps)) {
|
|
|
warn$1(`root props passed to app.mount() must be an object.`);
|
|
|
rootProps = null;
|
|
|
}
|
|
|
@@ -4360,7 +4602,7 @@ const publicPropertiesMap = (
|
|
|
})
|
|
|
);
|
|
|
const isReservedPrefix = (key) => key === "_" || key === "$";
|
|
|
-const hasSetupBinding = (state, key) => state !== EMPTY_OBJ && !state.__isScriptSetup && hasOwn(state, key);
|
|
|
+const hasSetupBinding = (state, key) => state !== EMPTY_OBJ && !state.__isScriptSetup && hasOwn$1(state, key);
|
|
|
const PublicInstanceProxyHandlers = {
|
|
|
get({ _: instance }, key) {
|
|
|
const { ctx, setupState, data, props, accessCache, type, appContext } = instance;
|
|
|
@@ -4384,17 +4626,17 @@ const PublicInstanceProxyHandlers = {
|
|
|
} else if (hasSetupBinding(setupState, key)) {
|
|
|
accessCache[key] = 1;
|
|
|
return setupState[key];
|
|
|
- } else if (data !== EMPTY_OBJ && hasOwn(data, key)) {
|
|
|
+ } else if (data !== EMPTY_OBJ && hasOwn$1(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)
|
|
|
+ (normalizedProps = instance.propsOptions[0]) && hasOwn$1(normalizedProps, key)
|
|
|
) {
|
|
|
accessCache[key] = 3;
|
|
|
return props[key];
|
|
|
- } else if (ctx !== EMPTY_OBJ && hasOwn(ctx, key)) {
|
|
|
+ } else if (ctx !== EMPTY_OBJ && hasOwn$1(ctx, key)) {
|
|
|
accessCache[key] = 4;
|
|
|
return ctx[key];
|
|
|
} else if (shouldCacheAccess) {
|
|
|
@@ -4415,12 +4657,12 @@ const PublicInstanceProxyHandlers = {
|
|
|
(cssModule = type.__cssModules) && (cssModule = cssModule[key])
|
|
|
) {
|
|
|
return cssModule;
|
|
|
- } else if (ctx !== EMPTY_OBJ && hasOwn(ctx, key)) {
|
|
|
+ } else if (ctx !== EMPTY_OBJ && hasOwn$1(ctx, key)) {
|
|
|
accessCache[key] = 4;
|
|
|
return ctx[key];
|
|
|
} else if (
|
|
|
// global properties
|
|
|
- globalProperties = appContext.config.globalProperties, hasOwn(globalProperties, key)
|
|
|
+ globalProperties = appContext.config.globalProperties, hasOwn$1(globalProperties, key)
|
|
|
) {
|
|
|
{
|
|
|
return globalProperties[key];
|
|
|
@@ -4428,7 +4670,7 @@ const PublicInstanceProxyHandlers = {
|
|
|
} 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)) {
|
|
|
+ if (data !== EMPTY_OBJ && isReservedPrefix(key[0]) && hasOwn$1(data, key)) {
|
|
|
warn$1(
|
|
|
`Property ${JSON.stringify(
|
|
|
key
|
|
|
@@ -4446,13 +4688,13 @@ const PublicInstanceProxyHandlers = {
|
|
|
if (hasSetupBinding(setupState, key)) {
|
|
|
setupState[key] = value;
|
|
|
return true;
|
|
|
- } else if (setupState.__isScriptSetup && hasOwn(setupState, key)) {
|
|
|
+ } else if (setupState.__isScriptSetup && hasOwn$1(setupState, key)) {
|
|
|
warn$1(`Cannot mutate <script setup> binding "${key}" from Options API.`);
|
|
|
return false;
|
|
|
- } else if (data !== EMPTY_OBJ && hasOwn(data, key)) {
|
|
|
+ } else if (data !== EMPTY_OBJ && hasOwn$1(data, key)) {
|
|
|
data[key] = value;
|
|
|
return true;
|
|
|
- } else if (hasOwn(instance.props, key)) {
|
|
|
+ } else if (hasOwn$1(instance.props, key)) {
|
|
|
warn$1(`Attempting to mutate prop "${key}". Props are readonly.`);
|
|
|
return false;
|
|
|
}
|
|
|
@@ -4478,12 +4720,12 @@ const PublicInstanceProxyHandlers = {
|
|
|
_: { 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);
|
|
|
+ return !!accessCache[key] || data !== EMPTY_OBJ && hasOwn$1(data, key) || hasSetupBinding(setupState, key) || (normalizedProps = propsOptions[0]) && hasOwn$1(normalizedProps, key) || hasOwn$1(ctx, key) || hasOwn$1(publicPropertiesMap, key) || hasOwn$1(appContext.config.globalProperties, key);
|
|
|
},
|
|
|
defineProperty(target, key, descriptor) {
|
|
|
if (descriptor.get != null) {
|
|
|
target._.accessCache[key] = 0;
|
|
|
- } else if (hasOwn(descriptor, "value")) {
|
|
|
+ } else if (hasOwn$1(descriptor, "value")) {
|
|
|
this.set(target, key, descriptor.value, null);
|
|
|
}
|
|
|
return Reflect.defineProperty(target, key, descriptor);
|
|
|
@@ -4657,7 +4899,7 @@ function applyOptions$1(instance) {
|
|
|
`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)) {
|
|
|
+ if (!isObject$1(data)) {
|
|
|
warn$1(`data() should return an object.`);
|
|
|
} else {
|
|
|
instance.data = reactive(data);
|
|
|
@@ -4775,7 +5017,7 @@ function resolveInjections(injectOptions, ctx, checkDuplicateProperties = NOOP)
|
|
|
for (const key in injectOptions) {
|
|
|
const opt = injectOptions[key];
|
|
|
let injected;
|
|
|
- if (isObject(opt)) {
|
|
|
+ if (isObject$1(opt)) {
|
|
|
if ("default" in opt) {
|
|
|
injected = inject(
|
|
|
opt.from || key,
|
|
|
@@ -4821,7 +5063,7 @@ function createWatcher(raw, ctx, publicThis, key) {
|
|
|
}
|
|
|
} else if (isFunction(raw)) {
|
|
|
watch(getter, raw.bind(publicThis));
|
|
|
- } else if (isObject(raw)) {
|
|
|
+ } else if (isObject$1(raw)) {
|
|
|
if (isArray(raw)) {
|
|
|
raw.forEach((r2) => createWatcher(r2, ctx, publicThis, key));
|
|
|
} else {
|
|
|
@@ -4861,7 +5103,7 @@ function resolveMergedOptions(instance) {
|
|
|
}
|
|
|
mergeOptions(resolved, base, optionMergeStrategies);
|
|
|
}
|
|
|
- if (isObject(base)) {
|
|
|
+ if (isObject$1(base)) {
|
|
|
cache.set(base, resolved);
|
|
|
}
|
|
|
return resolved;
|
|
|
@@ -5032,7 +5274,7 @@ function updateProps(instance, rawProps, rawPrevProps, optimized) {
|
|
|
}
|
|
|
const value = rawProps[key];
|
|
|
if (options) {
|
|
|
- if (hasOwn(attrs, key)) {
|
|
|
+ if (hasOwn$1(attrs, key)) {
|
|
|
if (value !== attrs[key]) {
|
|
|
attrs[key] = value;
|
|
|
hasAttrsChanged = true;
|
|
|
@@ -5063,9 +5305,9 @@ function updateProps(instance, rawProps, rawPrevProps, optimized) {
|
|
|
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
|
|
|
+ !hasOwn$1(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))) {
|
|
|
+ ((kebabKey = hyphenate(key)) === key || !hasOwn$1(rawProps, kebabKey))) {
|
|
|
if (options) {
|
|
|
if (rawPrevProps && // for camelCase
|
|
|
(rawPrevProps[key] !== void 0 || // for kebab-case
|
|
|
@@ -5086,7 +5328,7 @@ function updateProps(instance, rawProps, rawPrevProps, optimized) {
|
|
|
}
|
|
|
if (attrs !== rawCurrentProps) {
|
|
|
for (const key in attrs) {
|
|
|
- if (!rawProps || !hasOwn(rawProps, key) && true) {
|
|
|
+ if (!rawProps || !hasOwn$1(rawProps, key) && true) {
|
|
|
delete attrs[key];
|
|
|
hasAttrsChanged = true;
|
|
|
}
|
|
|
@@ -5111,7 +5353,7 @@ function setFullProps(instance, rawProps, props, attrs) {
|
|
|
}
|
|
|
const value = rawProps[key];
|
|
|
let camelKey;
|
|
|
- if (options && hasOwn(options, camelKey = camelize(key))) {
|
|
|
+ if (options && hasOwn$1(options, camelKey = camelize(key))) {
|
|
|
if (!needCastKeys || !needCastKeys.includes(camelKey)) {
|
|
|
props[camelKey] = value;
|
|
|
} else {
|
|
|
@@ -5136,7 +5378,7 @@ function setFullProps(instance, rawProps, props, attrs) {
|
|
|
key,
|
|
|
castValues[key],
|
|
|
instance,
|
|
|
- !hasOwn(castValues, key)
|
|
|
+ !hasOwn$1(castValues, key)
|
|
|
);
|
|
|
}
|
|
|
}
|
|
|
@@ -5145,7 +5387,7 @@ function setFullProps(instance, rawProps, props, attrs) {
|
|
|
function resolvePropValue(options, props, key, value, instance, isAbsent) {
|
|
|
const opt = options[key];
|
|
|
if (opt != null) {
|
|
|
- const hasDefault = hasOwn(opt, "default");
|
|
|
+ const hasDefault = hasOwn$1(opt, "default");
|
|
|
if (hasDefault && value === void 0) {
|
|
|
const defaultValue = opt.default;
|
|
|
if (opt.type !== Function && !opt.skipFactory && isFunction(defaultValue)) {
|
|
|
@@ -5209,7 +5451,7 @@ function normalizePropsOptions(comp, appContext, asMixin = false) {
|
|
|
}
|
|
|
}
|
|
|
if (!raw && !hasExtends) {
|
|
|
- if (isObject(comp)) {
|
|
|
+ if (isObject$1(comp)) {
|
|
|
cache.set(comp, EMPTY_ARR);
|
|
|
}
|
|
|
return EMPTY_ARR;
|
|
|
@@ -5225,7 +5467,7 @@ function normalizePropsOptions(comp, appContext, asMixin = false) {
|
|
|
}
|
|
|
}
|
|
|
} else if (raw) {
|
|
|
- if (!isObject(raw)) {
|
|
|
+ if (!isObject$1(raw)) {
|
|
|
warn$1(`invalid props options`, raw);
|
|
|
}
|
|
|
for (const key in raw) {
|
|
|
@@ -5244,7 +5486,7 @@ function normalizePropsOptions(comp, appContext, asMixin = false) {
|
|
|
1
|
|
|
/* shouldCastTrue */
|
|
|
] = stringIndex < 0 || booleanIndex < stringIndex;
|
|
|
- if (booleanIndex > -1 || hasOwn(prop, "default")) {
|
|
|
+ if (booleanIndex > -1 || hasOwn$1(prop, "default")) {
|
|
|
needCastKeys.push(normalizedKey);
|
|
|
}
|
|
|
}
|
|
|
@@ -5252,7 +5494,7 @@ function normalizePropsOptions(comp, appContext, asMixin = false) {
|
|
|
}
|
|
|
}
|
|
|
const res = [normalized, needCastKeys];
|
|
|
- if (isObject(comp)) {
|
|
|
+ if (isObject$1(comp)) {
|
|
|
cache.set(comp, res);
|
|
|
}
|
|
|
return res;
|
|
|
@@ -5300,7 +5542,7 @@ function validateProps(rawProps, props, instance) {
|
|
|
resolvedValues[key],
|
|
|
opt,
|
|
|
shallowReadonly(resolvedValues),
|
|
|
- !hasOwn(rawProps, key) && !hasOwn(rawProps, hyphenate(key))
|
|
|
+ !hasOwn$1(rawProps, key) && !hasOwn$1(rawProps, hyphenate(key))
|
|
|
);
|
|
|
}
|
|
|
}
|
|
|
@@ -5344,7 +5586,7 @@ function assertType(value, type) {
|
|
|
valid = value instanceof type;
|
|
|
}
|
|
|
} else if (expectedType === "Object") {
|
|
|
- valid = isObject(value);
|
|
|
+ valid = isObject$1(value);
|
|
|
} else if (expectedType === "Array") {
|
|
|
valid = isArray(value);
|
|
|
} else if (expectedType === "null") {
|
|
|
@@ -5648,7 +5890,7 @@ function handleSetupResult(instance, setupResult, isSSR) {
|
|
|
{
|
|
|
instance.render = setupResult;
|
|
|
}
|
|
|
- } else if (isObject(setupResult)) {
|
|
|
+ } else if (isObject$1(setupResult)) {
|
|
|
if (isVNode(setupResult)) {
|
|
|
warn$1(
|
|
|
`setup() should not return VNodes directly - return a render function instead.`
|
|
|
@@ -5993,7 +6235,7 @@ function clone(src, seen) {
|
|
|
copy = {};
|
|
|
seen.set(src, copy);
|
|
|
for (const name in src) {
|
|
|
- if (hasOwn(src, name)) {
|
|
|
+ if (hasOwn$1(src, name)) {
|
|
|
copy[name] = clone(src[name], seen);
|
|
|
}
|
|
|
}
|
|
|
@@ -6113,7 +6355,7 @@ function setRef$1(instance, isUnmount = false) {
|
|
|
}
|
|
|
}
|
|
|
function toSkip(value) {
|
|
|
- if (isObject(value)) {
|
|
|
+ if (isObject$1(value)) {
|
|
|
markRaw(value);
|
|
|
}
|
|
|
return value;
|
|
|
@@ -6154,7 +6396,7 @@ function setTemplateRef({ r: r2, f: f2 }, refValue, setupState) {
|
|
|
onBeforeUnmount(() => remove(existing, refValue), refValue.$);
|
|
|
}
|
|
|
} else if (_isString) {
|
|
|
- if (hasOwn(setupState, r2)) {
|
|
|
+ if (hasOwn$1(setupState, r2)) {
|
|
|
setupState[r2] = refValue;
|
|
|
}
|
|
|
} else if (isRef(r2)) {
|
|
|
@@ -6735,14 +6977,14 @@ function patchMPEvent(event) {
|
|
|
event.preventDefault = NOOP;
|
|
|
event.stopPropagation = NOOP;
|
|
|
event.stopImmediatePropagation = NOOP;
|
|
|
- if (!hasOwn(event, "detail")) {
|
|
|
+ if (!hasOwn$1(event, "detail")) {
|
|
|
event.detail = {};
|
|
|
}
|
|
|
- if (hasOwn(event, "markerId")) {
|
|
|
+ if (hasOwn$1(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")) {
|
|
|
+ if (isPlainObject(event.detail) && hasOwn$1(event.detail, "checked") && !hasOwn$1(event.detail, "value")) {
|
|
|
event.detail.value = event.detail.checked;
|
|
|
}
|
|
|
if (isPlainObject(event.detail)) {
|
|
|
@@ -6778,7 +7020,7 @@ function vFor(source, renderItem) {
|
|
|
for (let i = 0; i < source; i++) {
|
|
|
ret[i] = renderItem(i + 1, i, i);
|
|
|
}
|
|
|
- } else if (isObject(source)) {
|
|
|
+ } else if (isObject$1(source)) {
|
|
|
if (source[Symbol.iterator]) {
|
|
|
ret = Array.from(source, (item, i) => renderItem(item, i, i));
|
|
|
} else {
|
|
|
@@ -6888,7 +7130,7 @@ function initComponentInstance(instance, options) {
|
|
|
function initMocks(instance, mpInstance, mocks2) {
|
|
|
const ctx = instance.ctx;
|
|
|
mocks2.forEach((mock) => {
|
|
|
- if (hasOwn(mpInstance, mock)) {
|
|
|
+ if (hasOwn$1(mpInstance, mock)) {
|
|
|
instance[mock] = ctx[mock] = mpInstance[mock];
|
|
|
}
|
|
|
});
|
|
|
@@ -6944,7 +7186,7 @@ function findHooks(vueOptions, hooks = /* @__PURE__ */ new Set()) {
|
|
|
return hooks;
|
|
|
}
|
|
|
function initHook(mpOptions, hook, excludes) {
|
|
|
- if (excludes.indexOf(hook) === -1 && !hasOwn(mpOptions, hook)) {
|
|
|
+ if (excludes.indexOf(hook) === -1 && !hasOwn$1(mpOptions, hook)) {
|
|
|
mpOptions[hook] = function(args) {
|
|
|
return this.$vm && this.$vm.$callHook(hook, args);
|
|
|
};
|
|
|
@@ -6977,7 +7219,7 @@ const findMixinRuntimeHooks = /* @__PURE__ */ once(() => {
|
|
|
const hooks = Object.keys(MINI_PROGRAM_PAGE_RUNTIME_HOOKS);
|
|
|
mixins.forEach((mixin) => {
|
|
|
hooks.forEach((hook) => {
|
|
|
- if (hasOwn(mixin, hook) && !runtimeHooks.includes(hook)) {
|
|
|
+ if (hasOwn$1(mixin, hook) && !runtimeHooks.includes(hook)) {
|
|
|
runtimeHooks.push(hook);
|
|
|
}
|
|
|
});
|
|
|
@@ -7054,13 +7296,13 @@ function initCreateSubpackageApp(parseAppOptions) {
|
|
|
const globalData = app.globalData;
|
|
|
if (globalData) {
|
|
|
Object.keys(appOptions.globalData).forEach((name) => {
|
|
|
- if (!hasOwn(globalData, name)) {
|
|
|
+ if (!hasOwn$1(globalData, name)) {
|
|
|
globalData[name] = appOptions.globalData[name];
|
|
|
}
|
|
|
});
|
|
|
}
|
|
|
Object.keys(appOptions).forEach((name) => {
|
|
|
- if (!hasOwn(app, name)) {
|
|
|
+ if (!hasOwn$1(app, name)) {
|
|
|
app[name] = appOptions[name];
|
|
|
}
|
|
|
});
|
|
|
@@ -7110,7 +7352,7 @@ function initVueIds(vueIds, mpInstance) {
|
|
|
const EXTRAS = ["externalClasses"];
|
|
|
function initExtraOptions(miniProgramComponentOptions, vueOptions) {
|
|
|
EXTRAS.forEach((name) => {
|
|
|
- if (hasOwn(vueOptions, name)) {
|
|
|
+ if (hasOwn$1(vueOptions, name)) {
|
|
|
miniProgramComponentOptions[name] = vueOptions[name];
|
|
|
}
|
|
|
});
|
|
|
@@ -7417,7 +7659,7 @@ 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 }) {
|
|
|
+function parseComponent(vueOptions, { parse: parse2, mocks: mocks2, isPage: isPage2, initRelation: initRelation2, handleLink: handleLink2, initLifetimes: initLifetimes2 }) {
|
|
|
vueOptions = vueOptions.default || vueOptions;
|
|
|
const options = {
|
|
|
multipleSlots: true,
|
|
|
@@ -7427,7 +7669,7 @@ function parseComponent(vueOptions, { parse, mocks: mocks2, isPage: isPage2, ini
|
|
|
};
|
|
|
if (isArray(vueOptions.mixins)) {
|
|
|
vueOptions.mixins.forEach((item) => {
|
|
|
- if (isObject(item.options)) {
|
|
|
+ if (isObject$1(item.options)) {
|
|
|
extend(options, item.options);
|
|
|
}
|
|
|
});
|
|
|
@@ -7463,8 +7705,8 @@ function parseComponent(vueOptions, { parse, mocks: mocks2, isPage: isPage2, ini
|
|
|
{
|
|
|
initWorkletMethods(mpComponentOptions.methods, vueOptions.methods);
|
|
|
}
|
|
|
- if (parse) {
|
|
|
- parse(mpComponentOptions, { handleLink: handleLink2 });
|
|
|
+ if (parse2) {
|
|
|
+ parse2(mpComponentOptions, { handleLink: handleLink2 });
|
|
|
}
|
|
|
return mpComponentOptions;
|
|
|
}
|
|
|
@@ -7492,7 +7734,7 @@ function $destroyComponent(instance) {
|
|
|
return $destroyComponentFn(instance);
|
|
|
}
|
|
|
function parsePage(vueOptions, parseOptions2) {
|
|
|
- const { parse, mocks: mocks2, isPage: isPage2, initRelation: initRelation2, handleLink: handleLink2, initLifetimes: initLifetimes2 } = parseOptions2;
|
|
|
+ const { parse: parse2, mocks: mocks2, isPage: isPage2, initRelation: initRelation2, handleLink: handleLink2, initLifetimes: initLifetimes2 } = parseOptions2;
|
|
|
const miniProgramPageOptions = parseComponent(vueOptions, {
|
|
|
mocks: mocks2,
|
|
|
isPage: isPage2,
|
|
|
@@ -7515,7 +7757,7 @@ function parsePage(vueOptions, parseOptions2) {
|
|
|
}
|
|
|
initRuntimeHooks(methods, vueOptions.__runtimeHooks);
|
|
|
initMixinRuntimeHooks(methods);
|
|
|
- parse && parse(miniProgramPageOptions, { handleLink: handleLink2 });
|
|
|
+ parse2 && parse2(miniProgramPageOptions, { handleLink: handleLink2 });
|
|
|
return miniProgramPageOptions;
|
|
|
}
|
|
|
function initCreatePage(parseOptions2) {
|
|
|
@@ -7658,6 +7900,7 @@ exports.createSSRApp = createSSRApp;
|
|
|
exports.e = e;
|
|
|
exports.f = f;
|
|
|
exports.index = index;
|
|
|
+exports.initVueI18n = initVueI18n;
|
|
|
exports.n = n;
|
|
|
exports.o = o;
|
|
|
exports.p = p;
|
liuguofeng