"use strict";
Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" });
const vue = require("vue");
const shared = require("@vue/shared");
const uniShared = require("@dcloudio/uni-shared");
const vueRouter = require("vue-router");
const uniI18n = require("@dcloudio/uni-i18n");
function arrayPop(array) {
if (array.length === 0) {
return null;
}
return array.pop();
}
function arrayShift(array) {
if (array.length === 0) {
return null;
}
return array.shift();
}
function arrayFind(array, predicate) {
const index2 = array.findIndex(predicate);
if (index2 < 0) {
return null;
}
return array[index2];
}
function arrayFindLast(array, predicate) {
const index2 = array.findLastIndex(predicate);
if (index2 < 0) {
return null;
}
return array[index2];
}
function arrayAt(array, index2) {
if (index2 < -array.length || index2 >= array.length) {
return null;
}
return array.at(index2);
}
var IDENTIFIER;
(function(IDENTIFIER2) {
IDENTIFIER2["UTSJSONObject"] = "UTSJSONObject";
IDENTIFIER2["JSON"] = "JSON";
IDENTIFIER2["UTS"] = "UTS";
IDENTIFIER2["DEFINE_COMPONENT"] = "defineComponent";
IDENTIFIER2["VUE"] = "vue";
IDENTIFIER2["GLOBAL_THIS"] = "globalThis";
IDENTIFIER2["UTS_TYPE"] = "UTSType";
IDENTIFIER2["UTS_METADATA"] = "$UTSMetadata$";
IDENTIFIER2["TEMP_UTS_METADATA"] = "$TempUTSMetadata$";
IDENTIFIER2["JSON_FIELD"] = "JSON_FIELD";
})(IDENTIFIER || (IDENTIFIER = {}));
var UTS_CLASS_METADATA_KIND;
(function(UTS_CLASS_METADATA_KIND2) {
UTS_CLASS_METADATA_KIND2[UTS_CLASS_METADATA_KIND2["CLASS"] = 0] = "CLASS";
UTS_CLASS_METADATA_KIND2[UTS_CLASS_METADATA_KIND2["INTERFACE"] = 1] = "INTERFACE";
UTS_CLASS_METADATA_KIND2[UTS_CLASS_METADATA_KIND2["TYPE"] = 2] = "TYPE";
})(UTS_CLASS_METADATA_KIND || (UTS_CLASS_METADATA_KIND = {}));
function getType$1(val) {
return Object.prototype.toString.call(val).slice(8, -1).toLowerCase();
}
function isPlainObject(val) {
if (val == null || typeof val !== "object") {
return false;
}
const proto = Object.getPrototypeOf(val);
return proto === Object.prototype || proto === null;
}
class UTSError extends Error {
constructor(message) {
super(message);
}
}
function isUTSMetadata(metadata) {
return !!(metadata && metadata.kind in UTS_CLASS_METADATA_KIND && metadata.interfaces);
}
function isNativeType(proto) {
return !proto || proto === Object.prototype;
}
const utsMetadataKey = IDENTIFIER.UTS_METADATA;
function getParentTypeList(type) {
const metadata = utsMetadataKey in type ? type[utsMetadataKey] : {};
let interfaces = [];
if (!isUTSMetadata(metadata)) {
interfaces = [];
} else {
interfaces = metadata.interfaces || [];
}
const proto = Object.getPrototypeOf(type);
if (!isNativeType(proto)) {
interfaces.push(proto.constructor);
}
return interfaces;
}
function isImplementationOf(leftType, rightType, visited = []) {
if (isNativeType(leftType)) {
return false;
}
if (leftType === rightType) {
return true;
}
visited.push(leftType);
const parentTypeList = getParentTypeList(leftType);
return parentTypeList.some((parentType) => {
if (visited.includes(parentType)) {
return false;
}
return isImplementationOf(parentType, rightType, visited);
});
}
function isInstanceOf(value, type) {
const isNativeInstanceofType = value instanceof type;
if (isNativeInstanceofType || typeof value !== "object") {
return isNativeInstanceofType;
}
const proto = Object.getPrototypeOf(value).constructor;
return isImplementationOf(proto, type);
}
function isBaseType(type) {
return type === Number || type === String || type === Boolean;
}
function isUnknownType(type) {
return type === "Unknown";
}
function isAnyType(type) {
return type === "Any";
}
function isUTSType(type) {
return type && type.prototype && type.prototype instanceof UTSType;
}
function normalizeGenericValue(value, genericType, isJSONParse = false) {
return value == null ? null : isBaseType(genericType) || isUnknownType(genericType) || isAnyType(genericType) ? value : genericType === Array ? new Array(...value) : new genericType(value, void 0, isJSONParse);
}
class UTSType {
static get$UTSMetadata$(...args) {
return {
kind: UTS_CLASS_METADATA_KIND.TYPE,
interfaces: [],
fields: {}
};
}
get $UTSMetadata$() {
return UTSType.get$UTSMetadata$();
}
// TODO 缓存withGenerics结果
static withGenerics(parent, generics, isJSONParse = false) {
if (isJSONParse) {
const illegalGeneric = generics.find((item) => !(item === Array || isBaseType(item) || isUnknownType(item) || isAnyType(item) || item === UTSJSONObject || item.prototype && item.prototype instanceof UTSType));
if (illegalGeneric) {
throw new Error("Generic is not UTSType or Array or UTSJSONObject or base type, generic: " + illegalGeneric);
}
}
if (parent === Array) {
return class UTSArray extends UTSType {
constructor(options, isJSONParse2 = false) {
if (!Array.isArray(options)) {
throw new UTSError(`Failed to contruct type, ${options} is not an array`);
}
super();
return options.map((item) => {
return normalizeGenericValue(item, generics[0], isJSONParse2);
});
}
};
} else if (parent === Map || parent === WeakMap) {
return class UTSMap extends UTSType {
constructor(options, isJSONParse2 = false) {
if (options == null || typeof options !== "object") {
throw new UTSError(`Failed to contruct type, ${options} is not an object`);
}
super();
const obj = new parent();
for (const key in options) {
obj.set(normalizeGenericValue(key, generics[0], isJSONParse2), normalizeGenericValue(options[key], generics[1], isJSONParse2));
}
return obj;
}
};
} else if (isUTSType(parent)) {
return class VirtualClassWithGenerics extends parent {
static get$UTSMetadata$() {
return parent.get$UTSMetadata$(...generics);
}
constructor(options, metadata = VirtualClassWithGenerics.get$UTSMetadata$(), isJSONParse2 = false) {
super(options, metadata, isJSONParse2);
}
};
} else {
return parent;
}
}
constructor() {
}
static initProps(options, metadata, isJSONParse = false) {
const obj = {};
if (!metadata.fields) {
return obj;
}
for (const key in metadata.fields) {
const { type, optional, jsonField } = metadata.fields[key];
const realKey = isJSONParse ? jsonField || key : key;
if (options[realKey] == null) {
if (optional) {
obj[key] = null;
continue;
} else {
throw new UTSError(`Failed to contruct type, missing required property: ${key}`);
}
}
if (isUTSType(type)) {
obj[key] = new type(options[realKey], void 0, isJSONParse);
} else if (type === Array) {
if (!Array.isArray(options[realKey])) {
throw new UTSError(`Failed to contruct type, property ${key} is not an array`);
}
obj[key] = options[realKey].map((item) => {
return item == null ? null : item;
});
} else {
obj[key] = options[realKey];
}
}
return obj;
}
}
const OriginalJSON = JSON;
function createUTSJSONObject(obj) {
const result = new UTSJSONObject({});
for (const key in obj) {
const value = obj[key];
if (isPlainObject(value)) {
result[key] = createUTSJSONObject(value);
} else if (getType$1(value) === "array") {
result[key] = value.map((item) => {
if (isPlainObject(item)) {
return createUTSJSONObject(item);
} else {
return item;
}
});
} else {
result[key] = value;
}
}
return result;
}
function parseObjectOrArray(object, utsType) {
const objectType = getType$1(object);
if (object === null || objectType !== "object" && objectType !== "array") {
return object;
}
if (utsType && utsType !== UTSJSONObject) {
try {
return new utsType(object, void 0, true);
} catch (error) {
console.error(error);
return null;
}
}
if (objectType === "array") {
return object.map((value) => {
return parseObjectOrArray(value);
});
} else if (objectType === "object") {
return createUTSJSONObject(object);
}
return object;
}
const UTSJSON = {
parse: (text, reviver, utsType) => {
if (reviver && (isUTSType(reviver) || reviver === UTSJSONObject)) {
utsType = reviver;
reviver = void 0;
}
try {
const parseResult = OriginalJSON.parse(text, reviver);
return parseObjectOrArray(parseResult, utsType);
} catch (error) {
console.error(error);
return null;
}
},
parseArray(text, utsType) {
try {
const parseResult = OriginalJSON.parse(text);
if (Array.isArray(parseResult)) {
return parseObjectOrArray(parseResult, utsType ? UTSType.withGenerics(Array, [utsType], true) : void 0);
}
return null;
} catch (error) {
console.error(error);
return null;
}
},
parseObject(text, utsType) {
try {
const parseResult = OriginalJSON.parse(text);
if (Array.isArray(parseResult)) {
return null;
}
return parseObjectOrArray(parseResult, utsType);
} catch (error) {
console.error(error);
return null;
}
},
stringify: (value) => {
return OriginalJSON.stringify(value);
}
};
function mapGet(map, key) {
if (!map.has(key)) {
return null;
}
return map.get(key);
}
function stringCodePointAt(str, pos) {
if (pos < 0 || pos >= str.length) {
return null;
}
return str.codePointAt(pos);
}
function stringAt(str, pos) {
if (pos < -str.length || pos >= str.length) {
return null;
}
return str.at(pos);
}
function weakMapGet(map, key) {
if (!map.has(key)) {
return null;
}
return map.get(key);
}
const UTS$1 = {
arrayAt,
arrayFind,
arrayFindLast,
arrayPop,
arrayShift,
isInstanceOf,
UTSType,
mapGet,
stringAt,
stringCodePointAt,
weakMapGet,
JSON: UTSJSON
};
let UniError$1 = class UniError2 extends Error {
constructor(errSubject, errCode, errMsg) {
let options = {};
const argsLength = Array.from(arguments).length;
switch (argsLength) {
case 0:
errSubject = "";
errMsg = "";
errCode = 0;
break;
case 1:
errMsg = errSubject;
errSubject = "";
errCode = 0;
break;
case 2:
errMsg = errSubject;
options = errCode;
errCode = options.errCode || 0;
errSubject = options.errSubject || "";
break;
}
super(errMsg);
this.name = "UniError";
this.errSubject = errSubject;
this.errCode = errCode;
this.errMsg = errMsg;
if (options.data) {
this.data = options.data;
}
if (options.cause) {
this.cause = options.cause;
}
}
set errMsg(msg) {
this.message = msg;
}
get errMsg() {
return this.message;
}
toString() {
return this.errMsg;
}
toJSON() {
return {
errSubject: this.errSubject,
errCode: this.errCode,
errMsg: this.errMsg,
data: this.data,
cause: this.cause && typeof this.cause.toJSON === "function" ? this.cause.toJSON() : this.cause
};
}
};
function initUTSJSONObjectProperties(obj) {
const propertyList = [
"_resolveKeyPath",
"_getValue",
"toJSON",
"get",
"set",
"getAny",
"getString",
"getNumber",
"getBoolean",
"getJSON",
"getArray",
"toMap",
"forEach"
];
const propertyDescriptorMap = {};
for (let i = 0; i < propertyList.length; i++) {
const property = propertyList[i];
propertyDescriptorMap[property] = {
enumerable: false,
value: obj[property]
};
}
Object.defineProperties(obj, propertyDescriptorMap);
}
let UTSJSONObject$1 = class UTSJSONObject2 {
static keys(obj) {
return Object.keys(obj);
}
static assign(target, ...sources) {
for (let i = 0; i < sources.length; i++) {
const source = sources[i];
for (let key in source) {
target[key] = source[key];
}
}
return target;
}
constructor(content = {}) {
if (content instanceof Map) {
content.forEach((value, key) => {
this[key] = value;
});
} else {
for (const key in content) {
if (Object.prototype.hasOwnProperty.call(content, key)) {
this[key] = content[key];
}
}
}
initUTSJSONObjectProperties(this);
}
_resolveKeyPath(keyPath) {
let token = "";
const keyPathArr = [];
let inOpenParentheses = false;
for (let i = 0; i < keyPath.length; i++) {
const word = keyPath[i];
switch (word) {
case ".":
if (token.length > 0) {
keyPathArr.push(token);
token = "";
}
break;
case "[": {
inOpenParentheses = true;
if (token.length > 0) {
keyPathArr.push(token);
token = "";
}
break;
}
case "]":
if (inOpenParentheses) {
if (token.length > 0) {
const tokenFirstChar = token[0];
const tokenLastChar = token[token.length - 1];
if (tokenFirstChar === '"' && tokenLastChar === '"' || tokenFirstChar === "'" && tokenLastChar === "'" || tokenFirstChar === "`" && tokenLastChar === "`") {
if (token.length > 2) {
token = token.slice(1, -1);
} else {
return [];
}
} else if (!/^\d+$/.test(token)) {
return [];
}
keyPathArr.push(token);
token = "";
} else {
return [];
}
inOpenParentheses = false;
} else {
return [];
}
break;
default:
token += word;
break;
}
if (i === keyPath.length - 1) {
if (token.length > 0) {
keyPathArr.push(token);
token = "";
}
}
}
return keyPathArr;
}
_getValue(keyPath) {
const keyPathArr = this._resolveKeyPath(keyPath);
if (keyPathArr.length === 0) {
return null;
}
let value = this;
for (let i = 0; i < keyPathArr.length; i++) {
const key = keyPathArr[i];
if (value instanceof Object) {
value = value[key];
} else {
return null;
}
}
return value;
}
get(key) {
return this._getValue(key);
}
set(key, value) {
this[key] = value;
}
getAny(key) {
return this._getValue(key);
}
getString(key) {
const value = this._getValue(key);
if (typeof value === "string") {
return value;
} else {
return null;
}
}
getNumber(key) {
const value = this._getValue(key);
if (typeof value === "number") {
return value;
} else {
return null;
}
}
getBoolean(key) {
const boolean = this._getValue(key);
if (typeof boolean === "boolean") {
return boolean;
} else {
return null;
}
}
getJSON(key) {
let value = this._getValue(key);
if (value instanceof Object) {
return new UTSJSONObject2(value);
} else {
return null;
}
}
getArray(key) {
let value = this._getValue(key);
if (value instanceof Array) {
return value;
} else {
return null;
}
}
toMap() {
let map = /* @__PURE__ */ new Map();
for (let key in this) {
map.set(key, this[key]);
}
return map;
}
forEach(callback) {
for (let key in this) {
callback(this[key], key);
}
}
};
function getGlobal() {
if (typeof globalThis !== "undefined") {
return globalThis;
}
if (typeof self !== "undefined") {
return self;
}
if (typeof window !== "undefined") {
return window;
}
if (typeof global !== "undefined") {
return global;
}
function g2() {
return this;
}
if (typeof g2() !== "undefined") {
return g2();
}
return function() {
return new Function("return this")();
}();
}
const realGlobal = getGlobal();
realGlobal.UTSJSONObject = UTSJSONObject$1;
realGlobal.UniError = UniError$1;
realGlobal.UTS = UTS$1;
const isEnableLocale = /* @__PURE__ */ uniShared.once(
() => typeof __uniConfig !== "undefined" && __uniConfig.locales && !!Object.keys(__uniConfig.locales).length
);
let i18n;
function getLocaleMessage() {
const locale = uni.getLocale();
const locales = __uniConfig.locales;
return locales[locale] || locales[__uniConfig.fallbackLocale] || locales.en || {};
}
function formatI18n(message) {
if (uniI18n.isI18nStr(message, uniShared.I18N_JSON_DELIMITERS)) {
return useI18n().f(message, getLocaleMessage(), uniShared.I18N_JSON_DELIMITERS);
}
return message;
}
function resolveJsonObj(jsonObj, names) {
if (names.length === 1) {
if (jsonObj) {
const _isI18nStr = (value2) => shared.isString(value2) && uniI18n.isI18nStr(value2, uniShared.I18N_JSON_DELIMITERS);
const _name = names[0];
let filterJsonObj = [];
if (shared.isArray(jsonObj) && (filterJsonObj = jsonObj.filter((item) => _isI18nStr(item[_name]))).length) {
return filterJsonObj;
}
const value = jsonObj[names[0]];
if (_isI18nStr(value)) {
return jsonObj;
}
}
return;
}
const name = names.shift();
return resolveJsonObj(jsonObj && jsonObj[name], names);
}
function defineI18nProperties(obj, names) {
return names.map((name) => defineI18nProperty(obj, name));
}
function defineI18nProperty(obj, names) {
const jsonObj = resolveJsonObj(obj, names);
if (!jsonObj) {
return false;
}
const prop = names[names.length - 1];
if (shared.isArray(jsonObj)) {
jsonObj.forEach((item) => defineI18nProperty(item, [prop]));
} else {
let value = jsonObj[prop];
Object.defineProperty(jsonObj, prop, {
get() {
return formatI18n(value);
},
set(v2) {
value = v2;
}
});
}
return true;
}
function useI18n() {
if (!i18n) {
let locale;
{
{
locale = uniShared.getEnvLocale();
}
}
i18n = uniI18n.initVueI18n(locale);
if (isEnableLocale()) {
const localeKeys = Object.keys(__uniConfig.locales || {});
if (localeKeys.length) {
localeKeys.forEach(
(locale2) => i18n.add(locale2, __uniConfig.locales[locale2])
);
}
i18n.setLocale(locale);
}
}
return i18n;
}
function normalizeMessages(module2, keys, values) {
return keys.reduce((res, name, index2) => {
res[module2 + name] = values[index2];
return res;
}, {});
}
const initI18nAsyncMsgsOnce = /* @__PURE__ */ uniShared.once(() => {
const name = "uni.async.";
const keys = ["error"];
if (__UNI_FEATURE_I18N_EN__) {
useI18n().add(
uniI18n.LOCALE_EN,
normalizeMessages(name, keys, [
"The connection timed out, click the screen to try again."
]),
false
);
}
if (__UNI_FEATURE_I18N_ES__) {
useI18n().add(
uniI18n.LOCALE_ES,
normalizeMessages(name, keys, [
"Se agotó el tiempo de conexión, haga clic en la pantalla para volver a intentarlo."
]),
false
);
}
if (__UNI_FEATURE_I18N_FR__) {
useI18n().add(
uniI18n.LOCALE_FR,
normalizeMessages(name, keys, [
"La connexion a expiré, cliquez sur l'écran pour réessayer."
]),
false
);
}
if (__UNI_FEATURE_I18N_ZH_HANS__) {
useI18n().add(
uniI18n.LOCALE_ZH_HANS,
normalizeMessages(name, keys, ["连接服务器超时,点击屏幕重试"]),
false
);
}
if (__UNI_FEATURE_I18N_ZH_HANT__) {
useI18n().add(
uniI18n.LOCALE_ZH_HANT,
normalizeMessages(name, keys, ["連接服務器超時,點擊屏幕重試"]),
false
);
}
});
const initI18nPickerMsgsOnce = /* @__PURE__ */ uniShared.once(() => {
const name = "uni.picker.";
const keys = ["done", "cancel"];
if (__UNI_FEATURE_I18N_EN__) {
useI18n().add(
uniI18n.LOCALE_EN,
normalizeMessages(name, keys, ["Done", "Cancel"]),
false
);
}
if (__UNI_FEATURE_I18N_ES__) {
useI18n().add(
uniI18n.LOCALE_ES,
normalizeMessages(name, keys, ["OK", "Cancelar"]),
false
);
}
if (__UNI_FEATURE_I18N_FR__) {
useI18n().add(
uniI18n.LOCALE_FR,
normalizeMessages(name, keys, ["OK", "Annuler"]),
false
);
}
if (__UNI_FEATURE_I18N_ZH_HANS__) {
useI18n().add(
uniI18n.LOCALE_ZH_HANS,
normalizeMessages(name, keys, ["完成", "取消"]),
false
);
}
if (__UNI_FEATURE_I18N_ZH_HANT__) {
useI18n().add(
uniI18n.LOCALE_ZH_HANT,
normalizeMessages(name, keys, ["完成", "取消"]),
false
);
}
});
const initI18nVideoMsgsOnce = /* @__PURE__ */ uniShared.once(() => {
const name = "uni.video.";
const keys = ["danmu", "volume"];
if (__UNI_FEATURE_I18N_EN__) {
useI18n().add(
uniI18n.LOCALE_EN,
normalizeMessages(name, keys, ["Danmu", "Volume"]),
false
);
}
if (__UNI_FEATURE_I18N_ES__) {
useI18n().add(
uniI18n.LOCALE_ES,
normalizeMessages(name, keys, ["Danmu", "Volumen"]),
false
);
}
if (__UNI_FEATURE_I18N_FR__) {
useI18n().add(
uniI18n.LOCALE_FR,
normalizeMessages(name, keys, ["Danmu", "Le Volume"]),
false
);
}
if (__UNI_FEATURE_I18N_ZH_HANS__) {
useI18n().add(
uniI18n.LOCALE_ZH_HANS,
normalizeMessages(name, keys, ["弹幕", "音量"]),
false
);
}
if (__UNI_FEATURE_I18N_ZH_HANT__) {
useI18n().add(
uniI18n.LOCALE_ZH_HANT,
normalizeMessages(name, keys, ["彈幕", "音量"]),
false
);
}
});
function initNavigationBarI18n(navigationBar) {
if (isEnableLocale()) {
return defineI18nProperties(navigationBar, [
["titleText"],
["searchInput", "placeholder"],
["buttons", "text"]
]);
}
}
function initTabBarI18n(tabBar2) {
if (isEnableLocale() && tabBar2.list) {
tabBar2.list.forEach((item) => {
defineI18nProperty(item, ["text"]);
});
}
return tabBar2;
}
function initBridge(subscribeNamespace) {
const emitter = new uniShared.Emitter();
return {
on(event, callback) {
return emitter.on(event, callback);
},
once(event, callback) {
return emitter.once(event, callback);
},
off(event, callback) {
return emitter.off(event, callback);
},
emit(event, ...args) {
return emitter.emit(event, ...args);
},
subscribe(event, callback, once = false) {
emitter[once ? "once" : "on"](`${subscribeNamespace}.${event}`, callback);
},
unsubscribe(event, callback) {
emitter.off(`${subscribeNamespace}.${event}`, callback);
},
subscribeHandler(event, args, pageId) {
emitter.emit(`${subscribeNamespace}.${event}`, args, pageId);
}
};
}
const INVOKE_VIEW_API = "invokeViewApi";
const INVOKE_SERVICE_API = "invokeServiceApi";
let invokeServiceMethodId = 1;
const invokeServiceMethod = (name, args, callback) => {
const { subscribe, publishHandler } = UniViewJSBridge;
const id2 = callback ? invokeServiceMethodId++ : 0;
callback && subscribe(INVOKE_SERVICE_API + "." + id2, callback, true);
publishHandler(INVOKE_SERVICE_API, { id: id2, name, args });
};
const viewMethods = /* @__PURE__ */ Object.create(null);
function normalizeViewMethodName(pageId, name) {
return pageId + "." + name;
}
function registerViewMethod(pageId, name, fn) {
name = normalizeViewMethodName(pageId, name);
if (!viewMethods[name]) {
viewMethods[name] = fn;
}
}
const ViewJSBridge = /* @__PURE__ */ shared.extend(
/* @__PURE__ */ initBridge("service"),
{
invokeServiceMethod
}
);
const onEventPrevent = /* @__PURE__ */ vue.withModifiers(() => {
}, ["prevent"]);
const onEventStop = /* @__PURE__ */ vue.withModifiers(
(_event) => {
},
["stop"]
);
function updateCssVar(cssVars) {
const style = document.documentElement.style;
Object.keys(cssVars).forEach((name) => {
style.setProperty(name, cssVars[name]);
});
}
function updatePageCssVar(cssVars) {
return updateCssVar(cssVars);
}
function PolySymbol(name) {
return Symbol(process.env.NODE_ENV !== "production" ? "[uni-app]: " + name : name);
}
function rpx2px(str, replace = false) {
if (replace) {
return rpx2pxWithReplace(str);
}
{
return parseInt(str + "");
}
}
function rpx2pxWithReplace(str) {
{
return str;
}
}
function get$pageByPage(page) {
return page.vm.$basePage;
}
const ICON_PATH_CANCEL = "M20.928 10.176l-4.928 4.928-4.928-4.928-0.896 0.896 4.928 4.928-4.928 4.928 0.896 0.896 4.928-4.928 4.928 4.928 0.896-0.896-4.928-4.928 4.928-4.928-0.896-0.896zM16 2.080q-3.776 0-7.040 1.888-3.136 1.856-4.992 4.992-1.888 3.264-1.888 7.040t1.888 7.040q1.856 3.136 4.992 4.992 3.264 1.888 7.040 1.888t7.040-1.888q3.136-1.856 4.992-4.992 1.888-3.264 1.888-7.040t-1.888-7.040q-1.856-3.136-4.992-4.992-3.264-1.888-7.040-1.888zM16 28.64q-3.424 0-6.4-1.728-2.848-1.664-4.512-4.512-1.728-2.976-1.728-6.4t1.728-6.4q1.664-2.848 4.512-4.512 2.976-1.728 6.4-1.728t6.4 1.728q2.848 1.664 4.512 4.512 1.728 2.976 1.728 6.4t-1.728 6.4q-1.664 2.848-4.512 4.512-2.976 1.728-6.4 1.728z";
const ICON_PATH_CLEAR = "M16 0q-4.352 0-8.064 2.176-3.616 2.144-5.76 5.76-2.176 3.712-2.176 8.064t2.176 8.064q2.144 3.616 5.76 5.76 3.712 2.176 8.064 2.176t8.064-2.176q3.616-2.144 5.76-5.76 2.176-3.712 2.176-8.064t-2.176-8.064q-2.144-3.616-5.76-5.76-3.712-2.176-8.064-2.176zM22.688 21.408q0.32 0.32 0.304 0.752t-0.336 0.736-0.752 0.304-0.752-0.32l-5.184-5.376-5.376 5.184q-0.32 0.32-0.752 0.304t-0.736-0.336-0.304-0.752 0.32-0.752l5.376-5.184-5.184-5.376q-0.32-0.32-0.304-0.752t0.336-0.752 0.752-0.304 0.752 0.336l5.184 5.376 5.376-5.184q0.32-0.32 0.752-0.304t0.752 0.336 0.304 0.752-0.336 0.752l-5.376 5.184 5.184 5.376z";
const ICON_PATH_DOWNLOAD = "M15.808 1.696q-3.776 0-7.072 1.984-3.2 1.888-5.088 5.152-1.952 3.392-1.952 7.36 0 3.776 1.952 7.072 1.888 3.2 5.088 5.088 3.296 1.952 7.072 1.952 3.968 0 7.36-1.952 3.264-1.888 5.152-5.088 1.984-3.296 1.984-7.072 0-4-1.984-7.36-1.888-3.264-5.152-5.152-3.36-1.984-7.36-1.984zM20.864 18.592l-3.776 4.928q-0.448 0.576-1.088 0.576t-1.088-0.576l-3.776-4.928q-0.448-0.576-0.24-0.992t0.944-0.416h2.976v-8.928q0-0.256 0.176-0.432t0.4-0.176h1.216q0.224 0 0.4 0.176t0.176 0.432v8.928h2.976q0.736 0 0.944 0.416t-0.24 0.992z";
const ICON_PATH_INFO = "M15.808 0.128q-4.224 0-7.872 2.176-3.552 2.112-5.632 5.728-2.176 3.776-2.176 8.16 0 4.224 2.176 7.872 2.080 3.552 5.632 5.632 3.648 2.176 7.872 2.176 4.384 0 8.16-2.176 3.616-2.080 5.728-5.632 2.176-3.648 2.176-7.872 0-4.416-2.176-8.16-2.112-3.616-5.728-5.728-3.744-2.176-8.16-2.176zM16.864 23.776q0 0.064-0.064 0.064h-1.568q-0.096 0-0.096-0.064l-0.256-11.328q0-0.064 0.064-0.064h2.112q0.096 0 0.064 0.064l-0.256 11.328zM16 10.88q-0.576 0-0.976-0.4t-0.4-0.96 0.4-0.96 0.976-0.4 0.976 0.4 0.4 0.96-0.4 0.96-0.976 0.4z";
const ICON_PATH_SEARCH = "M20.928 22.688q-1.696 1.376-3.744 2.112-2.112 0.768-4.384 0.768-3.488 0-6.464-1.728-2.88-1.696-4.576-4.608-1.76-2.976-1.76-6.464t1.76-6.464q1.696-2.88 4.576-4.576 2.976-1.76 6.464-1.76t6.464 1.76q2.912 1.696 4.608 4.576 1.728 2.976 1.728 6.464 0 2.272-0.768 4.384-0.736 2.048-2.112 3.744l9.312 9.28-1.824 1.824-9.28-9.312zM12.8 23.008q2.784 0 5.184-1.376 2.304-1.376 3.68-3.68 1.376-2.4 1.376-5.184t-1.376-5.152q-1.376-2.336-3.68-3.68-2.4-1.408-5.184-1.408t-5.152 1.408q-2.336 1.344-3.68 3.68-1.408 2.368-1.408 5.152t1.408 5.184q1.344 2.304 3.68 3.68 2.368 1.376 5.152 1.376zM12.8 23.008v0z";
const ICON_PATH_SUCCESS_NO_CIRCLE = "M1.952 18.080q-0.32-0.352-0.416-0.88t0.128-0.976l0.16-0.352q0.224-0.416 0.64-0.528t0.8 0.176l6.496 4.704q0.384 0.288 0.912 0.272t0.88-0.336l17.312-14.272q0.352-0.288 0.848-0.256t0.848 0.352l-0.416-0.416q0.32 0.352 0.32 0.816t-0.32 0.816l-18.656 18.912q-0.32 0.352-0.8 0.352t-0.8-0.32l-7.936-8.064z";
const ICON_PATH_SUCCESS = "M15.808 0.16q-4.224 0-7.872 2.176-3.552 2.112-5.632 5.728-2.144 3.744-2.144 8.128 0 4.192 2.144 7.872 2.112 3.52 5.632 5.632 3.68 2.144 7.872 2.144 4.384 0 8.128-2.144 3.616-2.080 5.728-5.632 2.176-3.648 2.176-7.872 0-4.384-2.176-8.128-2.112-3.616-5.728-5.728-3.744-2.176-8.128-2.176zM24.832 11.328l-11.264 11.104q-0.032 0.032-0.112 0.032t-0.112-0.032l-5.216-5.376q-0.096-0.128 0-0.288l0.704-0.96q0.032-0.064 0.112-0.064t0.112 0.032l4.256 3.264q0.064 0.032 0.144 0.032t0.112-0.032l10.336-8.608q0.064-0.064 0.144-0.064t0.112 0.064l0.672 0.672q0.128 0.128 0 0.224z";
const ICON_PATH_WAITING = "M15.84 0.096q-4.224 0-7.872 2.176-3.552 2.112-5.632 5.728-2.144 3.744-2.144 8.128 0 4.192 2.144 7.872 2.112 3.52 5.632 5.632 3.68 2.144 7.872 2.144 4.384 0 8.128-2.144 3.616-2.080 5.728-5.632 2.176-3.648 2.176-7.872 0-4.384-2.176-8.128-2.112-3.616-5.728-5.728-3.744-2.176-8.128-2.176zM23.008 21.92l-0.512 0.896q-0.096 0.128-0.224 0.064l-8-3.808q-0.096-0.064-0.16-0.128-0.128-0.096-0.128-0.288l0.512-12.096q0-0.064 0.048-0.112t0.112-0.048h1.376q0.064 0 0.112 0.048t0.048 0.112l0.448 10.848 6.304 4.256q0.064 0.064 0.080 0.128t-0.016 0.128z";
const ICON_PATH_WARN = "M15.808 0.16q-4.224 0-7.872 2.176-3.552 2.112-5.632 5.728-2.144 3.744-2.144 8.128 0 4.192 2.144 7.872 2.112 3.52 5.632 5.632 3.68 2.144 7.872 2.144 4.384 0 8.128-2.144 3.616-2.080 5.728-5.632 2.176-3.648 2.176-7.872 0-4.384-2.176-8.128-2.112-3.616-5.728-5.728-3.744-2.176-8.128-2.176zM15.136 8.672h1.728q0.128 0 0.224 0.096t0.096 0.256l-0.384 10.24q0 0.064-0.048 0.112t-0.112 0.048h-1.248q-0.096 0-0.144-0.048t-0.048-0.112l-0.384-10.24q0-0.16 0.096-0.256t0.224-0.096zM16 23.328q-0.48 0-0.832-0.352t-0.352-0.848 0.352-0.848 0.832-0.352 0.832 0.352 0.352 0.848-0.352 0.848-0.832 0.352z";
const ICON_PATH_BACK = "M21.781 7.844l-9.063 8.594 9.063 8.594q0.25 0.25 0.25 0.609t-0.25 0.578q-0.25 0.25-0.578 0.25t-0.578-0.25l-9.625-9.125q-0.156-0.125-0.203-0.297t-0.047-0.359q0-0.156 0.047-0.328t0.203-0.297l9.625-9.125q0.25-0.25 0.578-0.25t0.578 0.25q0.25 0.219 0.25 0.578t-0.25 0.578z";
const ICON_PATH_CLOSE = "M17.25 16.156l7.375-7.313q0.281-0.281 0.281-0.641t-0.281-0.641q-0.25-0.25-0.625-0.25t-0.625 0.25l-7.375 7.344-7.313-7.344q-0.25-0.25-0.625-0.25t-0.625 0.25q-0.281 0.25-0.281 0.625t0.281 0.625l7.313 7.344-7.375 7.344q-0.281 0.25-0.281 0.625t0.281 0.625q0.125 0.125 0.281 0.188t0.344 0.063q0.156 0 0.328-0.063t0.297-0.188l7.375-7.344 7.375 7.406q0.125 0.156 0.297 0.219t0.328 0.063q0.188 0 0.344-0.078t0.281-0.203q0.281-0.25 0.281-0.609t-0.281-0.641l-7.375-7.406z";
function createSvgIconVNode(path, color = "#000", size = 27) {
return vue.createVNode(
"svg",
{
width: size,
height: size,
viewBox: "0 0 32 32"
},
[
vue.createVNode(
"path",
{
d: path,
fill: color
},
null,
8,
["d", "fill"]
)
],
8,
["width", "height"]
);
}
function useCurrentPageId() {
{
const { $pageInstance } = vue.getCurrentInstance();
return $pageInstance && getPageProxyId($pageInstance.proxy);
}
}
function getCurrentPage() {
const pages = getCurrentPages();
const len = pages.length;
if (len) {
return pages[len - 1];
}
}
function getCurrentPageMeta() {
var _a, _b;
const $page = (_b = (_a = getCurrentPage()) == null ? void 0 : _a.vm) == null ? void 0 : _b.$basePage;
if ($page) {
return $page.meta;
}
}
function getCurrentPageId() {
const meta = getCurrentPageMeta();
if (meta) {
return meta.id;
}
return -1;
}
function getCurrentPageVm() {
var _a;
const page = (_a = getCurrentPage()) == null ? void 0 : _a.vm;
if (page) {
return page.$vm;
}
}
const PAGE_META_KEYS = ["navigationBar", "pullToRefresh"];
function initGlobalStyle() {
return JSON.parse(JSON.stringify(__uniConfig.globalStyle || {}));
}
function initRouteMeta(pageMeta, id2) {
const globalStyle = initGlobalStyle();
const res = shared.extend({ id: id2 }, globalStyle, pageMeta);
PAGE_META_KEYS.forEach((name) => {
res[name] = shared.extend({}, globalStyle[name], pageMeta[name]);
});
const { navigationBar } = res;
navigationBar.titleText && navigationBar.titleImage && (navigationBar.titleText = "");
return res;
}
function normalizePullToRefreshRpx(pullToRefresh) {
if (pullToRefresh.offset) {
pullToRefresh.offset = rpx2px(pullToRefresh.offset);
}
if (pullToRefresh.height) {
pullToRefresh.height = rpx2px(pullToRefresh.height);
}
if (pullToRefresh.range) {
pullToRefresh.range = rpx2px(pullToRefresh.range);
}
return pullToRefresh;
}
function initPageInternalInstance(openType, url, pageQuery, meta, eventChannel, themeMode) {
const { id: id2, route } = meta;
const titleColor = uniShared.normalizeStyles(
meta.navigationBar,
__uniConfig.themeConfig,
themeMode
).titleColor;
return {
id: id2,
path: uniShared.addLeadingSlash(route),
route,
fullPath: url,
options: pageQuery,
meta,
openType,
eventChannel,
statusBarStyle: titleColor === "#ffffff" ? "light" : "dark"
};
}
function getPageProxyId(proxy) {
var _a, _b;
return ((_a = proxy.$page) == null ? void 0 : _a.id) || ((_b = proxy.$basePage) == null ? void 0 : _b.id);
}
function invokeHook(vm, name, args) {
if (shared.isString(vm)) {
args = name;
name = vm;
vm = getCurrentPageVm();
} else if (typeof vm === "number") {
const page = getCurrentPages().find(
(page2) => get$pageByPage(page2).id === vm
);
if (page) {
vm = page.$vm;
} else {
vm = getCurrentPageVm();
}
}
if (!vm) {
return;
}
const hooks = vm.$[name];
return hooks && uniShared.invokeArrayFns(hooks, args);
}
function getRealRoute(fromRoute, toRoute) {
if (toRoute.indexOf("/") === 0) {
return toRoute;
}
if (toRoute.indexOf("./") === 0) {
return getRealRoute(fromRoute, toRoute.slice(2));
}
const toRouteArray = toRoute.split("/");
const toRouteLength = toRouteArray.length;
let i = 0;
for (; i < toRouteLength && toRouteArray[i] === ".."; i++) {
}
toRouteArray.splice(0, i);
toRoute = toRouteArray.join("/");
const fromRouteArray = fromRoute.length > 0 ? fromRoute.split("/") : [];
fromRouteArray.splice(fromRouteArray.length - i - 1, i + 1);
return uniShared.addLeadingSlash(fromRouteArray.concat(toRouteArray).join("/"));
}
function getRouteOptions(path, alias = false) {
if (alias) {
return __uniRoutes.find(
(route) => route.path === path || route.alias === path
);
}
return __uniRoutes.find((route) => route.path === path);
}
const invokeOnCallback = (name, res) => UniServiceJSBridge.emit("api." + name, res);
let invokeViewMethodId = 1;
function publishViewMethodName(pageId) {
return (pageId || getCurrentPageId()) + "." + INVOKE_VIEW_API;
}
const invokeViewMethod = (name, args, pageId, callback) => {
const { subscribe, publishHandler } = UniServiceJSBridge;
const id2 = callback ? invokeViewMethodId++ : 0;
callback && subscribe(INVOKE_VIEW_API + "." + id2, callback, true);
publishHandler(publishViewMethodName(pageId), { id: id2, name, args }, pageId);
};
const invokeViewMethodKeepAlive = (name, args, callback, pageId) => {
const { subscribe, unsubscribe, publishHandler } = UniServiceJSBridge;
const id2 = invokeViewMethodId++;
const subscribeName = INVOKE_VIEW_API + "." + id2;
subscribe(subscribeName, callback);
publishHandler(publishViewMethodName(pageId), { id: id2, name, args }, pageId);
return () => {
unsubscribe(subscribeName);
};
};
const ServiceJSBridge = /* @__PURE__ */ shared.extend(
/* @__PURE__ */ initBridge(
"view"
/* view 指的是 service 层订阅的是 view 层事件 */
),
{
invokeOnCallback,
invokeViewMethod,
invokeViewMethodKeepAlive
}
);
function initAppVm(appVm2) {
appVm2.$vm = appVm2;
appVm2.$mpType = "app";
const locale = vue.ref(useI18n().getLocale());
Object.defineProperty(appVm2, "$locale", {
get() {
return locale.value;
},
set(v2) {
locale.value = v2;
}
});
}
function initPageVm(pageVm, page) {
pageVm.route = page.route;
pageVm.$vm = pageVm;
pageVm.$page = page;
pageVm.$mpType = "page";
pageVm.$fontFamilySet = /* @__PURE__ */ new Set();
if (page.meta.isTabBar) {
pageVm.$.__isTabBar = true;
pageVm.$.__isActive = true;
}
}
function defineGlobalData(app, defaultGlobalData) {
const options = app.$options || {};
options.globalData = shared.extend(options.globalData || {}, defaultGlobalData);
Object.defineProperty(app, "globalData", {
get() {
return options.globalData;
},
set(newGlobalData) {
options.globalData = newGlobalData;
}
});
}
function converPx(value) {
if (/^-?\d+[ur]px$/i.test(value)) {
return value.replace(/(^-?\d+)[ur]px$/i, (text, num) => {
return `${uni.upx2px(parseFloat(num))}px`;
});
} else if (/^-?[\d\.]+$/.test(value)) {
return `${value}px`;
}
return value || "";
}
function converType(type) {
return type.replace(/[A-Z]/g, (text) => {
return `-${text.toLowerCase()}`;
}).replace("webkit", "-webkit");
}
function getStyle(action) {
const animateTypes1 = [
"matrix",
"matrix3d",
"scale",
"scale3d",
"rotate3d",
"skew",
"translate",
"translate3d"
];
const animateTypes2 = [
"scaleX",
"scaleY",
"scaleZ",
"rotate",
"rotateX",
"rotateY",
"rotateZ",
"skewX",
"skewY",
"translateX",
"translateY",
"translateZ"
];
const animateTypes3 = ["opacity", "background-color"];
const animateTypes4 = ["width", "height", "left", "right", "top", "bottom"];
const animates = action.animates;
const option = action.option;
const transition = option.transition;
const style = {};
const transform = [];
animates.forEach((animate) => {
let type = animate.type;
let args = [...animate.args];
if (animateTypes1.concat(animateTypes2).includes(type)) {
if (type.startsWith("rotate") || type.startsWith("skew")) {
args = args.map((value) => parseFloat(value) + "deg");
} else if (type.startsWith("translate")) {
args = args.map(converPx);
}
if (animateTypes2.indexOf(type) >= 0) {
args.length = 1;
}
transform.push(`${type}(${args.join(",")})`);
} else if (animateTypes3.concat(animateTypes4).includes(args[0])) {
type = args[0];
const value = args[1];
style[type] = animateTypes4.includes(type) ? converPx(value) : value;
}
});
style.transform = style.webkitTransform = transform.join(" ");
style.transition = style.webkitTransition = Object.keys(style).map(
(type) => `${converType(type)} ${transition.duration}ms ${transition.timingFunction} ${transition.delay}ms`
).join(",");
style.transformOrigin = style.webkitTransformOrigin = option.transformOrigin;
return style;
}
function startAnimation(context) {
const animation2 = context.animation;
if (!animation2 || !animation2.actions || !animation2.actions.length) {
return;
}
let index2 = 0;
const actions = animation2.actions;
const length = animation2.actions.length;
function animate() {
const action = actions[index2];
const transition = action.option.transition;
const style = getStyle(action);
Object.keys(style).forEach((key) => {
context.$el.style[key] = style[key];
});
index2 += 1;
if (index2 < length) {
setTimeout(animate, transition.duration + transition.delay);
}
}
setTimeout(() => {
animate();
}, 0);
}
const animation = {
props: ["animation"],
watch: {
animation: {
deep: true,
handler() {
startAnimation(this);
}
}
},
mounted() {
startAnimation(this);
}
};
const defineBuiltInComponent = (options) => {
options.__reserved = true;
const { props: props2, mixins } = options;
if (!props2 || !props2.animation) {
(mixins || (options.mixins = [])).push(animation);
}
return defineSystemComponent(options);
};
const defineSystemComponent = (options) => {
options.__reserved = true;
options.compatConfig = {
MODE: 3
// 标记为vue3
};
return vue.defineComponent(options);
};
const defineUnsupportedComponent = (name) => {
return defineBuiltInComponent({
name: shared.capitalize(shared.camelize(name)),
setup() {
return () => (vue.openBlock(), vue.createElementBlock("uni-" + name, null, name + " is unsupported"));
}
});
};
function withWebEvent(fn) {
return fn.__wwe = true, fn;
}
function useCustomEvent(ref, emit2) {
return (name, evt, detail) => {
if (ref.value) {
emit2(name, normalizeCustomEvent(name, evt, ref.value, detail || {}));
}
};
}
function normalizeCustomEvent(name, domEvt, el, detail) {
let target;
target = uniShared.normalizeTarget(el);
return {
type: detail.type || name,
timeStamp: domEvt.timeStamp || 0,
target,
currentTarget: target,
detail
};
}
const hoverProps = {
hoverClass: {
type: String,
default: "none"
},
hoverStopPropagation: {
type: Boolean,
default: false
},
hoverStartTime: {
type: [Number, String],
default: 50
},
hoverStayTime: {
type: [Number, String],
default: 400
}
};
function useHover(props2) {
const hovering = vue.ref(false);
let hoverTouch = false;
let hoverStartTimer;
let hoverStayTimer;
function hoverReset() {
requestAnimationFrame(() => {
clearTimeout(hoverStayTimer);
hoverStayTimer = setTimeout(() => {
hovering.value = false;
}, parseInt(props2.hoverStayTime));
});
}
function onTouchstartPassive(evt) {
if (evt.touches.length > 1) {
return;
}
handleHoverStart(evt);
}
function onMousedown(evt) {
if (hoverTouch) {
return;
}
handleHoverStart(evt);
window.addEventListener("mouseup", handlePCHoverEnd);
}
function handleHoverStart(evt) {
if (evt._hoverPropagationStopped) {
return;
}
if (!props2.hoverClass || props2.hoverClass === "none" || props2.disabled) {
return;
}
if (props2.hoverStopPropagation) {
evt._hoverPropagationStopped = true;
}
hoverTouch = true;
hoverStartTimer = setTimeout(() => {
hovering.value = true;
if (!hoverTouch) {
hoverReset();
}
}, parseInt(props2.hoverStartTime));
}
function onTouchend() {
handleHoverEnd();
}
function onMouseup() {
if (!hoverTouch) {
return;
}
handlePCHoverEnd();
}
function handleHoverEnd() {
hoverTouch = false;
if (hovering.value) {
hoverReset();
}
}
function handlePCHoverEnd() {
handleHoverEnd();
window.removeEventListener("mouseup", handlePCHoverEnd);
}
function onTouchcancel() {
hoverTouch = false;
hovering.value = false;
clearTimeout(hoverStartTimer);
}
return {
hovering,
binding: {
onTouchstartPassive: withWebEvent(onTouchstartPassive),
onMousedown: withWebEvent(onMousedown),
onTouchend: withWebEvent(onTouchend),
onMouseup: withWebEvent(onMouseup),
onTouchcancel: withWebEvent(onTouchcancel)
}
};
}
function useBooleanAttr(props2, keys) {
if (shared.isString(keys)) {
keys = [keys];
}
return keys.reduce((res, key) => {
if (props2[key]) {
res[key] = true;
}
return res;
}, /* @__PURE__ */ Object.create(null));
}
uniShared.createRpx2Unit(
uniShared.defaultRpx2Unit.unit,
uniShared.defaultRpx2Unit.unitRatio,
uniShared.defaultRpx2Unit.unitPrecision
);
const uniFormKey = PolySymbol(process.env.NODE_ENV !== "production" ? "uniForm" : "uf");
const index$A = /* @__PURE__ */ defineBuiltInComponent({
name: "Form",
emits: ["submit", "reset"],
setup(_props, {
slots,
emit: emit2
}) {
const rootRef = vue.ref(null);
provideForm(useCustomEvent(rootRef, emit2));
return () => vue.createVNode("uni-form", {
"ref": rootRef
}, [vue.createVNode("span", null, [slots.default && slots.default()])], 512);
}
});
function provideForm(trigger) {
const fields2 = [];
vue.provide(uniFormKey, {
addField(field) {
fields2.push(field);
},
removeField(field) {
fields2.splice(fields2.indexOf(field), 1);
},
submit(evt) {
trigger("submit", evt, {
value: fields2.reduce((res, field) => {
if (field.submit) {
const [name, value] = field.submit();
name && (res[name] = value);
}
return res;
}, /* @__PURE__ */ Object.create(null))
});
},
reset(evt) {
fields2.forEach((field) => field.reset && field.reset());
trigger("reset", evt);
}
});
return fields2;
}
const labelProps = {
for: {
type: String,
default: ""
}
};
const uniLabelKey = PolySymbol(process.env.NODE_ENV !== "production" ? "uniLabel" : "ul");
function useProvideLabel() {
const handlers = [];
vue.provide(uniLabelKey, {
addHandler(handler) {
handlers.push(handler);
},
removeHandler(handler) {
handlers.splice(handlers.indexOf(handler), 1);
}
});
return handlers;
}
const index$z = /* @__PURE__ */ defineBuiltInComponent({
name: "Label",
props: labelProps,
setup(props2, {
slots
}) {
const rootRef = vue.ref(null);
const pageId = useCurrentPageId();
const handlers = useProvideLabel();
const pointer = vue.computed(() => props2.for || slots.default && slots.default.length);
const _onClick = withWebEvent(($event) => {
const EventTarget = $event.target;
let stopPropagation = /^uni-(checkbox|radio|switch)-/.test(EventTarget.className);
if (!stopPropagation) {
stopPropagation = /^uni-(checkbox|radio|switch|button)$|^(svg|path)$/i.test(EventTarget.tagName);
}
if (stopPropagation) {
return;
}
if (props2.for) {
UniViewJSBridge.emit("uni-label-click-" + pageId + "-" + props2.for, $event, true);
} else {
handlers.length && handlers[0]($event, true);
}
});
return () => vue.createVNode("uni-label", {
"ref": rootRef,
"class": {
"uni-label-pointer": pointer
},
"onClick": _onClick
}, [slots.default && slots.default()], 10, ["onClick"]);
}
});
const buttonProps = {
id: {
type: String,
default: ""
},
hoverClass: {
type: String,
default: "button-hover"
},
hoverStartTime: {
type: [Number, String],
default: 20
},
hoverStayTime: {
type: [Number, String],
default: 70
},
hoverStopPropagation: {
type: Boolean,
default: false
},
disabled: {
type: [Boolean, String],
default: false
},
formType: {
type: String,
default: ""
},
openType: {
type: String,
default: ""
},
loading: {
type: [Boolean, String],
default: false
},
plain: {
type: [Boolean, String],
default: false
}
};
const index$y = /* @__PURE__ */ defineBuiltInComponent({
name: "Button",
props: buttonProps,
setup(props2, {
slots
}) {
const rootRef = vue.ref(null);
const uniForm = vue.inject(uniFormKey, false);
const {
hovering,
binding
} = useHover(props2);
const onClick = withWebEvent((e2, isLabelClick) => {
if (props2.disabled) {
return e2.stopImmediatePropagation();
}
if (isLabelClick) {
rootRef.value.click();
}
const formType = props2.formType;
if (formType) {
if (!uniForm) {
return;
}
if (formType === "submit") {
uniForm.submit(e2);
} else if (formType === "reset") {
uniForm.reset(e2);
}
return;
}
});
const uniLabel = vue.inject(uniLabelKey, false);
if (uniLabel) {
uniLabel.addHandler(onClick);
}
return () => {
const hoverClass = props2.hoverClass;
const booleanAttrs = useBooleanAttr(props2, "disabled");
const loadingAttrs = useBooleanAttr(props2, "loading");
const plainAttrs = useBooleanAttr(props2, "plain");
const hasHoverClass = hoverClass && hoverClass !== "none";
return vue.createVNode("uni-button", vue.mergeProps({
"ref": rootRef,
"onClick": onClick,
"id": props2.id,
"class": hasHoverClass && hovering.value ? hoverClass : ""
}, hasHoverClass && binding, booleanAttrs, loadingAttrs, plainAttrs), [slots.default && slots.default()], 16, ["onClick", "id"]);
};
}
});
const props$r = {
disableScroll: {
type: [Boolean, String],
default: false
}
};
const indexX$4 = /* @__PURE__ */ defineBuiltInComponent({
inheritAttrs: true,
name: "Canvas",
compatConfig: {
MODE: 3
},
props: props$r,
setup(props2, {}) {
const rootRef = vue.ref(null);
const canvas = vue.ref(null);
return () => {
return vue.createVNode("uni-canvas", {
"ref": rootRef
}, [vue.createVNode("canvas", {
"ref": canvas,
"class": "uni-canvas-canvas"
}, null, 512)], 512);
};
}
});
const uniCheckGroupKey = PolySymbol(process.env.NODE_ENV !== "production" ? "uniCheckGroup" : "ucg");
const props$q = {
name: {
type: String,
default: ""
}
};
const index$x = /* @__PURE__ */ defineBuiltInComponent({
name: "CheckboxGroup",
props: props$q,
emits: ["change"],
setup(props2, {
emit: emit2,
slots
}) {
const rootRef = vue.ref(null);
const trigger = useCustomEvent(rootRef, emit2);
useProvideCheckGroup(props2, trigger);
return () => {
return vue.createVNode("uni-checkbox-group", {
"ref": rootRef
}, [slots.default && slots.default()], 512);
};
}
});
function useProvideCheckGroup(props2, trigger) {
const fields2 = [];
const getFieldsValue = () => fields2.reduce((res, field) => {
if (field.value.checkboxChecked) {
res.push(field.value.value);
}
return res;
}, new Array());
vue.provide(uniCheckGroupKey, {
addField(field) {
fields2.push(field);
},
removeField(field) {
fields2.splice(fields2.indexOf(field), 1);
},
checkboxChange($event) {
trigger("change", $event, {
value: getFieldsValue()
});
}
});
const uniForm = vue.inject(uniFormKey, false);
if (uniForm) {
uniForm.addField({
submit: () => {
let data = ["", null];
if (props2.name !== "") {
data[0] = props2.name;
data[1] = getFieldsValue();
}
return data;
}
});
}
return getFieldsValue;
}
const props$p = {
checked: {
type: [Boolean, String],
default: false
},
id: {
type: String,
default: ""
},
disabled: {
type: [Boolean, String],
default: false
},
value: {
type: String,
default: ""
},
color: {
type: String,
default: "#007aff"
},
backgroundColor: {
type: String,
default: ""
},
borderColor: {
type: String,
default: ""
},
activeBackgroundColor: {
type: String,
default: ""
},
activeBorderColor: {
type: String,
default: ""
},
iconColor: {
type: String,
default: ""
},
// 图标颜色,同color,优先级大于iconColor
foreColor: {
type: String,
default: ""
}
};
const index$w = /* @__PURE__ */ defineBuiltInComponent({
name: "Checkbox",
props: props$p,
setup(props2, {
slots
}) {
const rootRef = vue.ref(null);
const checkboxChecked = vue.ref(props2.checked);
const checkboxCheckedBool = vue.computed(() => {
return checkboxChecked.value === "true" || checkboxChecked.value === true;
});
const checkboxValue = vue.ref(props2.value);
function getCheckBoxStyle(checked) {
if (props2.disabled) {
return {
backgroundColor: "#E1E1E1",
borderColor: "#D1D1D1"
};
}
const style = {};
if (checked) {
if (props2.activeBorderColor)
style.borderColor = props2.activeBorderColor;
if (props2.activeBackgroundColor)
style.backgroundColor = props2.activeBackgroundColor;
} else {
if (props2.borderColor)
style.borderColor = props2.borderColor;
if (props2.backgroundColor)
style.backgroundColor = props2.backgroundColor;
}
return style;
}
const checkboxStyle = vue.computed(() => {
return getCheckBoxStyle(checkboxCheckedBool.value);
});
vue.watch([() => props2.checked, () => props2.value], ([newChecked, newModelValue]) => {
checkboxChecked.value = newChecked;
checkboxValue.value = newModelValue;
});
const reset = () => {
checkboxChecked.value = false;
};
const {
uniCheckGroup,
uniLabel
} = useCheckboxInject(checkboxChecked, checkboxValue, reset);
const _onClick = ($event) => {
if (props2.disabled) {
return;
}
checkboxChecked.value = !checkboxChecked.value;
uniCheckGroup && uniCheckGroup.checkboxChange($event);
$event.stopPropagation();
};
if (!!uniLabel) {
uniLabel.addHandler(_onClick);
}
return () => {
const booleanAttrs = useBooleanAttr(props2, "disabled");
let realCheckValue;
realCheckValue = checkboxChecked.value;
return vue.createVNode("uni-checkbox", vue.mergeProps(booleanAttrs, {
"id": props2.id,
"onClick": _onClick,
"ref": rootRef
}), [vue.createVNode("div", {
"class": "uni-checkbox-wrapper",
"style": {
"--HOVER-BD-COLOR": props2.activeBorderColor
}
}, [vue.createVNode("div", {
"class": ["uni-checkbox-input", {
"uni-checkbox-input-disabled": props2.disabled
}],
"style": checkboxStyle.value
}, [realCheckValue ? createSvgIconVNode(ICON_PATH_SUCCESS_NO_CIRCLE, props2.disabled ? "#ADADAD" : props2.foreColor || props2.iconColor || props2.color, 22) : ""], 6), slots.default && slots.default()], 4)], 16, ["id", "onClick"]);
};
}
});
function useCheckboxInject(checkboxChecked, checkboxValue, reset) {
const field = vue.computed(() => ({
checkboxChecked: Boolean(checkboxChecked.value),
value: checkboxValue.value
}));
const formField = {
reset
};
const uniCheckGroup = vue.inject(uniCheckGroupKey, false);
if (!!uniCheckGroup) {
uniCheckGroup.addField(field);
}
const uniForm = vue.inject(uniFormKey, false);
if (!!uniForm) {
uniForm.addField(formField);
}
const uniLabel = vue.inject(uniLabelKey, false);
return {
uniCheckGroup,
uniForm,
uniLabel
};
}
let resetTimer;
function iosHideKeyboard() {
}
const props$o = {
cursorSpacing: {
type: [Number, String],
default: 0
},
showConfirmBar: {
type: [Boolean, String],
default: "auto"
},
adjustPosition: {
type: [Boolean, String],
default: true
},
autoBlur: {
type: [Boolean, String],
default: false
}
};
const emit$1 = ["keyboardheightchange"];
function useKeyboard$1(props2, elRef, trigger) {
function initKeyboard(el) {
const isApple = vue.computed(
() => String(navigator.vendor).indexOf("Apple") === 0
);
el.addEventListener("focus", () => {
clearTimeout(resetTimer);
document.addEventListener("click", iosHideKeyboard, false);
});
const onKeyboardHide = () => {
document.removeEventListener("click", iosHideKeyboard, false);
if (isApple.value) {
document.documentElement.scrollTo(
document.documentElement.scrollLeft,
document.documentElement.scrollTop
);
}
};
el.addEventListener("blur", () => {
if (isApple.value) {
el.blur();
}
onKeyboardHide();
});
}
vue.watch(
() => elRef.value,
(el) => el && initKeyboard(el)
);
}
const pageMetaKey = PolySymbol(process.env.NODE_ENV !== "production" ? "UniPageMeta" : "upm");
function usePageMeta() {
return vue.inject(pageMetaKey);
}
function providePageMeta(id2) {
const pageMeta = initPageMeta(id2);
vue.provide(pageMetaKey, pageMeta);
return pageMeta;
}
function usePageRoute() {
if (__UNI_FEATURE_PAGES__) {
return vueRouter.useRoute();
}
const url = location.href;
const searchPos = url.indexOf("?");
const hashPos = url.indexOf("#", searchPos > -1 ? searchPos : 0);
let query = {};
if (searchPos > -1) {
query = uniShared.parseQuery(
url.slice(searchPos + 1, hashPos > -1 ? hashPos : url.length)
);
}
const { meta } = __uniRoutes[0];
const path = uniShared.addLeadingSlash(meta.route);
return {
meta,
query,
path,
matched: [{ path }]
};
}
function initPageMeta(id2) {
if (__UNI_FEATURE_PAGES__) {
return vue.reactive(
normalizePageMeta(
JSON.parse(
JSON.stringify(
initRouteMeta(
vueRouter.useRoute().meta,
id2
)
)
)
)
);
}
return vue.reactive(
normalizePageMeta(
JSON.parse(JSON.stringify(initRouteMeta(__uniRoutes[0].meta, id2)))
)
);
}
function normalizePageMeta(pageMeta) {
if (__UNI_FEATURE_PULL_DOWN_REFRESH__) {
const { enablePullDownRefresh, navigationBar } = pageMeta;
{
const pullToRefresh = normalizePullToRefreshRpx(
shared.extend(
{
support: true,
color: "#2BD009",
style: "circle",
height: 70,
range: 150,
offset: 0
},
pageMeta.pullToRefresh
)
);
const { type, style } = navigationBar;
if (style !== "custom" && type !== "transparent") {
pullToRefresh.offset += uniShared.NAVBAR_HEIGHT + 0;
}
pageMeta.pullToRefresh = pullToRefresh;
}
}
if (__UNI_FEATURE_NAVIGATIONBAR__) {
const { navigationBar } = pageMeta;
const { titleSize, titleColor, backgroundColor } = navigationBar;
navigationBar.titleText = navigationBar.titleText || "";
navigationBar.type = navigationBar.type || "default";
navigationBar.titleSize = titleSize || "16px";
navigationBar.titleColor = titleColor || "#000000";
navigationBar.backgroundColor = backgroundColor || "#F8F8F8";
__UNI_FEATURE_I18N_LOCALE__ && initNavigationBarI18n(navigationBar);
}
return pageMeta;
}
function getStateId() {
{
return 1;
}
}
const HTTP_METHODS = [
"GET",
"OPTIONS",
"HEAD",
"POST",
"PUT",
"DELETE",
"TRACE",
"CONNECT",
"PATCH"
];
function elemInArray(str, arr) {
if (!str || arr.indexOf(str) === -1) {
return arr[0];
}
return str;
}
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(
key,
data[key],
protocol[key],
!shared.hasOwn(data, key)
);
if (shared.isString(errMsg)) {
onFail(name, errMsg);
}
}
}
function validateProtocols(name, args, protocol, onFail) {
if (!protocol) {
return;
}
if (!shared.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(name, value, prop, isAbsent) {
if (!shared.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 = shared.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) {
return getInvalidTypeMessage(name, value, expectedTypes);
}
}
if (validator) {
return validator(value);
}
}
const isSimpleType = /* @__PURE__ */ shared.makeMap(
"String,Number,Boolean,Function,Symbol"
);
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 = shared.isObject(value);
} else if (expectedType === "Array") {
valid = shared.isArray(value);
} else {
{
valid = value instanceof type;
}
}
return {
valid,
expectedType
};
}
function getInvalidTypeMessage(name, value, expectedTypes) {
let message = `Invalid args: type check failed for args "${name}". Expected ${expectedTypes.map(shared.capitalize).join(", ")}`;
const expectedType = expectedTypes[0];
const receivedType = shared.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 getType(ctor) {
const match = ctor && ctor.toString().match(/^\s*function (\w+)/);
return match ? match[1] : "";
}
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");
}
function tryCatch(fn) {
return function() {
try {
return fn.apply(fn, arguments);
} catch (e2) {
console.error(e2);
}
};
}
let invokeCallbackId = 1;
const invokeCallbacks = {};
function addInvokeCallback(id2, name, callback, keepAlive = false) {
invokeCallbacks[id2] = {
name,
keepAlive,
callback
};
return id2;
}
function invokeCallback(id2, res, extras) {
if (typeof id2 === "number") {
const opts = invokeCallbacks[id2];
if (opts) {
if (!opts.keepAlive) {
delete invokeCallbacks[id2];
}
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 (shared.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 (!shared.isPlainObject(args)) {
args = {};
}
const { success, fail, complete } = getApiCallbacks(args);
const hasSuccess = shared.isFunction(success);
const hasFail = shared.isFunction(fail);
const hasComplete = shared.isFunction(complete);
const callbackId = invokeCallbackId++;
addInvokeCallback(callbackId, name, (res) => {
res = res || {};
res.errMsg = normalizeErrMsg(res.errMsg, name);
shared.isFunction(beforeAll) && beforeAll(res);
if (res.errMsg === name + ":ok") {
shared.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(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 (shared.isPromise(res)) {
promise = Promise.resolve(res);
}
if (res === false) {
return {
then() {
},
catch() {
}
};
}
}
}
return promise || {
then(callback) {
return callback(data);
},
catch() {
}
};
}
function wrapperOptions(interceptors, options = {}) {
[HOOK_SUCCESS, HOOK_FAIL, HOOK_COMPLETE].forEach((name) => {
const hooks = interceptors[name];
if (!shared.isArray(hooks)) {
return;
}
const oldCallback = options[name];
options[name] = function callbackInterceptor(res) {
queue(hooks, res, options).then((res2) => {
return shared.isFunction(oldCallback) && oldCallback(res2) || res2;
});
};
});
return options;
}
function wrapperReturnValue(method, returnValue) {
const returnValueHooks = [];
if (shared.isArray(globalInterceptors.returnValue)) {
returnValueHooks.push(...globalInterceptors.returnValue);
}
const interceptor = scopedInterceptors[method];
if (interceptor && shared.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, api2, options, params) {
const interceptor = getApiInterceptorHooks(method);
if (interceptor && Object.keys(interceptor).length) {
if (shared.isArray(interceptor.invoke)) {
const res = queue(interceptor.invoke, options);
return res.then((options2) => {
return api2(
wrapperOptions(getApiInterceptorHooks(method), options2),
...params
);
});
} else {
return api2(wrapperOptions(interceptor, options), ...params);
}
}
return api2(options, ...params);
}
function hasCallback(args) {
if (shared.isPlainObject(args) && [API_SUCCESS, API_FAIL, API_COMPLETE].find(
(cb) => shared.isFunction(args[cb])
)) {
return true;
}
return false;
}
function handlePromise(promise) {
return promise;
}
function promisify(name, fn) {
return (args = {}, ...rest) => {
if (hasCallback(args)) {
return wrapperReturnValue(name, invokeApi(name, fn, args, rest));
}
return wrapperReturnValue(
name,
handlePromise(
new Promise((resolve, reject) => {
invokeApi(
name,
fn,
shared.extend(args, { success: resolve, fail: reject }),
rest
);
})
)
);
};
}
function formatApiArgs(args, options) {
const params = args[0];
if (!options || !options.formatArgs || !shared.isPlainObject(options.formatArgs) && shared.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 (shared.isFunction(formatterOrDefaultValue)) {
const errMsg = formatterOrDefaultValue(args[0][name], params);
if (shared.isString(errMsg)) {
return errMsg;
}
} else {
if (!shared.hasOwn(params, name)) {
params[name] = formatterOrDefaultValue;
}
}
}
}
function invokeSuccess(id2, name, res) {
const result = {
errMsg: name + ":ok"
};
{
result.errSubject = name;
}
return invokeCallback(id2, shared.extend(res || {}, result));
}
function invokeFail(id2, name, errMsg, errRes = {}) {
const errMsgPrefix = name + ":fail";
let apiErrMsg = "";
if (!errMsg) {
apiErrMsg = errMsgPrefix;
} else if (errMsg.indexOf(errMsgPrefix) === 0) {
apiErrMsg = errMsg;
} else {
apiErrMsg = errMsgPrefix + " " + errMsg;
}
let res = shared.extend({ errMsg: apiErrMsg }, errRes);
{
if (typeof UniError !== "undefined") {
res = typeof errRes.errCode !== "undefined" ? new UniError(name, errRes.errCode, apiErrMsg) : new UniError(apiErrMsg, errRes);
}
}
return invokeCallback(id2, res);
}
function beforeInvokeApi(name, args, protocol, options) {
if (process.env.NODE_ENV !== "production") {
validateProtocols(name, args, protocol);
}
if (options && options.beforeInvoke) {
const errMsg2 = options.beforeInvoke(args);
if (shared.isString(errMsg2)) {
return errMsg2;
}
}
const errMsg = formatApiArgs(args, options);
if (errMsg) {
return errMsg;
}
}
function parseErrMsg(errMsg) {
if (!errMsg || shared.isString(errMsg)) {
return errMsg;
}
if (errMsg.stack) {
return errMsg.message;
}
return errMsg;
}
function wrapperTaskApi(name, fn, protocol, options) {
return (args) => {
const id2 = createAsyncApiCallback(name, args, options);
const errMsg = beforeInvokeApi(name, [args], protocol, options);
if (errMsg) {
return invokeFail(id2, name, errMsg);
}
return fn(args, {
resolve: (res) => invokeSuccess(id2, name, res),
reject: (errMsg2, errRes) => invokeFail(id2, 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 defineTaskApi(name, fn, protocol, options) {
return promisify(
name,
wrapperTaskApi(name, fn, process.env.NODE_ENV !== "production" ? protocol : void 0, options)
);
}
function defineSyncApi(name, fn, protocol, options) {
return wrapperSyncApi(
name,
fn,
process.env.NODE_ENV !== "production" ? protocol : void 0,
options
);
}
function defineAsyncApi(name, fn, protocol, options) {
return promisify(
name,
wrapperAsyncApi(name, fn, process.env.NODE_ENV !== "production" ? protocol : void 0, options)
);
}
const API_ON_TAB_BAR_MID_BUTTON_TAP = "onTabBarMidButtonTap";
const API_GET_LOCALE = "getLocale";
const getLocale = /* @__PURE__ */ defineSyncApi(
API_GET_LOCALE,
() => {
const app = getApp({ allowDefault: true });
if (app && app.$vm) {
return app.$vm.$locale;
}
return useI18n().getLocale();
}
);
const API_GET_STORAGE = "getStorage";
const GetStorageProtocol = {
key: {
type: String,
required: true
}
};
const API_GET_STORAGE_SYNC = "getStorageSync";
const GetStorageSyncProtocol = [
{
name: "key",
type: String,
required: true
}
];
const API_SET_STORAGE = "setStorage";
const SetStorageProtocol = {
key: {
type: String,
required: true
},
data: {
required: true
}
};
const API_SET_STORAGE_SYNC = "setStorageSync";
const SetStorageSyncProtocol = [
{
name: "key",
type: String,
required: true
},
{
name: "data",
required: true
}
];
const API_REMOVE_STORAGE = "removeStorage";
const RemoveStorageProtocol = GetStorageProtocol;
const RemoveStorageSyncProtocol = GetStorageSyncProtocol;
const API_REQUEST = "request";
const dataType = {
JSON: "json"
};
const RESPONSE_TYPE = ["text", "arraybuffer"];
const DEFAULT_RESPONSE_TYPE = "text";
const encode = encodeURIComponent;
function stringifyQuery(url, data) {
let str = url.split("#");
const hash = str[1] || "";
str = str[0].split("?");
let query = str[1] || "";
url = str[0];
const search = query.split("&").filter((item) => item);
const params = {};
search.forEach((item) => {
const part = item.split("=");
params[part[0]] = part[1];
});
for (const key in data) {
if (shared.hasOwn(data, key)) {
let v2 = data[key];
if (typeof v2 === "undefined" || v2 === null) {
v2 = "";
} else if (shared.isPlainObject(v2)) {
v2 = JSON.stringify(v2);
}
params[encode(key)] = encode(v2);
}
}
query = Object.keys(params).map((item) => `${item}=${params[item]}`).join("&");
return url + (query ? "?" + query : "") + (hash ? "#" + hash : "");
}
const RequestProtocol = {
method: String,
data: [Object, String, Array, ArrayBuffer],
url: {
type: String,
required: true
},
header: Object,
dataType: String,
responseType: String,
withCredentials: Boolean
};
const RequestOptions = {
formatArgs: {
method(value, params) {
params.method = elemInArray(
(value || "").toUpperCase(),
HTTP_METHODS
);
},
data(value, params) {
params.data = value || "";
},
url(value, params) {
if (params.method === HTTP_METHODS[0] && shared.isPlainObject(params.data) && Object.keys(params.data).length) {
params.url = stringifyQuery(value, params.data);
}
},
header(value, params) {
const header = params.header = value || {};
if (params.method !== HTTP_METHODS[0]) {
if (!Object.keys(header).find(
(key) => key.toLowerCase() === "content-type"
)) {
header["Content-Type"] = "application/json";
}
}
},
dataType(value, params) {
params.dataType = (value || dataType.JSON).toLowerCase();
},
responseType(value, params) {
params.responseType = (value || "").toLowerCase();
if (RESPONSE_TYPE.indexOf(params.responseType) === -1) {
params.responseType = DEFAULT_RESPONSE_TYPE;
}
}
}
};
const API_SET_NAVIGATION_BAR_COLOR = "setNavigationBarColor";
const API_SET_NAVIGATION_BAR_TITLE = "setNavigationBarTitle";
const SetNavigationBarTitleProtocol = {
title: {
type: String,
required: true
}
};
const API_SHOW_NAVIGATION_BAR_LOADING = "showNavigationBarLoading";
const API_HIDE_NAVIGATION_BAR_LOADING = "hideNavigationBarLoading";
function removeNonTabBarPages() {
const curTabBarPageVm = getCurrentPageVm();
if (!curTabBarPageVm) {
return;
}
const pagesMap = getCurrentPagesMap();
const keys = pagesMap.keys();
for (const routeKey of keys) {
const page = pagesMap.get(routeKey);
if (!page.$.__isTabBar) {
removePage(routeKey);
} else {
page.$.__isActive = false;
}
}
if (curTabBarPageVm.$.__isTabBar) {
curTabBarPageVm.$.__isVisible = false;
invokeHook(curTabBarPageVm, uniShared.ON_HIDE);
}
}
function isSamePage(url, $page) {
return url === $page.fullPath || url === "/" && $page.meta.isEntry;
}
function getTabBarPageId(url) {
const pages = getCurrentPagesMap().values();
for (const page of pages) {
const $page = getPage$BasePage(page);
if (isSamePage(url, $page)) {
page.$.__isActive = true;
return $page.id;
}
}
}
function removeLastPage() {
var _a;
const page = (_a = getCurrentPage()) == null ? void 0 : _a.vm;
if (!page) {
return;
}
const $page = getPage$BasePage(page);
removePage(normalizeRouteKey($page.path, $page.id));
}
function removeAllPages() {
const keys = getCurrentPagesMap().keys();
for (const routeKey of keys) {
removePage(routeKey);
}
}
function navigate({ type, url, tabBarText, events, isAutomatedTesting }, __id__) {
if (process.env.NODE_ENV !== "production" && !__UNI_FEATURE_PAGES__) {
console.warn(
"当前项目为单页面工程,不能执行页面跳转api。如果需进行页面跳转, 需要在pages.json文件的pages字段中配置多个页面,然后重新运行。"
);
}
const router = getApp().vm.$router;
const { path, query } = uniShared.parseUrl(url);
return new Promise((resolve, reject) => {
const state = createPageState(type, __id__);
router[type === "navigateTo" ? "push" : "replace"]({
path,
query,
state,
force: true
}).then((failure) => {
if (vueRouter.isNavigationFailure(failure)) {
return reject(failure.message);
}
if (type === "switchTab") {
router.currentRoute.value.meta.tabBarText = tabBarText;
}
if (type === "navigateTo") {
const meta = router.currentRoute.value.meta;
if (!meta.eventChannel) {
meta.eventChannel = new uniShared.EventChannel(state.__id__, events);
} else if (events) {
Object.keys(events).forEach((eventName) => {
meta.eventChannel._addListener(
eventName,
"on",
events[eventName]
);
});
meta.eventChannel._clearCache();
}
return isAutomatedTesting ? resolve({
__id__: state.__id__
}) : resolve({
eventChannel: meta.eventChannel
});
}
return isAutomatedTesting ? resolve({ __id__: state.__id__ }) : resolve();
});
});
}
function handleBeforeEntryPageRoutes() {
if (entryPageState.handledBeforeEntryPageRoutes) {
return;
}
entryPageState.handledBeforeEntryPageRoutes = true;
const navigateToPages = [...navigateToPagesBeforeEntryPages];
navigateToPagesBeforeEntryPages.length = 0;
navigateToPages.forEach(
({ args, resolve, reject }) => (
// @ts-expect-error
navigate(args).then(resolve).catch(reject)
)
);
const switchTabPages = [...switchTabPagesBeforeEntryPages];
switchTabPagesBeforeEntryPages.length = 0;
switchTabPages.forEach(
({ args, resolve, reject }) => (removeNonTabBarPages(), navigate(args, getTabBarPageId(args.url)).then(resolve).catch(reject))
);
const redirectToPages = [...redirectToPagesBeforeEntryPages];
redirectToPagesBeforeEntryPages.length = 0;
redirectToPages.forEach(
({ args, resolve, reject }) => (removeLastPage(), navigate(args).then(resolve).catch(reject))
);
const reLaunchPages = [...reLaunchPagesBeforeEntryPages];
reLaunchPagesBeforeEntryPages.length = 0;
reLaunchPages.forEach(
({ args, resolve, reject }) => (removeAllPages(), navigate(args).then(resolve).catch(reject))
);
}
let tabBar;
function useTabBar() {
if (!tabBar) {
tabBar = __uniConfig.tabBar && vue.reactive(initTabBarI18n(__uniConfig.tabBar));
}
return tabBar;
}
const envMethod = /* @__PURE__ */ (() => "env")();
function normalizeWindowBottom(windowBottom) {
return envMethod ? `calc(${windowBottom}px + ${envMethod}(safe-area-inset-bottom))` : `${windowBottom}px`;
}
const DIALOG_TAG = "dialog";
const SYSTEM_DIALOG_TAG = "systemDialog";
function isDialogPageInstance(vm) {
return isNormalDialogPageInstance(vm) || isSystemDialogPageInstance(vm);
}
function isNormalDialogPageInstance(vm) {
return vm.attrs["data-type"] === DIALOG_TAG;
}
function isSystemDialogPageInstance(vm) {
return vm.attrs["data-type"] === SYSTEM_DIALOG_TAG;
}
const homeDialogPages = [];
const homeSystemDialogPages = [];
class UniPageImpl {
constructor({
route,
options,
vm
}) {
this.getParentPage = () => null;
this.route = route;
this.options = options;
this.vm = vm;
this.$vm = vm;
}
getPageStyle() {
return new UTSJSONObject({});
}
$getPageStyle() {
return this.getPageStyle();
}
setPageStyle(style) {
}
$setPageStyle(style) {
this.setPageStyle(style);
}
getElementById(id2) {
const currentPage = getCurrentPage();
if (currentPage !== this) {
return null;
}
const uniPageBody = document.querySelector("uni-page-body");
return uniPageBody ? uniPageBody.querySelector(`#${id2}`) : null;
}
getAndroidView() {
return null;
}
getHTMLElement() {
const currentPage = getCurrentPage();
if (currentPage !== this) {
return null;
}
return document.querySelector("uni-page-body");
}
getDialogPages() {
return [];
}
}
class UniNormalPageImpl extends UniPageImpl {
getDialogPages() {
var _a, _b;
return ((_b = (_a = this.vm) == null ? void 0 : _a.$pageLayoutInstance) == null ? void 0 : _b.$dialogPages.value) || [];
}
constructor({
route,
options,
vm
}) {
super({ route, options, vm });
}
}
function initXPage(vm, route, page) {
var _a, _b;
initPageVm(vm, page);
Object.defineProperty(vm, "$pageLayoutInstance", {
get() {
var _a2, _b2;
let res = (_a2 = vm.$) == null ? void 0 : _a2.parent;
while (res && ((_b2 = res.type) == null ? void 0 : _b2.name) !== "Page") {
res = res.parent;
}
return res;
}
});
vm.$basePage = vm.$page;
const pageInstance = vm.$pageLayoutInstance;
if (!isDialogPageInstance(pageInstance)) {
const uniPage = new UniNormalPageImpl({
route: (route == null ? void 0 : route.path) || "",
options: new UTSJSONObject((route == null ? void 0 : route.query) || {}),
vm
});
vm.$page = uniPage;
const pageMeta = page.meta;
uniPage.setPageStyle = (style) => {
for (const key in style) {
switch (key) {
case "navigationBarBackgroundColor":
pageMeta.navigationBar.backgroundColor = style[key];
break;
case "navigationBarTextStyle":
const textStyle = style[key];
if (textStyle == null) {
continue;
}
pageMeta.navigationBar.titleColor = ["black", "white"].includes(
textStyle
) ? uniShared.normalizeTitleColor(textStyle || "") : textStyle;
break;
case "navigationBarTitleText":
pageMeta.navigationBar.titleText = style[key];
break;
case "titleImage":
pageMeta.navigationBar.titleImage = style[key];
break;
case "navigationStyle":
pageMeta.navigationBar.style = style[key];
break;
default:
pageMeta[key] = style[key];
break;
}
}
};
uniPage.getPageStyle = () => new UTSJSONObject({
navigationBarBackgroundColor: pageMeta.navigationBar.backgroundColor,
navigationBarTextStyle: pageMeta.navigationBar.titleColor,
navigationBarTitleText: pageMeta.navigationBar.titleText,
titleImage: pageMeta.navigationBar.titleImage || "",
navigationStyle: pageMeta.navigationBar.style || "default",
disableScroll: pageMeta.disableScroll || false,
enablePullDownRefresh: pageMeta.enablePullDownRefresh || false,
onReachBottomDistance: pageMeta.onReachBottomDistance || uniShared.ON_REACH_BOTTOM_DISTANCE,
backgroundColorContent: pageMeta.backgroundColorContent
});
vm.$dialogPage = (_a = vm.$pageLayoutInstance) == null ? void 0 : _a.$dialogPage;
currentPagesMap.set(normalizeRouteKey(page.path, page.id), vm);
if (currentPagesMap.size === 1) {
setTimeout(() => {
handleBeforeEntryPageRoutes();
}, 0);
if (homeDialogPages.length) {
homeDialogPages.forEach((dialogPage) => {
dialogPage.getParentPage = () => vm.$page;
pageInstance.$dialogPages.value.push(dialogPage);
});
homeDialogPages.length = 0;
}
if (homeSystemDialogPages.length) {
homeSystemDialogPages.forEach((dialogPage) => {
dialogPage.getParentPage = () => vm.$page;
pageInstance.$systemDialogPages.value.push(dialogPage);
});
homeSystemDialogPages.length = 0;
}
}
} else {
vm.$page = (_b = vm.$pageLayoutInstance) == null ? void 0 : _b.$dialogPage;
pageInstance.$dialogPage.vm = vm;
pageInstance.$dialogPage.$vm = vm;
}
}
const SEP = "$$";
const currentPagesMap = /* @__PURE__ */ new Map();
function getPage$BasePage(page) {
return page.$basePage;
}
const entryPageState = {
handledBeforeEntryPageRoutes: false
};
const navigateToPagesBeforeEntryPages = [];
const switchTabPagesBeforeEntryPages = [];
const redirectToPagesBeforeEntryPages = [];
const reLaunchPagesBeforeEntryPages = [];
function pruneCurrentPages() {
currentPagesMap.forEach((page, id2) => {
if (page.$.isUnmounted) {
currentPagesMap.delete(id2);
}
});
}
function getCurrentPagesMap() {
return currentPagesMap;
}
function getCurrentPages$1() {
const curPages = getCurrentBasePages();
{
return curPages.map((page) => page.$page);
}
}
function getCurrentBasePages() {
const curPages = [];
const pages = currentPagesMap.values();
for (const page of pages) {
if (page.$.__isTabBar) {
if (page.$.__isActive) {
curPages.push(page);
}
} else {
curPages.push(page);
}
}
return curPages;
}
function removeRouteCache(routeKey) {
const vnode = pageCacheMap.get(routeKey);
if (vnode) {
pageCacheMap.delete(routeKey);
routeCache.pruneCacheEntry(vnode);
}
}
function removePage(routeKey, removeRouteCaches = true) {
const pageVm = currentPagesMap.get(routeKey);
pageVm.$.__isUnload = true;
invokeHook(pageVm, uniShared.ON_UNLOAD);
currentPagesMap.delete(routeKey);
removeRouteCaches && removeRouteCache(routeKey);
}
let id = /* @__PURE__ */ getStateId();
function createPageState(type, __id__) {
return {
__id__: __id__ || ++id,
__type__: type
};
}
function initPublicPage(route) {
const meta = usePageMeta();
if (!__UNI_FEATURE_PAGES__) {
return initPageInternalInstance("navigateTo", __uniRoutes[0].path, {}, meta);
}
let fullPath = route.fullPath;
if (route.meta.isEntry && fullPath.indexOf(route.meta.route) === -1) {
fullPath = "/" + route.meta.route + fullPath.replace("/", "");
}
return initPageInternalInstance("navigateTo", fullPath, {}, meta);
}
function initPage(vm) {
const route = vm.$route;
const page = initPublicPage(route);
initPageVm(vm, page);
{
initXPage(vm, route, page);
}
}
function normalizeRouteKey(path, id2) {
return path + SEP + id2;
}
function useKeepAliveRoute() {
const route = vueRouter.useRoute();
const routeKey = vue.computed(
() => normalizeRouteKey("/" + route.meta.route, getStateId())
);
const isTabBar = vue.computed(() => route.meta.isTabBar);
return {
routeKey,
isTabBar,
routeCache
};
}
const pageCacheMap = /* @__PURE__ */ new Map();
const routeCache = {
get(key) {
return pageCacheMap.get(key);
},
set(key, value) {
pruneRouteCache(key);
pageCacheMap.set(key, value);
},
delete(key) {
const vnode = pageCacheMap.get(key);
if (!vnode) {
return;
}
pageCacheMap.delete(key);
},
forEach(fn) {
pageCacheMap.forEach(fn);
}
};
function isTabBarVNode(vnode) {
return vnode.props.type === "tabBar";
}
function pruneRouteCache(key) {
const pageId = parseInt(key.split(SEP)[1]);
if (!pageId) {
return;
}
routeCache.forEach((vnode, key2) => {
const cPageId = parseInt(key2.split(SEP)[1]);
if (cPageId && cPageId > pageId) {
if (__UNI_FEATURE_TABBAR__ && isTabBarVNode(vnode)) {
return;
}
routeCache.delete(key2);
routeCache.pruneCacheEntry(vnode);
vue.nextTick(() => pruneCurrentPages());
}
});
}
function addBase(filePath) {
const { base: baseUrl } = __uniConfig.router;
if (uniShared.addLeadingSlash(filePath).indexOf(baseUrl) === 0) {
return uniShared.addLeadingSlash(filePath);
}
return baseUrl + filePath;
}
function getRealPath(filePath) {
const { base, assets } = __uniConfig.router;
if (base === "./") {
if (filePath.indexOf("./") === 0 && (filePath.includes("/static/") || filePath.indexOf("./" + (assets || "assets") + "/") === 0)) {
filePath = filePath.slice(1);
}
}
if (filePath.indexOf("/") === 0) {
if (filePath.indexOf("//") === 0) {
filePath = "https:" + filePath;
} else {
return addBase(filePath.slice(1));
}
}
if (uniShared.SCHEME_RE.test(filePath) || uniShared.DATA_RE.test(filePath) || filePath.indexOf("blob:") === 0) {
return filePath;
}
{
if (process.env.NODE_ENV !== "production") {
if (!filePath.includes("/static/")) {
return filePath;
}
}
}
const pages = getCurrentBasePages();
if (pages.length) {
return addBase(
getRealRoute(
getPage$BasePage(pages[pages.length - 1]).route,
filePath
).slice(1)
);
}
return filePath;
}
function getPageInstanceByChild(child) {
var _a;
let pageInstance = child;
while (((_a = pageInstance.type) == null ? void 0 : _a.name) !== "Page") {
pageInstance = pageInstance.parent;
}
return pageInstance;
}
const clazz = { class: "uni-async-loading" };
const loadingVNode = /* @__PURE__ */ vue.createVNode(
"i",
{ class: "uni-loading" },
null,
-1
/* HOISTED */
);
const AsyncLoadingComponent = /* @__PURE__ */ defineSystemComponent({
name: "AsyncLoading",
render() {
return vue.openBlock(), vue.createBlock("div", clazz, [loadingVNode]);
}
});
function reload() {
window.location.reload();
}
const AsyncErrorComponent = /* @__PURE__ */ defineSystemComponent({
name: "AsyncError",
setup() {
initI18nAsyncMsgsOnce();
const {
t: t2
} = useI18n();
return () => vue.createVNode("div", {
"class": "uni-async-error",
"onClick": reload
}, [t2("uni.async.error")], 8, ["onClick"]);
}
});
let appVm;
let $uniApp;
{
class UniAppImpl {
get vm() {
return appVm;
}
get $vm() {
return appVm;
}
get globalData() {
return (appVm == null ? void 0 : appVm.globalData) || {};
}
getAndroidApplication() {
return null;
}
}
$uniApp = new UniAppImpl();
}
function getApp$1() {
{
return $uniApp;
}
}
function initApp$1(vm) {
appVm = vm;
Object.defineProperty(appVm.$.ctx, "$children", {
get() {
return getCurrentBasePages().map((page) => page.$vm);
}
});
const app = appVm.$.appContext.app;
if (!app.component(AsyncLoadingComponent.name)) {
app.component(AsyncLoadingComponent.name, AsyncLoadingComponent);
}
if (!app.component(AsyncErrorComponent.name)) {
app.component(AsyncErrorComponent.name, AsyncErrorComponent);
}
initAppVm(appVm);
defineGlobalData(appVm);
}
function wrapperComponentSetup(comp, { clone, init, setup, before }) {
if (clone) {
comp = shared.extend({}, comp);
}
before && before(comp);
const oldSetup = comp.setup;
comp.setup = (props2, ctx) => {
const instance = vue.getCurrentInstance();
init(instance.proxy);
setup(instance);
if (oldSetup) {
return oldSetup(props2, ctx);
}
};
return comp;
}
function setupComponent(comp, options) {
if (comp && (comp.__esModule || comp[Symbol.toStringTag] === "Module")) {
return wrapperComponentSetup(comp.default, options);
}
return wrapperComponentSetup(comp, options);
}
function setupWindow(comp, id2) {
return setupComponent(comp, {
init: (vm) => {
{
vm.$basePage = {
id: id2
};
}
},
setup(instance) {
instance.$pageInstance = instance;
}
});
}
function setupPage(comp) {
if (process.env.NODE_ENV !== "production") {
comp.__mpType = "page";
}
return setupComponent(comp, {
clone: true,
// 页面组件可能会被其他地方手动引用,比如 windows 等,需要 clone 一份新的作为页面组件
init: initPage,
setup(instance) {
instance.$pageInstance = instance;
const route = usePageRoute();
const query = uniShared.decodedQuery(route.query);
instance.attrs.__pageQuery = query;
{
const pageInstance = getPageInstanceByChild(instance);
if (isDialogPageInstance(pageInstance)) {
instance.attrs.__pageQuery = uniShared.decodedQuery(
uniShared.parseQuery(pageInstance.attrs.route.split("?")[1] || "")
);
}
}
getPage$BasePage(instance.proxy).options = query;
instance.proxy.options = query;
{
return query;
}
}
});
}
function setupApp(comp) {
if (process.env.NODE_ENV !== "production") {
comp.__mpType = "app";
}
return setupComponent(comp, {
init: initApp$1,
setup(instance) {
const route = usePageRoute();
{
return route.query;
}
},
before(comp2) {
comp2.mpType = "app";
const { setup } = comp2;
const render = () => {
return vue.openBlock(), vue.createBlock(LayoutComponent);
};
comp2.setup = (props2, ctx) => {
const res = setup && setup(props2, ctx);
return shared.isFunction(res) ? render : res;
};
comp2.render = render;
}
});
}
function updateDocumentTitle(title) {
{
const ssrContext = getApp$1().$vm.$.appContext.provides[vue.ssrContextKey];
if (ssrContext) {
ssrContext[uniShared.UNI_SSR_TITLE] = title;
}
}
UniServiceJSBridge.emit(uniShared.ON_NAVIGATION_BAR_CHANGE, { titleText: title });
}
function useDocumentTitle(pageMeta) {
function update() {
updateDocumentTitle(pageMeta.navigationBar.titleText);
}
vue.watchEffect(update);
}
function getTheme() {
if (__uniConfig.darkmode !== true)
return shared.isString(__uniConfig.darkmode) ? __uniConfig.darkmode : "light";
try {
return window.matchMedia("(prefers-color-scheme: light)").matches ? "light" : "dark";
} catch (error) {
return "light";
}
}
function onThemeChange(callback) {
if (__uniConfig.darkmode) {
UniServiceJSBridge.on(uniShared.ON_THEME_CHANGE, callback);
}
}
function parseTheme(pageStyle) {
let parsedStyle = {};
if (__uniConfig.darkmode) {
parsedStyle = uniShared.normalizeStyles(
pageStyle,
__uniConfig.themeConfig,
getTheme()
);
}
return __uniConfig.darkmode ? parsedStyle : pageStyle;
}
function useTheme(pageStyle, onThemeChangeCallback) {
const isReactivity = vue.isReactive(pageStyle);
const reactivePageStyle = isReactivity ? vue.reactive(parseTheme(pageStyle)) : parseTheme(pageStyle);
if (__uniConfig.darkmode && isReactivity) {
vue.watch(pageStyle, (value) => {
const _pageStyle = parseTheme(value);
for (const key in _pageStyle) {
reactivePageStyle[key] = _pageStyle[key];
}
});
}
onThemeChangeCallback && onThemeChange(onThemeChangeCallback);
return reactivePageStyle;
}
function updateBackgroundColorContent(backgroundColorContent) {
{
return;
}
}
function useBackgroundColorContent(pageMeta) {
function update() {
if (pageMeta.backgroundColorContent) {
updateBackgroundColorContent(
parseTheme({ backgroundColorContent: pageMeta.backgroundColorContent }).backgroundColorContent
);
}
}
onThemeChange(update);
vue.watchEffect(update);
}
function hexToRgba(hex) {
if (!hex) {
return {
r: 0,
g: 0,
b: 0,
a: 0
};
}
let tmpHex = hex.slice(1);
const tmpHexLen = tmpHex.length;
if (![3, 4, 6, 8].includes(tmpHexLen)) {
return {
r: 0,
g: 0,
b: 0,
a: 0
};
}
if (tmpHexLen === 3 || tmpHexLen === 4) {
tmpHex = tmpHex.replace(/(\w{1})/g, "$1$1");
}
let [sr, sg, sb, sa] = tmpHex.match(/(\w{2})/g);
const r = parseInt(sr, 16), g2 = parseInt(sg, 16), b = parseInt(sb, 16);
if (!sa) {
return { r, g: g2, b, a: 1 };
}
return {
r,
g: g2,
b,
a: (`0x100${sa}` - 65536) / 255
};
}
function usePageHeadTransparentBackgroundColor(backgroundColor) {
const { r, g: g2, b } = hexToRgba(backgroundColor);
return `rgba(${r},${g2},${b},0)`;
}
function usePageHeadTransparent(headRef, {
id: id2,
navigationBar: { titleColor, coverage, backgroundColor }
}) {
vue.computed(() => hexToRgba(backgroundColor));
}
const ICON_PATHS = {
none: "",
forward: "M11 7.844q-0.25-0.219-0.25-0.578t0.25-0.578q0.219-0.25 0.563-0.25t0.563 0.25l9.656 9.125q0.125 0.125 0.188 0.297t0.063 0.328q0 0.188-0.063 0.359t-0.188 0.297l-9.656 9.125q-0.219 0.25-0.563 0.25t-0.563-0.25q-0.25-0.219-0.25-0.578t0.25-0.609l9.063-8.594-9.063-8.594z",
back: ICON_PATH_BACK,
select: ICON_PATH_BACK,
share: "M26.563 24.844q0 0.125-0.109 0.234t-0.234 0.109h-17.938q-0.125 0-0.219-0.109t-0.094-0.234v-13.25q0-0.156 0.094-0.25t0.219-0.094h5.5v-1.531h-6q-0.531 0-0.906 0.391t-0.375 0.922v14.375q0 0.531 0.375 0.922t0.906 0.391h18.969q0.531 0 0.891-0.391t0.359-0.953v-5.156h-1.438v4.625zM29.813 10.969l-5.125-5.375-1.031 1.094 3.438 3.594-3.719 0.031q-2.313 0.188-4.344 1.125t-3.578 2.422-2.5 3.453-1.109 4.188l-0.031 0.25h1.469v-0.219q0.156-1.875 1-3.594t2.25-3.063 3.234-2.125 3.828-0.906l0.188-0.031 3.313-0.031-3.438 3.625 1.031 1.063 5.125-5.375-0.031-0.063 0.031-0.063z",
favorite: "M27.594 13.375q-0.063-0.188-0.219-0.313t-0.344-0.156l-7.094-0.969-3.219-6.406q-0.094-0.188-0.25-0.281t-0.375-0.094q-0.188 0-0.344 0.094t-0.25 0.281l-3.125 6.438-7.094 1.094q-0.188 0.031-0.344 0.156t-0.219 0.313q-0.031 0.188 0.016 0.375t0.172 0.313l5.156 4.969-1.156 7.063q-0.031 0.188 0.047 0.375t0.234 0.313q0.094 0.063 0.188 0.094t0.219 0.031q0.063 0 0.141-0.031t0.172-0.063l6.313-3.375 6.375 3.313q0.063 0.031 0.141 0.047t0.172 0.016q0.188 0 0.344-0.094t0.25-0.281q0.063-0.094 0.078-0.234t-0.016-0.234q0-0.031 0-0.063l-1.25-6.938 5.094-5.031q0.156-0.156 0.203-0.344t-0.016-0.375zM11.469 19.063q0.031-0.188-0.016-0.344t-0.172-0.281l-4.406-4.25 6.063-0.906q0.156-0.031 0.297-0.125t0.203-0.25l2.688-5.531 2.75 5.5q0.063 0.156 0.203 0.25t0.297 0.125l6.094 0.844-4.375 4.281q-0.125 0.125-0.172 0.297t-0.016 0.328l1.063 6.031-5.438-2.813q-0.156-0.094-0.328-0.078t-0.297 0.078l-5.438 2.875 1-6.031z",
home: "M23.719 16.5q-0.313 0-0.531 0.219t-0.219 0.5v7.063q0 0.219-0.172 0.391t-0.391 0.172h-12.344q-0.25 0-0.422-0.172t-0.172-0.391v-7.063q0-0.281-0.219-0.5t-0.531-0.219q-0.281 0-0.516 0.219t-0.234 0.5v7.063q0.031 0.844 0.625 1.453t1.438 0.609h12.375q0.844 0 1.453-0.609t0.609-1.453v-7.063q0-0.125-0.063-0.266t-0.156-0.234q-0.094-0.125-0.234-0.172t-0.297-0.047zM26.5 14.875l-8.813-8.813q-0.313-0.313-0.688-0.453t-0.781-0.141-0.781 0.141-0.656 0.422l-8.813 8.844q-0.188 0.219-0.188 0.516t0.219 0.484q0.094 0.125 0.234 0.172t0.297 0.047q0.125 0 0.25-0.047t0.25-0.141l8.781-8.781q0.156-0.156 0.406-0.156t0.406 0.156l8.813 8.781q0.219 0.188 0.516 0.188t0.516-0.219q0.188-0.188 0.203-0.484t-0.172-0.516z",
menu: "M8.938 18.313q0.875 0 1.484-0.609t0.609-1.453-0.609-1.453-1.484-0.609q-0.844 0-1.453 0.609t-0.609 1.453 0.609 1.453 1.453 0.609zM16.188 18.313q0.875 0 1.484-0.609t0.609-1.453-0.609-1.453-1.484-0.609q-0.844 0-1.453 0.609t-0.609 1.453 0.609 1.453 1.453 0.609zM23.469 18.313q0.844 0 1.453-0.609t0.609-1.453-0.609-1.453-1.453-0.609q-0.875 0-1.484 0.609t-0.609 1.453 0.609 1.453 1.484 0.609z",
close: ICON_PATH_CLOSE
};
const PageHead = /* @__PURE__ */ defineSystemComponent({
name: "PageHead",
setup() {
const headRef = vue.ref(null);
const pageMeta = usePageMeta();
const navigationBar = useTheme(pageMeta.navigationBar, () => {
const _navigationBar = parseTheme(pageMeta.navigationBar);
navigationBar.backgroundColor = _navigationBar.backgroundColor;
navigationBar.titleColor = _navigationBar.titleColor;
});
const {
clazz: clazz2,
style
} = usePageHead(navigationBar);
const buttons = __UNI_FEATURE_NAVIGATIONBAR_BUTTONS__ && usePageHeadButtons(pageMeta);
const searchInput = __UNI_FEATURE_NAVIGATIONBAR_SEARCHINPUT__ && navigationBar.searchInput && usePageHeadSearchInput(pageMeta);
__UNI_FEATURE_NAVIGATIONBAR_TRANSPARENT__ && navigationBar.type === "transparent" && usePageHeadTransparent(headRef, pageMeta);
return () => {
const backButtonTsx = __UNI_FEATURE_PAGES__ ? createBackButtonTsx(navigationBar, pageMeta.isQuit) : null;
const leftButtonsTsx = __UNI_FEATURE_NAVIGATIONBAR_BUTTONS__ ? createButtonsTsx(buttons.left) : [];
const rightButtonsTsx = __UNI_FEATURE_NAVIGATIONBAR_BUTTONS__ ? createButtonsTsx(buttons.right) : [];
const type = navigationBar.type || "default";
const placeholderTsx = type !== "transparent" && type !== "float" && vue.createVNode("div", {
"class": {
"uni-placeholder": true,
"uni-placeholder-titlePenetrate": navigationBar.titlePenetrate
}
}, null, 2);
return vue.createVNode("uni-page-head", {
"uni-page-head-type": type
}, [vue.createVNode("div", {
"ref": headRef,
"class": clazz2.value,
"style": style.value
}, [vue.createVNode("div", {
"class": "uni-page-head-hd"
}, [backButtonTsx, ...leftButtonsTsx]), createPageHeadBdTsx(navigationBar, searchInput), vue.createVNode("div", {
"class": "uni-page-head-ft"
}, [...rightButtonsTsx])], 6), placeholderTsx], 8, ["uni-page-head-type"]);
};
}
});
function createBackButtonTsx(navigationBar, isQuit) {
if (!isQuit) {
return vue.createVNode("div", {
"class": "uni-page-head-btn",
"onClick": onPageHeadBackButton
}, [createSvgIconVNode(ICON_PATH_BACK, navigationBar.type === "transparent" ? "#fff" : navigationBar.titleColor, 26)], 8, ["onClick"]);
}
}
function createButtonsTsx(btns) {
return btns.map(({
onClick,
btnClass,
btnStyle,
btnText,
btnIconPath,
badgeText,
iconStyle,
btnSelect
}, index2) => {
return vue.createVNode("div", {
"key": index2,
"class": btnClass,
"style": btnStyle,
"onClick": onClick,
"badge-text": badgeText
}, [btnIconPath ? createSvgIconVNode(btnIconPath, iconStyle.color, iconStyle.fontSize) : btnSelect ? vue.createVNode("span", {
"style": iconStyle
}, [vue.createVNode("i", {
"class": "uni-btn-icon",
"innerHTML": btnText
}, null, 8, ["innerHTML"]), createSvgIconVNode(ICON_PATHS["select"], "#000", 14)], 4) : vue.createVNode("i", {
"class": "uni-btn-icon",
"style": iconStyle,
"innerHTML": btnText
}, null, 12, ["innerHTML"])], 14, ["onClick", "badge-text"]);
});
}
function createPageHeadBdTsx(navigationBar, searchInput) {
if (!__UNI_FEATURE_NAVIGATIONBAR_SEARCHINPUT__ || !navigationBar.searchInput) {
return createPageHeadTitleTextTsx(navigationBar);
}
return createPageHeadSearchInputTsx(navigationBar, searchInput);
}
function createPageHeadTitleTextTsx({
type,
loading,
titleSize,
titleText,
titleImage
}) {
return vue.createVNode("div", {
"class": "uni-page-head-bd"
}, [vue.createVNode("div", {
"style": {
fontSize: titleSize,
opacity: type === "transparent" ? 0 : 1
},
"class": "uni-page-head__title"
}, [loading ? vue.createVNode("i", {
"class": "uni-loading"
}, null) : titleImage ? vue.createVNode("img", {
"src": titleImage,
"class": "uni-page-head__title_image"
}, null, 8, ["src"]) : titleText], 4)]);
}
function createPageHeadSearchInputTsx(navigationBar, {
text,
focus,
composing,
onBlur,
onFocus,
onInput,
onConfirm,
onClick
}) {
const {
color,
align,
autoFocus,
disabled,
borderRadius,
backgroundColor,
placeholder,
placeholderColor
} = navigationBar.searchInput;
const searchStyle = {
borderRadius,
backgroundColor
};
const placeholderClass = ["uni-page-head-search-placeholder", `uni-page-head-search-placeholder-${focus.value || text.value ? "left" : align}`];
return vue.createVNode("div", {
"class": "uni-page-head-search",
"style": searchStyle
}, [vue.createVNode("div", {
"style": {
color: placeholderColor
},
"class": placeholderClass
}, [vue.createVNode("div", {
"class": "uni-page-head-search-icon"
}, [createSvgIconVNode(ICON_PATH_SEARCH, placeholderColor, 20)]), text.value || composing.value ? "" : placeholder], 6), disabled ? vue.createVNode(Input, {
"disabled": true,
"style": {
color
},
"placeholder-style": "color: " + placeholderColor,
"class": "uni-page-head-search-input",
"confirm-type": "search",
"onClick": onClick
}, null, 8, ["style", "placeholder-style", "onClick"]) : vue.createVNode(Input, {
"focus": autoFocus,
"style": {
color
},
"placeholder-style": "color: " + placeholderColor,
"class": "uni-page-head-search-input",
"confirm-type": "search",
"onFocus": onFocus,
"onBlur": onBlur,
"onInput": onInput,
"onConfirm": onConfirm
}, null, 8, ["focus", "style", "placeholder-style", "onFocus", "onBlur", "onInput", "onConfirm"])], 4);
}
function onPageHeadBackButton() {
if (getCurrentPages().length === 1) {
uni.reLaunch({
url: "/"
});
} else {
uni.navigateBack({
from: "backbutton",
success() {
}
// 传入空方法,避免返回Promise,因为onBackPress可能导致fail
});
}
}
function usePageHead(navigationBar) {
const clazz2 = vue.computed(() => {
const {
type,
titlePenetrate,
shadowColorType
} = navigationBar;
const clazz3 = {
"uni-page-head": true,
"uni-page-head-transparent": type === "transparent",
"uni-page-head-titlePenetrate": titlePenetrate === "YES",
"uni-page-head-shadow": !!shadowColorType
};
if (shadowColorType) {
clazz3[`uni-page-head-shadow-${shadowColorType}`] = true;
}
return clazz3;
});
const style = vue.computed(() => {
const backgroundColor = __UNI_FEATURE_NAVIGATIONBAR_TRANSPARENT__ && navigationBar.type === "transparent" ? usePageHeadTransparentBackgroundColor(navigationBar.backgroundColor) : navigationBar.backgroundColor;
return {
backgroundColor,
color: navigationBar.titleColor,
transitionDuration: navigationBar.duration,
transitionTimingFunction: navigationBar.timingFunc
};
});
return {
clazz: clazz2,
style
};
}
function usePageHeadButtons({
id: id2,
navigationBar
}) {
const left = [];
const right = [];
const {
buttons
} = navigationBar;
if (shared.isArray(buttons)) {
const {
type
} = navigationBar;
const isTransparent = type === "transparent";
const fonts = /* @__PURE__ */ Object.create(null);
buttons.forEach((btn, index2) => {
if (btn.fontSrc && !btn.fontFamily) {
const fontSrc = getRealPath(btn.fontSrc);
let fontFamily = fonts[fontSrc];
if (!fontFamily) {
fontFamily = `font${Date.now()}`;
fonts[fontSrc] = fontFamily;
}
btn.fontFamily = fontFamily;
}
const pageHeadBtn = usePageHeadButton(id2, index2, btn, isTransparent);
if (btn.float === "left") {
left.push(pageHeadBtn);
} else {
right.push(pageHeadBtn);
}
});
}
return {
left,
right
};
}
function usePageHeadButton(pageId, index2, btn, isTransparent) {
const iconStyle = {
color: btn.color,
fontSize: btn.fontSize,
fontWeight: btn.fontWeight
};
if (btn.fontFamily) {
iconStyle.fontFamily = btn.fontFamily;
}
return new Proxy({
btnClass: {
// 类似这样的大量重复的字符串,会在gzip时压缩大小,无需在代码层考虑优化相同字符串
"uni-page-head-btn": true,
"uni-page-head-btn-red-dot": !!(btn.redDot || btn.badgeText),
"uni-page-head-btn-select": !!btn.select
},
btnStyle: {
backgroundColor: isTransparent ? btn.background : "transparent",
width: btn.width
},
btnText: "",
btnIconPath: ICON_PATHS[btn.type],
badgeText: btn.badgeText,
iconStyle,
onClick() {
invokeHook(pageId, uniShared.ON_NAVIGATION_BAR_BUTTON_TAP, shared.extend({
index: index2
}, btn));
},
btnSelect: btn.select
}, {
get(target, key, receiver) {
if (["btnText"].includes(key)) {
return btn.fontSrc && btn.fontFamily ? btn.text.replace("\\u", "") : btn.text;
} else {
return Reflect.get(target, key, receiver);
}
}
});
}
function usePageHeadSearchInput({
id: id2,
navigationBar: {
searchInput
}
}) {
const focus = vue.ref(false);
const text = vue.ref("");
const composing = vue.ref(false);
const {
disabled
} = searchInput;
if (disabled) {
const onClick = () => {
invokeHook(id2, uniShared.ON_NAVIGATION_BAR_SEARCH_INPUT_CLICKED);
};
return {
focus,
text,
composing,
onClick
};
}
const onFocus = () => {
focus.value = true;
invokeHook(id2, uniShared.ON_NAVIGATION_BAR_SEARCH_INPUT_FOCUS_CHANGED, {
focus: true
});
};
const onBlur = () => {
focus.value = false;
invokeHook(id2, uniShared.ON_NAVIGATION_BAR_SEARCH_INPUT_FOCUS_CHANGED, {
focus: false
});
};
const onInput = (evt) => {
text.value = evt.detail.value;
invokeHook(id2, uniShared.ON_NAVIGATION_BAR_SEARCH_INPUT_CHANGED, {
text: text.value
});
};
const onConfirm = (evt) => {
invokeHook(id2, uniShared.ON_NAVIGATION_BAR_SEARCH_INPUT_CONFIRMED, {
text: text.value
});
};
return {
focus,
text,
composing,
onFocus,
onBlur,
onInput,
onConfirm
};
}
const _sfc_main = {
name: "PageRefresh",
setup() {
const { pullToRefresh } = usePageMeta();
return {
offset: pullToRefresh.offset,
color: pullToRefresh.color
};
}
};
const _export_sfc = (sfc, props2) => {
const target = sfc.__vccOpts || sfc;
for (const [key, val] of props2) {
target[key] = val;
}
return target;
};
const _hoisted_1 = { class: "uni-page-refresh-inner" };
const _hoisted_2 = ["fill"];
const _hoisted_3 = /* @__PURE__ */ vue.createElementVNode("path", { d: "M17.65 6.35C16.2 4.9 14.21 4 12 4c-4.42 0-7.99 3.58-7.99 8s3.57 8 7.99 8c3.73 0 6.84-2.55 7.73-6h-2.08c-.82 2.33-3.04 4-5.65 4-3.31 0-6-2.69-6-6s2.69-6 6-6c1.66 0 3.14.69 4.22 1.78L13 11h7V4l-2.35 2.35z" }, null, -1);
const _hoisted_4 = /* @__PURE__ */ vue.createElementVNode("path", {
d: "M0 0h24v24H0z",
fill: "none"
}, null, -1);
const _hoisted_5 = [
_hoisted_3,
_hoisted_4
];
const _hoisted_6 = {
class: "uni-page-refresh__spinner",
width: "24",
height: "24",
viewBox: "25 25 50 50"
};
const _hoisted_7 = ["stroke"];
function _sfc_render(_ctx, _cache, $props, $setup, $data, $options) {
return vue.openBlock(), vue.createElementBlock("uni-page-refresh", null, [
vue.createElementVNode("div", {
style: vue.normalizeStyle({ "margin-top": $setup.offset + "px" }),
class: "uni-page-refresh"
}, [
vue.createElementVNode("div", _hoisted_1, [
(vue.openBlock(), vue.createElementBlock("svg", {
fill: $setup.color,
class: "uni-page-refresh__icon",
width: "24",
height: "24",
viewBox: "0 0 24 24"
}, _hoisted_5, 8, _hoisted_2)),
(vue.openBlock(), vue.createElementBlock("svg", _hoisted_6, [
vue.createElementVNode("circle", {
stroke: $setup.color,
class: "uni-page-refresh__path",
cx: "50",
cy: "50",
r: "20",
fill: "none",
"stroke-width": "4",
"stroke-miterlimit": "10"
}, null, 8, _hoisted_7)
]))
])
], 4)
]);
}
const PageRefresh = /* @__PURE__ */ _export_sfc(_sfc_main, [["render", _sfc_render]]);
const PageBody = /* @__PURE__ */ defineSystemComponent({
name: "PageBody",
setup(props2, ctx) {
const pageMeta = __UNI_FEATURE_PULL_DOWN_REFRESH__ && usePageMeta();
const refreshRef = __UNI_FEATURE_PULL_DOWN_REFRESH__ && vue.ref(null);
const _pageRefresh = null;
const pageRefresh = vue.ref(null);
vue.watch(() => {
return pageMeta.enablePullDownRefresh;
}, () => {
pageRefresh.value = pageMeta.enablePullDownRefresh ? _pageRefresh : null;
}, {
immediate: true
});
return () => {
const pageRefreshTsx = __UNI_FEATURE_PULL_DOWN_REFRESH__ && createPageRefreshTsx(refreshRef);
return vue.createVNode(vue.Fragment, null, [pageRefreshTsx, vue.createVNode("uni-page-wrapper", pageRefresh.value, [vue.createVNode("uni-page-body", null, [vue.renderSlot(ctx.slots, "default")])], 16)]);
};
}
});
function createPageRefreshTsx(refreshRef, pageMeta) {
return vue.createVNode(PageRefresh, {
"ref": refreshRef
}, null, 512);
}
const PageComponent = /* @__PURE__ */ defineSystemComponent({
name: "Page",
setup(_props, ctx) {
const pageMeta = providePageMeta(getStateId());
const navigationBar = pageMeta.navigationBar;
const pageStyle = {};
useDocumentTitle(pageMeta);
const currentInstance = vue.getCurrentInstance();
{
currentInstance.$dialogPages = vue.ref([]);
currentInstance.$systemDialogPages = vue.ref([]);
useBackgroundColorContent(pageMeta);
if (isDialogPageInstance(ctx)) {
navigationBar.style = "custom";
pageMeta.route = ctx.attrs.route;
const parentInstance = vue.inject(
"parentInstance"
);
if (currentInstance && parentInstance) {
currentInstance.$parentInstance = parentInstance;
if (isNormalDialogPageInstance(
ctx
)) {
const parentDialogPages = parentInstance.$dialogPages.value;
currentInstance.$dialogPage = parentDialogPages[parentDialogPages.length - 1];
}
if (isSystemDialogPageInstance(
ctx
)) {
const parentSystemDialogPages = parentInstance.$systemDialogPages.value;
currentInstance.$dialogPage = parentSystemDialogPages[parentSystemDialogPages.length - 1];
}
}
} else {
vue.provide("parentInstance", currentInstance);
}
}
return () => vue.createVNode(
"uni-page",
{
"data-page": pageMeta.route,
style: pageStyle
},
__UNI_FEATURE_NAVIGATIONBAR__ && navigationBar.style !== "custom" ? [
vue.createVNode(PageHead),
createPageBodyVNode(ctx),
createDialogPageVNode(
currentInstance.$dialogPages,
currentInstance.$systemDialogPages
)
] : [
createPageBodyVNode(ctx),
createDialogPageVNode(
currentInstance.$dialogPages,
currentInstance.$systemDialogPages
)
]
);
}
});
function createPageBodyVNode(ctx) {
return vue.openBlock(), vue.createBlock(
PageBody,
{ key: 0 },
{
default: vue.withCtx(() => [vue.renderSlot(ctx.slots, "page")]),
_: 3
}
);
}
function createDialogPageVNode(normalDialogPages, systemDialogPages) {
const dialogPages = [
...normalDialogPages.value.map((page) => ({ page, type: DIALOG_TAG })),
...systemDialogPages.value.map((page) => ({
page,
type: SYSTEM_DIALOG_TAG
}))
];
return vue.openBlock(true), vue.createElementBlock(
vue.Fragment,
null,
vue.renderList(dialogPages, (dialogPage) => {
const { type, page } = dialogPage;
const fullUrl = `${page.route}${uniShared.stringifyQuery(page.options)}`;
return vue.openBlock(), vue.createBlock(
vue.createVNode(
page.$component,
{
key: fullUrl,
style: {
position: "fixed",
"z-index": 999,
top: 0,
right: 0,
bottom: 0,
left: 0
},
"data-type": type,
route: fullUrl
},
null
)
);
})
);
}
var startTag = /^<([-A-Za-z0-9_]+)((?:\s+[a-zA-Z_:][-a-zA-Z0-9_:.]*(?:\s*=\s*(?:(?:"[^"]*")|(?:'[^']*')|[^>\s]+))?)*)\s*(\/?)>/;
var endTag = /^<\/([-A-Za-z0-9_]+)[^>]*>/;
var attr = /([a-zA-Z_:][-a-zA-Z0-9_:.]*)(?:\s*=\s*(?:(?:"((?:\\.|[^"])*)")|(?:'((?:\\.|[^'])*)')|([^>\s]+)))?/g;
var empty = /* @__PURE__ */ makeMap(
"area,base,basefont,br,col,frame,hr,img,input,link,meta,param,embed,command,keygen,source,track,wbr"
);
var block = /* @__PURE__ */ makeMap(
"a,address,article,applet,aside,audio,blockquote,button,canvas,center,dd,del,dir,div,dl,dt,fieldset,figcaption,figure,footer,form,frameset,h1,h2,h3,h4,h5,h6,header,hgroup,hr,iframe,isindex,li,map,menu,noframes,noscript,object,ol,output,p,pre,section,script,table,tbody,td,tfoot,th,thead,tr,ul,video"
);
var inline = /* @__PURE__ */ makeMap(
"abbr,acronym,applet,b,basefont,bdo,big,br,button,cite,code,del,dfn,em,font,i,iframe,img,input,ins,kbd,label,map,object,q,s,samp,script,select,small,span,strike,strong,sub,sup,textarea,tt,u,var"
);
var closeSelf = /* @__PURE__ */ makeMap(
"colgroup,dd,dt,li,options,p,td,tfoot,th,thead,tr"
);
var fillAttrs = /* @__PURE__ */ makeMap(
"checked,compact,declare,defer,disabled,ismap,multiple,nohref,noresize,noshade,nowrap,readonly,selected"
);
var special = /* @__PURE__ */ makeMap("script,style");
function HTMLParser(html, handler) {
var index2;
var chars;
var match;
var stack = [];
var last = html;
stack.last = function() {
return this[this.length - 1];
};
while (html) {
chars = true;
if (!stack.last() || !special[stack.last()]) {
if (html.indexOf("");
if (index2 >= 0) {
if (handler.comment) {
handler.comment(html.substring(4, index2));
}
html = html.substring(index2 + 3);
chars = false;
}
} else if (html.indexOf("") == 0) {
match = html.match(endTag);
if (match) {
html = html.substring(match[0].length);
match[0].replace(endTag, parseEndTag);
chars = false;
}
} else if (html.indexOf("<") == 0) {
match = html.match(startTag);
if (match) {
html = html.substring(match[0].length);
match[0].replace(startTag, parseStartTag);
chars = false;
}
}
if (chars) {
index2 = html.indexOf("<");
var text = index2 < 0 ? html : html.substring(0, index2);
html = index2 < 0 ? "" : html.substring(index2);
if (handler.chars) {
handler.chars(text);
}
}
} else {
html = html.replace(
new RegExp("([\\s\\S]*?)" + stack.last() + "[^>]*>"),
function(all, text2) {
text2 = text2.replace(
/|/g,
"$1$2"
);
if (handler.chars) {
handler.chars(text2);
}
return "";
}
);
parseEndTag("", stack.last());
}
if (html == last) {
throw "Parse Error: " + html;
}
last = html;
}
parseEndTag();
function parseStartTag(tag, tagName, rest, unary) {
tagName = tagName.toLowerCase();
if (block[tagName]) {
while (stack.last() && inline[stack.last()]) {
parseEndTag("", stack.last());
}
}
if (closeSelf[tagName] && stack.last() == tagName) {
parseEndTag("", tagName);
}
unary = empty[tagName] || !!unary;
if (!unary) {
stack.push(tagName);
}
if (handler.start) {
var attrs = [];
rest.replace(attr, function(match2, name) {
var value = arguments[2] ? arguments[2] : arguments[3] ? arguments[3] : arguments[4] ? arguments[4] : fillAttrs[name] ? name : "";
attrs.push({
name,
value,
escaped: value.replace(/(^|[^\\])"/g, '$1\\"')
// "
});
});
if (handler.start) {
handler.start(tagName, attrs, unary);
}
}
}
function parseEndTag(tag, tagName) {
if (!tagName) {
var pos = 0;
} else {
for (var pos = stack.length - 1; pos >= 0; pos--) {
if (stack[pos] == tagName) {
break;
}
}
}
if (pos >= 0) {
for (var i = stack.length - 1; i >= pos; i--) {
if (handler.end) {
handler.end(stack[i]);
}
}
stack.length = pos;
}
}
}
function makeMap(str) {
var obj = {};
var items = str.split(",");
for (var i = 0; i < items.length; i++) {
obj[items[i]] = true;
}
return obj;
}
function useQuill(props2, rootRef, trigger) {
vue.watch(
() => props2.readOnly,
(value) => {
}
);
vue.watch(
() => props2.placeholder,
(value) => {
}
);
useContextInfo();
useSubscribe();
}
const props$n = /* @__PURE__ */ shared.extend({}, props$o, {
id: {
type: String,
default: ""
},
readOnly: {
type: [Boolean, String],
default: false
},
placeholder: {
type: String,
default: ""
},
showImgSize: {
type: [Boolean, String],
default: false
},
showImgToolbar: {
type: [Boolean, String],
default: false
},
showImgResize: {
type: [Boolean, String],
default: false
}
});
const index$v = /* @__PURE__ */ defineBuiltInComponent({
name: "Editor",
props: props$n,
emit: ["ready", "focus", "blur", "input", "statuschange", ...emit$1],
setup(props2, {
emit: emit2
}) {
const rootRef = vue.ref(null);
useQuill(props2);
useKeyboard$1(props2, rootRef);
return () => {
return vue.createVNode("uni-editor", {
"ref": rootRef,
"id": props2.id,
"class": "ql-container"
}, null, 8, ["id"]);
};
}
});
const INFO_COLOR = "#10aeff";
const WARN_COLOR = "#f76260";
const GREY_COLOR = "#b2b2b2";
const CANCEL_COLOR = "#f43530";
const ICONS = {
success: {
d: ICON_PATH_SUCCESS,
c: uniShared.PRIMARY_COLOR
},
success_no_circle: {
d: ICON_PATH_SUCCESS_NO_CIRCLE,
c: uniShared.PRIMARY_COLOR
},
info: {
d: ICON_PATH_INFO,
c: INFO_COLOR
},
warn: {
d: ICON_PATH_WARN,
c: WARN_COLOR
},
waiting: {
d: ICON_PATH_WAITING,
c: INFO_COLOR
},
cancel: {
d: ICON_PATH_CANCEL,
c: CANCEL_COLOR
},
download: {
d: ICON_PATH_DOWNLOAD,
c: uniShared.PRIMARY_COLOR
},
search: {
d: ICON_PATH_SEARCH,
c: GREY_COLOR
},
clear: {
d: ICON_PATH_CLEAR,
c: GREY_COLOR
}
};
const index$u = /* @__PURE__ */ defineBuiltInComponent({
name: "Icon",
props: {
type: {
type: String,
required: true,
default: ""
},
size: {
type: [String, Number],
default: 23
},
color: {
type: String,
default: ""
}
},
setup(props2) {
const rootRef = vue.ref(null);
const path = vue.computed(() => ICONS[props2.type]);
return () => {
const {
value
} = path;
return vue.createVNode("uni-icon", {
"ref": rootRef
}, [value && value.d && createSvgIconVNode(value.d, props2.color || value.c, rpx2px(props2.size))], 512);
};
}
});
const ResizeSensor = /* @__PURE__ */ defineBuiltInComponent({
name: "ResizeSensor",
props: {
initial: {
type: Boolean,
default: false
}
},
emits: ["resize"],
setup(props2, {
emit: emit2
}) {
const rootRef = vue.ref(null);
const reset = useResizeSensorReset(rootRef);
const update = useResizeSensorUpdate(rootRef, emit2, reset);
return () => vue.createVNode("uni-resize-sensor", {
"ref": rootRef,
"onAnimationstartOnce": update
}, [vue.createVNode("div", {
"onScroll": update
}, [vue.createVNode("div", null, null)], 40, ["onScroll"]), vue.createVNode("div", {
"onScroll": update
}, [vue.createVNode("div", null, null)], 40, ["onScroll"])], 40, ["onAnimationstartOnce"]);
}
});
function useResizeSensorUpdate(rootRef, emit2, reset) {
const size = vue.reactive({
width: -1,
height: -1
});
vue.watch(() => shared.extend({}, size), (value) => emit2("resize", value));
return () => {
const rootEl = rootRef.value;
if (!rootEl)
return;
size.width = rootEl.offsetWidth;
size.height = rootEl.offsetHeight;
reset();
};
}
function useResizeSensorReset(rootRef) {
return () => {
const {
firstElementChild,
lastElementChild
} = rootRef.value;
firstElementChild.scrollLeft = 1e5;
firstElementChild.scrollTop = 1e5;
lastElementChild.scrollLeft = 1e5;
lastElementChild.scrollTop = 1e5;
};
}
const props$m = {
src: {
type: String,
default: ""
},
mode: {
type: String,
default: "scaleToFill"
},
lazyLoad: {
type: [Boolean, String],
default: false
},
draggable: {
type: Boolean,
default: false
}
};
const FIX_MODES = {
widthFix: ["offsetWidth", "height", (value, ratio) => value / ratio],
heightFix: ["offsetHeight", "width", (value, ratio) => value * ratio]
};
const IMAGE_MODES = {
aspectFit: ["center center", "contain"],
aspectFill: ["center center", "cover"],
widthFix: [, "100% 100%"],
heightFix: [, "100% 100%"],
top: ["center top"],
bottom: ["center bottom"],
center: ["center center"],
left: ["left center"],
right: ["right center"],
"top left": ["left top"],
"top right": ["right top"],
"bottom left": ["left bottom"],
"bottom right": ["right bottom"]
};
const index$t = /* @__PURE__ */ defineBuiltInComponent({
name: "Image",
props: props$m,
setup(props2, {
emit: emit2
}) {
const rootRef = vue.ref(null);
const state = useImageState(rootRef, props2);
const trigger = useCustomEvent(rootRef, emit2);
const {
fixSize
} = useImageSize(rootRef, props2, state);
useImageLoader(state, props2, rootRef, fixSize, trigger);
return () => {
return vue.createVNode("uni-image", {
"ref": rootRef
}, [vue.createVNode("div", {
"style": state.modeStyle
}, null, 4), FIX_MODES[props2.mode] ? vue.createVNode(ResizeSensor, {
"onResize": fixSize
}, null, 8, ["onResize"]) : vue.createVNode("span", null, null)], 512);
};
}
});
function useImageState(rootRef, props2) {
const imgSrc = vue.ref("");
const modeStyleRef = vue.computed(() => {
let size = "auto";
let position = "";
const opts = IMAGE_MODES[props2.mode];
if (!opts) {
position = "0% 0%";
size = "100% 100%";
} else {
opts[0] && (position = opts[0]);
opts[1] && (size = opts[1]);
}
return `background-image:${imgSrc.value ? 'url("' + imgSrc.value + '")' : "none"};background-position:${position};background-size:${size};`;
});
const state = vue.reactive({
rootEl: rootRef,
src: vue.computed(() => props2.src ? getRealPath(props2.src) : ""),
origWidth: 0,
origHeight: 0,
origStyle: {
width: "",
height: ""
},
modeStyle: modeStyleRef,
imgSrc
});
return state;
}
function useImageLoader(state, props2, rootRef, fixSize, trigger) {
let img;
let draggableImg;
const setState = (width = 0, height = 0, imgSrc = "") => {
state.origWidth = width;
state.origHeight = height;
state.imgSrc = imgSrc;
};
const loadImage = (src) => {
if (!src) {
resetImage();
setState();
return;
}
img = img || new Image();
img.onload = (evt) => {
const {
width,
height
} = img;
setState(width, height, src);
vue.nextTick(() => {
fixSize();
});
img.draggable = props2.draggable;
if (draggableImg) {
draggableImg.remove();
}
draggableImg = img;
rootRef.value.appendChild(img);
resetImage();
trigger("load", evt, {
width,
height
});
};
img.onerror = (evt) => {
setState();
resetImage();
trigger("error", evt, {
errMsg: `GET ${state.src} 404 (Not Found)`
});
};
img.src = src;
};
const resetImage = () => {
if (img) {
img.onload = null;
img.onerror = null;
img = null;
}
};
vue.watch(() => state.src, (value) => loadImage(value));
vue.watch(() => state.imgSrc, (value) => {
if (!value && draggableImg) {
draggableImg.remove();
draggableImg = null;
}
});
}
function fixNumber(num) {
return num;
}
function useImageSize(rootRef, props2, state) {
const fixSize = () => {
const {
mode: mode2
} = props2;
const names = FIX_MODES[mode2];
if (!names) {
return;
}
const {
origWidth,
origHeight
} = state;
const ratio = origWidth && origHeight ? origWidth / origHeight : 0;
if (!ratio) {
return;
}
const rootEl = rootRef.value;
const value = rootEl[names[0]];
if (value) {
rootEl.style[names[1]] = fixNumber(names[2](value, ratio)) + "px";
}
};
const resetSize = () => {
const {
style
} = rootRef.value;
const {
origStyle: {
width,
height
}
} = state;
style.width = width;
style.height = height;
};
vue.watch(() => props2.mode, (value, oldValue) => {
if (FIX_MODES[oldValue]) {
resetSize();
}
if (FIX_MODES[value]) {
fixSize();
}
});
return {
fixSize,
resetSize
};
}
function throttle(fn, wait) {
let last = 0;
let timeout;
let waitCallback;
const newFn = function(...arg) {
const now = Date.now();
clearTimeout(timeout);
waitCallback = () => {
waitCallback = null;
last = now;
fn.apply(this, arg);
};
if (now - last < wait) {
timeout = setTimeout(waitCallback, wait - (now - last));
return;
}
waitCallback();
};
newFn.cancel = function() {
clearTimeout(timeout);
waitCallback = null;
};
newFn.flush = function() {
clearTimeout(timeout);
waitCallback && waitCallback();
};
return newFn;
}
function useUserAction() {
const state = vue.reactive({
/**
* 是否用户激活
*/
userAction: false
});
return {
state
};
}
function useScopedAttrs() {
const state = vue.reactive({
attrs: {}
});
return {
state
};
}
function useFormField(nameKey, value) {
const uniForm = vue.inject(
uniFormKey,
false
// remove warning
);
if (!uniForm) {
return;
}
const instance = vue.getCurrentInstance();
const ctx = {
submit() {
const proxy = instance.proxy;
return [
proxy[nameKey],
shared.isString(value) ? proxy[value] : value.value
];
},
reset() {
if (shared.isString(value)) {
instance.proxy[value] = "";
} else {
value.value = "";
}
}
};
uniForm.addField(ctx);
}
function getSelectedTextRange(_, resolve) {
const activeElement = document.activeElement;
if (!activeElement) {
return resolve({});
}
const data = {};
if (["input", "textarea"].includes(activeElement.tagName.toLowerCase())) {
data.start = activeElement.selectionStart;
data.end = activeElement.selectionEnd;
}
resolve(data);
}
const UniViewJSBridgeSubscribe = function() {
registerViewMethod(
getCurrentPageId(),
"getSelectedTextRange",
getSelectedTextRange
);
};
function getValueString(value, type, maxlength) {
if (type === "number" && isNaN(Number(value))) {
value = "";
}
const valueStr = value === null || value === void 0 ? "" : String(value);
if (maxlength == void 0) {
return valueStr;
}
return valueStr.slice(0, maxlength);
}
const INPUT_MODES = [
"none",
"text",
"decimal",
"numeric",
"tel",
"search",
"email",
"url"
];
const props$l = /* @__PURE__ */ shared.extend(
{},
{
name: {
type: String,
default: ""
},
modelValue: {
type: [String, Number]
},
value: {
type: [String, Number]
},
disabled: {
type: [Boolean, String],
default: false
},
/**
* 已废弃属性,用于历史兼容
*/
autoFocus: {
type: [Boolean, String],
default: false
},
focus: {
type: [Boolean, String],
default: false
},
cursor: {
type: [Number, String],
default: -1
},
selectionStart: {
type: [Number, String],
default: -1
},
selectionEnd: {
type: [Number, String],
default: -1
},
type: {
type: String,
default: "text"
},
password: {
type: [Boolean, String],
default: false
},
placeholder: {
type: String,
default: ""
},
placeholderStyle: {
type: String,
default: ""
},
placeholderClass: {
type: String,
default: ""
},
maxlength: {
type: [Number, String],
default: Infinity
},
confirmType: {
type: String,
default: "done"
},
confirmHold: {
type: Boolean,
default: false
},
ignoreCompositionEvent: {
type: Boolean,
default: true
},
step: {
type: String,
default: "0.000000000000000001"
},
inputmode: {
type: String,
default: void 0,
validator: (value) => !!~INPUT_MODES.indexOf(value)
},
cursorColor: {
type: String,
default: ""
}
},
props$o
);
const emit = [
"input",
"focus",
"blur",
"update:value",
"update:modelValue",
"update:focus",
"compositionstart",
"compositionupdate",
"compositionend",
...emit$1
];
function useBase(props2, rootRef, emit2) {
const fieldRef = vue.ref(null);
const trigger = useCustomEvent(rootRef, emit2);
const selectionStart = vue.computed(() => {
const selectionStart2 = Number(props2.selectionStart);
return isNaN(selectionStart2) ? -1 : selectionStart2;
});
const selectionEnd = vue.computed(() => {
const selectionEnd2 = Number(props2.selectionEnd);
return isNaN(selectionEnd2) ? -1 : selectionEnd2;
});
const cursor = vue.computed(() => {
const cursor2 = Number(props2.cursor);
return isNaN(cursor2) ? -1 : cursor2;
});
const maxlength = vue.computed(() => {
var maxlength2 = Number(props2.maxlength);
{
return isNaN(maxlength2) || maxlength2 < 0 ? Infinity : Math.floor(maxlength2);
}
});
let value = "";
{
const modelValueString = getValueString(
props2.modelValue,
props2.type,
maxlength.value
);
const valueString = getValueString(props2.value, props2.type, maxlength.value);
value = props2.modelValue !== void 0 ? modelValueString !== null && modelValueString !== void 0 ? modelValueString : valueString : valueString;
}
const state = vue.reactive({
value,
valueOrigin: value,
maxlength,
focus: props2.focus,
composing: false,
selectionStart,
selectionEnd,
cursor
});
vue.watch(
() => state.focus,
(val) => emit2("update:focus", val)
);
vue.watch(
() => state.maxlength,
(val) => state.value = state.value.slice(0, val),
{
immediate: true
}
);
return {
fieldRef,
state,
trigger
};
}
function useValueSync(props2, state, emit2, trigger) {
let valueChangeFn = null;
{
valueChangeFn = throttle((val) => {
state.value = getValueString(val, props2.type, state.maxlength);
}, 100);
}
vue.watch(() => props2.modelValue, valueChangeFn);
vue.watch(() => props2.value, valueChangeFn);
const triggerInputFn = throttle((event, detail) => {
valueChangeFn.cancel();
emit2("update:modelValue", detail.value);
emit2("update:value", detail.value);
trigger("input", event, detail);
}, 100);
const triggerInput = (event, detail, force) => {
valueChangeFn.cancel();
triggerInputFn(event, detail);
if (force) {
triggerInputFn.flush();
}
};
return {
trigger,
triggerInput
};
}
function useAutoFocus(props2, fieldRef) {
useUserAction();
const needFocus = vue.computed(() => props2.autoFocus || props2.focus);
function focus() {
if (!needFocus.value) {
return;
}
const field = fieldRef.value;
if (!field || false) {
setTimeout(focus, 100);
return;
}
{
field.focus();
}
}
function blur() {
const field = fieldRef.value;
if (field) {
field.blur();
}
}
vue.watch(
() => props2.focus,
(value) => {
if (value) {
focus();
} else {
blur();
}
}
);
}
function useEvent(fieldRef, state, props2, trigger, triggerInput, beforeInput) {
function checkSelection() {
const field = fieldRef.value;
if (field && state.focus && state.selectionStart > -1 && state.selectionEnd > -1 && field.type !== "number") {
field.selectionStart = state.selectionStart;
field.selectionEnd = state.selectionEnd;
}
}
function checkCursor() {
const field = fieldRef.value;
if (field && state.focus && state.selectionStart < 0 && state.selectionEnd < 0 && state.cursor > -1 && field.type !== "number") {
field.selectionEnd = field.selectionStart = state.cursor;
}
}
function getFieldSelectionEnd(field) {
if (field.type === "number") {
return null;
} else {
return field.selectionEnd;
}
}
function initField() {
const field = fieldRef.value;
if (!field)
return;
const onFocus = function(event) {
state.focus = true;
trigger("focus", event, {
value: state.value
});
checkSelection();
checkCursor();
};
const onInput = function(event, force) {
event.stopPropagation();
if (shared.isFunction(beforeInput) && beforeInput(event, state) === false) {
return;
}
state.value = field.value;
if (!state.composing || !props2.ignoreCompositionEvent) {
triggerInput(
event,
{
value: field.value,
cursor: getFieldSelectionEnd(field)
},
force
);
}
};
const onBlur = function(event) {
if (state.composing) {
state.composing = false;
onInput(event, true);
}
state.focus = false;
trigger("blur", event, {
value: state.value,
cursor: getFieldSelectionEnd(event.target)
});
};
field.addEventListener("change", (event) => event.stopPropagation());
field.addEventListener("focus", onFocus);
field.addEventListener("blur", onBlur);
field.addEventListener("input", onInput);
field.addEventListener("compositionstart", (event) => {
event.stopPropagation();
state.composing = true;
_onComposition(event);
});
field.addEventListener("compositionend", (event) => {
event.stopPropagation();
if (state.composing) {
state.composing = false;
onInput(event);
}
_onComposition(event);
});
field.addEventListener("compositionupdate", _onComposition);
function _onComposition(event) {
if (!props2.ignoreCompositionEvent) {
trigger(event.type, event, {
value: event.data
});
}
}
}
vue.watch([() => state.selectionStart, () => state.selectionEnd], checkSelection);
vue.watch(() => state.cursor, checkCursor);
vue.watch(() => fieldRef.value, initField);
}
function useField(props2, rootRef, emit2, beforeInput) {
UniViewJSBridgeSubscribe();
const { fieldRef, state, trigger } = useBase(props2, rootRef, emit2);
const { triggerInput } = useValueSync(props2, state, emit2, trigger);
useAutoFocus(props2, fieldRef);
useKeyboard$1(props2, fieldRef);
const { state: scopedAttrsState } = useScopedAttrs();
useFormField("name", state);
useEvent(fieldRef, state, props2, trigger, triggerInput, beforeInput);
const fixDisabledColor = false;
return {
fieldRef,
state,
scopedAttrsState,
fixDisabledColor,
trigger
};
}
const props$k = /* @__PURE__ */ shared.extend({}, props$l, {
placeholderClass: {
type: String,
default: "input-placeholder"
},
textContentType: {
type: String,
default: ""
}
});
const resolveDigitDecimalPointDeleteContentBackward = uniShared.once(() => {
});
function resolveDigitDecimalPoint(event, cache, state, input, resetCache) {
if (cache.value) {
if (event.data === ".") {
if (cache.value.slice(-1) === ".") {
state.value = input.value = cache.value = cache.value.slice(0, -1);
return false;
}
if (cache.value && !cache.value.includes(".")) {
cache.value += ".";
if (resetCache) {
resetCache.fn = () => {
state.value = input.value = cache.value = cache.value.slice(0, -1);
input.removeEventListener("blur", resetCache.fn);
};
input.addEventListener("blur", resetCache.fn);
}
return false;
}
} else if (event.inputType === "deleteContentBackward") {
if (resolveDigitDecimalPointDeleteContentBackward()) {
if (cache.value.slice(-2, -1) === ".") {
cache.value = state.value = input.value = cache.value.slice(0, -2);
return true;
}
}
}
}
}
function useCache(props2, type) {
if (type.value === "number") {
const value = typeof props2.modelValue === "undefined" ? props2.value : props2.modelValue;
const cache = vue.ref(typeof value !== "undefined" && value !== null ? value.toLocaleString() : "");
vue.watch(() => props2.modelValue, (value2) => {
cache.value = typeof value2 !== "undefined" && value2 !== null ? value2.toLocaleString() : "";
});
vue.watch(() => props2.value, (value2) => {
cache.value = typeof value2 !== "undefined" && value2 !== null ? value2.toLocaleString() : "";
});
return cache;
} else {
return vue.ref("");
}
}
const Input = /* @__PURE__ */ defineBuiltInComponent({
name: "Input",
props: props$k,
emits: ["confirm", ...emit],
setup(props2, {
emit: emit2,
expose
}) {
const INPUT_TYPES = ["text", "number", "idcard", "digit", "password", "tel"];
const AUTOCOMPLETES = ["off", "one-time-code"];
const type = vue.computed(() => {
let type2 = "";
switch (props2.type) {
case "text":
type2 = "text";
if (props2.confirmType === "search") {
type2 = "search";
}
break;
case "idcard":
type2 = "text";
break;
case "digit":
type2 = "number";
break;
default:
type2 = INPUT_TYPES.includes(props2.type) ? props2.type : "text";
break;
}
return props2.password ? "password" : type2;
});
const autocomplete = vue.computed(() => {
const camelizeIndex = AUTOCOMPLETES.indexOf(props2.textContentType);
const kebabCaseIndex = AUTOCOMPLETES.indexOf(shared.hyphenate(props2.textContentType));
const index2 = camelizeIndex !== -1 ? camelizeIndex : kebabCaseIndex !== -1 ? kebabCaseIndex : 0;
return AUTOCOMPLETES[index2];
});
let cache = useCache(props2, type);
let resetCache = {
fn: null
};
const rootRef = vue.ref(null);
const {
fieldRef,
state,
scopedAttrsState,
fixDisabledColor,
trigger
} = useField(props2, rootRef, emit2, (event, state2) => {
const input = event.target;
if (type.value === "number") {
if (resetCache.fn) {
input.removeEventListener("blur", resetCache.fn);
resetCache.fn = null;
}
if (input.validity && !input.validity.valid) {
if ((!cache.value || !input.value) && event.data === "-" || cache.value[0] === "-" && event.inputType === "deleteContentBackward") {
cache.value = "-";
state2.value = "";
resetCache.fn = () => {
cache.value = input.value = "";
};
input.addEventListener("blur", resetCache.fn);
return false;
}
const res = resolveDigitDecimalPoint(event, cache, state2, input, resetCache);
if (typeof res === "boolean")
return res;
cache.value = state2.value = input.value = cache.value === "-" ? "" : cache.value;
return false;
} else {
const res = resolveDigitDecimalPoint(event, cache, state2, input, resetCache);
if (typeof res === "boolean")
return res;
cache.value = input.value;
}
const maxlength = state2.maxlength;
if (maxlength > 0 && input.value.length > maxlength) {
input.value = input.value.slice(0, maxlength);
state2.value = input.value;
const modelValue = props2.modelValue !== void 0 && props2.modelValue !== null ? props2.modelValue.toString() : "";
return modelValue !== input.value;
}
}
});
vue.watch(() => state.value, (value) => {
if (props2.type === "number" && !(cache.value === "-" && value === "")) {
cache.value = value.toString();
}
});
const NUMBER_TYPES = ["number", "digit"];
const step = vue.computed(() => NUMBER_TYPES.includes(props2.type) ? props2.step : "");
function onKeyUpEnter(event) {
if (event.key !== "Enter") {
return;
}
const input = event.target;
event.stopPropagation();
trigger("confirm", event, {
value: input.value
});
!props2.confirmHold && input.blur();
}
expose({
$triggerInput: (detail) => {
emit2("update:modelValue", detail.value);
emit2("update:value", detail.value);
state.value = detail.value;
}
});
return () => {
let inputNode = props2.disabled && fixDisabledColor ? vue.createVNode("input", {
"key": "disabled-input",
"ref": fieldRef,
"value": state.value,
"tabindex": "-1",
"readonly": !!props2.disabled,
"type": type.value,
"maxlength": state.maxlength,
"step": step.value,
"class": "uni-input-input",
"style": props2.cursorColor ? {
caretColor: props2.cursorColor
} : {},
"onFocus": (event) => event.target.blur()
}, null, 44, ["value", "readonly", "type", "maxlength", "step", "onFocus"]) : vue.createVNode("input", {
"key": "input",
"ref": fieldRef,
"value": state.value,
"onInput": (event) => {
state.value = event.target.value.toString();
},
"disabled": !!props2.disabled,
"type": type.value,
"maxlength": state.maxlength,
"step": step.value,
"enterkeyhint": props2.confirmType,
"pattern": props2.type === "number" ? "[0-9]*" : void 0,
"class": "uni-input-input",
"style": props2.cursorColor ? {
caretColor: props2.cursorColor
} : {},
"autocomplete": autocomplete.value,
"onKeyup": onKeyUpEnter,
"inputmode": props2.inputmode
}, null, 44, ["value", "onInput", "disabled", "type", "maxlength", "step", "enterkeyhint", "pattern", "autocomplete", "onKeyup", "inputmode"]);
return vue.createVNode("uni-input", {
"ref": rootRef
}, [vue.createVNode("div", {
"class": "uni-input-wrapper"
}, [vue.withDirectives(vue.createVNode("div", vue.mergeProps(scopedAttrsState.attrs, {
"style": props2.placeholderStyle,
"class": ["uni-input-placeholder", props2.placeholderClass]
}), [props2.placeholder], 16), [[vue.vShow, !(state.value.length || cache.value === "-" || cache.value.includes("."))]]), props2.confirmType === "search" ? vue.createVNode("form", {
"action": "",
"onSubmit": (event) => event.preventDefault(),
"class": "uni-input-form"
}, [inputNode], 40, ["onSubmit"]) : inputNode])], 512);
};
}
});
function entries(obj) {
return Object.keys(obj).map((key) => [key, obj[key]]);
}
const DEFAULT_EXCLUDE_KEYS = ["class", "style"];
const LISTENER_PREFIX = /^on[A-Z]+/;
const useAttrs = (params = {}) => {
const { excludeListeners = false, excludeKeys = [] } = params;
const instance = vue.getCurrentInstance();
const attrs = vue.shallowRef({});
const listeners = vue.shallowRef({});
const excludeAttrs = vue.shallowRef({});
const allExcludeKeys = excludeKeys.concat(DEFAULT_EXCLUDE_KEYS);
instance.attrs = vue.reactive(instance.attrs);
vue.watchEffect(() => {
const res = entries(instance.attrs).reduce(
(acc, [key, val]) => {
if (allExcludeKeys.includes(key)) {
acc.exclude[key] = val;
} else if (LISTENER_PREFIX.test(key)) {
if (!excludeListeners) {
acc.attrs[key] = val;
}
acc.listeners[key] = val;
} else {
acc.attrs[key] = val;
}
return acc;
},
{
exclude: {},
attrs: {},
listeners: {}
}
);
attrs.value = res.attrs;
listeners.value = res.listeners;
excludeAttrs.value = res.exclude;
});
return { $attrs: attrs, $listeners: listeners, $excludeAttrs: excludeAttrs };
};
function flatVNode(nodes) {
const array = [];
if (shared.isArray(nodes)) {
nodes.forEach((vnode) => {
if (vue.isVNode(vnode)) {
if (vnode.type === vue.Fragment) {
array.push(...flatVNode(vnode.children));
} else {
array.push(vnode);
}
} else if (shared.isArray(vnode)) {
array.push(...flatVNode(vnode));
}
});
}
return array;
}
const movableAreaProps = {
scaleArea: {
type: Boolean,
default: false
}
};
const index$s = /* @__PURE__ */ defineBuiltInComponent({
inheritAttrs: false,
name: "MovableArea",
props: movableAreaProps,
setup(props2, {
slots
}) {
const rootRef = vue.ref(null);
const _isMounted = vue.ref(false);
let {
setContexts,
events: movableAreaEvents
} = useMovableAreaState(props2, rootRef);
const {
$listeners,
$attrs,
$excludeAttrs
} = useAttrs();
const _listeners = $listeners.value;
let events = ["onTouchstart", "onTouchmove", "onTouchend"];
events.forEach((event) => {
let existing = _listeners[event];
let ours = movableAreaEvents[`_${event}`];
_listeners[event] = existing ? [].concat(existing, ours) : ours;
});
let movableViewItems = [];
const originMovableViewContexts = [];
function updateMovableViewContexts() {
const contexts = [];
for (let index2 = 0; index2 < movableViewItems.length; index2++) {
let movableViewItem = movableViewItems[index2];
{
movableViewItem = movableViewItem.el;
}
const movableViewContext = originMovableViewContexts.find((context) => movableViewItem === context.rootRef.value);
if (movableViewContext) {
contexts.push(vue.markRaw(movableViewContext));
}
}
setContexts(contexts);
}
const addMovableViewContext = (movableViewContext) => {
originMovableViewContexts.push(movableViewContext);
updateMovableViewContexts();
};
const removeMovableViewContext = (movableViewContext) => {
const index2 = originMovableViewContexts.indexOf(movableViewContext);
if (index2 >= 0) {
originMovableViewContexts.splice(index2, 1);
updateMovableViewContexts();
}
};
vue.provide("_isMounted", _isMounted);
vue.provide("movableAreaRootRef", rootRef);
vue.provide("addMovableViewContext", addMovableViewContext);
vue.provide("removeMovableViewContext", removeMovableViewContext);
return () => {
const defaultSlots = slots.default && slots.default();
{
movableViewItems = flatVNode(defaultSlots);
}
return vue.createVNode("uni-movable-area", vue.mergeProps({
"ref": rootRef
}, $attrs.value, $excludeAttrs.value, _listeners), [vue.createVNode(ResizeSensor, {
"onResize": movableAreaEvents._resize
}, null, 8, ["onResize"]), movableViewItems], 16);
};
}
});
function calc(e2) {
return Math.sqrt(e2.x * e2.x + e2.y * e2.y);
}
function useMovableAreaState(props2, rootRef) {
const width = vue.ref(0);
const height = vue.ref(0);
const gapV = vue.reactive({
x: null,
y: null
});
const pinchStartLen = vue.ref(null);
let _scaleMovableView = null;
let movableViewContexts = [];
function _updateScale(e2) {
if (e2 && e2 !== 1) {
if (props2.scaleArea) {
movableViewContexts.forEach(function(item) {
item._setScale(e2);
});
} else {
if (_scaleMovableView) {
_scaleMovableView._setScale(e2);
}
}
}
}
function _find(target, items = movableViewContexts) {
let root = rootRef.value;
function get(node) {
for (let i = 0; i < items.length; i++) {
const item = items[i];
if (node === item.rootRef.value) {
return item;
}
}
if (node === root || node === document.body || node === document) {
return null;
}
return get(node.parentNode);
}
return get(target);
}
const _onTouchstart = withWebEvent((t2) => {
let i = t2.touches;
if (i) {
if (i.length > 1) {
let r = {
x: i[1].pageX - i[0].pageX,
y: i[1].pageY - i[0].pageY
};
pinchStartLen.value = calc(r);
gapV.x = r.x;
gapV.y = r.y;
if (!props2.scaleArea) {
let touch0 = _find(i[0].target);
let touch1 = _find(i[1].target);
_scaleMovableView = touch0 && touch0 === touch1 ? touch0 : null;
}
}
}
});
const _onTouchmove = withWebEvent((t2) => {
let n = t2.touches;
if (n) {
if (n.length > 1) {
t2.preventDefault();
let i = {
x: n[1].pageX - n[0].pageX,
y: n[1].pageY - n[0].pageY
};
if (gapV.x !== null && pinchStartLen.value && pinchStartLen.value > 0) {
let r = calc(i) / pinchStartLen.value;
_updateScale(r);
}
gapV.x = i.x;
gapV.y = i.y;
}
}
});
const _onTouchend = withWebEvent((e2) => {
let t2 = e2.touches;
if (!(t2 && t2.length)) {
if (e2.changedTouches) {
gapV.x = 0;
gapV.y = 0;
pinchStartLen.value = null;
if (props2.scaleArea) {
movableViewContexts.forEach(function(item) {
item._endScale();
});
} else {
if (_scaleMovableView) {
_scaleMovableView._endScale();
}
}
}
}
});
function _resize() {
_getWH();
movableViewContexts.forEach(function(item, index2) {
item.setParent();
});
}
function _getWH() {
let style = window.getComputedStyle(rootRef.value);
let rect = rootRef.value.getBoundingClientRect();
width.value = rect.width - ["Left", "Right"].reduce(function(all, item) {
const LEFT = "border" + item + "Width";
const RIGHT = "padding" + item;
return all + parseFloat(style[LEFT]) + parseFloat(style[RIGHT]);
}, 0);
height.value = rect.height - ["Top", "Bottom"].reduce(function(all, item) {
const TOP = "border" + item + "Width";
const BOTTOM = "padding" + item;
return all + parseFloat(style[TOP]) + parseFloat(style[BOTTOM]);
}, 0);
}
vue.provide("movableAreaWidth", width);
vue.provide("movableAreaHeight", height);
return {
setContexts(contexts) {
movableViewContexts = contexts;
},
events: {
_onTouchstart,
_onTouchmove,
_onTouchend,
_resize
}
};
}
function e(e2, t2, n) {
return e2 > t2 - n && e2 < t2 + n;
}
function t(t2, n) {
return e(t2, 0, n);
}
function Friction(e2, t2) {
this._m = e2;
this._f = 1e3 * t2;
this._startTime = 0;
this._v = 0;
}
Friction.prototype.setV = function(x, y) {
const n = Math.pow(Math.pow(x, 2) + Math.pow(y, 2), 0.5);
this._x_v = x;
this._y_v = y;
this._x_a = -this._f * this._x_v / n;
this._y_a = -this._f * this._y_v / n;
this._t = Math.abs(x / this._x_a) || Math.abs(y / this._y_a);
this._lastDt = null;
this._startTime = (/* @__PURE__ */ new Date()).getTime();
};
Friction.prototype.setS = function(x, y) {
this._x_s = x;
this._y_s = y;
};
Friction.prototype.s = function(t2) {
if (void 0 === t2) {
t2 = ((/* @__PURE__ */ new Date()).getTime() - this._startTime) / 1e3;
}
if (t2 > this._t) {
t2 = this._t;
this._lastDt = t2;
}
let x = this._x_v * t2 + 0.5 * this._x_a * Math.pow(t2, 2) + this._x_s;
let y = this._y_v * t2 + 0.5 * this._y_a * Math.pow(t2, 2) + this._y_s;
if (this._x_a > 0 && x < this._endPositionX || this._x_a < 0 && x > this._endPositionX) {
x = this._endPositionX;
}
if (this._y_a > 0 && y < this._endPositionY || this._y_a < 0 && y > this._endPositionY) {
y = this._endPositionY;
}
return {
x,
y
};
};
Friction.prototype.ds = function(t2) {
if (void 0 === t2) {
t2 = ((/* @__PURE__ */ new Date()).getTime() - this._startTime) / 1e3;
}
if (t2 > this._t) {
t2 = this._t;
}
return {
dx: this._x_v + this._x_a * t2,
dy: this._y_v + this._y_a * t2
};
};
Friction.prototype.delta = function() {
return {
x: -1.5 * Math.pow(this._x_v, 2) / this._x_a || 0,
y: -1.5 * Math.pow(this._y_v, 2) / this._y_a || 0
};
};
Friction.prototype.dt = function() {
return -this._x_v / this._x_a;
};
Friction.prototype.done = function() {
const t2 = e(this.s().x, this._endPositionX) || e(this.s().y, this._endPositionY) || this._lastDt === this._t;
this._lastDt = null;
return t2;
};
Friction.prototype.setEnd = function(x, y) {
this._endPositionX = x;
this._endPositionY = y;
};
Friction.prototype.reconfigure = function(m, f2) {
this._m = m;
this._f = 1e3 * f2;
};
function Spring(m, k, c) {
this._m = m;
this._k = k;
this._c = c;
this._solution = null;
this._endPosition = 0;
this._startTime = 0;
}
Spring.prototype._solve = function(e2, t2) {
const n = this._c;
const i = this._m;
const r = this._k;
const o = n * n - 4 * i * r;
if (o === 0) {
const a = -n / (2 * i);
const s = e2;
const l = t2 / (a * e2);
return {
x: function(e3) {
return (s + l * e3) * Math.pow(Math.E, a * e3);
},
dx: function(e3) {
const t3 = Math.pow(Math.E, a * e3);
return a * (s + l * e3) * t3 + l * t3;
}
};
}
if (o > 0) {
const c = (-n - Math.sqrt(o)) / (2 * i);
const u = (-n + Math.sqrt(o)) / (2 * i);
const d = (t2 - c * e2) / (u - c);
const h = e2 - d;
return {
x: function(e3) {
let t3;
let n2;
if (e3 === this._t) {
t3 = this._powER1T;
n2 = this._powER2T;
}
this._t = e3;
if (!t3) {
t3 = this._powER1T = Math.pow(Math.E, c * e3);
}
if (!n2) {
n2 = this._powER2T = Math.pow(Math.E, u * e3);
}
return h * t3 + d * n2;
},
dx: function(e3) {
let t3;
let n2;
if (e3 === this._t) {
t3 = this._powER1T;
n2 = this._powER2T;
}
this._t = e3;
if (!t3) {
t3 = this._powER1T = Math.pow(Math.E, c * e3);
}
if (!n2) {
n2 = this._powER2T = Math.pow(Math.E, u * e3);
}
return h * c * t3 + d * u * n2;
}
};
}
const p2 = Math.sqrt(4 * i * r - n * n) / (2 * i);
const f2 = -n / 2 * i;
const v2 = e2;
const g2 = (t2 - f2 * e2) / p2;
return {
x: function(e3) {
return Math.pow(Math.E, f2 * e3) * (v2 * Math.cos(p2 * e3) + g2 * Math.sin(p2 * e3));
},
dx: function(e3) {
const t3 = Math.pow(Math.E, f2 * e3);
const n2 = Math.cos(p2 * e3);
const i2 = Math.sin(p2 * e3);
return t3 * (g2 * p2 * n2 - v2 * p2 * i2) + f2 * t3 * (g2 * i2 + v2 * n2);
}
};
};
Spring.prototype.x = function(e2) {
if (void 0 === e2) {
e2 = ((/* @__PURE__ */ new Date()).getTime() - this._startTime) / 1e3;
}
return this._solution ? this._endPosition + this._solution.x(e2) : 0;
};
Spring.prototype.dx = function(e2) {
if (void 0 === e2) {
e2 = ((/* @__PURE__ */ new Date()).getTime() - this._startTime) / 1e3;
}
return this._solution ? this._solution.dx(e2) : 0;
};
Spring.prototype.setEnd = function(e2, n, i) {
if (!i) {
i = (/* @__PURE__ */ new Date()).getTime();
}
if (e2 !== this._endPosition || !t(n, 0.1)) {
n = n || 0;
let r = this._endPosition;
if (this._solution) {
if (t(n, 0.1)) {
n = this._solution.dx((i - this._startTime) / 1e3);
}
r = this._solution.x((i - this._startTime) / 1e3);
if (t(n, 0.1)) {
n = 0;
}
if (t(r, 0.1)) {
r = 0;
}
r += this._endPosition;
}
if (!(this._solution && t(r - e2, 0.1) && t(n, 0.1))) {
this._endPosition = e2;
this._solution = this._solve(r - this._endPosition, n);
this._startTime = i;
}
}
};
Spring.prototype.snap = function(e2) {
this._startTime = (/* @__PURE__ */ new Date()).getTime();
this._endPosition = e2;
this._solution = {
x: function() {
return 0;
},
dx: function() {
return 0;
}
};
};
Spring.prototype.done = function(n) {
if (!n) {
n = (/* @__PURE__ */ new Date()).getTime();
}
return e(this.x(), this._endPosition, 0.1) && t(this.dx(), 0.1);
};
Spring.prototype.reconfigure = function(m, t2, c) {
this._m = m;
this._k = t2;
this._c = c;
if (!this.done()) {
this._solution = this._solve(this.x() - this._endPosition, this.dx());
this._startTime = (/* @__PURE__ */ new Date()).getTime();
}
};
Spring.prototype.springConstant = function() {
return this._k;
};
Spring.prototype.damping = function() {
return this._c;
};
Spring.prototype.configuration = function() {
function e2(e3, t3) {
e3.reconfigure(1, t3, e3.damping());
}
function t2(e3, t3) {
e3.reconfigure(1, e3.springConstant(), t3);
}
return [
{
label: "Spring Constant",
read: this.springConstant.bind(this),
write: e2.bind(this, this),
min: 100,
max: 1e3
},
{
label: "Damping",
read: this.damping.bind(this),
write: t2.bind(this, this),
min: 1,
max: 500
}
];
};
function STD(e2, t2, n) {
this._springX = new Spring(e2, t2, n);
this._springY = new Spring(e2, t2, n);
this._springScale = new Spring(e2, t2, n);
this._startTime = 0;
}
STD.prototype.setEnd = function(e2, t2, n, i) {
const r = (/* @__PURE__ */ new Date()).getTime();
this._springX.setEnd(e2, i, r);
this._springY.setEnd(t2, i, r);
this._springScale.setEnd(n, i, r);
this._startTime = r;
};
STD.prototype.x = function() {
const e2 = ((/* @__PURE__ */ new Date()).getTime() - this._startTime) / 1e3;
return {
x: this._springX.x(e2),
y: this._springY.x(e2),
scale: this._springScale.x(e2)
};
};
STD.prototype.done = function() {
const e2 = (/* @__PURE__ */ new Date()).getTime();
return this._springX.done(e2) && this._springY.done(e2) && this._springScale.done(e2);
};
STD.prototype.reconfigure = function(e2, t2, n) {
this._springX.reconfigure(e2, t2, n);
this._springY.reconfigure(e2, t2, n);
this._springScale.reconfigure(e2, t2, n);
};
const movableViewProps = {
direction: {
type: String,
default: "none"
},
inertia: {
type: [Boolean, String],
default: false
},
outOfBounds: {
type: [Boolean, String],
default: false
},
x: {
type: [Number, String],
default: 0
},
y: {
type: [Number, String],
default: 0
},
damping: {
type: [Number, String],
default: 20
},
friction: {
type: [Number, String],
default: 2
},
disabled: {
type: [Boolean, String],
default: false
},
scale: {
type: [Boolean, String],
default: false
},
scaleMin: {
type: [Number, String],
default: 0.5
},
scaleMax: {
type: [Number, String],
default: 10
},
scaleValue: {
type: [Number, String],
default: 1
},
animation: {
type: [Boolean, String],
default: true
}
};
function v(a, b) {
return +((1e3 * a - 1e3 * b) / 1e3).toFixed(1);
}
const index$r = /* @__PURE__ */ defineBuiltInComponent({
name: "MovableView",
props: movableViewProps,
emits: ["change", "scale"],
setup(props2, {
slots,
emit: emit2
}) {
const rootRef = vue.ref(null);
const trigger = useCustomEvent(rootRef, emit2);
const {
setParent
} = useMovableViewState(props2, trigger, rootRef);
return () => {
return vue.createVNode("uni-movable-view", {
"ref": rootRef
}, [vue.createVNode(ResizeSensor, {
"onResize": setParent
}, null, 8, ["onResize"]), slots.default && slots.default()], 512);
};
}
});
let requesting = false;
function _requestAnimationFrame(e2) {
if (!requesting) {
requesting = true;
requestAnimationFrame(function() {
e2();
requesting = false;
});
}
}
function p(t2, n) {
if (t2 === n) {
return 0;
}
let i = t2.offsetLeft;
return t2.offsetParent ? i += p(t2.offsetParent, n) : 0;
}
function f(t2, n) {
if (t2 === n) {
return 0;
}
let i = t2.offsetTop;
return t2.offsetParent ? i += f(t2.offsetParent, n) : 0;
}
function g(friction, execute, endCallback) {
let record = {
id: 0,
cancelled: false
};
let cancel = function(record2) {
if (record2 && record2.id) {
cancelAnimationFrame(record2.id);
}
if (record2) {
record2.cancelled = true;
}
};
function fn(record2, friction2, execute2, endCallback2) {
if (!record2 || !record2.cancelled) {
execute2(friction2);
let isDone = friction2.done();
if (!isDone) {
if (!record2.cancelled) {
record2.id = requestAnimationFrame(fn.bind(null, record2, friction2, execute2, endCallback2));
}
}
if (isDone && endCallback2) {
endCallback2(friction2);
}
}
}
fn(record, friction, execute, endCallback);
return {
cancel: cancel.bind(null, record),
model: friction
};
}
function _getPx(val) {
if (/\d+[ur]px$/i.test(val)) {
return uni.upx2px(parseFloat(val));
}
return Number(val) || 0;
}
function useMovableViewLayout(rootRef, _scale, _adjustScale) {
const movableAreaWidth = vue.inject("movableAreaWidth", vue.ref(0));
const movableAreaHeight = vue.inject("movableAreaHeight", vue.ref(0));
const movableAreaRootRef = vue.inject("movableAreaRootRef");
const _offset = {
x: 0,
y: 0
};
const _scaleOffset = {
x: 0,
y: 0
};
const width = vue.ref(0);
const height = vue.ref(0);
const minX = vue.ref(0);
const minY = vue.ref(0);
const maxX = vue.ref(0);
const maxY = vue.ref(0);
function _updateBoundary() {
let x = 0 - _offset.x + _scaleOffset.x;
let _width = movableAreaWidth.value - width.value - _offset.x - _scaleOffset.x;
minX.value = Math.min(x, _width);
maxX.value = Math.max(x, _width);
let y = 0 - _offset.y + _scaleOffset.y;
let _height = movableAreaHeight.value - height.value - _offset.y - _scaleOffset.y;
minY.value = Math.min(y, _height);
maxY.value = Math.max(y, _height);
}
function _updateOffset() {
_offset.x = p(rootRef.value, movableAreaRootRef.value);
_offset.y = f(rootRef.value, movableAreaRootRef.value);
}
function _updateWH(scale) {
scale = scale || _scale.value;
scale = _adjustScale(scale);
let rect = rootRef.value.getBoundingClientRect();
height.value = rect.height / _scale.value;
width.value = rect.width / _scale.value;
let _height = height.value * scale;
let _width = width.value * scale;
_scaleOffset.x = (_width - width.value) / 2;
_scaleOffset.y = (_height - height.value) / 2;
}
return {
_updateBoundary,
_updateOffset,
_updateWH,
_scaleOffset,
minX,
minY,
maxX,
maxY
};
}
function useMovableViewTransform(rootRef, props2, _scaleOffset, _scale, maxX, maxY, minX, minY, _translateX, _translateY, _SFA, _FA, _adjustScale, trigger) {
const dampingNumber = vue.computed(() => {
let val = Number(props2.damping);
return isNaN(val) ? 20 : val;
});
const xMove = vue.computed(() => props2.direction === "all" || props2.direction === "horizontal");
const yMove = vue.computed(() => props2.direction === "all" || props2.direction === "vertical");
const xSync = vue.ref(_getPx(props2.x));
const ySync = vue.ref(_getPx(props2.y));
vue.watch(() => props2.x, (val) => {
xSync.value = _getPx(val);
});
vue.watch(() => props2.y, (val) => {
ySync.value = _getPx(val);
});
vue.watch(xSync, (val) => {
_setX(val);
});
vue.watch(ySync, (val) => {
_setY(val);
});
const _STD = new STD(1, 9 * Math.pow(dampingNumber.value, 2) / 40, dampingNumber.value);
function _getLimitXY(x, y) {
let outOfBounds = false;
if (x > maxX.value) {
x = maxX.value;
outOfBounds = true;
} else {
if (x < minX.value) {
x = minX.value;
outOfBounds = true;
}
}
if (y > maxY.value) {
y = maxY.value;
outOfBounds = true;
} else {
if (y < minY.value) {
y = minY.value;
outOfBounds = true;
}
}
return {
x,
y,
outOfBounds
};
}
function FAandSFACancel() {
if (_SFA) {
_SFA.cancel();
}
}
function _animationTo(x, y, scale, source, r, o) {
FAandSFACancel();
if (!xMove.value) {
x = _translateX.value;
}
if (!yMove.value) {
y = _translateY.value;
}
if (!props2.scale) {
scale = _scale.value;
}
let limitXY = _getLimitXY(x, y);
x = limitXY.x;
y = limitXY.y;
if (!props2.animation) {
_setTransform(x, y, scale, source, r, o);
return;
}
_STD._springX._solution = null;
_STD._springY._solution = null;
_STD._springScale._solution = null;
_STD._springX._endPosition = _translateX.value;
_STD._springY._endPosition = _translateY.value;
_STD._springScale._endPosition = _scale.value;
_STD.setEnd(x, y, scale, 1);
_SFA = g(_STD, function() {
let data = _STD.x();
let x2 = data.x;
let y2 = data.y;
let scale2 = data.scale;
_setTransform(x2, y2, scale2, source, r, o);
}, function() {
_SFA.cancel();
});
}
function _setTransform(x, y, scale, source = "", r, o) {
if (!(x !== null && x.toString() !== "NaN" && typeof x === "number")) {
x = _translateX.value || 0;
}
if (!(y !== null && y.toString() !== "NaN" && typeof y === "number")) {
y = _translateY.value || 0;
}
x = Number(x.toFixed(1));
y = Number(y.toFixed(1));
scale = Number(scale.toFixed(1));
if (!(_translateX.value === x && _translateY.value === y)) {
if (!r) {
trigger("change", {}, {
x: v(x, _scaleOffset.x),
y: v(y, _scaleOffset.y),
source
});
}
}
if (!props2.scale) {
scale = _scale.value;
}
scale = _adjustScale(scale);
scale = +scale.toFixed(3);
if (o && scale !== _scale.value) {
trigger("scale", {}, {
x,
y,
scale
});
}
let transform = "translateX(" + x + "px) translateY(" + y + "px) translateZ(0px) scale(" + scale + ")";
if (rootRef.value) {
rootRef.value.style.transform = transform;
rootRef.value.style.webkitTransform = transform;
_translateX.value = x;
_translateY.value = y;
_scale.value = scale;
}
}
function _revise(source) {
let limitXY = _getLimitXY(_translateX.value, _translateY.value);
let x = limitXY.x;
let y = limitXY.y;
let outOfBounds = limitXY.outOfBounds;
if (outOfBounds) {
_animationTo(x, y, _scale.value, source);
}
return outOfBounds;
}
function _setX(val) {
if (xMove.value) {
if (val + _scaleOffset.x === _translateX.value) {
return _translateX;
} else {
if (_SFA) {
_SFA.cancel();
}
_animationTo(val + _scaleOffset.x, ySync.value + _scaleOffset.y, _scale.value);
}
}
return val;
}
function _setY(val) {
if (yMove.value) {
if (val + _scaleOffset.y === _translateY.value) {
return _translateY;
} else {
if (_SFA) {
_SFA.cancel();
}
_animationTo(xSync.value + _scaleOffset.x, val + _scaleOffset.y, _scale.value);
}
}
return val;
}
return {
FAandSFACancel,
_getLimitXY,
_animationTo,
_setTransform,
_revise,
dampingNumber,
xMove,
yMove,
xSync,
ySync,
_STD
};
}
function useMovableViewInit(props2, rootRef, trigger, _scale, _oldScale, _isScaling, _translateX, _translateY, _SFA, _FA) {
const scaleMinNumber = vue.computed(() => {
let val = Number(props2.scaleMin);
return isNaN(val) ? 0.5 : val;
});
const scaleMaxNumber = vue.computed(() => {
let val = Number(props2.scaleMax);
return isNaN(val) ? 10 : val;
});
const scaleValueSync = vue.ref(Number(props2.scaleValue) || 1);
vue.watch(scaleValueSync, (val) => {
_setScaleValue(val);
});
vue.watch(scaleMinNumber, () => {
_setScaleMinOrMax();
});
vue.watch(scaleMaxNumber, () => {
_setScaleMinOrMax();
});
vue.watch(() => props2.scaleValue, (val) => {
scaleValueSync.value = Number(val) || 0;
});
const {
_updateBoundary,
_updateOffset,
_updateWH,
_scaleOffset,
minX,
minY,
maxX,
maxY
} = useMovableViewLayout(rootRef, _scale, _adjustScale);
const {
FAandSFACancel,
_getLimitXY,
_animationTo,
_setTransform,
_revise,
dampingNumber,
xMove,
yMove,
xSync,
ySync,
_STD
} = useMovableViewTransform(rootRef, props2, _scaleOffset, _scale, maxX, maxY, minX, minY, _translateX, _translateY, _SFA, _FA, _adjustScale, trigger);
function _updateScale(scale, animat) {
if (props2.scale) {
scale = _adjustScale(scale);
_updateWH(scale);
_updateBoundary();
const limitXY = _getLimitXY(_translateX.value, _translateY.value);
const x = limitXY.x;
const y = limitXY.y;
if (animat) {
_animationTo(x, y, scale, "", true, true);
} else {
_requestAnimationFrame(function() {
_setTransform(x, y, scale, "", true, true);
});
}
}
}
function _beginScale() {
_isScaling.value = true;
}
function _updateOldScale(scale) {
_oldScale.value = scale;
}
function _adjustScale(scale) {
scale = Math.max(0.5, scaleMinNumber.value, scale);
scale = Math.min(10, scaleMaxNumber.value, scale);
return scale;
}
function _setScaleMinOrMax() {
if (!props2.scale) {
return false;
}
_updateScale(_scale.value, true);
_updateOldScale(_scale.value);
}
function _setScaleValue(scale) {
if (!props2.scale) {
return false;
}
scale = _adjustScale(scale);
_updateScale(scale, true);
_updateOldScale(scale);
return scale;
}
function _endScale() {
_isScaling.value = false;
_updateOldScale(_scale.value);
}
function _setScale(scale) {
if (scale) {
scale = _oldScale.value * scale;
_beginScale();
_updateScale(scale);
}
}
return {
// scale
_updateOldScale,
_endScale,
_setScale,
scaleValueSync,
// layout
_updateBoundary,
_updateOffset,
_updateWH,
_scaleOffset,
minX,
minY,
maxX,
maxY,
// transform
FAandSFACancel,
_getLimitXY,
_animationTo,
_setTransform,
_revise,
dampingNumber,
xMove,
yMove,
xSync,
ySync,
_STD
};
}
function useMovableViewState(props2, trigger, rootRef) {
const _isMounted = vue.inject("_isMounted", vue.ref(false));
vue.inject("addMovableViewContext", () => {
});
vue.inject("removeMovableViewContext", () => {
});
let _scale = vue.ref(1);
let _oldScale = vue.ref(1);
let _isScaling = vue.ref(false);
let _translateX = vue.ref(0);
let _translateY = vue.ref(0);
let _SFA = null;
let _FA = null;
const frictionNumber = vue.computed(() => {
let val = Number(props2.friction);
return isNaN(val) || val <= 0 ? 2 : val;
});
new Friction(1, frictionNumber.value);
vue.watch(() => props2.disabled, () => {
__handleTouchStart();
});
const {
// scale
_updateOldScale,
_endScale,
_setScale,
scaleValueSync,
// layout
_updateBoundary,
_updateOffset,
_updateWH,
_scaleOffset,
minX,
minY,
maxX,
maxY,
// transform
FAandSFACancel,
_getLimitXY,
_setTransform,
_revise,
dampingNumber,
xMove,
yMove,
xSync,
ySync,
_STD
} = useMovableViewInit(props2, rootRef, trigger, _scale, _oldScale, _isScaling, _translateX, _translateY, _SFA, _FA);
function __handleTouchStart() {
if (!_isScaling.value) {
if (!props2.disabled) {
FAandSFACancel();
if (xMove.value) {
_translateX.value;
}
if (yMove.value) {
_translateY.value;
}
rootRef.value.style.willChange = "transform";
}
}
}
function setParent() {
if (!_isMounted.value) {
return;
}
FAandSFACancel();
let scale = props2.scale ? scaleValueSync.value : 1;
_updateOffset();
_updateWH(scale);
_updateBoundary();
let limitXY = _getLimitXY(xSync.value + _scaleOffset.x, ySync.value + _scaleOffset.y);
let x = limitXY.x;
let y = limitXY.y;
_setTransform(x, y, scale, "", true);
_updateOldScale(scale);
}
return {
setParent
};
}
const OPEN_TYPES = [
"navigate",
"redirect",
"switchTab",
"reLaunch",
"navigateBack"
];
const ANIMATION_IN = [
"slide-in-right",
"slide-in-left",
"slide-in-top",
"slide-in-bottom",
"fade-in",
"zoom-out",
"zoom-fade-out",
"pop-in",
"none"
];
const ANIMATION_OUT = [
"slide-out-right",
"slide-out-left",
"slide-out-top",
"slide-out-bottom",
"fade-out",
"zoom-in",
"zoom-fade-in",
"pop-out",
"none"
];
const navigatorProps = {
hoverClass: {
type: String,
default: "navigator-hover"
},
url: {
type: String,
default: ""
},
openType: {
type: String,
default: "navigate",
validator(value) {
return Boolean(~OPEN_TYPES.indexOf(value));
}
},
delta: {
type: Number,
default: 1
},
hoverStartTime: {
type: [Number, String],
default: 50
},
hoverStayTime: {
type: [Number, String],
default: 600
},
exists: {
type: String,
default: ""
},
hoverStopPropagation: {
type: Boolean,
default: false
},
animationType: {
type: String,
default: "",
validator(value) {
return !value || ANIMATION_IN.concat(ANIMATION_OUT).includes(value);
}
},
animationDuration: {
type: [String, Number],
default: 300
}
};
function createNavigatorOnClick(props2) {
return () => {
if (props2.openType !== "navigateBack" && !props2.url) {
console.error(
"