diff --git a/doc/03_软件需求规格说明书.docx b/doc/03_软件需求规格说明书.docx new file mode 100644 index 0000000..a43fd0f Binary files /dev/null and b/doc/03_软件需求规格说明书.docx differ diff --git a/doc/04_软件设计规格说明书.doc b/doc/04_软件设计规格说明书.doc new file mode 100644 index 0000000..b0e0134 Binary files /dev/null and b/doc/04_软件设计规格说明书.doc differ diff --git a/doc/设计模型_健康监测小程序_张明敏.docx b/doc/设计模型_健康监测小程序_张明敏.docx index 38b175e..000456e 100644 Binary files a/doc/设计模型_健康监测小程序_张明敏.docx and b/doc/设计模型_健康监测小程序_张明敏.docx differ diff --git a/doc/需求模型_健康监测小程序_张明敏.docx b/doc/需求模型_健康监测小程序_张明敏.docx index b9fd31d..e6263c9 100644 Binary files a/doc/需求模型_健康监测小程序_张明敏.docx and b/doc/需求模型_健康监测小程序_张明敏.docx differ diff --git a/other/06_软件开发项目的个人自评报告.xlsx b/other/06_软件开发项目的个人自评报告.xlsx new file mode 100644 index 0000000..76256d1 Binary files /dev/null and b/other/06_软件开发项目的个人自评报告.xlsx differ diff --git a/other/07_软件开发项目的团队自评报告.xlsx b/other/07_软件开发项目的团队自评报告.xlsx new file mode 100644 index 0000000..a8cc011 Binary files /dev/null and b/other/07_软件开发项目的团队自评报告.xlsx differ diff --git a/other/08_210340019鲁慧聪-实践总结报告.doc b/other/08_210340019鲁慧聪-实践总结报告.doc new file mode 100644 index 0000000..6b23786 Binary files /dev/null and b/other/08_210340019鲁慧聪-实践总结报告.doc differ diff --git a/other/08_210340030王乐-实践总结报告.docx b/other/08_210340030王乐-实践总结报告.docx new file mode 100644 index 0000000..4933b87 Binary files /dev/null and b/other/08_210340030王乐-实践总结报告.docx differ diff --git a/other/08_210340032徐鑫实践总结报告.docx b/other/08_210340032徐鑫实践总结报告.docx new file mode 100644 index 0000000..b8f52d8 Binary files /dev/null and b/other/08_210340032徐鑫实践总结报告.docx differ diff --git a/other/08_210340035 张明敏-实践总结报告.docx b/other/08_210340035 张明敏-实践总结报告.docx new file mode 100644 index 0000000..4937c74 Binary files /dev/null and b/other/08_210340035 张明敏-实践总结报告.docx differ diff --git a/other/08_210340037张译丹-实践总结报告.docx b/other/08_210340037张译丹-实践总结报告.docx new file mode 100644 index 0000000..8656642 Binary files /dev/null and b/other/08_210340037张译丹-实践总结报告.docx differ diff --git a/src/hyy1/.hbuilderx/launch.json b/src/hyy1/.hbuilderx/launch.json new file mode 100644 index 0000000..81f13f4 --- /dev/null +++ b/src/hyy1/.hbuilderx/launch.json @@ -0,0 +1,16 @@ +{ // launch.json 配置了启动调试时相关设置，configurations下节点名称可为 app-plus/h5/mp-weixin/mp-baidu/mp-alipay/mp-qq/mp-toutiao/mp-360/ + // launchtype项可配置值为local或remote, local代表前端连本地云函数，remote代表前端连云端云函数 + "version": "0.0", + "configurations": [{ + "default" : + { + "launchtype" : "local" + }, + "mp-weixin" : + { + "launchtype" : "local" + }, + "type" : "uniCloud" + } + ] +} diff --git a/src/hyy1/App.vue b/src/hyy1/App.vue new file mode 100644 index 0000000..ce0e4f3 --- /dev/null +++ b/src/hyy1/App.vue @@ -0,0 +1,84 @@ + + + \ No newline at end of file diff --git a/src/hyy1/main.js b/src/hyy1/main.js new file mode 100644 index 0000000..fb558da --- /dev/null +++ b/src/hyy1/main.js @@ -0,0 +1,30 @@ +import App from './App' +// #ifndef VUE3 +import Vue from 'vue' +import './uni.promisify.adaptor' +import { + myRequest +} from './util/api.js' + +Vue.prototype.$myRequest = myRequest +Vue.config.productionTip = false +Vue.prototype.$BASE_URL = 'https://www.yingcloud.com:8000' +Vue.prototype.$BASE_URL_MEDIA = 'https://www.yingcloud.com:8000/media/' +App.mpType = 'app' +const app = new Vue({ + ...App +}) +app.$mount() +// #endif + +// #ifdef VUE3 +import { + createSSRApp +} from 'vue' +export function createApp() { + const app = createSSRApp(App) + return { + app + } +} +// #endif \ No newline at end of file diff --git a/src/hyy1/manifest.json b/src/hyy1/manifest.json new file mode 100644 index 0000000..67066f7 --- /dev/null +++ b/src/hyy1/manifest.json @@ -0,0 +1,83 @@ +{ + "name" : "hyy", + "appid" : "__UNI__9F628B4", + "description" : "", + "versionName" : "1.0.0", + "versionCode" : "100", + "transformPx" : false, + /* 5+App特有相关 */ + "app-plus" : { + "statusbar" : { + "immersed" : false + }, + "usingComponents" : true, + "nvueStyleCompiler" : "uni-app", + "compilerVersion" : 3, + "splashscreen" : { + "alwaysShowBeforeRender" : true, + "waiting" : true, + "autoclose" : true, + "delay" : 0 + }, + /* 模块配置 */ + "modules" : {}, + /* 应用发布信息 */ + "distribute" : { + /* android打包配置 */ + "android" : { + "permissions" : [ + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "", + "" + ] + }, + /* ios打包配置 */ + "ios" : {}, + /* SDK配置 */ + "sdkConfigs" : { + "geolocation" : {} + } + } + }, + /* 快应用特有相关 */ + "quickapp" : {}, + /* 小程序特有相关 */ + "mp-weixin" : { + "appid" : "wx7fd4c57dfed68264", + "setting" : { + "urlCheck" : false + }, + "usingComponents" : true, + "permission" : { + "scope.userLocation" : { + "desc" : "运动打卡功能需要定位" + } + }, + "requiredPrivateInfos" : [ "chooseLocation", "getLocation" ] + }, + "mp-alipay" : { + "usingComponents" : true + }, + "mp-baidu" : { + "usingComponents" : true + }, + "mp-toutiao" : { + "usingComponents" : true + }, + "uniStatistics" : { + "enable" : false + }, + "vueVersion" : "3" +} diff --git a/src/hyy1/pages.json b/src/hyy1/pages.json new file mode 100644 index 0000000..88d86dc --- /dev/null +++ b/src/hyy1/pages.json @@ -0,0 +1,97 @@ +{ + "pages": [ //pages数组中第一项表示应用启动页，参考：https://uniapp.dcloud.io/collocation/pages + { + "path": "pages/welcome/welcome", + "style": { + "navigationBarTitleText": "健康监测", + "enablePullDownRefresh": false + } + + }, + { + "path": "pages/message/message", + "style": { + "navigationBarTitleText": "", + "enablePullDownRefresh": false + } + }, + { + "path": "pages/test/test", + "style": { + "navigationBarTitleText": "健康监测", + "enablePullDownRefresh": false + } + }, + { + "path": "pages/index/index", + "style": { + "navigationBarTitleText": "健康监测", + "navigationBarBackgroundColor": "#ffffff" + } + }, { + "path": "pages/yddk/yddk", + "style": { + "navigationBarTitleText": "运动打卡", + "enablePullDownRefresh": false, + "navigationBarBackgroundColor": "#ffffff" + } + + }, { + "path": "pages/zxtx/zxtx", + "style": { + "navigationBarTitleText": "作息提醒", + "enablePullDownRefresh": false, + "navigationBarBackgroundColor": "#ffffff" + } + + }, { + "path": "pages/scgl/scgl", + "style": { + "navigationBarTitleText": "身材管理", + "enablePullDownRefresh": false, + "navigationBarBackgroundColor": "#ffffff" + } + + }, { + "path": "pages/jqjl/jqjl", + "style": { + "navigationBarTitleText": "月经记录", + "enablePullDownRefresh": false, + "navigationBarBackgroundColor": "#ffffff" + } + + }, { + "path": "pages/yddk/add", + "style": { + "navigationBarTitleText": "打卡", + "enablePullDownRefresh": false, + "navigationBarBackgroundColor": "#ffffff" + } + + } + ], + "tabBar": { + "color": "#333333", + "selectedColor": "#28C76F", + "list": [{ + "text": "首页", + "pagePath": "pages/index/index", + "iconPath": "static/main(1).png", + "selectedIconPath": "static/main(1).png" + }, + { + "text": "我的", + "pagePath": "pages/message/message", + "iconPath": "static/myself(1).png", + "selectedIconPath": "static/myself(1).png" + } + ] + }, + "globalStyle": { + "navigationBarTextStyle": "black", + "navigationBarTitleText": "健康监测", + "navigationBarBackgroundColor": "#F8F8F8", + "backgroundColor": "#F8F8F8" + }, + "uniIdRouter": {} +} \ No newline at end of file diff --git a/src/hyy1/pages/index/index.vue b/src/hyy1/pages/index/index.vue new file mode 100644 index 0000000..8851bc6 --- /dev/null +++ b/src/hyy1/pages/index/index.vue @@ -0,0 +1,88 @@ + + + + + \ No newline at end of file diff --git a/src/hyy1/pages/jqjl/jqjl.vue b/src/hyy1/pages/jqjl/jqjl.vue new file mode 100644 index 0000000..6466b76 --- /dev/null +++ b/src/hyy1/pages/jqjl/jqjl.vue @@ -0,0 +1,170 @@ + + + + + \ No newline at end of file diff --git a/src/hyy1/pages/message/message.vue b/src/hyy1/pages/message/message.vue new file mode 100644 index 0000000..13113e6 --- /dev/null +++ b/src/hyy1/pages/message/message.vue @@ -0,0 +1,126 @@ + + + + + \ No newline at end of file diff --git a/src/hyy1/pages/scgl/scgl.vue b/src/hyy1/pages/scgl/scgl.vue new file mode 100644 index 0000000..e8bca79 --- /dev/null +++ b/src/hyy1/pages/scgl/scgl.vue @@ -0,0 +1,180 @@ + + + + + \ No newline at end of file diff --git a/src/hyy1/pages/test/test.vue b/src/hyy1/pages/test/test.vue new file mode 100644 index 0000000..7563dec --- /dev/null +++ b/src/hyy1/pages/test/test.vue @@ -0,0 +1,22 @@ + + + + + \ No newline at end of file diff --git a/src/hyy1/pages/welcome/welcome.vue b/src/hyy1/pages/welcome/welcome.vue new file mode 100644 index 0000000..05e1c48 --- /dev/null +++ b/src/hyy1/pages/welcome/welcome.vue @@ -0,0 +1,52 @@ + + + + + \ No newline at end of file diff --git a/src/hyy1/pages/yddk/add.vue b/src/hyy1/pages/yddk/add.vue new file mode 100644 index 0000000..6d8c58c --- /dev/null +++ b/src/hyy1/pages/yddk/add.vue @@ -0,0 +1,154 @@ + + + + + \ No newline at end of file diff --git a/src/hyy1/pages/yddk/yddk.vue b/src/hyy1/pages/yddk/yddk.vue new file mode 100644 index 0000000..a9bef7d --- /dev/null +++ b/src/hyy1/pages/yddk/yddk.vue @@ -0,0 +1,121 @@ + + + + + \ No newline at end of file diff --git a/src/hyy1/pages/zxtx/zxtx.vue b/src/hyy1/pages/zxtx/zxtx.vue new file mode 100644 index 0000000..8a96b1d --- /dev/null +++ b/src/hyy1/pages/zxtx/zxtx.vue @@ -0,0 +1,124 @@ + + + + + \ No newline at end of file diff --git a/src/hyy1/static/2337c3ee6b9755614eb03430e757d31(1).png b/src/hyy1/static/2337c3ee6b9755614eb03430e757d31(1).png new file mode 100644 index 0000000..da0e3d9 Binary files /dev/null and b/src/hyy1/static/2337c3ee6b9755614eb03430e757d31(1).png differ diff --git a/src/hyy1/static/k1.png b/src/hyy1/static/k1.png new file mode 100644 index 0000000..3b3bbf5 Binary files /dev/null and b/src/hyy1/static/k1.png differ diff --git a/src/hyy1/static/k2.png b/src/hyy1/static/k2.png new file mode 100644 index 0000000..3d7d3ec Binary files /dev/null and b/src/hyy1/static/k2.png differ diff --git a/src/hyy1/static/k3.png b/src/hyy1/static/k3.png new file mode 100644 index 0000000..eec2804 Binary files /dev/null and b/src/hyy1/static/k3.png differ diff --git a/src/hyy1/static/k4.png b/src/hyy1/static/k4.png new file mode 100644 index 0000000..789549a Binary files /dev/null and b/src/hyy1/static/k4.png differ diff --git a/src/hyy1/static/k5(1)(1).png b/src/hyy1/static/k5(1)(1).png new file mode 100644 index 0000000..fe26366 Binary files /dev/null and b/src/hyy1/static/k5(1)(1).png differ diff --git a/src/hyy1/static/k5.png b/src/hyy1/static/k5.png new file mode 100644 index 0000000..fe26366 Binary files /dev/null and b/src/hyy1/static/k5.png differ diff --git a/src/hyy1/static/k6(1)(1).png b/src/hyy1/static/k6(1)(1).png new file mode 100644 index 0000000..1531b0a Binary files /dev/null and b/src/hyy1/static/k6(1)(1).png differ diff --git a/src/hyy1/static/k6.png b/src/hyy1/static/k6.png new file mode 100644 index 0000000..18157a1 Binary files /dev/null and b/src/hyy1/static/k6.png differ diff --git a/src/hyy1/static/logo.png b/src/hyy1/static/logo.png new file mode 100644 index 0000000..b5771e2 Binary files /dev/null and b/src/hyy1/static/logo.png differ diff --git a/src/hyy1/static/logo1(1).png b/src/hyy1/static/logo1(1).png new file mode 100644 index 0000000..649db3a Binary files /dev/null and b/src/hyy1/static/logo1(1).png differ diff --git a/src/hyy1/static/main(1).png b/src/hyy1/static/main(1).png new file mode 100644 index 0000000..1d1e22b Binary files /dev/null and b/src/hyy1/static/main(1).png differ diff --git a/src/hyy1/static/myself(1).png b/src/hyy1/static/myself(1).png new file mode 100644 index 0000000..10b96f6 Binary files /dev/null and b/src/hyy1/static/myself(1).png differ diff --git a/src/hyy1/uni.promisify.adaptor.js b/src/hyy1/uni.promisify.adaptor.js new file mode 100644 index 0000000..47fbce1 --- /dev/null +++ b/src/hyy1/uni.promisify.adaptor.js @@ -0,0 +1,10 @@ +uni.addInterceptor({ + returnValue (res) { + if (!(!!res && (typeof res === "object" || typeof res === "function") && typeof res.then === "function")) { + return res; + } + return new Promise((resolve, reject) => { + res.then((res) => res[0] ? reject(res[0]) : resolve(res[1])); + }); + }, +}); \ No newline at end of file diff --git a/src/hyy1/uni.scss b/src/hyy1/uni.scss new file mode 100644 index 0000000..a05adb4 --- /dev/null +++ b/src/hyy1/uni.scss @@ -0,0 +1,76 @@ +/** + * 这里是uni-app内置的常用样式变量 + * + * uni-app 官方扩展插件及插件市场（https://ext.dcloud.net.cn）上很多三方插件均使用了这些样式变量 + * 如果你是插件开发者，建议你使用scss预处理，并在插件代码中直接使用这些变量（无需 import 这个文件），方便用户通过搭积木的方式开发整体风格一致的App + * + */ + +/** + * 如果你是App开发者（插件使用者），你可以通过修改这些变量来定制自己的插件主题，实现自定义主题功能 + * + * 如果你的项目同样使用了scss预处理，你也可以直接在你的 scss 代码中使用如下变量，同时无需 import 这个文件 + */ + +/* 颜色变量 */ + +/* 行为相关颜色 */ +$uni-color-primary: #007aff; +$uni-color-success: #4cd964; +$uni-color-warning: #f0ad4e; +$uni-color-error: #dd524d; + +/* 文字基本颜色 */ +$uni-text-color:#333;//基本色 +$uni-text-color-inverse:#fff;//反色 +$uni-text-color-grey:#999;//辅助灰色，如加载更多的提示信息 +$uni-text-color-placeholder: #808080; +$uni-text-color-disable:#c0c0c0; + +/* 背景颜色 */ +$uni-bg-color:#ffffff; +$uni-bg-color-grey:#f8f8f8; +$uni-bg-color-hover:#f1f1f1;//点击状态颜色 +$uni-bg-color-mask:rgba(0, 0, 0, 0.4);//遮罩颜色 + +/* 边框颜色 */ +$uni-border-color:#c8c7cc; + +/* 尺寸变量 */ + +/* 文字尺寸 */ +$uni-font-size-sm:12px; +$uni-font-size-base:14px; +$uni-font-size-lg:16; + +/* 图片尺寸 */ +$uni-img-size-sm:20px; +$uni-img-size-base:26px; +$uni-img-size-lg:40px; + +/* Border Radius */ +$uni-border-radius-sm: 2px; +$uni-border-radius-base: 3px; +$uni-border-radius-lg: 6px; +$uni-border-radius-circle: 50%; + +/* 水平间距 */ +$uni-spacing-row-sm: 5px; +$uni-spacing-row-base: 10px; +$uni-spacing-row-lg: 15px; + +/* 垂直间距 */ +$uni-spacing-col-sm: 4px; +$uni-spacing-col-base: 8px; +$uni-spacing-col-lg: 12px; + +/* 透明度 */ +$uni-opacity-disabled: 0.3; // 组件禁用态的透明度 + +/* 文章场景相关 */ +$uni-color-title: #2C405A; // 文章标题颜色 +$uni-font-size-title:20px; +$uni-color-subtitle: #555555; // 二级标题颜色 +$uni-font-size-subtitle:26px; +$uni-color-paragraph: #3F536E; // 文章段落颜色 +$uni-font-size-paragraph:15px; diff --git a/src/hyy1/uniCloud-aliyun/database/JQL查询.jql b/src/hyy1/uniCloud-aliyun/database/JQL查询.jql new file mode 100644 index 0000000..35d21de --- /dev/null +++ b/src/hyy1/uniCloud-aliyun/database/JQL查询.jql @@ -0,0 +1,12 @@ +// 本文件用于，使用JQL语法操作项目关联的uniCloud空间的数据库，方便开发调试和远程数据库管理 +// 编写clientDB的js API（也支持常规js语法，比如var），可以对云数据库进行增删改查操作。不支持uniCloud-db组件写法 +// 可以全部运行，也可以选中部分代码运行。点击工具栏上的运行按钮或者按下【F5】键运行代码 +// 如果文档中存在多条JQL语句，只有最后一条语句生效 +// 如果混写了普通js，最后一条语句需是数据库操作语句 +// 此处代码运行不受DB Schema的权限控制，移植代码到实际业务中注意在schema中配好permission +// 不支持clientDB的action +// 数据库查询有最大返回条数限制，详见：https://uniapp.dcloud.net.cn/uniCloud/cf-database.html#limit +// 详细JQL语法，请参考：https://uniapp.dcloud.net.cn/uniCloud/jql.html + +// 下面示例查询uni-id-users表的所有数据 +db.collection('uni-id-users').get(); diff --git a/src/hyy1/uni_modules/uni-config-center/changelog.md b/src/hyy1/uni_modules/uni-config-center/changelog.md new file mode 100644 index 0000000..57dbcb5 --- /dev/null +++ b/src/hyy1/uni_modules/uni-config-center/changelog.md @@ -0,0 +1,6 @@ +## 0.0.3（2022-11-11） +- 修复 config 方法获取根节点为数组格式配置时错误的转化为了对象的Bug +## 0.0.2（2021-04-16） +- 修改插件package信息 +## 0.0.1（2021-03-15） +- 初始化项目 diff --git a/src/hyy1/uni_modules/uni-config-center/package.json b/src/hyy1/uni_modules/uni-config-center/package.json new file mode 100644 index 0000000..6ca0fa0 --- /dev/null +++ b/src/hyy1/uni_modules/uni-config-center/package.json @@ -0,0 +1,81 @@ +{ + "id": "uni-config-center", + "displayName": "uni-config-center", + "version": "0.0.3", + "description": "uniCloud 配置中心", + "keywords": [ + "配置", + "配置中心" + ], + "repository": "", + "engines": { + "HBuilderX": "^3.1.0" + }, + "dcloudext": { + "sale": { + "regular": { + "price": "0.00" + }, + "sourcecode": { + "price": "0.00" + } + }, + "contact": { + "qq": "" + }, + "declaration": { + "ads": "无", + "data": "无", + "permissions": "无" + }, + "npmurl": "", + "type": "unicloud-template-function" + }, + "directories": { + "example": "../../../scripts/dist" + }, + "uni_modules": { + "dependencies": [], + "encrypt": [], + "platforms": { + "cloud": { + "tcb": "y", + "aliyun": "y" + }, + "client": { + "App": { + "app-vue": "u", + "app-nvue": "u" + }, + "H5-mobile": { + "Safari": "u", + "Android Browser": "u", + "微信浏览器(Android)": "u", + "QQ浏览器(Android)": "u" + }, + "H5-pc": { + "Chrome": "u", + "IE": "u", + "Edge": "u", + "Firefox": "u", + "Safari": "u" + }, + "小程序": { + "微信": "u", + "阿里": "u", + "百度": "u", + "字节跳动": "u", + "QQ": "u" + }, + "快应用": { + "华为": "u", + "联盟": "u" + }, + "Vue": { + "vue2": "y", + "vue3": "u" + }, + } + } + } +} \ No newline at end of file diff --git a/src/hyy1/uni_modules/uni-config-center/readme.md b/src/hyy1/uni_modules/uni-config-center/readme.md new file mode 100644 index 0000000..03f7fc2 --- /dev/null +++ b/src/hyy1/uni_modules/uni-config-center/readme.md @@ -0,0 +1,93 @@ +# 为什么使用uni-config-center + +实际开发中很多插件需要配置文件才可以正常运行，如果每个插件都单独进行配置的话就会产生下面这样的目录结构 + +```bash +cloudfunctions +└─────common 公共模块 + ├─plugin-a // 插件A对应的目录 + │ ├─index.js + │ ├─config.json // plugin-a对应的配置文件 + │ └─other-file.cert // plugin-a依赖的其他文件 + └─plugin-b // plugin-b对应的目录 + ├─index.js + └─config.json // plugin-b对应的配置文件 +``` + +假设插件作者要发布一个项目模板，里面使用了很多需要配置的插件，无论是作者发布还是用户使用都是一个大麻烦。 + +uni-config-center就是用了统一管理这些配置文件的，使用uni-config-center后的目录结构如下 + +```bash +cloudfunctions +└─────common 公共模块 + ├─plugin-a // 插件A对应的目录 + │ └─index.js + ├─plugin-b // plugin-b对应的目录 + │ └─index.js + └─uni-config-center + ├─index.js // config-center入口文件 + ├─plugin-a + │ ├─config.json // plugin-a对应的配置文件 + │ └─other-file.cert // plugin-a依赖的其他文件 + └─plugin-b + └─config.json // plugin-b对应的配置文件 +``` + +使用uni-config-center后的优势 + +- 配置文件统一管理，分离插件主体和配置信息，更新插件更方便 +- 支持对config.json设置schema，插件使用者在HBuilderX内编写config.json文件时会有更好的提示（后续HBuilderX会提供支持） + +# 用法 + +在要使用uni-config-center的公共模块或云函数内引入uni-config-center依赖，请参考：[使用公共模块](https://uniapp.dcloud.net.cn/uniCloud/cf-common) + +```js +const createConfig = require('uni-config-center') + +const uniIdConfig = createConfig({ + pluginId: 'uni-id', // 插件id + defaultConfig: { // 默认配置 + tokenExpiresIn: 7200, + tokenExpiresThreshold: 600, + }, + customMerge: function(defaultConfig, userConfig) { // 自定义默认配置和用户配置的合并规则，不设置的情况侠会对默认配置和用户配置进行深度合并 + // defaudltConfig 默认配置 + // userConfig 用户配置 + return Object.assign(defaultConfig, userConfig) + } +}) + + +// 以如下配置为例 +// { +// "tokenExpiresIn": 7200, +// "passwordErrorLimit": 6, +// "bindTokenToDevice": false, +// "passwordErrorRetryTime": 3600, +// "app-plus": { +// "tokenExpiresIn": 2592000 +// }, +// "service": { +// "sms": { +// "codeExpiresIn": 300 +// } +// } +// } + +// 获取配置 +uniIdConfig.config() // 获取全部配置，注意：uni-config-center内不存在对应插件目录时会返回空对象 +uniIdConfig.config('tokenExpiresIn') // 指定键值获取配置，返回：7200 +uniIdConfig.config('service.sms.codeExpiresIn') // 指定键值获取配置，返回：300 +uniIdConfig.config('tokenExpiresThreshold', 600) // 指定键值获取配置，如果不存在则取传入的默认值，返回：600 + +// 获取文件绝对路径 +uniIdConfig.resolve('custom-token.js') // 获取uni-config-center/uni-id/custom-token.js文件的路径 + +// 引用文件（require） +uniIDConfig.requireFile('custom-token.js') // 使用require方式引用uni-config-center/uni-id/custom-token.js文件。文件不存在时返回undefined，文件内有其他错误导致require失败时会抛出错误。 + +// 判断是否包含某文件 +uniIDConfig.hasFile('custom-token.js') // 配置目录是否包含某文件，true: 文件存在，false: 文件不存在 +``` \ No newline at end of file diff --git a/src/hyy1/uni_modules/uni-config-center/uniCloud/cloudfunctions/common/uni-config-center/index.js b/src/hyy1/uni_modules/uni-config-center/uniCloud/cloudfunctions/common/uni-config-center/index.js new file mode 100644 index 0000000..00ba62f --- /dev/null +++ b/src/hyy1/uni_modules/uni-config-center/uniCloud/cloudfunctions/common/uni-config-center/index.js @@ -0,0 +1 @@ +"use strict";var t=require("fs"),r=require("path");function e(t){return t&&"object"==typeof t&&"default"in t?t:{default:t}}var n=e(t),o=e(r),i="undefined"!=typeof globalThis?globalThis:"undefined"!=typeof window?window:"undefined"!=typeof global?global:"undefined"!=typeof self?self:{};var u=function(t){var r={exports:{}};return t(r,r.exports),r.exports}((function(t,r){var e="__lodash_hash_undefined__",n=9007199254740991,o="[object Arguments]",u="[object Function]",c="[object Object]",a=/^\[object .+?Constructor\]$/,f=/^(?:0|[1-9]\d*)$/,s={};s["[object Float32Array]"]=s["[object Float64Array]"]=s["[object Int8Array]"]=s["[object Int16Array]"]=s["[object Int32Array]"]=s["[object Uint8Array]"]=s["[object Uint8ClampedArray]"]=s["[object Uint16Array]"]=s["[object Uint32Array]"]=!0,s[o]=s["[object Array]"]=s["[object ArrayBuffer]"]=s["[object Boolean]"]=s["[object DataView]"]=s["[object Date]"]=s["[object Error]"]=s[u]=s["[object Map]"]=s["[object Number]"]=s[c]=s["[object RegExp]"]=s["[object Set]"]=s["[object String]"]=s["[object WeakMap]"]=!1;var l="object"==typeof i&&i&&i.Object===Object&&i,h="object"==typeof self&&self&&self.Object===Object&&self,p=l||h||Function("return this")(),_=r&&!r.nodeType&&r,v=_&&t&&!t.nodeType&&t,d=v&&v.exports===_,y=d&&l.process,g=function(){try{var t=v&&v.require&&v.require("util").types;return t||y&&y.binding&&y.binding("util")}catch(t){}}(),b=g&&g.isTypedArray;function j(t,r,e){switch(e.length){case 0:return t.call(r);case 1:return t.call(r,e[0]);case 2:return t.call(r,e[0],e[1]);case 3:return t.call(r,e[0],e[1],e[2])}return t.apply(r,e)}var w,O,m,A=Array.prototype,z=Function.prototype,M=Object.prototype,x=p["__core-js_shared__"],C=z.toString,F=M.hasOwnProperty,U=(w=/[^.]+$/.exec(x&&x.keys&&x.keys.IE_PROTO||""))?"Symbol(src)_1."+w:"",S=M.toString,I=C.call(Object),P=RegExp("^"+C.call(F).replace(/[\\^$.*+?()[\]{}|]/g,"\\$&").replace(/hasOwnProperty|(function).*?(?=\\\()| for .+?(?=\\\])/g,"$1.*?")+"$"),T=d?p.Buffer:void 0,q=p.Symbol,E=p.Uint8Array,$=T?T.allocUnsafe:void 0,D=(O=Object.getPrototypeOf,m=Object,function(t){return O(m(t))}),k=Object.create,B=M.propertyIsEnumerable,N=A.splice,L=q?q.toStringTag:void 0,R=function(){try{var t=vt(Object,"defineProperty");return t({},"",{}),t}catch(t){}}(),G=T?T.isBuffer:void 0,V=Math.max,W=Date.now,H=vt(p,"Map"),J=vt(Object,"create"),K=function(){function t(){}return function(r){if(!xt(r))return{};if(k)return k(r);t.prototype=r;var e=new t;return t.prototype=void 0,e}}();function Q(t){var r=-1,e=null==t?0:t.length;for(this.clear();++r-1},X.prototype.set=function(t,r){var e=this.__data__,n=nt(e,t);return n<0?(++this.size,e.push([t,r])):e[n][1]=r,this},Y.prototype.clear=function(){this.size=0,this.__data__={hash:new Q,map:new(H||X),string:new Q}},Y.prototype.delete=function(t){var r=_t(this,t).delete(t);return this.size-=r?1:0,r},Y.prototype.get=function(t){return _t(this,t).get(t)},Y.prototype.has=function(t){return _t(this,t).has(t)},Y.prototype.set=function(t,r){var e=_t(this,t),n=e.size;return e.set(t,r),this.size+=e.size==n?0:1,this},Z.prototype.clear=function(){this.__data__=new X,this.size=0},Z.prototype.delete=function(t){var r=this.__data__,e=r.delete(t);return this.size=r.size,e},Z.prototype.get=function(t){return this.__data__.get(t)},Z.prototype.has=function(t){return this.__data__.has(t)},Z.prototype.set=function(t,r){var e=this.__data__;if(e instanceof X){var n=e.__data__;if(!H||n.length<199)return n.push([t,r]),this.size=++e.size,this;e=this.__data__=new Y(n)}return e.set(t,r),this.size=e.size,this};var it,ut=function(t,r,e){for(var n=-1,o=Object(t),i=e(t),u=i.length;u--;){var c=i[it?u:++n];if(!1===r(o[c],c,o))break}return t};function ct(t){return null==t?void 0===t?"[object Undefined]":"[object Null]":L&&L in Object(t)?function(t){var r=F.call(t,L),e=t[L];try{t[L]=void 0;var n=!0}catch(t){}var o=S.call(t);n&&(r?t[L]=e:delete t[L]);return o}(t):function(t){return S.call(t)}(t)}function at(t){return Ct(t)&&ct(t)==o}function ft(t){return!(!xt(t)||function(t){return!!U&&U in t}(t))&&(zt(t)?P:a).test(function(t){if(null!=t){try{return C.call(t)}catch(t){}try{return t+""}catch(t){}}return""}(t))}function st(t){if(!xt(t))return function(t){var r=[];if(null!=t)for(var e in Object(t))r.push(e);return r}(t);var r=yt(t),e=[];for(var n in t)("constructor"!=n||!r&&F.call(t,n))&&e.push(n);return e}function lt(t,r,e,n,o){t!==r&&ut(r,(function(i,u){if(o||(o=new Z),xt(i))!function(t,r,e,n,o,i,u){var a=gt(t,e),f=gt(r,e),s=u.get(f);if(s)return void rt(t,e,s);var l=i?i(a,f,e+"",t,r,u):void 0,h=void 0===l;if(h){var p=Ot(f),_=!p&&At(f),v=!p&&!_&&Ft(f);l=f,p||_||v?Ot(a)?l=a:Ct(j=a)&&mt(j)?l=function(t,r){var e=-1,n=t.length;r||(r=Array(n));for(;++e-1&&t%1==0&&t0){if(++r>=800)return arguments[0]}else r=0;return t.apply(void 0,arguments)}}(pt);function jt(t,r){return t===r||t!=t&&r!=r}var wt=at(function(){return arguments}())?at:function(t){return Ct(t)&&F.call(t,"callee")&&!B.call(t,"callee")},Ot=Array.isArray;function mt(t){return null!=t&&Mt(t.length)&&!zt(t)}var At=G||function(){return!1};function zt(t){if(!xt(t))return!1;var r=ct(t);return r==u||"[object GeneratorFunction]"==r||"[object AsyncFunction]"==r||"[object Proxy]"==r}function Mt(t){return"number"==typeof t&&t>-1&&t%1==0&&t<=n}function xt(t){var r=typeof t;return null!=t&&("object"==r||"function"==r)}function Ct(t){return null!=t&&"object"==typeof t}var Ft=b?function(t){return function(r){return t(r)}}(b):function(t){return Ct(t)&&Mt(t.length)&&!!s[ct(t)]};function Ut(t){return mt(t)?tt(t,!0):st(t)}var St,It=(St=function(t,r,e){lt(t,r,e)},ht((function(t,r){var e=-1,n=r.length,o=n>1?r[n-1]:void 0,i=n>2?r[2]:void 0;for(o=St.length>3&&"function"==typeof o?(n--,o):void 0,i&&function(t,r,e){if(!xt(e))return!1;var n=typeof r;return!!("number"==n?mt(e)&&dt(r,e.length):"string"==n&&r in e)&&jt(e[r],t)}(r[0],r[1],i)&&(o=n<3?void 0:o,n=1),t=Object(t);++ec.call(t,r);class f{constructor({pluginId:t,defaultConfig:r={},customMerge:e,root:n}){this.pluginId=t,this.defaultConfig=r,this.pluginConfigPath=o.default.resolve(n||__dirname,t),this.customMerge=e,this._config=void 0}resolve(t){return o.default.resolve(this.pluginConfigPath,t)}hasFile(t){return n.default.existsSync(this.resolve(t))}requireFile(t){try{return require(this.resolve(t))}catch(t){if("MODULE_NOT_FOUND"===t.code)return;throw t}}_getUserConfig(){return this.requireFile("config.json")}config(t,r){if(!this._config){const t=this._getUserConfig();this._config=Array.isArray(t)?t:(this.customMerge||u)(this.defaultConfig,t)}let e=this._config;return t?function(t,r,e){if("number"==typeof r)return t[r];if("symbol"==typeof r)return a(t,r)?t[r]:e;const n="string"!=typeof(o=r)?o:o.split(".").reduce(((t,r)=>(r.split(/\[([^}]+)\]/g).forEach((r=>r&&t.push(r))),t)),[]);var o;let i=t;for(let t=0;tparseInt(e)):void 0}function o(e,t){const n=r(e),i=r(t);return n?i?function(e,t){const n=Math.max(e.length,t.length);for(let i=0;ir)return 1;if(n=e)throw new Error("Config error, tokenExpiresThreshold should be less than tokenExpiresIn");t>e/2&&console.warn(`Please check whether the tokenExpiresThreshold configuration is set too large, tokenExpiresThreshold: ${t}, tokenExpiresIn: ${e}`)}get customToken(){return this.uniId.interceptorMap.get("customToken")}isTokenInDb(e){return o(e,"1.0.10")>=0}async getUserRecord(){if(this.userRecord)return this.userRecord;const e=await C.doc(this.uid).get();if(this.userRecord=e.data[0],!this.userRecord)throw{errCode:n.ACCOUNT_NOT_EXISTS};switch(this.userRecord.status){case void 0:case 0:break;case 1:throw{errCode:n.ACCOUNT_BANNED};case 2:throw{errCode:n.ACCOUNT_AUDITING};case 3:throw{errCode:n.ACCOUNT_AUDIT_FAILED};case 4:throw{errCode:n.ACCOUNT_CLOSED}}if(this.oldTokenPayload){if(this.isTokenInDb(this.oldTokenPayload.uniIdVersion)){if(-1===(this.userRecord.token||[]).indexOf(this.oldToken))throw{errCode:n.CHECK_TOKEN_FAILED}}if(this.userRecord.valid_token_date&&this.userRecord.valid_token_date>1e3*this.oldTokenPayload.iat)throw{errCode:n.TOKEN_EXPIRED}}return this.userRecord}async updateUserRecord(e){await C.doc(this.uid).update(e)}async getUserPermission(){if(this.userPermission)return this.userPermission;const e=(await this.getUserRecord()).role||[];if(0===e.length)return this.userPermission={role:[],permission:[]},this.userPermission;if(e.includes("admin"))return this.userPermission={role:e,permission:[]},this.userPermission;const t=await T.where({role_id:_.in(e)}).get(),n=(i=t.data.reduce((e,t)=>(t.permission&&e.push(...t.permission),e),[]),Array.from(new Set(i)));var i;return this.userPermission={role:e,permission:n},this.userPermission}async _createToken({uid:e,role:t,permission:i}={}){if(!t||!i){const e=await this.getUserPermission();t=e.role,i=e.permission}let r={uid:e,role:t,permission:i};if(this.uniId.interceptorMap.has("customToken")){const n=this.uniId.interceptorMap.get("customToken");if("function"!=typeof n)throw new Error("Invalid custom token file");r=await n({uid:e,role:t,permission:i})}const o=Date.now(),{tokenSecret:s,tokenExpiresIn:c,maxTokenLength:a=10}=this.config,u=g({...r,uniIdVersion:"1.0.16"},s,{expiresIn:c}),d=await this.getUserRecord(),l=(d.token||[]).filter(e=>{try{const t=this._checkToken(e);if(d.valid_token_date&&d.valid_token_date>1e3*t.iat)return!1}catch(e){if(e.errCode===n.TOKEN_EXPIRED)return!1}return!0});return l.push(u),l.length>a&&l.splice(0,l.length-a),await this.updateUserRecord({last_login_ip:this.clientInfo.clientIP,last_login_date:o,token:l}),{token:u,tokenExpired:o+1e3*c}}async createToken({uid:e,role:t,permission:i}={}){if(!e)throw{errCode:n.PARAM_REQUIRED,errMsgValue:{param:"uid"}};this.uid=e;const{token:r,tokenExpired:o}=await this._createToken({uid:e,role:t,permission:i});return{errCode:0,token:r,tokenExpired:o}}async refreshToken({token:e}={}){if(!e)throw{errCode:n.PARAM_REQUIRED,errMsgValue:{param:"token"}};this.oldToken=e;const t=this._checkToken(e);this.uid=t.uid,this.oldTokenPayload=t;const{uid:i}=t,{role:r,permission:o}=await this.getUserPermission(),{token:s,tokenExpired:c}=await this._createToken({uid:i,role:r,permission:o});return{errCode:0,token:s,tokenExpired:c}}_checkToken(e){const{tokenSecret:t}=this.config;let i;try{i=k(e,t)}catch(e){if("TokenExpiredError"===e.name)throw{errCode:n.TOKEN_EXPIRED};throw{errCode:n.CHECK_TOKEN_FAILED}}return i}async checkToken(e,{autoRefresh:t=!0}={}){if(!e)throw{errCode:n.PARAM_REQUIRED,errMsgValue:{param:"token"}};this.oldToken=e;const i=this._checkToken(e);this.uid=i.uid,this.oldTokenPayload=i;const{tokenExpiresThreshold:r}=this.config,{uid:o,role:s,permission:c}=i,a={role:s,permission:c};if(!s&&!c){const{role:e,permission:t}=await this.getUserPermission();a.role=e,a.permission=t}if(!r||!t){const e={code:0,errCode:0,...i,...a};return delete e.uniIdVersion,e}const u=Date.now();let d={};1e3*i.exp-u<1e3*r&&(d=await this._createToken({uid:o}));const l={code:0,errCode:0,...i,...a,...d};return delete l.uniIdVersion,l}}var E=Object.freeze({__proto__:null,checkToken:async function(e,{autoRefresh:t=!0}={}){return new m({uniId:this}).checkToken(e,{autoRefresh:t})},createToken:async function({uid:e,role:t,permission:n}={}){return new m({uniId:this}).createToken({uid:e,role:t,permission:n})},refreshToken:async function({token:e}={}){return new m({uniId:this}).refreshToken({token:e})}});const w=require("uni-config-center")({pluginId:"uni-id"});class x{constructor({context:e,clientInfo:t,config:n}={}){this._clientInfo=e?function(e){return{appId:e.APPID,platform:e.PLATFORM,locale:e.LOCALE,clientIP:e.CLIENTIP,deviceId:e.DEVICEID}}(e):t,this.config=n||this._getOriginConfig(),this.interceptorMap=new Map,w.hasFile("custom-token.js")&&this.setInterceptor("customToken",require(w.resolve("custom-token.js")));this._i18n=uniCloud.initI18n({locale:this._clientInfo.locale,fallbackLocale:"zh-Hans",messages:JSON.parse(JSON.stringify(d))}),d[this._i18n.locale]||this._i18n.setLocale("zh-Hans")}setInterceptor(e,t){this.interceptorMap.set(e,t)}_t(...e){return this._i18n.t(...e)}_parseOriginConfig(e){return Array.isArray(e)?e:e[0]?Object.values(e):e}_getOriginConfig(){if(w.hasFile("config.json")){let e;try{e=w.config()}catch(e){throw new Error("Invalid uni-id config file\n"+e.message)}return this._parseOriginConfig(e)}try{return this._parseOriginConfig(require("uni-id/config.json"))}catch(e){throw new Error("Invalid uni-id config file")}}_getAppConfig(){const e=this._getOriginConfig();return Array.isArray(e)?e.find(e=>e.dcloudAppid===this._clientInfo.appId)||e.find(e=>e.isDefaultConfig):e}_getPlatformConfig(){const e=this._getAppConfig();if(!e)throw new Error(`Config for current app (${this._clientInfo.appId}) was not found, please check your config file or client appId`);let t;switch("app-plus"===this._clientInfo.platform&&(this._clientInfo.platform="app"),"h5"===this._clientInfo.platform&&(this._clientInfo.platform="web"),this._clientInfo.platform){case"web":t="h5";break;case"app":t="app-plus"}const n=[{tokenExpiresIn:7200,tokenExpiresThreshold:1200,passwordErrorLimit:6,passwordErrorRetryTime:3600},e];t&&e[t]&&n.push(e[t]),n.push(e[this._clientInfo.platform]);const i=Object.assign(...n);return["tokenSecret","tokenExpiresIn"].forEach(e=>{if(!i||!i[e])throw new Error(`Config parameter missing, ${e} is required`)}),i}_getConfig(){return this._getPlatformConfig()}}for(const e in E)x.prototype[e]=E[e];function y(e){const t=new x(e);return new Proxy(t,{get(e,t){if(t in e&&0!==t.indexOf("_")){if("function"==typeof e[t])return(n=e[t],function(){let e;try{e=n.apply(this,arguments)}catch(e){if(a(e))return c.call(this,e),e;throw e}return i(e)?e.then(e=>(a(e)&&c.call(this,e),e),e=>{if(a(e))return c.call(this,e),e;throw e}):(a(e)&&c.call(this,e),e)}).bind(e);if("context"!==t&&"config"!==t)return e[t]}var n}})}x.prototype.createInstance=y;const A={createInstance:y};module.exports=A; diff --git a/src/hyy1/uni_modules/uni-id-common/uniCloud/cloudfunctions/common/uni-id-common/package.json b/src/hyy1/uni_modules/uni-id-common/uniCloud/cloudfunctions/common/uni-id-common/package.json new file mode 100644 index 0000000..437addd --- /dev/null +++ b/src/hyy1/uni_modules/uni-id-common/uniCloud/cloudfunctions/common/uni-id-common/package.json @@ -0,0 +1,16 @@ +{ + "name": "uni-id-common", + "version": "1.0.16", + "description": "uni-id token生成、校验、刷新", + "main": "index.js", + "homepage": "https://uniapp.dcloud.io/uniCloud/uni-id-common.html", + "repository": { + "type": "git", + "url": "git+https://gitee.com/dcloud/uni-id-common.git" + }, + "author": "DCloud", + "license": "Apache-2.0", + "dependencies": { + "uni-config-center": "file:../../../../../uni-config-center/uniCloud/cloudfunctions/common/uni-config-center", + } +} \ No newline at end of file diff --git a/src/hyy1/unpackage/dist/dev/mp-weixin/app.js b/src/hyy1/unpackage/dist/dev/mp-weixin/app.js new file mode 100644 index 0000000..02aac92 --- /dev/null +++ b/src/hyy1/unpackage/dist/dev/mp-weixin/app.js @@ -0,0 +1,89 @@ +"use strict"; +Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" }); +const common_vendor = require("./common/vendor.js"); +if (!Math) { + "./pages/welcome/welcome.js"; + "./pages/message/message.js"; + "./pages/test/test.js"; + "./pages/index/index.js"; + "./pages/yddk/yddk.js"; + "./pages/zxtx/zxtx.js"; + "./pages/scgl/scgl.js"; + "./pages/jqjl/jqjl.js"; + "./pages/yddk/add.js"; +} +const _sfc_main = { + onLaunch: function() { + let notifiedSleepTime = false; + let notifiedExerciseTime = false; + setInterval(() => { + const remindTime = common_vendor.index.getStorageSync("remindTime"); + const currentTime = this.getCurrentTime(); + if (remindTime && remindTime.sleepTime === currentTime && !notifiedSleepTime) { + common_vendor.index.showModal({ + title: "提醒", + content: "睡眠时间到了！", + showCancel: false + }); + notifiedSleepTime = true; + } + if (remindTime && remindTime.exerciseTime === currentTime && !notifiedExerciseTime) { + common_vendor.index.showModal({ + title: "提醒", + content: "运动时间到了！", + showCancel: false + }); + notifiedExerciseTime = true; + } + if (currentTime === "00:00") { + notifiedSleepTime = false; + notifiedExerciseTime = false; + } + const yjDate = common_vendor.index.getStorageSync("yjDate"); + const currentDate = this.getCurrentDate(); + if (yjDate && currentDate === yjDate.nextPeriod) { + const currentHour = (/* @__PURE__ */ new Date()).getHours(); + if (currentHour >= 8) { + common_vendor.index.removeStorageSync("yjDate"); + common_vendor.index.showModal({ + title: "提醒", + content: "经期时间到了！", + showCancel: false, + success: () => { + } + }); + } + } + }, 1e3); + }, + onShow: function() { + }, + onHide: function() { + console.log("App Hide"); + }, + methods: { + getCurrentTime() { + const now = /* @__PURE__ */ new Date(); + const hours = String(now.getHours()).padStart(2, "0"); + const minutes = String(now.getMinutes()).padStart(2, "0"); + return `${hours}:${minutes}`; + }, + // 获取当前日期，格式为 "YYYY-MM-DD" + getCurrentDate() { + const now = /* @__PURE__ */ new Date(); + const year = now.getFullYear(); + const month = String(now.getMonth() + 1).padStart(2, "0"); + const day = String(now.getDate()).padStart(2, "0"); + return `${year}-${month}-${day}`; + } + } +}; +const App = /* @__PURE__ */ common_vendor._export_sfc(_sfc_main, [["__file", "D:/health/hyy1/App.vue"]]); +function createApp() { + const app = common_vendor.createSSRApp(App); + return { + app + }; +} +createApp().app.mount("#app"); +exports.createApp = createApp; diff --git a/src/hyy1/unpackage/dist/dev/mp-weixin/app.json b/src/hyy1/unpackage/dist/dev/mp-weixin/app.json new file mode 100644 index 0000000..7825dc5 --- /dev/null +++ b/src/hyy1/unpackage/dist/dev/mp-weixin/app.json @@ -0,0 +1,47 @@ +{ + "pages": [ + "pages/welcome/welcome", + "pages/message/message", + "pages/test/test", + "pages/index/index", + "pages/yddk/yddk", + "pages/zxtx/zxtx", + "pages/scgl/scgl", + "pages/jqjl/jqjl", + "pages/yddk/add" + ], + "window": { + "navigationBarTextStyle": "black", + "navigationBarTitleText": "健康监测", + "navigationBarBackgroundColor": "#F8F8F8", + "backgroundColor": "#F8F8F8" + }, + "tabBar": { + "color": "#333333", + "selectedColor": "#28C76F", + "list": [ + { + "text": "首页", + "pagePath": "pages/index/index", + "iconPath": "static/main(1).png", + "selectedIconPath": "static/main(1).png" + }, + { + "text": "我的", + "pagePath": "pages/message/message", + "iconPath": "static/myself(1).png", + "selectedIconPath": "static/myself(1).png" + } + ] + }, + "permission": { + "scope.userLocation": { + "desc": "运动打卡功能需要定位" + } + }, + "requiredPrivateInfos": [ + "chooseLocation", + "getLocation" + ], + "usingComponents": {} +} \ No newline at end of file diff --git a/src/hyy1/unpackage/dist/dev/mp-weixin/app.wxss b/src/hyy1/unpackage/dist/dev/mp-weixin/app.wxss new file mode 100644 index 0000000..517a703 --- /dev/null +++ b/src/hyy1/unpackage/dist/dev/mp-weixin/app.wxss @@ -0,0 +1,3 @@ + + /*每个页面公共css */ +page{--status-bar-height:25px;--top-window-height:0px;--window-top:0px;--window-bottom:0px;--window-left:0px;--window-right:0px;--window-magin:0px}[data-c-h="true"]{display: none !important;} \ No newline at end of file diff --git a/src/hyy1/unpackage/dist/dev/mp-weixin/common/vendor.js b/src/hyy1/unpackage/dist/dev/mp-weixin/common/vendor.js new file mode 100644 index 0000000..d3c08f4 --- /dev/null +++ b/src/hyy1/unpackage/dist/dev/mp-weixin/common/vendor.js @@ -0,0 +1,9566 @@ +"use strict"; +const _export_sfc = (sfc, props) => { + const target = sfc.__vccOpts || sfc; + for (const [key, val] of props) { + target[key] = val; + } + return target; +}; +function makeMap(str, expectsLowerCase) { + const map = /* @__PURE__ */ Object.create(null); + const list = str.split(","); + for (let i2 = 0; i2 < list.length; i2++) { + map[list[i2]] = true; + } + return expectsLowerCase ? (val) => !!map[val.toLowerCase()] : (val) => !!map[val]; +} +const toDisplayString = (val) => { + return isString(val) ? val : val == null ? "" : isArray(val) || isObject$1(val) && (val.toString === objectToString || !isFunction(val.toString)) ? JSON.stringify(val, replacer, 2) : String(val); +}; +const replacer = (_key, val) => { + if (val && val.__v_isRef) { + return replacer(_key, val.value); + } else if (isMap(val)) { + return { + [`Map(${val.size})`]: [...val.entries()].reduce((entries, [key, val2]) => { + entries[`${key} =>`] = val2; + return entries; + }, {}) + }; + } else if (isSet(val)) { + return { + [`Set(${val.size})`]: [...val.values()] + }; + } else if (isObject$1(val) && !isArray(val) && !isPlainObject(val)) { + return String(val); + } + return val; +}; +const EMPTY_OBJ = Object.freeze({}); +const EMPTY_ARR = Object.freeze([]); +const NOOP = () => { +}; +const NO = () => false; +const onRE = /^on[^a-z]/; +const isOn = (key) => onRE.test(key); +const isModelListener = (key) => key.startsWith("onUpdate:"); +const extend = Object.assign; +const remove = (arr, el) => { + const i2 = arr.indexOf(el); + if (i2 > -1) { + arr.splice(i2, 1); + } +}; +const hasOwnProperty$2 = Object.prototype.hasOwnProperty; +const hasOwn$1 = (val, key) => hasOwnProperty$2.call(val, key); +const isArray = Array.isArray; +const isMap = (val) => toTypeString(val) === "[object Map]"; +const isSet = (val) => toTypeString(val) === "[object Set]"; +const isFunction = (val) => typeof val === "function"; +const isString = (val) => typeof val === "string"; +const isSymbol = (val) => typeof val === "symbol"; +const isObject$1 = (val) => val !== null && typeof val === "object"; +const isPromise = (val) => { + return isObject$1(val) && isFunction(val.then) && isFunction(val.catch); +}; +const objectToString = Object.prototype.toString; +const toTypeString = (value) => objectToString.call(value); +const toRawType = (value) => { + return toTypeString(value).slice(8, -1); +}; +const isPlainObject = (val) => toTypeString(val) === "[object Object]"; +const isIntegerKey = (key) => isString(key) && key !== "NaN" && key[0] !== "-" && "" + parseInt(key, 10) === key; +const isReservedProp = /* @__PURE__ */ makeMap( + // the leading comma is intentional so empty string "" is also included + ",key,ref,ref_for,ref_key,onVnodeBeforeMount,onVnodeMounted,onVnodeBeforeUpdate,onVnodeUpdated,onVnodeBeforeUnmount,onVnodeUnmounted" +); +const isBuiltInDirective = /* @__PURE__ */ makeMap("bind,cloak,else-if,else,for,html,if,model,on,once,pre,show,slot,text,memo"); +const cacheStringFunction = (fn) => { + const cache = /* @__PURE__ */ Object.create(null); + return (str) => { + const hit = cache[str]; + return hit || (cache[str] = fn(str)); + }; +}; +const camelizeRE = /-(\w)/g; +const camelize = cacheStringFunction((str) => { + return str.replace(camelizeRE, (_2, c2) => c2 ? c2.toUpperCase() : ""); +}); +const hyphenateRE = /\B([A-Z])/g; +const hyphenate = cacheStringFunction((str) => str.replace(hyphenateRE, "-$1").toLowerCase()); +const capitalize = cacheStringFunction((str) => str.charAt(0).toUpperCase() + str.slice(1)); +const toHandlerKey = cacheStringFunction((str) => str ? `on${capitalize(str)}` : ``); +const hasChanged = (value, oldValue) => !Object.is(value, oldValue); +const invokeArrayFns$1 = (fns, arg) => { + for (let i2 = 0; i2 < fns.length; i2++) { + fns[i2](arg); + } +}; +const def = (obj, key, value) => { + Object.defineProperty(obj, key, { + configurable: true, + enumerable: false, + value + }); +}; +const looseToNumber = (val) => { + const n2 = parseFloat(val); + return isNaN(n2) ? val : n2; +}; +const LINEFEED = "\n"; +const SLOT_DEFAULT_NAME = "d"; +const ON_SHOW = "onShow"; +const ON_HIDE = "onHide"; +const ON_LAUNCH = "onLaunch"; +const ON_ERROR = "onError"; +const ON_THEME_CHANGE = "onThemeChange"; +const ON_PAGE_NOT_FOUND = "onPageNotFound"; +const ON_UNHANDLE_REJECTION = "onUnhandledRejection"; +const ON_LOAD = "onLoad"; +const ON_READY = "onReady"; +const ON_UNLOAD = "onUnload"; +const ON_INIT = "onInit"; +const ON_SAVE_EXIT_STATE = "onSaveExitState"; +const ON_RESIZE = "onResize"; +const ON_BACK_PRESS = "onBackPress"; +const ON_PAGE_SCROLL = "onPageScroll"; +const ON_TAB_ITEM_TAP = "onTabItemTap"; +const ON_REACH_BOTTOM = "onReachBottom"; +const ON_PULL_DOWN_REFRESH = "onPullDownRefresh"; +const ON_SHARE_TIMELINE = "onShareTimeline"; +const ON_ADD_TO_FAVORITES = "onAddToFavorites"; +const ON_SHARE_APP_MESSAGE = "onShareAppMessage"; +const ON_NAVIGATION_BAR_BUTTON_TAP = "onNavigationBarButtonTap"; +const ON_NAVIGATION_BAR_SEARCH_INPUT_CLICKED = "onNavigationBarSearchInputClicked"; +const ON_NAVIGATION_BAR_SEARCH_INPUT_CHANGED = "onNavigationBarSearchInputChanged"; +const ON_NAVIGATION_BAR_SEARCH_INPUT_CONFIRMED = "onNavigationBarSearchInputConfirmed"; +const ON_NAVIGATION_BAR_SEARCH_INPUT_FOCUS_CHANGED = "onNavigationBarSearchInputFocusChanged"; +const customizeRE = /:/g; +function customizeEvent(str) { + return camelize(str.replace(customizeRE, "-")); +} +function hasLeadingSlash(str) { + return str.indexOf("/") === 0; +} +function addLeadingSlash(str) { + return hasLeadingSlash(str) ? str : "/" + str; +} +const invokeArrayFns = (fns, arg) => { + let ret; + for (let i2 = 0; i2 < fns.length; i2++) { + ret = fns[i2](arg); + } + return ret; +}; +function once(fn, ctx = null) { + let res; + return (...args) => { + if (fn) { + res = fn.apply(ctx, args); + fn = null; + } + return res; + }; +} +function getValueByDataPath(obj, path) { + if (!isString(path)) { + return; + } + path = path.replace(/\[(\d+)\]/g, ".$1"); + const parts = path.split("."); + let key = parts[0]; + if (!obj) { + obj = {}; + } + if (parts.length === 1) { + return obj[key]; + } + return getValueByDataPath(obj[key], parts.slice(1).join(".")); +} +function sortObject(obj) { + let sortObj = {}; + if (isPlainObject(obj)) { + Object.keys(obj).sort().forEach((key) => { + const _key = key; + sortObj[_key] = obj[_key]; + }); + } + return !Object.keys(sortObj) ? obj : sortObj; +} +const encode = encodeURIComponent; +function stringifyQuery(obj, encodeStr = encode) { + const res = obj ? Object.keys(obj).map((key) => { + let val = obj[key]; + if (typeof val === void 0 || val === null) { + val = ""; + } else if (isPlainObject(val)) { + val = JSON.stringify(val); + } + return encodeStr(key) + "=" + encodeStr(val); + }).filter((x2) => x2.length > 0).join("&") : null; + return res ? `?${res}` : ""; +} +const PAGE_HOOKS = [ + ON_INIT, + ON_LOAD, + ON_SHOW, + ON_HIDE, + ON_UNLOAD, + ON_BACK_PRESS, + ON_PAGE_SCROLL, + ON_TAB_ITEM_TAP, + ON_REACH_BOTTOM, + ON_PULL_DOWN_REFRESH, + ON_SHARE_TIMELINE, + ON_SHARE_APP_MESSAGE, + ON_ADD_TO_FAVORITES, + ON_SAVE_EXIT_STATE, + ON_NAVIGATION_BAR_BUTTON_TAP, + ON_NAVIGATION_BAR_SEARCH_INPUT_CLICKED, + ON_NAVIGATION_BAR_SEARCH_INPUT_CHANGED, + ON_NAVIGATION_BAR_SEARCH_INPUT_CONFIRMED, + ON_NAVIGATION_BAR_SEARCH_INPUT_FOCUS_CHANGED +]; +function isRootHook(name) { + return PAGE_HOOKS.indexOf(name) > -1; +} +const UniLifecycleHooks = [ + ON_SHOW, + ON_HIDE, + ON_LAUNCH, + ON_ERROR, + ON_THEME_CHANGE, + ON_PAGE_NOT_FOUND, + ON_UNHANDLE_REJECTION, + ON_INIT, + ON_LOAD, + ON_READY, + ON_UNLOAD, + ON_RESIZE, + ON_BACK_PRESS, + ON_PAGE_SCROLL, + ON_TAB_ITEM_TAP, + ON_REACH_BOTTOM, + ON_PULL_DOWN_REFRESH, + ON_SHARE_TIMELINE, + ON_ADD_TO_FAVORITES, + ON_SHARE_APP_MESSAGE, + ON_SAVE_EXIT_STATE, + ON_NAVIGATION_BAR_BUTTON_TAP, + ON_NAVIGATION_BAR_SEARCH_INPUT_CLICKED, + ON_NAVIGATION_BAR_SEARCH_INPUT_CHANGED, + ON_NAVIGATION_BAR_SEARCH_INPUT_CONFIRMED, + ON_NAVIGATION_BAR_SEARCH_INPUT_FOCUS_CHANGED +]; +const MINI_PROGRAM_PAGE_RUNTIME_HOOKS = /* @__PURE__ */ (() => { + return { + onPageScroll: 1, + onShareAppMessage: 1 << 1, + onShareTimeline: 1 << 2 + }; +})(); +function isUniLifecycleHook(name, value, checkType = true) { + if (checkType && !isFunction(value)) { + return false; + } + if (UniLifecycleHooks.indexOf(name) > -1) { + return true; + } else if (name.indexOf("on") === 0) { + return true; + } + return false; +} +let vueApp; +const createVueAppHooks = []; +function onCreateVueApp(hook) { + if (vueApp) { + return hook(vueApp); + } + createVueAppHooks.push(hook); +} +function invokeCreateVueAppHook(app) { + vueApp = app; + createVueAppHooks.forEach((hook) => hook(app)); +} +const invokeCreateErrorHandler = once((app, createErrorHandler2) => { + if (isFunction(app._component.onError)) { + return createErrorHandler2(app); + } +}); +const E$1 = function() { +}; +E$1.prototype = { + on: function(name, callback, ctx) { + var e2 = this.e || (this.e = {}); + (e2[name] || (e2[name] = [])).push({ + fn: callback, + ctx + }); + return this; + }, + once: function(name, callback, ctx) { + var self = this; + function listener() { + self.off(name, listener); + callback.apply(ctx, arguments); + } + listener._ = callback; + return this.on(name, listener, ctx); + }, + emit: function(name) { + var data = [].slice.call(arguments, 1); + var evtArr = ((this.e || (this.e = {}))[name] || []).slice(); + var i2 = 0; + var len = evtArr.length; + for (i2; i2 < len; i2++) { + evtArr[i2].fn.apply(evtArr[i2].ctx, data); + } + return this; + }, + off: function(name, callback) { + var e2 = this.e || (this.e = {}); + var evts = e2[name]; + var liveEvents = []; + if (evts && callback) { + for (var i2 = 0, len = evts.length; i2 < len; i2++) { + if (evts[i2].fn !== callback && evts[i2].fn._ !== callback) + liveEvents.push(evts[i2]); + } + } + liveEvents.length ? e2[name] = liveEvents : delete e2[name]; + return this; + } +}; +var E$1$1 = E$1; +const isObject = (val) => val !== null && typeof val === "object"; +const defaultDelimiters = ["{", "}"]; +class BaseFormatter { + constructor() { + this._caches = /* @__PURE__ */ Object.create(null); + } + interpolate(message, values, delimiters = defaultDelimiters) { + if (!values) { + return [message]; + } + let tokens = this._caches[message]; + if (!tokens) { + tokens = parse(message, delimiters); + this._caches[message] = tokens; + } + return compile$1(tokens, values); + } +} +const RE_TOKEN_LIST_VALUE = /^(?:\d)+/; +const RE_TOKEN_NAMED_VALUE = /^(?:\w)+/; +function parse(format, [startDelimiter, endDelimiter]) { + const tokens = []; + let position = 0; + let text = ""; + while (position < format.length) { + let char = format[position++]; + if (char === startDelimiter) { + if (text) { + tokens.push({ type: "text", value: text }); + } + text = ""; + let sub = ""; + char = format[position++]; + while (char !== void 0 && char !== endDelimiter) { + sub += char; + char = format[position++]; + } + const isClosed = char === endDelimiter; + const type = RE_TOKEN_LIST_VALUE.test(sub) ? "list" : isClosed && RE_TOKEN_NAMED_VALUE.test(sub) ? "named" : "unknown"; + tokens.push({ value: sub, type }); + } else { + text += char; + } + } + text && tokens.push({ type: "text", value: text }); + return tokens; +} +function compile$1(tokens, values) { + const compiled = []; + let index2 = 0; + const mode = Array.isArray(values) ? "list" : isObject(values) ? "named" : "unknown"; + if (mode === "unknown") { + return compiled; + } + while (index2 < tokens.length) { + const token = tokens[index2]; + switch (token.type) { + case "text": + compiled.push(token.value); + break; + case "list": + compiled.push(values[parseInt(token.value, 10)]); + break; + case "named": + if (mode === "named") { + compiled.push(values[token.value]); + } else { + { + console.warn(`Type of token '${token.type}' and format of value '${mode}' don't match!`); + } + } + break; + case "unknown": + { + console.warn(`Detect 'unknown' type of token!`); + } + break; + } + index2++; + } + return compiled; +} +const LOCALE_ZH_HANS = "zh-Hans"; +const LOCALE_ZH_HANT = "zh-Hant"; +const LOCALE_EN = "en"; +const LOCALE_FR = "fr"; +const LOCALE_ES = "es"; +const hasOwnProperty$1 = Object.prototype.hasOwnProperty; +const hasOwn = (val, key) => hasOwnProperty$1.call(val, key); +const defaultFormatter = new BaseFormatter(); +function include(str, parts) { + return !!parts.find((part) => str.indexOf(part) !== -1); +} +function startsWith(str, parts) { + return parts.find((part) => str.indexOf(part) === 0); +} +function normalizeLocale(locale, messages) { + if (!locale) { + return; + } + locale = locale.trim().replace(/_/g, "-"); + if (messages && messages[locale]) { + return locale; + } + locale = locale.toLowerCase(); + if (locale === "chinese") { + return LOCALE_ZH_HANS; + } + if (locale.indexOf("zh") === 0) { + if (locale.indexOf("-hans") > -1) { + return LOCALE_ZH_HANS; + } + if (locale.indexOf("-hant") > -1) { + return LOCALE_ZH_HANT; + } + if (include(locale, ["-tw", "-hk", "-mo", "-cht"])) { + return LOCALE_ZH_HANT; + } + return LOCALE_ZH_HANS; + } + let locales = [LOCALE_EN, LOCALE_FR, LOCALE_ES]; + if (messages && Object.keys(messages).length > 0) { + locales = Object.keys(messages); + } + const lang = startsWith(locale, locales); + if (lang) { + return lang; + } +} +class I18n { + constructor({ locale, fallbackLocale, messages, watcher, formater }) { + this.locale = LOCALE_EN; + this.fallbackLocale = LOCALE_EN; + this.message = {}; + this.messages = {}; + this.watchers = []; + if (fallbackLocale) { + this.fallbackLocale = fallbackLocale; + } + this.formater = formater || defaultFormatter; + this.messages = messages || {}; + this.setLocale(locale || LOCALE_EN); + if (watcher) { + this.watchLocale(watcher); + } + } + setLocale(locale) { + const oldLocale = this.locale; + this.locale = normalizeLocale(locale, this.messages) || this.fallbackLocale; + if (!this.messages[this.locale]) { + this.messages[this.locale] = {}; + } + this.message = this.messages[this.locale]; + if (oldLocale !== this.locale) { + this.watchers.forEach((watcher) => { + watcher(this.locale, oldLocale); + }); + } + } + getLocale() { + return this.locale; + } + watchLocale(fn) { + const index2 = this.watchers.push(fn) - 1; + return () => { + this.watchers.splice(index2, 1); + }; + } + add(locale, message, override = true) { + const curMessages = this.messages[locale]; + if (curMessages) { + if (override) { + Object.assign(curMessages, message); + } else { + Object.keys(message).forEach((key) => { + if (!hasOwn(curMessages, key)) { + curMessages[key] = message[key]; + } + }); + } + } else { + this.messages[locale] = message; + } + } + f(message, values, delimiters) { + return this.formater.interpolate(message, values, delimiters).join(""); + } + t(key, locale, values) { + let message = this.message; + if (typeof locale === "string") { + locale = normalizeLocale(locale, this.messages); + locale && (message = this.messages[locale]); + } else { + values = locale; + } + if (!hasOwn(message, key)) { + console.warn(`Cannot translate the value of keypath ${key}. Use the value of keypath as default.`); + return key; + } + return this.formater.interpolate(message[key], values).join(""); + } +} +function watchAppLocale(appVm, i18n) { + if (appVm.$watchLocale) { + appVm.$watchLocale((newLocale) => { + i18n.setLocale(newLocale); + }); + } else { + appVm.$watch(() => appVm.$locale, (newLocale) => { + i18n.setLocale(newLocale); + }); + } +} +function getDefaultLocale() { + if (typeof index !== "undefined" && index.getLocale) { + return index.getLocale(); + } + if (typeof global !== "undefined" && global.getLocale) { + return global.getLocale(); + } + return LOCALE_EN; +} +function initVueI18n(locale, messages = {}, fallbackLocale, watcher) { + if (typeof locale !== "string") { + [locale, messages] = [ + messages, + locale + ]; + } + if (typeof locale !== "string") { + locale = getDefaultLocale(); + } + if (typeof fallbackLocale !== "string") { + fallbackLocale = typeof __uniConfig !== "undefined" && __uniConfig.fallbackLocale || LOCALE_EN; + } + const i18n = new I18n({ + locale, + fallbackLocale, + messages, + watcher + }); + let t2 = (key, values) => { + if (typeof getApp !== "function") { + t2 = function(key2, values2) { + return i18n.t(key2, values2); + }; + } else { + let isWatchedAppLocale = false; + t2 = function(key2, values2) { + const appVm = getApp().$vm; + if (appVm) { + appVm.$locale; + if (!isWatchedAppLocale) { + isWatchedAppLocale = true; + watchAppLocale(appVm, i18n); + } + } + return i18n.t(key2, values2); + }; + } + return t2(key, values); + }; + return { + i18n, + f(message, values, delimiters) { + return i18n.f(message, values, delimiters); + }, + t(key, values) { + return t2(key, values); + }, + add(locale2, message, override = true) { + return i18n.add(locale2, message, override); + }, + watch(fn) { + return i18n.watchLocale(fn); + }, + getLocale() { + return i18n.getLocale(); + }, + setLocale(newLocale) { + return i18n.setLocale(newLocale); + } + }; +} +function getBaseSystemInfo() { + return wx.getSystemInfoSync(); +} +function validateProtocolFail(name, msg) { + console.warn(`${name}: ${msg}`); +} +function validateProtocol(name, data, protocol, onFail) { + if (!onFail) { + onFail = validateProtocolFail; + } + for (const key in protocol) { + const errMsg = validateProp$1(key, data[key], protocol[key], !hasOwn$1(data, key)); + if (isString(errMsg)) { + onFail(name, errMsg); + } + } +} +function validateProtocols(name, args, protocol, onFail) { + if (!protocol) { + return; + } + if (!isArray(protocol)) { + return validateProtocol(name, args[0] || /* @__PURE__ */ Object.create(null), protocol, onFail); + } + const len = protocol.length; + const argsLen = args.length; + for (let i2 = 0; i2 < len; i2++) { + const opts = protocol[i2]; + const data = /* @__PURE__ */ Object.create(null); + if (argsLen > i2) { + data[opts.name] = args[i2]; + } + validateProtocol(name, data, { [opts.name]: opts }, onFail); + } +} +function validateProp$1(name, value, prop, isAbsent) { + if (!isPlainObject(prop)) { + prop = { type: prop }; + } + const { type, required, validator } = prop; + if (required && isAbsent) { + return 'Missing required args: "' + name + '"'; + } + if (value == null && !required) { + return; + } + if (type != null) { + let isValid = false; + const types = isArray(type) ? type : [type]; + const expectedTypes = []; + for (let i2 = 0; i2 < types.length && !isValid; i2++) { + const { valid, expectedType } = assertType$1(value, types[i2]); + expectedTypes.push(expectedType || ""); + isValid = valid; + } + if (!isValid) { + return getInvalidTypeMessage$1(name, value, expectedTypes); + } + } + if (validator) { + return validator(value); + } +} +const isSimpleType$1 = /* @__PURE__ */ makeMap("String,Number,Boolean,Function,Symbol"); +function assertType$1(value, type) { + let valid; + const expectedType = getType$1(type); + if (isSimpleType$1(expectedType)) { + const t2 = typeof value; + valid = t2 === expectedType.toLowerCase(); + if (!valid && t2 === "object") { + valid = value instanceof type; + } + } else if (expectedType === "Object") { + valid = isObject$1(value); + } else if (expectedType === "Array") { + valid = isArray(value); + } else { + { + valid = value instanceof type; + } + } + return { + valid, + expectedType + }; +} +function getInvalidTypeMessage$1(name, value, expectedTypes) { + let message = `Invalid args: type check failed for args "${name}". Expected ${expectedTypes.map(capitalize).join(", ")}`; + const expectedType = expectedTypes[0]; + const receivedType = toRawType(value); + const expectedValue = styleValue$1(value, expectedType); + const receivedValue = styleValue$1(value, receivedType); + if (expectedTypes.length === 1 && isExplicable$1(expectedType) && !isBoolean$1(expectedType, receivedType)) { + message += ` with value ${expectedValue}`; + } + message += `, got ${receivedType} `; + if (isExplicable$1(receivedType)) { + message += `with value ${receivedValue}.`; + } + return message; +} +function getType$1(ctor) { + const match = ctor && ctor.toString().match(/^\s*function (\w+)/); + return match ? match[1] : ""; +} +function styleValue$1(value, type) { + if (type === "String") { + return `"${value}"`; + } else if (type === "Number") { + return `${Number(value)}`; + } else { + return `${value}`; + } +} +function isExplicable$1(type) { + const explicitTypes = ["string", "number", "boolean"]; + return explicitTypes.some((elem) => type.toLowerCase() === elem); +} +function isBoolean$1(...args) { + return args.some((elem) => elem.toLowerCase() === "boolean"); +} +function tryCatch(fn) { + return function() { + try { + return fn.apply(fn, arguments); + } catch (e2) { + console.error(e2); + } + }; +} +let invokeCallbackId = 1; +const invokeCallbacks = {}; +function addInvokeCallback(id, name, callback, keepAlive = false) { + invokeCallbacks[id] = { + name, + keepAlive, + callback + }; + return id; +} +function invokeCallback(id, res, extras) { + if (typeof id === "number") { + const opts = invokeCallbacks[id]; + if (opts) { + if (!opts.keepAlive) { + delete invokeCallbacks[id]; + } + return opts.callback(res, extras); + } + } + return res; +} +const API_SUCCESS = "success"; +const API_FAIL = "fail"; +const API_COMPLETE = "complete"; +function getApiCallbacks(args) { + const apiCallbacks = {}; + for (const name in args) { + const fn = args[name]; + if (isFunction(fn)) { + apiCallbacks[name] = tryCatch(fn); + delete args[name]; + } + } + return apiCallbacks; +} +function normalizeErrMsg$1(errMsg, name) { + if (!errMsg || errMsg.indexOf(":fail") === -1) { + return name + ":ok"; + } + return name + errMsg.substring(errMsg.indexOf(":fail")); +} +function createAsyncApiCallback(name, args = {}, { beforeAll, beforeSuccess } = {}) { + if (!isPlainObject(args)) { + args = {}; + } + const { success, fail, complete } = getApiCallbacks(args); + const hasSuccess = isFunction(success); + const hasFail = isFunction(fail); + const hasComplete = isFunction(complete); + const callbackId = invokeCallbackId++; + addInvokeCallback(callbackId, name, (res) => { + res = res || {}; + res.errMsg = normalizeErrMsg$1(res.errMsg, name); + isFunction(beforeAll) && beforeAll(res); + if (res.errMsg === name + ":ok") { + isFunction(beforeSuccess) && beforeSuccess(res, args); + hasSuccess && success(res); + } else { + hasFail && fail(res); + } + hasComplete && complete(res); + }); + return callbackId; +} +const HOOK_SUCCESS = "success"; +const HOOK_FAIL = "fail"; +const HOOK_COMPLETE = "complete"; +const globalInterceptors = {}; +const scopedInterceptors = {}; +function wrapperHook(hook, params) { + return function(data) { + return hook(data, params) || data; + }; +} +function queue$1(hooks, data, params) { + let promise = false; + for (let i2 = 0; i2 < hooks.length; i2++) { + const hook = hooks[i2]; + if (promise) { + promise = Promise.resolve(wrapperHook(hook, params)); + } else { + const res = hook(data, params); + if (isPromise(res)) { + promise = Promise.resolve(res); + } + if (res === false) { + return { + then() { + }, + catch() { + } + }; + } + } + } + return promise || { + then(callback) { + return callback(data); + }, + catch() { + } + }; +} +function wrapperOptions(interceptors2, options = {}) { + [HOOK_SUCCESS, HOOK_FAIL, HOOK_COMPLETE].forEach((name) => { + const hooks = interceptors2[name]; + if (!isArray(hooks)) { + return; + } + const oldCallback = options[name]; + options[name] = function callbackInterceptor(res) { + queue$1(hooks, res, options).then((res2) => { + return isFunction(oldCallback) && oldCallback(res2) || res2; + }); + }; + }); + return options; +} +function wrapperReturnValue(method, returnValue) { + const returnValueHooks = []; + if (isArray(globalInterceptors.returnValue)) { + returnValueHooks.push(...globalInterceptors.returnValue); + } + const interceptor = scopedInterceptors[method]; + if (interceptor && isArray(interceptor.returnValue)) { + returnValueHooks.push(...interceptor.returnValue); + } + returnValueHooks.forEach((hook) => { + returnValue = hook(returnValue) || returnValue; + }); + return returnValue; +} +function getApiInterceptorHooks(method) { + const interceptor = /* @__PURE__ */ Object.create(null); + Object.keys(globalInterceptors).forEach((hook) => { + if (hook !== "returnValue") { + interceptor[hook] = globalInterceptors[hook].slice(); + } + }); + const scopedInterceptor = scopedInterceptors[method]; + if (scopedInterceptor) { + Object.keys(scopedInterceptor).forEach((hook) => { + if (hook !== "returnValue") { + interceptor[hook] = (interceptor[hook] || []).concat(scopedInterceptor[hook]); + } + }); + } + return interceptor; +} +function invokeApi(method, api, options, params) { + const interceptor = getApiInterceptorHooks(method); + if (interceptor && Object.keys(interceptor).length) { + if (isArray(interceptor.invoke)) { + const res = queue$1(interceptor.invoke, options); + return res.then((options2) => { + return api(wrapperOptions(getApiInterceptorHooks(method), options2), ...params); + }); + } else { + return api(wrapperOptions(interceptor, options), ...params); + } + } + return api(options, ...params); +} +function hasCallback(args) { + if (isPlainObject(args) && [API_SUCCESS, API_FAIL, API_COMPLETE].find((cb) => isFunction(args[cb]))) { + return true; + } + return false; +} +function handlePromise(promise) { + return promise; +} +function promisify$1(name, fn) { + return (args = {}, ...rest) => { + if (hasCallback(args)) { + return wrapperReturnValue(name, invokeApi(name, fn, args, rest)); + } + return wrapperReturnValue(name, handlePromise(new Promise((resolve, reject) => { + invokeApi(name, fn, extend(args, { success: resolve, fail: reject }), rest); + }))); + }; +} +function formatApiArgs(args, options) { + const params = args[0]; + if (!options || !isPlainObject(options.formatArgs) && isPlainObject(params)) { + return; + } + const formatArgs = options.formatArgs; + const keys = Object.keys(formatArgs); + for (let i2 = 0; i2 < keys.length; i2++) { + const name = keys[i2]; + const formatterOrDefaultValue = formatArgs[name]; + if (isFunction(formatterOrDefaultValue)) { + const errMsg = formatterOrDefaultValue(args[0][name], params); + if (isString(errMsg)) { + return errMsg; + } + } else { + if (!hasOwn$1(params, name)) { + params[name] = formatterOrDefaultValue; + } + } + } +} +function invokeSuccess(id, name, res) { + return invokeCallback(id, extend(res || {}, { errMsg: name + ":ok" })); +} +function invokeFail(id, name, errMsg, errRes) { + return invokeCallback(id, extend({ errMsg: name + ":fail" + (errMsg ? " " + errMsg : "") }, errRes)); +} +function beforeInvokeApi(name, args, protocol, options) { + { + validateProtocols(name, args, protocol); + } + if (options && options.beforeInvoke) { + const errMsg2 = options.beforeInvoke(args); + if (isString(errMsg2)) { + return errMsg2; + } + } + const errMsg = formatApiArgs(args, options); + if (errMsg) { + return errMsg; + } +} +function normalizeErrMsg(errMsg) { + if (!errMsg || isString(errMsg)) { + return errMsg; + } + if (errMsg.stack) { + console.error(errMsg.message + LINEFEED + errMsg.stack); + return errMsg.message; + } + return errMsg; +} +function wrapperTaskApi(name, fn, protocol, options) { + return (args) => { + const id = createAsyncApiCallback(name, args, options); + const errMsg = beforeInvokeApi(name, [args], protocol, options); + if (errMsg) { + return invokeFail(id, name, errMsg); + } + return fn(args, { + resolve: (res) => invokeSuccess(id, name, res), + reject: (errMsg2, errRes) => invokeFail(id, name, normalizeErrMsg(errMsg2), errRes) + }); + }; +} +function wrapperSyncApi(name, fn, protocol, options) { + return (...args) => { + const errMsg = beforeInvokeApi(name, args, protocol, options); + if (errMsg) { + throw new Error(errMsg); + } + return fn.apply(null, args); + }; +} +function wrapperAsyncApi(name, fn, protocol, options) { + return wrapperTaskApi(name, fn, protocol, options); +} +function defineSyncApi(name, fn, protocol, options) { + return wrapperSyncApi(name, fn, protocol, options); +} +function defineAsyncApi(name, fn, protocol, options) { + return promisify$1(name, wrapperAsyncApi(name, fn, protocol, options)); +} +const API_UPX2PX = "upx2px"; +const Upx2pxProtocol = [ + { + name: "upx", + type: [Number, String], + required: true + } +]; +const EPS = 1e-4; +const BASE_DEVICE_WIDTH = 750; +let isIOS = false; +let deviceWidth = 0; +let deviceDPR = 0; +function checkDeviceWidth() { + const { platform, pixelRatio, windowWidth } = getBaseSystemInfo(); + deviceWidth = windowWidth; + deviceDPR = pixelRatio; + isIOS = platform === "ios"; +} +const upx2px = defineSyncApi(API_UPX2PX, (number, newDeviceWidth) => { + if (deviceWidth === 0) { + checkDeviceWidth(); + } + number = Number(number); + if (number === 0) { + return 0; + } + let width = newDeviceWidth || deviceWidth; + let result = number / BASE_DEVICE_WIDTH * width; + if (result < 0) { + result = -result; + } + result = Math.floor(result + EPS); + if (result === 0) { + if (deviceDPR === 1 || !isIOS) { + result = 1; + } else { + result = 0.5; + } + } + return number < 0 ? -result : result; +}, Upx2pxProtocol); +const API_ADD_INTERCEPTOR = "addInterceptor"; +const API_REMOVE_INTERCEPTOR = "removeInterceptor"; +const AddInterceptorProtocol = [ + { + name: "method", + type: [String, Object], + required: true + } +]; +const RemoveInterceptorProtocol = AddInterceptorProtocol; +function mergeInterceptorHook(interceptors2, interceptor) { + Object.keys(interceptor).forEach((hook) => { + if (isFunction(interceptor[hook])) { + interceptors2[hook] = mergeHook(interceptors2[hook], interceptor[hook]); + } + }); +} +function removeInterceptorHook(interceptors2, interceptor) { + if (!interceptors2 || !interceptor) { + return; + } + Object.keys(interceptor).forEach((name) => { + const hooks = interceptors2[name]; + const hook = interceptor[name]; + if (isArray(hooks) && isFunction(hook)) { + remove(hooks, hook); + } + }); +} +function mergeHook(parentVal, childVal) { + const res = childVal ? parentVal ? parentVal.concat(childVal) : isArray(childVal) ? childVal : [childVal] : parentVal; + return res ? dedupeHooks(res) : res; +} +function dedupeHooks(hooks) { + const res = []; + for (let i2 = 0; i2 < hooks.length; i2++) { + if (res.indexOf(hooks[i2]) === -1) { + res.push(hooks[i2]); + } + } + return res; +} +const addInterceptor = defineSyncApi(API_ADD_INTERCEPTOR, (method, interceptor) => { + if (isString(method) && isPlainObject(interceptor)) { + mergeInterceptorHook(scopedInterceptors[method] || (scopedInterceptors[method] = {}), interceptor); + } else if (isPlainObject(method)) { + mergeInterceptorHook(globalInterceptors, method); + } +}, AddInterceptorProtocol); +const removeInterceptor = defineSyncApi(API_REMOVE_INTERCEPTOR, (method, interceptor) => { + if (isString(method)) { + if (isPlainObject(interceptor)) { + removeInterceptorHook(scopedInterceptors[method], interceptor); + } else { + delete scopedInterceptors[method]; + } + } else if (isPlainObject(method)) { + removeInterceptorHook(globalInterceptors, method); + } +}, RemoveInterceptorProtocol); +const interceptors = {}; +const API_ON = "$on"; +const OnProtocol = [ + { + name: "event", + type: String, + required: true + }, + { + name: "callback", + type: Function, + required: true + } +]; +const API_ONCE = "$once"; +const OnceProtocol = OnProtocol; +const API_OFF = "$off"; +const OffProtocol = [ + { + name: "event", + type: [String, Array] + }, + { + name: "callback", + type: Function + } +]; +const API_EMIT = "$emit"; +const EmitProtocol = [ + { + name: "event", + type: String, + required: true + } +]; +const emitter = new E$1$1(); +const $on = defineSyncApi(API_ON, (name, callback) => { + emitter.on(name, callback); + return () => emitter.off(name, callback); +}, OnProtocol); +const $once = defineSyncApi(API_ONCE, (name, callback) => { + emitter.once(name, callback); + return () => emitter.off(name, callback); +}, OnceProtocol); +const $off = defineSyncApi(API_OFF, (name, callback) => { + if (!name) { + emitter.e = {}; + return; + } + if (!isArray(name)) + name = [name]; + name.forEach((n2) => emitter.off(n2, callback)); +}, OffProtocol); +const $emit = defineSyncApi(API_EMIT, (name, ...args) => { + emitter.emit(name, ...args); +}, EmitProtocol); +let cid; +let cidErrMsg; +let enabled; +function normalizePushMessage(message) { + try { + return JSON.parse(message); + } catch (e2) { + } + return message; +} +function invokePushCallback(args) { + if (args.type === "enabled") { + enabled = true; + } else if (args.type === "clientId") { + cid = args.cid; + cidErrMsg = args.errMsg; + invokeGetPushCidCallbacks(cid, args.errMsg); + } else if (args.type === "pushMsg") { + const message = { + type: "receive", + data: normalizePushMessage(args.message) + }; + for (let i2 = 0; i2 < onPushMessageCallbacks.length; i2++) { + const callback = onPushMessageCallbacks[i2]; + callback(message); + if (message.stopped) { + break; + } + } + } else if (args.type === "click") { + onPushMessageCallbacks.forEach((callback) => { + callback({ + type: "click", + data: normalizePushMessage(args.message) + }); + }); + } +} +const getPushCidCallbacks = []; +function invokeGetPushCidCallbacks(cid2, errMsg) { + getPushCidCallbacks.forEach((callback) => { + callback(cid2, errMsg); + }); + getPushCidCallbacks.length = 0; +} +const API_GET_PUSH_CLIENT_ID = "getPushClientId"; +const getPushClientId = defineAsyncApi(API_GET_PUSH_CLIENT_ID, (_2, { resolve, reject }) => { + Promise.resolve().then(() => { + if (typeof enabled === "undefined") { + enabled = false; + cid = ""; + cidErrMsg = "uniPush is not enabled"; + } + getPushCidCallbacks.push((cid2, errMsg) => { + if (cid2) { + resolve({ cid: cid2 }); + } else { + reject(errMsg); + } + }); + if (typeof cid !== "undefined") { + invokeGetPushCidCallbacks(cid, cidErrMsg); + } + }); +}); +const onPushMessageCallbacks = []; +const onPushMessage = (fn) => { + if (onPushMessageCallbacks.indexOf(fn) === -1) { + onPushMessageCallbacks.push(fn); + } +}; +const offPushMessage = (fn) => { + if (!fn) { + onPushMessageCallbacks.length = 0; + } else { + const index2 = onPushMessageCallbacks.indexOf(fn); + if (index2 > -1) { + onPushMessageCallbacks.splice(index2, 1); + } + } +}; +const SYNC_API_RE = /^\$|getLocale|setLocale|sendNativeEvent|restoreGlobal|requireGlobal|getCurrentSubNVue|getMenuButtonBoundingClientRect|^report|interceptors|Interceptor$|getSubNVueById|requireNativePlugin|upx2px|hideKeyboard|canIUse|^create|Sync$|Manager$|base64ToArrayBuffer|arrayBufferToBase64|getDeviceInfo|getAppBaseInfo|getWindowInfo|getSystemSetting|getAppAuthorizeSetting/; +const CONTEXT_API_RE = /^create|Manager$/; +const CONTEXT_API_RE_EXC = ["createBLEConnection"]; +const ASYNC_API = ["createBLEConnection"]; +const CALLBACK_API_RE = /^on|^off/; +function isContextApi(name) { + return CONTEXT_API_RE.test(name) && CONTEXT_API_RE_EXC.indexOf(name) === -1; +} +function isSyncApi(name) { + return SYNC_API_RE.test(name) && ASYNC_API.indexOf(name) === -1; +} +function isCallbackApi(name) { + return CALLBACK_API_RE.test(name) && name !== "onPush"; +} +function shouldPromise(name) { + if (isContextApi(name) || isSyncApi(name) || isCallbackApi(name)) { + return false; + } + return true; +} +if (!Promise.prototype.finally) { + Promise.prototype.finally = function(onfinally) { + const promise = this.constructor; + return this.then((value) => promise.resolve(onfinally && onfinally()).then(() => value), (reason) => promise.resolve(onfinally && onfinally()).then(() => { + throw reason; + })); + }; +} +function promisify(name, api) { + if (!shouldPromise(name)) { + return api; + } + if (!isFunction(api)) { + return api; + } + return function promiseApi(options = {}, ...rest) { + if (isFunction(options.success) || isFunction(options.fail) || isFunction(options.complete)) { + return wrapperReturnValue(name, invokeApi(name, api, options, rest)); + } + return wrapperReturnValue(name, handlePromise(new Promise((resolve, reject) => { + invokeApi(name, api, extend({}, options, { + success: resolve, + fail: reject + }), rest); + }))); + }; +} +const CALLBACKS = ["success", "fail", "cancel", "complete"]; +function initWrapper(protocols2) { + function processCallback(methodName, method, returnValue) { + return function(res) { + return method(processReturnValue(methodName, res, returnValue)); + }; + } + function processArgs(methodName, fromArgs, argsOption = {}, returnValue = {}, keepFromArgs = false) { + if (isPlainObject(fromArgs)) { + const toArgs = keepFromArgs === true ? fromArgs : {}; + if (isFunction(argsOption)) { + argsOption = argsOption(fromArgs, toArgs) || {}; + } + for (const key in fromArgs) { + if (hasOwn$1(argsOption, key)) { + let keyOption = argsOption[key]; + if (isFunction(keyOption)) { + keyOption = keyOption(fromArgs[key], fromArgs, toArgs); + } + if (!keyOption) { + console.warn(`微信小程序 ${methodName} 暂不支持 ${key}`); + } else if (isString(keyOption)) { + toArgs[keyOption] = fromArgs[key]; + } else if (isPlainObject(keyOption)) { + toArgs[keyOption.name ? keyOption.name : key] = keyOption.value; + } + } else if (CALLBACKS.indexOf(key) !== -1) { + const callback = fromArgs[key]; + if (isFunction(callback)) { + toArgs[key] = processCallback(methodName, callback, returnValue); + } + } else { + if (!keepFromArgs && !hasOwn$1(toArgs, key)) { + toArgs[key] = fromArgs[key]; + } + } + } + return toArgs; + } else if (isFunction(fromArgs)) { + fromArgs = processCallback(methodName, fromArgs, returnValue); + } + return fromArgs; + } + function processReturnValue(methodName, res, returnValue, keepReturnValue = false) { + if (isFunction(protocols2.returnValue)) { + res = protocols2.returnValue(methodName, res); + } + return processArgs(methodName, res, returnValue, {}, keepReturnValue); + } + return function wrapper(methodName, method) { + if (!hasOwn$1(protocols2, methodName)) { + return method; + } + const protocol = protocols2[methodName]; + if (!protocol) { + return function() { + console.error(`微信小程序 暂不支持${methodName}`); + }; + } + return function(arg1, arg2) { + let options = protocol; + if (isFunction(protocol)) { + options = protocol(arg1); + } + arg1 = processArgs(methodName, arg1, options.args, options.returnValue); + const args = [arg1]; + if (typeof arg2 !== "undefined") { + args.push(arg2); + } + const returnValue = wx[options.name || methodName].apply(wx, args); + if (isSyncApi(methodName)) { + return processReturnValue(methodName, returnValue, options.returnValue, isContextApi(methodName)); + } + return returnValue; + }; + }; +} +const getLocale = () => { + const app = isFunction(getApp) && getApp({ allowDefault: true }); + if (app && app.$vm) { + return app.$vm.$locale; + } + return normalizeLocale(wx.getSystemInfoSync().language) || LOCALE_EN; +}; +const setLocale = (locale) => { + const app = isFunction(getApp) && getApp(); + if (!app) { + return false; + } + const oldLocale = app.$vm.$locale; + if (oldLocale !== locale) { + app.$vm.$locale = locale; + onLocaleChangeCallbacks.forEach((fn) => fn({ locale })); + return true; + } + return false; +}; +const onLocaleChangeCallbacks = []; +const onLocaleChange = (fn) => { + if (onLocaleChangeCallbacks.indexOf(fn) === -1) { + onLocaleChangeCallbacks.push(fn); + } +}; +if (typeof global !== "undefined") { + global.getLocale = getLocale; +} +const UUID_KEY = "__DC_STAT_UUID"; +let deviceId; +function useDeviceId(global2 = wx) { + return function addDeviceId(_2, toRes) { + deviceId = deviceId || global2.getStorageSync(UUID_KEY); + if (!deviceId) { + deviceId = Date.now() + "" + Math.floor(Math.random() * 1e7); + wx.setStorage({ + key: UUID_KEY, + data: deviceId + }); + } + toRes.deviceId = deviceId; + }; +} +function addSafeAreaInsets(fromRes, toRes) { + if (fromRes.safeArea) { + const safeArea = fromRes.safeArea; + toRes.safeAreaInsets = { + top: safeArea.top, + left: safeArea.left, + right: fromRes.windowWidth - safeArea.right, + bottom: fromRes.screenHeight - safeArea.bottom + }; + } +} +function populateParameters(fromRes, toRes) { + const { brand = "", model = "", system = "", language = "", theme, version: version2, platform, fontSizeSetting, SDKVersion, pixelRatio, deviceOrientation } = fromRes; + let osName = ""; + let osVersion = ""; + { + osName = system.split(" ")[0] || ""; + osVersion = system.split(" ")[1] || ""; + } + let hostVersion = version2; + let deviceType = getGetDeviceType(fromRes, model); + let deviceBrand = getDeviceBrand(brand); + let _hostName = getHostName(fromRes); + let _deviceOrientation = deviceOrientation; + let _devicePixelRatio = pixelRatio; + let _SDKVersion = SDKVersion; + const hostLanguage = language.replace(/_/g, "-"); + const parameters = { + appId: "__UNI__9F628B4", + appName: "hyy", + appVersion: "1.0.0", + appVersionCode: "100", + appLanguage: getAppLanguage(hostLanguage), + uniCompileVersion: "3.8.12", + uniRuntimeVersion: "3.8.12", + uniPlatform: "mp-weixin", + deviceBrand, + deviceModel: model, + deviceType, + devicePixelRatio: _devicePixelRatio, + deviceOrientation: _deviceOrientation, + osName: osName.toLocaleLowerCase(), + osVersion, + hostTheme: theme, + hostVersion, + hostLanguage, + hostName: _hostName, + hostSDKVersion: _SDKVersion, + hostFontSizeSetting: fontSizeSetting, + windowTop: 0, + windowBottom: 0, + // TODO + osLanguage: void 0, + osTheme: void 0, + ua: void 0, + hostPackageName: void 0, + browserName: void 0, + browserVersion: void 0 + }; + extend(toRes, parameters); +} +function getGetDeviceType(fromRes, model) { + let deviceType = fromRes.deviceType || "phone"; + { + const deviceTypeMaps = { + ipad: "pad", + windows: "pc", + mac: "pc" + }; + const deviceTypeMapsKeys = Object.keys(deviceTypeMaps); + const _model = model.toLocaleLowerCase(); + for (let index2 = 0; index2 < deviceTypeMapsKeys.length; index2++) { + const _m = deviceTypeMapsKeys[index2]; + if (_model.indexOf(_m) !== -1) { + deviceType = deviceTypeMaps[_m]; + break; + } + } + } + return deviceType; +} +function getDeviceBrand(brand) { + let deviceBrand = brand; + if (deviceBrand) { + deviceBrand = deviceBrand.toLocaleLowerCase(); + } + return deviceBrand; +} +function getAppLanguage(defaultLanguage) { + return getLocale ? getLocale() : defaultLanguage; +} +function getHostName(fromRes) { + const _platform = "WeChat"; + let _hostName = fromRes.hostName || _platform; + { + if (fromRes.environment) { + _hostName = fromRes.environment; + } else if (fromRes.host && fromRes.host.env) { + _hostName = fromRes.host.env; + } + } + return _hostName; +} +const getSystemInfo = { + returnValue: (fromRes, toRes) => { + addSafeAreaInsets(fromRes, toRes); + useDeviceId()(fromRes, toRes); + populateParameters(fromRes, toRes); + } +}; +const getSystemInfoSync = getSystemInfo; +const redirectTo = {}; +const previewImage = { + args(fromArgs, toArgs) { + let currentIndex = parseInt(fromArgs.current); + if (isNaN(currentIndex)) { + return; + } + const urls = fromArgs.urls; + if (!isArray(urls)) { + return; + } + const len = urls.length; + if (!len) { + return; + } + if (currentIndex < 0) { + currentIndex = 0; + } else if (currentIndex >= len) { + currentIndex = len - 1; + } + if (currentIndex > 0) { + toArgs.current = urls[currentIndex]; + toArgs.urls = urls.filter((item, index2) => index2 < currentIndex ? item !== urls[currentIndex] : true); + } else { + toArgs.current = urls[0]; + } + return { + indicator: false, + loop: false + }; + } +}; +const showActionSheet = { + args(fromArgs, toArgs) { + toArgs.alertText = fromArgs.title; + } +}; +const getDeviceInfo = { + returnValue: (fromRes, toRes) => { + const { brand, model } = fromRes; + let deviceType = getGetDeviceType(fromRes, model); + let deviceBrand = getDeviceBrand(brand); + useDeviceId()(fromRes, toRes); + toRes = sortObject(extend(toRes, { + deviceType, + deviceBrand, + deviceModel: model + })); + } +}; +const getAppBaseInfo = { + returnValue: (fromRes, toRes) => { + const { version: version2, language, SDKVersion, theme } = fromRes; + let _hostName = getHostName(fromRes); + let hostLanguage = language.replace(/_/g, "-"); + toRes = sortObject(extend(toRes, { + hostVersion: version2, + hostLanguage, + hostName: _hostName, + hostSDKVersion: SDKVersion, + hostTheme: theme, + appId: "__UNI__9F628B4", + appName: "hyy", + appVersion: "1.0.0", + appVersionCode: "100", + appLanguage: getAppLanguage(hostLanguage) + })); + } +}; +const getWindowInfo = { + returnValue: (fromRes, toRes) => { + addSafeAreaInsets(fromRes, toRes); + toRes = sortObject(extend(toRes, { + windowTop: 0, + windowBottom: 0 + })); + } +}; +const getAppAuthorizeSetting = { + returnValue: function(fromRes, toRes) { + const { locationReducedAccuracy } = fromRes; + toRes.locationAccuracy = "unsupported"; + if (locationReducedAccuracy === true) { + toRes.locationAccuracy = "reduced"; + } else if (locationReducedAccuracy === false) { + toRes.locationAccuracy = "full"; + } + } +}; +const baseApis = { + $on, + $off, + $once, + $emit, + upx2px, + interceptors, + addInterceptor, + removeInterceptor, + onCreateVueApp, + invokeCreateVueAppHook, + getLocale, + setLocale, + onLocaleChange, + getPushClientId, + onPushMessage, + offPushMessage, + invokePushCallback +}; +function initUni(api, protocols2, platform = wx) { + const wrapper = initWrapper(protocols2); + const UniProxyHandlers = { + get(target, key) { + if (hasOwn$1(target, key)) { + return target[key]; + } + if (hasOwn$1(api, key)) { + return promisify(key, api[key]); + } + if (hasOwn$1(baseApis, key)) { + return promisify(key, baseApis[key]); + } + return promisify(key, wrapper(key, platform[key])); + } + }; + return new Proxy({}, UniProxyHandlers); +} +function initGetProvider(providers) { + return function getProvider2({ service, success, fail, complete }) { + let res; + if (providers[service]) { + res = { + errMsg: "getProvider:ok", + service, + provider: providers[service] + }; + isFunction(success) && success(res); + } else { + res = { + errMsg: "getProvider:fail:服务[" + service + "]不存在" + }; + isFunction(fail) && fail(res); + } + isFunction(complete) && complete(res); + }; +} +const objectKeys = [ + "qy", + "env", + "error", + "version", + "lanDebug", + "cloud", + "serviceMarket", + "router", + "worklet", + "__webpack_require_UNI_MP_PLUGIN__" +]; +const singlePageDisableKey = ["lanDebug", "router", "worklet"]; +const launchOption = wx.getLaunchOptionsSync ? wx.getLaunchOptionsSync() : null; +function isWxKey(key) { + if (launchOption && launchOption.scene === 1154 && singlePageDisableKey.includes(key)) { + return false; + } + return objectKeys.indexOf(key) > -1 || typeof wx[key] === "function"; +} +function initWx() { + const newWx = {}; + for (const key in wx) { + if (isWxKey(key)) { + newWx[key] = wx[key]; + } + } + if (typeof globalThis !== "undefined" && typeof requireMiniProgram === "undefined") { + globalThis.wx = newWx; + } + return newWx; +} +const mocks$1 = ["__route__", "__wxExparserNodeId__", "__wxWebviewId__"]; +const getProvider = initGetProvider({ + oauth: ["weixin"], + share: ["weixin"], + payment: ["wxpay"], + push: ["weixin"] +}); +function initComponentMocks(component) { + const res = /* @__PURE__ */ Object.create(null); + mocks$1.forEach((name) => { + res[name] = component[name]; + }); + return res; +} +function createSelectorQuery() { + const query = wx$2.createSelectorQuery(); + const oldIn = query.in; + query.in = function newIn(component) { + return oldIn.call(this, initComponentMocks(component)); + }; + return query; +} +const wx$2 = initWx(); +let baseInfo = wx$2.getAppBaseInfo && wx$2.getAppBaseInfo(); +if (!baseInfo) { + baseInfo = wx$2.getSystemInfoSync(); +} +const host = baseInfo ? baseInfo.host : null; +const shareVideoMessage = host && host.env === "SAAASDK" ? wx$2.miniapp.shareVideoMessage : wx$2.shareVideoMessage; +var shims = /* @__PURE__ */ Object.freeze({ + __proto__: null, + createSelectorQuery, + getProvider, + shareVideoMessage +}); +const compressImage = { + args(fromArgs, toArgs) { + if (fromArgs.compressedHeight && !toArgs.compressHeight) { + toArgs.compressHeight = fromArgs.compressedHeight; + } + if (fromArgs.compressedWidth && !toArgs.compressWidth) { + toArgs.compressWidth = fromArgs.compressedWidth; + } + } +}; +var protocols = /* @__PURE__ */ Object.freeze({ + __proto__: null, + compressImage, + getAppAuthorizeSetting, + getAppBaseInfo, + getDeviceInfo, + getSystemInfo, + getSystemInfoSync, + getWindowInfo, + previewImage, + redirectTo, + showActionSheet +}); +const wx$1 = initWx(); +var index = initUni(shims, protocols, wx$1); +function warn$1(msg, ...args) { + console.warn(`[Vue warn] ${msg}`, ...args); +} +let activeEffectScope; +class EffectScope { + constructor(detached = false) { + this.detached = detached; + this._active = true; + this.effects = []; + this.cleanups = []; + this.parent = activeEffectScope; + if (!detached && activeEffectScope) { + this.index = (activeEffectScope.scopes || (activeEffectScope.scopes = [])).push(this) - 1; + } + } + get active() { + return this._active; + } + run(fn) { + if (this._active) { + const currentEffectScope = activeEffectScope; + try { + activeEffectScope = this; + return fn(); + } finally { + activeEffectScope = currentEffectScope; + } + } else { + warn$1(`cannot run an inactive effect scope.`); + } + } + /** + * This should only be called on non-detached scopes + * @internal + */ + on() { + activeEffectScope = this; + } + /** + * This should only be called on non-detached scopes + * @internal + */ + off() { + activeEffectScope = this.parent; + } + stop(fromParent) { + if (this._active) { + let i2, l2; + for (i2 = 0, l2 = this.effects.length; i2 < l2; i2++) { + this.effects[i2].stop(); + } + for (i2 = 0, l2 = this.cleanups.length; i2 < l2; i2++) { + this.cleanups[i2](); + } + if (this.scopes) { + for (i2 = 0, l2 = this.scopes.length; i2 < l2; i2++) { + this.scopes[i2].stop(true); + } + } + if (!this.detached && this.parent && !fromParent) { + const last = this.parent.scopes.pop(); + if (last && last !== this) { + this.parent.scopes[this.index] = last; + last.index = this.index; + } + } + this.parent = void 0; + this._active = false; + } + } +} +function recordEffectScope(effect, scope = activeEffectScope) { + if (scope && scope.active) { + scope.effects.push(effect); + } +} +function getCurrentScope() { + return activeEffectScope; +} +const createDep = (effects) => { + const dep = new Set(effects); + dep.w = 0; + dep.n = 0; + return dep; +}; +const wasTracked = (dep) => (dep.w & trackOpBit) > 0; +const newTracked = (dep) => (dep.n & trackOpBit) > 0; +const initDepMarkers = ({ deps }) => { + if (deps.length) { + for (let i2 = 0; i2 < deps.length; i2++) { + deps[i2].w |= trackOpBit; + } + } +}; +const finalizeDepMarkers = (effect) => { + const { deps } = effect; + if (deps.length) { + let ptr = 0; + for (let i2 = 0; i2 < deps.length; i2++) { + const dep = deps[i2]; + if (wasTracked(dep) && !newTracked(dep)) { + dep.delete(effect); + } else { + deps[ptr++] = dep; + } + dep.w &= ~trackOpBit; + dep.n &= ~trackOpBit; + } + deps.length = ptr; + } +}; +const targetMap = /* @__PURE__ */ new WeakMap(); +let effectTrackDepth = 0; +let trackOpBit = 1; +const maxMarkerBits = 30; +let activeEffect; +const ITERATE_KEY = Symbol("iterate"); +const MAP_KEY_ITERATE_KEY = Symbol("Map key iterate"); +class ReactiveEffect { + constructor(fn, scheduler = null, scope) { + this.fn = fn; + this.scheduler = scheduler; + this.active = true; + this.deps = []; + this.parent = void 0; + recordEffectScope(this, scope); + } + run() { + if (!this.active) { + return this.fn(); + } + let parent = activeEffect; + let lastShouldTrack = shouldTrack; + while (parent) { + if (parent === this) { + return; + } + parent = parent.parent; + } + try { + this.parent = activeEffect; + activeEffect = this; + shouldTrack = true; + trackOpBit = 1 << ++effectTrackDepth; + if (effectTrackDepth <= maxMarkerBits) { + initDepMarkers(this); + } else { + cleanupEffect(this); + } + return this.fn(); + } finally { + if (effectTrackDepth <= maxMarkerBits) { + finalizeDepMarkers(this); + } + trackOpBit = 1 << --effectTrackDepth; + activeEffect = this.parent; + shouldTrack = lastShouldTrack; + this.parent = void 0; + if (this.deferStop) { + this.stop(); + } + } + } + stop() { + if (activeEffect === this) { + this.deferStop = true; + } else if (this.active) { + cleanupEffect(this); + if (this.onStop) { + this.onStop(); + } + this.active = false; + } + } +} +function cleanupEffect(effect) { + const { deps } = effect; + if (deps.length) { + for (let i2 = 0; i2 < deps.length; i2++) { + deps[i2].delete(effect); + } + deps.length = 0; + } +} +let shouldTrack = true; +const trackStack = []; +function pauseTracking() { + trackStack.push(shouldTrack); + shouldTrack = false; +} +function resetTracking() { + const last = trackStack.pop(); + shouldTrack = last === void 0 ? true : last; +} +function track(target, type, key) { + if (shouldTrack && activeEffect) { + let depsMap = targetMap.get(target); + if (!depsMap) { + targetMap.set(target, depsMap = /* @__PURE__ */ new Map()); + } + let dep = depsMap.get(key); + if (!dep) { + depsMap.set(key, dep = createDep()); + } + const eventInfo = { effect: activeEffect, target, type, key }; + trackEffects(dep, eventInfo); + } +} +function trackEffects(dep, debuggerEventExtraInfo) { + let shouldTrack2 = false; + if (effectTrackDepth <= maxMarkerBits) { + if (!newTracked(dep)) { + dep.n |= trackOpBit; + shouldTrack2 = !wasTracked(dep); + } + } else { + shouldTrack2 = !dep.has(activeEffect); + } + if (shouldTrack2) { + dep.add(activeEffect); + activeEffect.deps.push(dep); + if (activeEffect.onTrack) { + activeEffect.onTrack(Object.assign({ effect: activeEffect }, debuggerEventExtraInfo)); + } + } +} +function trigger(target, type, key, newValue, oldValue, oldTarget) { + const depsMap = targetMap.get(target); + if (!depsMap) { + return; + } + let deps = []; + if (type === "clear") { + deps = [...depsMap.values()]; + } else if (key === "length" && isArray(target)) { + const newLength = Number(newValue); + depsMap.forEach((dep, key2) => { + if (key2 === "length" || key2 >= newLength) { + deps.push(dep); + } + }); + } else { + if (key !== void 0) { + deps.push(depsMap.get(key)); + } + switch (type) { + case "add": + if (!isArray(target)) { + deps.push(depsMap.get(ITERATE_KEY)); + if (isMap(target)) { + deps.push(depsMap.get(MAP_KEY_ITERATE_KEY)); + } + } else if (isIntegerKey(key)) { + deps.push(depsMap.get("length")); + } + break; + case "delete": + if (!isArray(target)) { + deps.push(depsMap.get(ITERATE_KEY)); + if (isMap(target)) { + deps.push(depsMap.get(MAP_KEY_ITERATE_KEY)); + } + } + break; + case "set": + if (isMap(target)) { + deps.push(depsMap.get(ITERATE_KEY)); + } + break; + } + } + const eventInfo = { target, type, key, newValue, oldValue, oldTarget }; + if (deps.length === 1) { + if (deps[0]) { + { + triggerEffects(deps[0], eventInfo); + } + } + } else { + const effects = []; + for (const dep of deps) { + if (dep) { + effects.push(...dep); + } + } + { + triggerEffects(createDep(effects), eventInfo); + } + } +} +function triggerEffects(dep, debuggerEventExtraInfo) { + const effects = isArray(dep) ? dep : [...dep]; + for (const effect of effects) { + if (effect.computed) { + triggerEffect(effect, debuggerEventExtraInfo); + } + } + for (const effect of effects) { + if (!effect.computed) { + triggerEffect(effect, debuggerEventExtraInfo); + } + } +} +function triggerEffect(effect, debuggerEventExtraInfo) { + if (effect !== activeEffect || effect.allowRecurse) { + if (effect.onTrigger) { + effect.onTrigger(extend({ effect }, debuggerEventExtraInfo)); + } + if (effect.scheduler) { + effect.scheduler(); + } else { + effect.run(); + } + } +} +const isNonTrackableKeys = /* @__PURE__ */ makeMap(`__proto__,__v_isRef,__isVue`); +const builtInSymbols = new Set( + /* @__PURE__ */ Object.getOwnPropertyNames(Symbol).filter((key) => key !== "arguments" && key !== "caller").map((key) => Symbol[key]).filter(isSymbol) +); +const get$1 = /* @__PURE__ */ createGetter(); +const shallowGet = /* @__PURE__ */ createGetter(false, true); +const readonlyGet = /* @__PURE__ */ createGetter(true); +const shallowReadonlyGet = /* @__PURE__ */ createGetter(true, true); +const arrayInstrumentations = /* @__PURE__ */ createArrayInstrumentations(); +function createArrayInstrumentations() { + const instrumentations = {}; + ["includes", "indexOf", "lastIndexOf"].forEach((key) => { + instrumentations[key] = function(...args) { + const arr = toRaw(this); + for (let i2 = 0, l2 = this.length; i2 < l2; i2++) { + track(arr, "get", i2 + ""); + } + const res = arr[key](...args); + if (res === -1 || res === false) { + return arr[key](...args.map(toRaw)); + } else { + return res; + } + }; + }); + ["push", "pop", "shift", "unshift", "splice"].forEach((key) => { + instrumentations[key] = function(...args) { + pauseTracking(); + const res = toRaw(this)[key].apply(this, args); + resetTracking(); + return res; + }; + }); + return instrumentations; +} +function hasOwnProperty(key) { + const obj = toRaw(this); + track(obj, "has", key); + return obj.hasOwnProperty(key); +} +function createGetter(isReadonly2 = false, shallow = false) { + return function get2(target, key, receiver) { + if (key === "__v_isReactive") { + return !isReadonly2; + } else if (key === "__v_isReadonly") { + return isReadonly2; + } else if (key === "__v_isShallow") { + return shallow; + } else if (key === "__v_raw" && receiver === (isReadonly2 ? shallow ? shallowReadonlyMap : readonlyMap : shallow ? shallowReactiveMap : reactiveMap).get(target)) { + return target; + } + const targetIsArray = isArray(target); + if (!isReadonly2) { + if (targetIsArray && hasOwn$1(arrayInstrumentations, key)) { + return Reflect.get(arrayInstrumentations, key, receiver); + } + if (key === "hasOwnProperty") { + return hasOwnProperty; + } + } + const res = Reflect.get(target, key, receiver); + if (isSymbol(key) ? builtInSymbols.has(key) : isNonTrackableKeys(key)) { + return res; + } + if (!isReadonly2) { + track(target, "get", key); + } + if (shallow) { + return res; + } + if (isRef(res)) { + return targetIsArray && isIntegerKey(key) ? res : res.value; + } + if (isObject$1(res)) { + return isReadonly2 ? readonly(res) : reactive(res); + } + return res; + }; +} +const set$1 = /* @__PURE__ */ createSetter(); +const shallowSet = /* @__PURE__ */ createSetter(true); +function createSetter(shallow = false) { + return function set2(target, key, value, receiver) { + let oldValue = target[key]; + if (isReadonly(oldValue) && isRef(oldValue) && !isRef(value)) { + return false; + } + if (!shallow) { + if (!isShallow(value) && !isReadonly(value)) { + oldValue = toRaw(oldValue); + value = toRaw(value); + } + if (!isArray(target) && isRef(oldValue) && !isRef(value)) { + oldValue.value = value; + return true; + } + } + const hadKey = isArray(target) && isIntegerKey(key) ? Number(key) < target.length : hasOwn$1(target, key); + const result = Reflect.set(target, key, value, receiver); + if (target === toRaw(receiver)) { + if (!hadKey) { + trigger(target, "add", key, value); + } else if (hasChanged(value, oldValue)) { + trigger(target, "set", key, value, oldValue); + } + } + return result; + }; +} +function deleteProperty(target, key) { + const hadKey = hasOwn$1(target, key); + const oldValue = target[key]; + const result = Reflect.deleteProperty(target, key); + if (result && hadKey) { + trigger(target, "delete", key, void 0, oldValue); + } + return result; +} +function has$1(target, key) { + const result = Reflect.has(target, key); + if (!isSymbol(key) || !builtInSymbols.has(key)) { + track(target, "has", key); + } + return result; +} +function ownKeys(target) { + track(target, "iterate", isArray(target) ? "length" : ITERATE_KEY); + return Reflect.ownKeys(target); +} +const mutableHandlers = { + get: get$1, + set: set$1, + deleteProperty, + has: has$1, + ownKeys +}; +const readonlyHandlers = { + get: readonlyGet, + set(target, key) { + { + warn$1(`Set operation on key "${String(key)}" failed: target is readonly.`, target); + } + return true; + }, + deleteProperty(target, key) { + { + warn$1(`Delete operation on key "${String(key)}" failed: target is readonly.`, target); + } + return true; + } +}; +const shallowReactiveHandlers = /* @__PURE__ */ extend({}, mutableHandlers, { + get: shallowGet, + set: shallowSet +}); +const shallowReadonlyHandlers = /* @__PURE__ */ extend({}, readonlyHandlers, { + get: shallowReadonlyGet +}); +const toShallow = (value) => value; +const getProto = (v2) => Reflect.getPrototypeOf(v2); +function get(target, key, isReadonly2 = false, isShallow2 = false) { + target = target[ + "__v_raw" + /* ReactiveFlags.RAW */ + ]; + const rawTarget = toRaw(target); + const rawKey = toRaw(key); + if (!isReadonly2) { + if (key !== rawKey) { + track(rawTarget, "get", key); + } + track(rawTarget, "get", rawKey); + } + const { has: has2 } = getProto(rawTarget); + const wrap = isShallow2 ? toShallow : isReadonly2 ? toReadonly : toReactive; + if (has2.call(rawTarget, key)) { + return wrap(target.get(key)); + } else if (has2.call(rawTarget, rawKey)) { + return wrap(target.get(rawKey)); + } else if (target !== rawTarget) { + target.get(key); + } +} +function has(key, isReadonly2 = false) { + const target = this[ + "__v_raw" + /* ReactiveFlags.RAW */ + ]; + const rawTarget = toRaw(target); + const rawKey = toRaw(key); + if (!isReadonly2) { + if (key !== rawKey) { + track(rawTarget, "has", key); + } + track(rawTarget, "has", rawKey); + } + return key === rawKey ? target.has(key) : target.has(key) || target.has(rawKey); +} +function size(target, isReadonly2 = false) { + target = target[ + "__v_raw" + /* ReactiveFlags.RAW */ + ]; + !isReadonly2 && track(toRaw(target), "iterate", ITERATE_KEY); + return Reflect.get(target, "size", target); +} +function add(value) { + value = toRaw(value); + const target = toRaw(this); + const proto = getProto(target); + const hadKey = proto.has.call(target, value); + if (!hadKey) { + target.add(value); + trigger(target, "add", value, value); + } + return this; +} +function set$2(key, value) { + value = toRaw(value); + const target = toRaw(this); + const { has: has2, get: get2 } = getProto(target); + let hadKey = has2.call(target, key); + if (!hadKey) { + key = toRaw(key); + hadKey = has2.call(target, key); + } else { + checkIdentityKeys(target, has2, key); + } + const oldValue = get2.call(target, key); + target.set(key, value); + if (!hadKey) { + trigger(target, "add", key, value); + } else if (hasChanged(value, oldValue)) { + trigger(target, "set", key, value, oldValue); + } + return this; +} +function deleteEntry(key) { + const target = toRaw(this); + const { has: has2, get: get2 } = getProto(target); + let hadKey = has2.call(target, key); + if (!hadKey) { + key = toRaw(key); + hadKey = has2.call(target, key); + } else { + checkIdentityKeys(target, has2, key); + } + const oldValue = get2 ? get2.call(target, key) : void 0; + const result = target.delete(key); + if (hadKey) { + trigger(target, "delete", key, void 0, oldValue); + } + return result; +} +function clear() { + const target = toRaw(this); + const hadItems = target.size !== 0; + const oldTarget = isMap(target) ? new Map(target) : new Set(target); + const result = target.clear(); + if (hadItems) { + trigger(target, "clear", void 0, void 0, oldTarget); + } + return result; +} +function createForEach(isReadonly2, isShallow2) { + return function forEach(callback, thisArg) { + const observed = this; + const target = observed[ + "__v_raw" + /* ReactiveFlags.RAW */ + ]; + const rawTarget = toRaw(target); + const wrap = isShallow2 ? toShallow : isReadonly2 ? toReadonly : toReactive; + !isReadonly2 && track(rawTarget, "iterate", ITERATE_KEY); + return target.forEach((value, key) => { + return callback.call(thisArg, wrap(value), wrap(key), observed); + }); + }; +} +function createIterableMethod(method, isReadonly2, isShallow2) { + return function(...args) { + const target = this[ + "__v_raw" + /* ReactiveFlags.RAW */ + ]; + const rawTarget = toRaw(target); + const targetIsMap = isMap(rawTarget); + const isPair = method === "entries" || method === Symbol.iterator && targetIsMap; + const isKeyOnly = method === "keys" && targetIsMap; + const innerIterator = target[method](...args); + const wrap = isShallow2 ? toShallow : isReadonly2 ? toReadonly : toReactive; + !isReadonly2 && track(rawTarget, "iterate", isKeyOnly ? MAP_KEY_ITERATE_KEY : ITERATE_KEY); + return { + // iterator protocol + next() { + const { value, done } = innerIterator.next(); + return done ? { value, done } : { + value: isPair ? [wrap(value[0]), wrap(value[1])] : wrap(value), + done + }; + }, + // iterable protocol + [Symbol.iterator]() { + return this; + } + }; + }; +} +function createReadonlyMethod(type) { + return function(...args) { + { + const key = args[0] ? `on key "${args[0]}" ` : ``; + console.warn(`${capitalize(type)} operation ${key}failed: target is readonly.`, toRaw(this)); + } + return type === "delete" ? false : this; + }; +} +function createInstrumentations() { + const mutableInstrumentations2 = { + get(key) { + return get(this, key); + }, + get size() { + return size(this); + }, + has, + add, + set: set$2, + delete: deleteEntry, + clear, + forEach: createForEach(false, false) + }; + const shallowInstrumentations2 = { + get(key) { + return get(this, key, false, true); + }, + get size() { + return size(this); + }, + has, + add, + set: set$2, + delete: deleteEntry, + clear, + forEach: createForEach(false, true) + }; + const readonlyInstrumentations2 = { + get(key) { + return get(this, key, true); + }, + get size() { + return size(this, true); + }, + has(key) { + return has.call(this, key, true); + }, + add: createReadonlyMethod( + "add" + /* TriggerOpTypes.ADD */ + ), + set: createReadonlyMethod( + "set" + /* TriggerOpTypes.SET */ + ), + delete: createReadonlyMethod( + "delete" + /* TriggerOpTypes.DELETE */ + ), + clear: createReadonlyMethod( + "clear" + /* TriggerOpTypes.CLEAR */ + ), + forEach: createForEach(true, false) + }; + const shallowReadonlyInstrumentations2 = { + get(key) { + return get(this, key, true, true); + }, + get size() { + return size(this, true); + }, + has(key) { + return has.call(this, key, true); + }, + add: createReadonlyMethod( + "add" + /* TriggerOpTypes.ADD */ + ), + set: createReadonlyMethod( + "set" + /* TriggerOpTypes.SET */ + ), + delete: createReadonlyMethod( + "delete" + /* TriggerOpTypes.DELETE */ + ), + clear: createReadonlyMethod( + "clear" + /* TriggerOpTypes.CLEAR */ + ), + forEach: createForEach(true, true) + }; + const iteratorMethods = ["keys", "values", "entries", Symbol.iterator]; + iteratorMethods.forEach((method) => { + mutableInstrumentations2[method] = createIterableMethod(method, false, false); + readonlyInstrumentations2[method] = createIterableMethod(method, true, false); + shallowInstrumentations2[method] = createIterableMethod(method, false, true); + shallowReadonlyInstrumentations2[method] = createIterableMethod(method, true, true); + }); + return [ + mutableInstrumentations2, + readonlyInstrumentations2, + shallowInstrumentations2, + shallowReadonlyInstrumentations2 + ]; +} +const [mutableInstrumentations, readonlyInstrumentations, shallowInstrumentations, shallowReadonlyInstrumentations] = /* @__PURE__ */ createInstrumentations(); +function createInstrumentationGetter(isReadonly2, shallow) { + const instrumentations = shallow ? isReadonly2 ? shallowReadonlyInstrumentations : shallowInstrumentations : isReadonly2 ? readonlyInstrumentations : mutableInstrumentations; + return (target, key, receiver) => { + if (key === "__v_isReactive") { + return !isReadonly2; + } else if (key === "__v_isReadonly") { + return isReadonly2; + } else if (key === "__v_raw") { + return target; + } + return Reflect.get(hasOwn$1(instrumentations, key) && key in target ? instrumentations : target, key, receiver); + }; +} +const mutableCollectionHandlers = { + get: /* @__PURE__ */ createInstrumentationGetter(false, false) +}; +const shallowCollectionHandlers = { + get: /* @__PURE__ */ createInstrumentationGetter(false, true) +}; +const readonlyCollectionHandlers = { + get: /* @__PURE__ */ createInstrumentationGetter(true, false) +}; +const shallowReadonlyCollectionHandlers = { + get: /* @__PURE__ */ createInstrumentationGetter(true, true) +}; +function checkIdentityKeys(target, has2, key) { + const rawKey = toRaw(key); + if (rawKey !== key && has2.call(target, rawKey)) { + const type = toRawType(target); + console.warn(`Reactive ${type} contains both the raw and reactive versions of the same object${type === `Map` ? ` as keys` : ``}, which can lead to inconsistencies. Avoid differentiating between the raw and reactive versions of an object and only use the reactive version if possible.`); + } +} +const reactiveMap = /* @__PURE__ */ new WeakMap(); +const shallowReactiveMap = /* @__PURE__ */ new WeakMap(); +const readonlyMap = /* @__PURE__ */ new WeakMap(); +const shallowReadonlyMap = /* @__PURE__ */ new WeakMap(); +function targetTypeMap(rawType) { + switch (rawType) { + case "Object": + case "Array": + return 1; + case "Map": + case "Set": + case "WeakMap": + case "WeakSet": + return 2; + default: + return 0; + } +} +function getTargetType(value) { + return value[ + "__v_skip" + /* ReactiveFlags.SKIP */ + ] || !Object.isExtensible(value) ? 0 : targetTypeMap(toRawType(value)); +} +function reactive(target) { + if (isReadonly(target)) { + return target; + } + return createReactiveObject(target, false, mutableHandlers, mutableCollectionHandlers, reactiveMap); +} +function shallowReactive(target) { + return createReactiveObject(target, false, shallowReactiveHandlers, shallowCollectionHandlers, shallowReactiveMap); +} +function readonly(target) { + return createReactiveObject(target, true, readonlyHandlers, readonlyCollectionHandlers, readonlyMap); +} +function shallowReadonly(target) { + return createReactiveObject(target, true, shallowReadonlyHandlers, shallowReadonlyCollectionHandlers, shallowReadonlyMap); +} +function createReactiveObject(target, isReadonly2, baseHandlers, collectionHandlers, proxyMap) { + if (!isObject$1(target)) { + { + console.warn(`value cannot be made reactive: ${String(target)}`); + } + return target; + } + if (target[ + "__v_raw" + /* ReactiveFlags.RAW */ + ] && !(isReadonly2 && target[ + "__v_isReactive" + /* ReactiveFlags.IS_REACTIVE */ + ])) { + return target; + } + const existingProxy = proxyMap.get(target); + if (existingProxy) { + return existingProxy; + } + const targetType = getTargetType(target); + if (targetType === 0) { + return target; + } + const proxy = new Proxy(target, targetType === 2 ? collectionHandlers : baseHandlers); + proxyMap.set(target, proxy); + return proxy; +} +function isReactive(value) { + if (isReadonly(value)) { + return isReactive(value[ + "__v_raw" + /* ReactiveFlags.RAW */ + ]); + } + return !!(value && value[ + "__v_isReactive" + /* ReactiveFlags.IS_REACTIVE */ + ]); +} +function isReadonly(value) { + return !!(value && value[ + "__v_isReadonly" + /* ReactiveFlags.IS_READONLY */ + ]); +} +function isShallow(value) { + return !!(value && value[ + "__v_isShallow" + /* ReactiveFlags.IS_SHALLOW */ + ]); +} +function toRaw(observed) { + const raw = observed && observed[ + "__v_raw" + /* ReactiveFlags.RAW */ + ]; + return raw ? toRaw(raw) : observed; +} +function markRaw(value) { + def(value, "__v_skip", true); + return value; +} +const toReactive = (value) => isObject$1(value) ? reactive(value) : value; +const toReadonly = (value) => isObject$1(value) ? readonly(value) : value; +function trackRefValue(ref2) { + if (shouldTrack && activeEffect) { + ref2 = toRaw(ref2); + { + trackEffects(ref2.dep || (ref2.dep = createDep()), { + target: ref2, + type: "get", + key: "value" + }); + } + } +} +function triggerRefValue(ref2, newVal) { + ref2 = toRaw(ref2); + const dep = ref2.dep; + if (dep) { + { + triggerEffects(dep, { + target: ref2, + type: "set", + key: "value", + newValue: newVal + }); + } + } +} +function isRef(r2) { + return !!(r2 && r2.__v_isRef === true); +} +function ref(value) { + return createRef(value, false); +} +function createRef(rawValue, shallow) { + if (isRef(rawValue)) { + return rawValue; + } + return new RefImpl(rawValue, shallow); +} +class RefImpl { + constructor(value, __v_isShallow) { + this.__v_isShallow = __v_isShallow; + this.dep = void 0; + this.__v_isRef = true; + this._rawValue = __v_isShallow ? value : toRaw(value); + this._value = __v_isShallow ? value : toReactive(value); + } + get value() { + trackRefValue(this); + return this._value; + } + set value(newVal) { + const useDirectValue = this.__v_isShallow || isShallow(newVal) || isReadonly(newVal); + newVal = useDirectValue ? newVal : toRaw(newVal); + if (hasChanged(newVal, this._rawValue)) { + this._rawValue = newVal; + this._value = useDirectValue ? newVal : toReactive(newVal); + triggerRefValue(this, newVal); + } + } +} +function unref(ref2) { + return isRef(ref2) ? ref2.value : ref2; +} +const shallowUnwrapHandlers = { + get: (target, key, receiver) => unref(Reflect.get(target, key, receiver)), + set: (target, key, value, receiver) => { + const oldValue = target[key]; + if (isRef(oldValue) && !isRef(value)) { + oldValue.value = value; + return true; + } else { + return Reflect.set(target, key, value, receiver); + } + } +}; +function proxyRefs(objectWithRefs) { + return isReactive(objectWithRefs) ? objectWithRefs : new Proxy(objectWithRefs, shallowUnwrapHandlers); +} +var _a; +class ComputedRefImpl { + constructor(getter, _setter, isReadonly2, isSSR) { + this._setter = _setter; + this.dep = void 0; + this.__v_isRef = true; + this[_a] = false; + this._dirty = true; + this.effect = new ReactiveEffect(getter, () => { + if (!this._dirty) { + this._dirty = true; + triggerRefValue(this); + } + }); + this.effect.computed = this; + this.effect.active = this._cacheable = !isSSR; + this[ + "__v_isReadonly" + /* ReactiveFlags.IS_READONLY */ + ] = isReadonly2; + } + get value() { + const self = toRaw(this); + trackRefValue(self); + if (self._dirty || !self._cacheable) { + self._dirty = false; + self._value = self.effect.run(); + } + return self._value; + } + set value(newValue) { + this._setter(newValue); + } +} +_a = "__v_isReadonly"; +function computed$1(getterOrOptions, debugOptions, isSSR = false) { + let getter; + let setter; + const onlyGetter = isFunction(getterOrOptions); + if (onlyGetter) { + getter = getterOrOptions; + setter = () => { + console.warn("Write operation failed: computed value is readonly"); + }; + } else { + getter = getterOrOptions.get; + setter = getterOrOptions.set; + } + const cRef = new ComputedRefImpl(getter, setter, onlyGetter || !setter, isSSR); + if (debugOptions && !isSSR) { + cRef.effect.onTrack = debugOptions.onTrack; + cRef.effect.onTrigger = debugOptions.onTrigger; + } + return cRef; +} +const stack = []; +function pushWarningContext(vnode) { + stack.push(vnode); +} +function popWarningContext() { + stack.pop(); +} +function warn(msg, ...args) { + pauseTracking(); + const instance = stack.length ? stack[stack.length - 1].component : null; + const appWarnHandler = instance && instance.appContext.config.warnHandler; + const trace = getComponentTrace(); + if (appWarnHandler) { + callWithErrorHandling(appWarnHandler, instance, 11, [ + msg + args.join(""), + instance && instance.proxy, + trace.map(({ vnode }) => `at <${formatComponentName(instance, vnode.type)}>`).join("\n"), + trace + ]); + } else { + const warnArgs = [`[Vue warn]: ${msg}`, ...args]; + if (trace.length && // avoid spamming console during tests + true) { + warnArgs.push(` +`, ...formatTrace(trace)); + } + console.warn(...warnArgs); + } + resetTracking(); +} +function getComponentTrace() { + let currentVNode = stack[stack.length - 1]; + if (!currentVNode) { + return []; + } + const normalizedStack = []; + while (currentVNode) { + const last = normalizedStack[0]; + if (last && last.vnode === currentVNode) { + last.recurseCount++; + } else { + normalizedStack.push({ + vnode: currentVNode, + recurseCount: 0 + }); + } + const parentInstance = currentVNode.component && currentVNode.component.parent; + currentVNode = parentInstance && parentInstance.vnode; + } + return normalizedStack; +} +function formatTrace(trace) { + const logs = []; + trace.forEach((entry, i2) => { + logs.push(...i2 === 0 ? [] : [` +`], ...formatTraceEntry(entry)); + }); + return logs; +} +function formatTraceEntry({ vnode, recurseCount }) { + const postfix = recurseCount > 0 ? `... (${recurseCount} recursive calls)` : ``; + const isRoot = vnode.component ? vnode.component.parent == null : false; + const open = ` at <${formatComponentName(vnode.component, vnode.type, isRoot)}`; + const close = `>` + postfix; + return vnode.props ? [open, ...formatProps(vnode.props), close] : [open + close]; +} +function formatProps(props) { + const res = []; + const keys = Object.keys(props); + keys.slice(0, 3).forEach((key) => { + res.push(...formatProp(key, props[key])); + }); + if (keys.length > 3) { + res.push(` ...`); + } + return res; +} +function formatProp(key, value, raw) { + if (isString(value)) { + value = JSON.stringify(value); + return raw ? value : [`${key}=${value}`]; + } else if (typeof value === "number" || typeof value === "boolean" || value == null) { + return raw ? value : [`${key}=${value}`]; + } else if (isRef(value)) { + value = formatProp(key, toRaw(value.value), true); + return raw ? value : [`${key}=Ref<`, value, `>`]; + } else if (isFunction(value)) { + return [`${key}=fn${value.name ? `<${value.name}>` : ``}`]; + } else { + value = toRaw(value); + return raw ? value : [`${key}=`, value]; + } +} +const ErrorTypeStrings = { + [ + "sp" + /* LifecycleHooks.SERVER_PREFETCH */ + ]: "serverPrefetch hook", + [ + "bc" + /* LifecycleHooks.BEFORE_CREATE */ + ]: "beforeCreate hook", + [ + "c" + /* LifecycleHooks.CREATED */ + ]: "created hook", + [ + "bm" + /* LifecycleHooks.BEFORE_MOUNT */ + ]: "beforeMount hook", + [ + "m" + /* LifecycleHooks.MOUNTED */ + ]: "mounted hook", + [ + "bu" + /* LifecycleHooks.BEFORE_UPDATE */ + ]: "beforeUpdate hook", + [ + "u" + /* LifecycleHooks.UPDATED */ + ]: "updated", + [ + "bum" + /* LifecycleHooks.BEFORE_UNMOUNT */ + ]: "beforeUnmount hook", + [ + "um" + /* LifecycleHooks.UNMOUNTED */ + ]: "unmounted hook", + [ + "a" + /* LifecycleHooks.ACTIVATED */ + ]: "activated hook", + [ + "da" + /* LifecycleHooks.DEACTIVATED */ + ]: "deactivated hook", + [ + "ec" + /* LifecycleHooks.ERROR_CAPTURED */ + ]: "errorCaptured hook", + [ + "rtc" + /* LifecycleHooks.RENDER_TRACKED */ + ]: "renderTracked hook", + [ + "rtg" + /* LifecycleHooks.RENDER_TRIGGERED */ + ]: "renderTriggered hook", + [ + 0 + /* ErrorCodes.SETUP_FUNCTION */ + ]: "setup function", + [ + 1 + /* ErrorCodes.RENDER_FUNCTION */ + ]: "render function", + [ + 2 + /* ErrorCodes.WATCH_GETTER */ + ]: "watcher getter", + [ + 3 + /* ErrorCodes.WATCH_CALLBACK */ + ]: "watcher callback", + [ + 4 + /* ErrorCodes.WATCH_CLEANUP */ + ]: "watcher cleanup function", + [ + 5 + /* ErrorCodes.NATIVE_EVENT_HANDLER */ + ]: "native event handler", + [ + 6 + /* ErrorCodes.COMPONENT_EVENT_HANDLER */ + ]: "component event handler", + [ + 7 + /* ErrorCodes.VNODE_HOOK */ + ]: "vnode hook", + [ + 8 + /* ErrorCodes.DIRECTIVE_HOOK */ + ]: "directive hook", + [ + 9 + /* ErrorCodes.TRANSITION_HOOK */ + ]: "transition hook", + [ + 10 + /* ErrorCodes.APP_ERROR_HANDLER */ + ]: "app errorHandler", + [ + 11 + /* ErrorCodes.APP_WARN_HANDLER */ + ]: "app warnHandler", + [ + 12 + /* ErrorCodes.FUNCTION_REF */ + ]: "ref function", + [ + 13 + /* ErrorCodes.ASYNC_COMPONENT_LOADER */ + ]: "async component loader", + [ + 14 + /* ErrorCodes.SCHEDULER */ + ]: "scheduler flush. This is likely a Vue internals bug. Please open an issue at https://new-issue.vuejs.org/?repo=vuejs/core" +}; +function callWithErrorHandling(fn, instance, type, args) { + let res; + try { + res = args ? fn(...args) : fn(); + } catch (err) { + handleError(err, instance, type); + } + return res; +} +function callWithAsyncErrorHandling(fn, instance, type, args) { + if (isFunction(fn)) { + const res = callWithErrorHandling(fn, instance, type, args); + if (res && isPromise(res)) { + res.catch((err) => { + handleError(err, instance, type); + }); + } + return res; + } + const values = []; + for (let i2 = 0; i2 < fn.length; i2++) { + values.push(callWithAsyncErrorHandling(fn[i2], instance, type, args)); + } + return values; +} +function handleError(err, instance, type, throwInDev = true) { + const contextVNode = instance ? instance.vnode : null; + if (instance) { + let cur = instance.parent; + const exposedInstance = instance.proxy; + const errorInfo = ErrorTypeStrings[type] || type; + while (cur) { + const errorCapturedHooks = cur.ec; + if (errorCapturedHooks) { + for (let i2 = 0; i2 < errorCapturedHooks.length; i2++) { + if (errorCapturedHooks[i2](err, exposedInstance, errorInfo) === false) { + return; + } + } + } + cur = cur.parent; + } + const appErrorHandler = instance.appContext.config.errorHandler; + if (appErrorHandler) { + callWithErrorHandling(appErrorHandler, null, 10, [err, exposedInstance, errorInfo]); + return; + } + } + logError(err, type, contextVNode, throwInDev); +} +function logError(err, type, contextVNode, throwInDev = true) { + { + const info = ErrorTypeStrings[type] || type; + if (contextVNode) { + pushWarningContext(contextVNode); + } + warn(`Unhandled error${info ? ` during execution of ${info}` : ``}`); + if (contextVNode) { + popWarningContext(); + } + if (throwInDev) { + console.error(err); + } else { + console.error(err); + } + } +} +let isFlushing = false; +let isFlushPending = false; +const queue = []; +let flushIndex = 0; +const pendingPostFlushCbs = []; +let activePostFlushCbs = null; +let postFlushIndex = 0; +const resolvedPromise = /* @__PURE__ */ Promise.resolve(); +let currentFlushPromise = null; +const RECURSION_LIMIT = 100; +function nextTick$1(fn) { + const p2 = currentFlushPromise || resolvedPromise; + return fn ? p2.then(this ? fn.bind(this) : fn) : p2; +} +function findInsertionIndex(id) { + let start = flushIndex + 1; + let end = queue.length; + while (start < end) { + const middle = start + end >>> 1; + const middleJobId = getId(queue[middle]); + middleJobId < id ? start = middle + 1 : end = middle; + } + return start; +} +function queueJob(job) { + if (!queue.length || !queue.includes(job, isFlushing && job.allowRecurse ? flushIndex + 1 : flushIndex)) { + if (job.id == null) { + queue.push(job); + } else { + queue.splice(findInsertionIndex(job.id), 0, job); + } + queueFlush(); + } +} +function queueFlush() { + if (!isFlushing && !isFlushPending) { + isFlushPending = true; + currentFlushPromise = resolvedPromise.then(flushJobs); + } +} +function hasQueueJob(job) { + return queue.indexOf(job) > -1; +} +function invalidateJob(job) { + const i2 = queue.indexOf(job); + if (i2 > flushIndex) { + queue.splice(i2, 1); + } +} +function queuePostFlushCb(cb) { + if (!isArray(cb)) { + if (!activePostFlushCbs || !activePostFlushCbs.includes(cb, cb.allowRecurse ? postFlushIndex + 1 : postFlushIndex)) { + pendingPostFlushCbs.push(cb); + } + } else { + pendingPostFlushCbs.push(...cb); + } + queueFlush(); +} +function flushPreFlushCbs(seen, i2 = isFlushing ? flushIndex + 1 : 0) { + { + seen = seen || /* @__PURE__ */ new Map(); + } + for (; i2 < queue.length; i2++) { + const cb = queue[i2]; + if (cb && cb.pre) { + if (checkRecursiveUpdates(seen, cb)) { + continue; + } + queue.splice(i2, 1); + i2--; + cb(); + } + } +} +function flushPostFlushCbs(seen) { + if (pendingPostFlushCbs.length) { + const deduped = [...new Set(pendingPostFlushCbs)]; + pendingPostFlushCbs.length = 0; + if (activePostFlushCbs) { + activePostFlushCbs.push(...deduped); + return; + } + activePostFlushCbs = deduped; + { + seen = seen || /* @__PURE__ */ new Map(); + } + activePostFlushCbs.sort((a2, b2) => getId(a2) - getId(b2)); + for (postFlushIndex = 0; postFlushIndex < activePostFlushCbs.length; postFlushIndex++) { + if (checkRecursiveUpdates(seen, activePostFlushCbs[postFlushIndex])) { + continue; + } + activePostFlushCbs[postFlushIndex](); + } + activePostFlushCbs = null; + postFlushIndex = 0; + } +} +const getId = (job) => job.id == null ? Infinity : job.id; +const comparator = (a2, b2) => { + const diff2 = getId(a2) - getId(b2); + if (diff2 === 0) { + if (a2.pre && !b2.pre) + return -1; + if (b2.pre && !a2.pre) + return 1; + } + return diff2; +}; +function flushJobs(seen) { + isFlushPending = false; + isFlushing = true; + { + seen = seen || /* @__PURE__ */ new Map(); + } + queue.sort(comparator); + const check = (job) => checkRecursiveUpdates(seen, job); + try { + for (flushIndex = 0; flushIndex < queue.length; flushIndex++) { + const job = queue[flushIndex]; + if (job && job.active !== false) { + if (check(job)) { + continue; + } + callWithErrorHandling( + job, + null, + 14 + /* ErrorCodes.SCHEDULER */ + ); + } + } + } finally { + flushIndex = 0; + queue.length = 0; + flushPostFlushCbs(seen); + isFlushing = false; + currentFlushPromise = null; + if (queue.length || pendingPostFlushCbs.length) { + flushJobs(seen); + } + } +} +function checkRecursiveUpdates(seen, fn) { + if (!seen.has(fn)) { + seen.set(fn, 1); + } else { + const count = seen.get(fn); + if (count > RECURSION_LIMIT) { + const instance = fn.ownerInstance; + const componentName = instance && getComponentName(instance.type); + warn(`Maximum recursive updates exceeded${componentName ? ` in component <${componentName}>` : ``}. This means you have a reactive effect that is mutating its own dependencies and thus recursively triggering itself. Possible sources include component template, render function, updated hook or watcher source function.`); + return true; + } else { + seen.set(fn, count + 1); + } + } +} +let devtools; +let buffer = []; +let devtoolsNotInstalled = false; +function emit$1(event, ...args) { + if (devtools) { + devtools.emit(event, ...args); + } else if (!devtoolsNotInstalled) { + buffer.push({ event, args }); + } +} +function setDevtoolsHook(hook, target) { + var _a2, _b; + devtools = hook; + if (devtools) { + devtools.enabled = true; + buffer.forEach(({ event, args }) => devtools.emit(event, ...args)); + buffer = []; + } else if ( + // handle late devtools injection - only do this if we are in an actual + // browser environment to avoid the timer handle stalling test runner exit + // (#4815) + typeof window !== "undefined" && // some envs mock window but not fully + // eslint-disable-next-line no-restricted-globals + window.HTMLElement && // also exclude jsdom + // eslint-disable-next-line no-restricted-globals + !((_b = (_a2 = window.navigator) === null || _a2 === void 0 ? void 0 : _a2.userAgent) === null || _b === void 0 ? void 0 : _b.includes("jsdom")) + ) { + const replay = target.__VUE_DEVTOOLS_HOOK_REPLAY__ = target.__VUE_DEVTOOLS_HOOK_REPLAY__ || []; + replay.push((newHook) => { + setDevtoolsHook(newHook, target); + }); + setTimeout(() => { + if (!devtools) { + target.__VUE_DEVTOOLS_HOOK_REPLAY__ = null; + devtoolsNotInstalled = true; + buffer = []; + } + }, 3e3); + } else { + devtoolsNotInstalled = true; + buffer = []; + } +} +function devtoolsInitApp(app, version2) { + emit$1("app:init", app, version2, { + Fragment, + Text, + Comment, + Static + }); +} +const devtoolsComponentAdded = /* @__PURE__ */ createDevtoolsComponentHook( + "component:added" + /* DevtoolsHooks.COMPONENT_ADDED */ +); +const devtoolsComponentUpdated = /* @__PURE__ */ createDevtoolsComponentHook( + "component:updated" + /* DevtoolsHooks.COMPONENT_UPDATED */ +); +const _devtoolsComponentRemoved = /* @__PURE__ */ createDevtoolsComponentHook( + "component:removed" + /* DevtoolsHooks.COMPONENT_REMOVED */ +); +const devtoolsComponentRemoved = (component) => { + if (devtools && typeof devtools.cleanupBuffer === "function" && // remove the component if it wasn't buffered + !devtools.cleanupBuffer(component)) { + _devtoolsComponentRemoved(component); + } +}; +function createDevtoolsComponentHook(hook) { + return (component) => { + emit$1( + hook, + component.appContext.app, + component.uid, + // fixed by xxxxxx + // 为 0 是 App，无 parent 是 Page 指向 App + component.uid === 0 ? void 0 : component.parent ? component.parent.uid : 0, + component + ); + }; +} +const devtoolsPerfStart = /* @__PURE__ */ createDevtoolsPerformanceHook( + "perf:start" + /* DevtoolsHooks.PERFORMANCE_START */ +); +const devtoolsPerfEnd = /* @__PURE__ */ createDevtoolsPerformanceHook( + "perf:end" + /* DevtoolsHooks.PERFORMANCE_END */ +); +function createDevtoolsPerformanceHook(hook) { + return (component, type, time) => { + emit$1(hook, component.appContext.app, component.uid, component, type, time); + }; +} +function devtoolsComponentEmit(component, event, params) { + emit$1("component:emit", component.appContext.app, component, event, params); +} +function emit(instance, event, ...rawArgs) { + if (instance.isUnmounted) + return; + const props = instance.vnode.props || EMPTY_OBJ; + { + const { emitsOptions, propsOptions: [propsOptions] } = instance; + if (emitsOptions) { + if (!(event in emitsOptions) && true) { + if (!propsOptions || !(toHandlerKey(event) in propsOptions)) { + warn(`Component emitted event "${event}" but it is neither declared in the emits option nor as an "${toHandlerKey(event)}" prop.`); + } + } else { + const validator = emitsOptions[event]; + if (isFunction(validator)) { + const isValid = validator(...rawArgs); + if (!isValid) { + warn(`Invalid event arguments: event validation failed for event "${event}".`); + } + } + } + } + } + let args = rawArgs; + const isModelListener2 = event.startsWith("update:"); + const modelArg = isModelListener2 && event.slice(7); + if (modelArg && modelArg in props) { + const modifiersKey = `${modelArg === "modelValue" ? "model" : modelArg}Modifiers`; + const { number, trim } = props[modifiersKey] || EMPTY_OBJ; + if (trim) { + args = rawArgs.map((a2) => isString(a2) ? a2.trim() : a2); + } + if (number) { + args = rawArgs.map(looseToNumber); + } + } + { + devtoolsComponentEmit(instance, event, args); + } + { + const lowerCaseEvent = event.toLowerCase(); + if (lowerCaseEvent !== event && props[toHandlerKey(lowerCaseEvent)]) { + warn(`Event "${lowerCaseEvent}" is emitted in component ${formatComponentName(instance, instance.type)} but the handler is registered for "${event}". Note that HTML attributes are case-insensitive and you cannot use v-on to listen to camelCase events when using in-DOM templates. You should probably use "${hyphenate(event)}" instead of "${event}".`); + } + } + let handlerName; + let handler = props[handlerName = toHandlerKey(event)] || // also try camelCase event handler (#2249) + props[handlerName = toHandlerKey(camelize(event))]; + if (!handler && isModelListener2) { + handler = props[handlerName = toHandlerKey(hyphenate(event))]; + } + if (handler) { + callWithAsyncErrorHandling(handler, instance, 6, args); + } + const onceHandler = props[handlerName + `Once`]; + if (onceHandler) { + if (!instance.emitted) { + instance.emitted = {}; + } else if (instance.emitted[handlerName]) { + return; + } + instance.emitted[handlerName] = true; + callWithAsyncErrorHandling(onceHandler, instance, 6, args); + } +} +function normalizeEmitsOptions(comp, appContext, asMixin = false) { + const cache = appContext.emitsCache; + const cached = cache.get(comp); + if (cached !== void 0) { + return cached; + } + const raw = comp.emits; + let normalized = {}; + let hasExtends = false; + if (!isFunction(comp)) { + const extendEmits = (raw2) => { + const normalizedFromExtend = normalizeEmitsOptions(raw2, appContext, true); + if (normalizedFromExtend) { + hasExtends = true; + extend(normalized, normalizedFromExtend); + } + }; + if (!asMixin && appContext.mixins.length) { + appContext.mixins.forEach(extendEmits); + } + if (comp.extends) { + extendEmits(comp.extends); + } + if (comp.mixins) { + comp.mixins.forEach(extendEmits); + } + } + if (!raw && !hasExtends) { + if (isObject$1(comp)) { + cache.set(comp, null); + } + return null; + } + if (isArray(raw)) { + raw.forEach((key) => normalized[key] = null); + } else { + extend(normalized, raw); + } + if (isObject$1(comp)) { + cache.set(comp, normalized); + } + return normalized; +} +function isEmitListener(options, key) { + if (!options || !isOn(key)) { + return false; + } + key = key.slice(2).replace(/Once$/, ""); + return hasOwn$1(options, key[0].toLowerCase() + key.slice(1)) || hasOwn$1(options, hyphenate(key)) || hasOwn$1(options, key); +} +let currentRenderingInstance = null; +function setCurrentRenderingInstance(instance) { + const prev = currentRenderingInstance; + currentRenderingInstance = instance; + instance && instance.type.__scopeId || null; + return prev; +} +function provide(key, value) { + if (!currentInstance) { + { + warn(`provide() can only be used inside setup().`); + } + } else { + let provides = currentInstance.provides; + const parentProvides = currentInstance.parent && currentInstance.parent.provides; + if (parentProvides === provides) { + provides = currentInstance.provides = Object.create(parentProvides); + } + provides[key] = value; + if (currentInstance.type.mpType === "app") { + currentInstance.appContext.app.provide(key, value); + } + } +} +function inject(key, defaultValue, treatDefaultAsFactory = false) { + const instance = currentInstance || currentRenderingInstance; + if (instance) { + const provides = instance.parent == null ? instance.vnode.appContext && instance.vnode.appContext.provides : instance.parent.provides; + if (provides && key in provides) { + return provides[key]; + } else if (arguments.length > 1) { + return treatDefaultAsFactory && isFunction(defaultValue) ? defaultValue.call(instance.proxy) : defaultValue; + } else { + warn(`injection "${String(key)}" not found.`); + } + } else { + warn(`inject() can only be used inside setup() or functional components.`); + } +} +const INITIAL_WATCHER_VALUE = {}; +function watch(source, cb, options) { + if (!isFunction(cb)) { + warn(`\`watch(fn, options?)\` signature has been moved to a separate API. Use \`watchEffect(fn, options?)\` instead. \`watch\` now only supports \`watch(source, cb, options?) signature.`); + } + return doWatch(source, cb, options); +} +function doWatch(source, cb, { immediate, deep, flush, onTrack, onTrigger } = EMPTY_OBJ) { + if (!cb) { + if (immediate !== void 0) { + warn(`watch() "immediate" option is only respected when using the watch(source, callback, options?) signature.`); + } + if (deep !== void 0) { + warn(`watch() "deep" option is only respected when using the watch(source, callback, options?) signature.`); + } + } + const warnInvalidSource = (s2) => { + warn(`Invalid watch source: `, s2, `A watch source can only be a getter/effect function, a ref, a reactive object, or an array of these types.`); + }; + const instance = getCurrentScope() === (currentInstance === null || currentInstance === void 0 ? void 0 : currentInstance.scope) ? currentInstance : null; + let getter; + let forceTrigger = false; + let isMultiSource = false; + if (isRef(source)) { + getter = () => source.value; + forceTrigger = isShallow(source); + } else if (isReactive(source)) { + getter = () => source; + deep = true; + } else if (isArray(source)) { + isMultiSource = true; + forceTrigger = source.some((s2) => isReactive(s2) || isShallow(s2)); + getter = () => source.map((s2) => { + if (isRef(s2)) { + return s2.value; + } else if (isReactive(s2)) { + return traverse(s2); + } else if (isFunction(s2)) { + return callWithErrorHandling( + s2, + instance, + 2 + /* ErrorCodes.WATCH_GETTER */ + ); + } else { + warnInvalidSource(s2); + } + }); + } else if (isFunction(source)) { + if (cb) { + getter = () => callWithErrorHandling( + source, + instance, + 2 + /* ErrorCodes.WATCH_GETTER */ + ); + } else { + getter = () => { + if (instance && instance.isUnmounted) { + return; + } + if (cleanup) { + cleanup(); + } + return callWithAsyncErrorHandling(source, instance, 3, [onCleanup]); + }; + } + } else { + getter = NOOP; + warnInvalidSource(source); + } + if (cb && deep) { + const baseGetter = getter; + getter = () => traverse(baseGetter()); + } + let cleanup; + let onCleanup = (fn) => { + cleanup = effect.onStop = () => { + callWithErrorHandling( + fn, + instance, + 4 + /* ErrorCodes.WATCH_CLEANUP */ + ); + }; + }; + let oldValue = isMultiSource ? new Array(source.length).fill(INITIAL_WATCHER_VALUE) : INITIAL_WATCHER_VALUE; + const job = () => { + if (!effect.active) { + return; + } + if (cb) { + const newValue = effect.run(); + if (deep || forceTrigger || (isMultiSource ? newValue.some((v2, i2) => hasChanged(v2, oldValue[i2])) : hasChanged(newValue, oldValue)) || false) { + if (cleanup) { + cleanup(); + } + callWithAsyncErrorHandling(cb, instance, 3, [ + newValue, + // pass undefined as the old value when it's changed for the first time + oldValue === INITIAL_WATCHER_VALUE ? void 0 : isMultiSource && oldValue[0] === INITIAL_WATCHER_VALUE ? [] : oldValue, + onCleanup + ]); + oldValue = newValue; + } + } else { + effect.run(); + } + }; + job.allowRecurse = !!cb; + let scheduler; + if (flush === "sync") { + scheduler = job; + } else if (flush === "post") { + scheduler = () => queuePostRenderEffect$1(job, instance && instance.suspense); + } else { + job.pre = true; + if (instance) + job.id = instance.uid; + scheduler = () => queueJob(job); + } + const effect = new ReactiveEffect(getter, scheduler); + { + effect.onTrack = onTrack; + effect.onTrigger = onTrigger; + } + if (cb) { + if (immediate) { + job(); + } else { + oldValue = effect.run(); + } + } else if (flush === "post") { + queuePostRenderEffect$1(effect.run.bind(effect), instance && instance.suspense); + } else { + effect.run(); + } + const unwatch = () => { + effect.stop(); + if (instance && instance.scope) { + remove(instance.scope.effects, effect); + } + }; + return unwatch; +} +function instanceWatch(source, value, options) { + const publicThis = this.proxy; + const getter = isString(source) ? source.includes(".") ? createPathGetter(publicThis, source) : () => publicThis[source] : source.bind(publicThis, publicThis); + let cb; + if (isFunction(value)) { + cb = value; + } else { + cb = value.handler; + options = value; + } + const cur = currentInstance; + setCurrentInstance(this); + const res = doWatch(getter, cb.bind(publicThis), options); + if (cur) { + setCurrentInstance(cur); + } else { + unsetCurrentInstance(); + } + return res; +} +function createPathGetter(ctx, path) { + const segments = path.split("."); + return () => { + let cur = ctx; + for (let i2 = 0; i2 < segments.length && cur; i2++) { + cur = cur[segments[i2]]; + } + return cur; + }; +} +function traverse(value, seen) { + if (!isObject$1(value) || value[ + "__v_skip" + /* ReactiveFlags.SKIP */ + ]) { + return value; + } + seen = seen || /* @__PURE__ */ new Set(); + if (seen.has(value)) { + return value; + } + seen.add(value); + if (isRef(value)) { + traverse(value.value, seen); + } else if (isArray(value)) { + for (let i2 = 0; i2 < value.length; i2++) { + traverse(value[i2], seen); + } + } else if (isSet(value) || isMap(value)) { + value.forEach((v2) => { + traverse(v2, seen); + }); + } else if (isPlainObject(value)) { + for (const key in value) { + traverse(value[key], seen); + } + } + return value; +} +const isKeepAlive = (vnode) => vnode.type.__isKeepAlive; +function onActivated(hook, target) { + registerKeepAliveHook(hook, "a", target); +} +function onDeactivated(hook, target) { + registerKeepAliveHook(hook, "da", target); +} +function registerKeepAliveHook(hook, type, target = currentInstance) { + const wrappedHook = hook.__wdc || (hook.__wdc = () => { + let current = target; + while (current) { + if (current.isDeactivated) { + return; + } + current = current.parent; + } + return hook(); + }); + injectHook(type, wrappedHook, target); + if (target) { + let current = target.parent; + while (current && current.parent) { + if (isKeepAlive(current.parent.vnode)) { + injectToKeepAliveRoot(wrappedHook, type, target, current); + } + current = current.parent; + } + } +} +function injectToKeepAliveRoot(hook, type, target, keepAliveRoot) { + const injected = injectHook( + type, + hook, + keepAliveRoot, + true + /* prepend */ + ); + onUnmounted(() => { + remove(keepAliveRoot[type], injected); + }, target); +} +function injectHook(type, hook, target = currentInstance, prepend = false) { + if (target) { + if (isRootHook(type)) { + target = target.root; + } + const hooks = target[type] || (target[type] = []); + const wrappedHook = hook.__weh || (hook.__weh = (...args) => { + if (target.isUnmounted) { + return; + } + pauseTracking(); + setCurrentInstance(target); + const res = callWithAsyncErrorHandling(hook, target, type, args); + unsetCurrentInstance(); + resetTracking(); + return res; + }); + if (prepend) { + hooks.unshift(wrappedHook); + } else { + hooks.push(wrappedHook); + } + return wrappedHook; + } else { + const apiName = toHandlerKey((ErrorTypeStrings[type] || type.replace(/^on/, "")).replace(/ hook$/, "")); + warn(`${apiName} is called when there is no active component instance to be associated with. Lifecycle injection APIs can only be used during execution of setup().`); + } +} +const createHook = (lifecycle) => (hook, target = currentInstance) => ( + // post-create lifecycle registrations are noops during SSR (except for serverPrefetch) + (!isInSSRComponentSetup || lifecycle === "sp") && injectHook(lifecycle, (...args) => hook(...args), target) +); +const onBeforeMount = createHook( + "bm" + /* LifecycleHooks.BEFORE_MOUNT */ +); +const onMounted = createHook( + "m" + /* LifecycleHooks.MOUNTED */ +); +const onBeforeUpdate = createHook( + "bu" + /* LifecycleHooks.BEFORE_UPDATE */ +); +const onUpdated = createHook( + "u" + /* LifecycleHooks.UPDATED */ +); +const onBeforeUnmount = createHook( + "bum" + /* LifecycleHooks.BEFORE_UNMOUNT */ +); +const onUnmounted = createHook( + "um" + /* LifecycleHooks.UNMOUNTED */ +); +const onServerPrefetch = createHook( + "sp" + /* LifecycleHooks.SERVER_PREFETCH */ +); +const onRenderTriggered = createHook( + "rtg" + /* LifecycleHooks.RENDER_TRIGGERED */ +); +const onRenderTracked = createHook( + "rtc" + /* LifecycleHooks.RENDER_TRACKED */ +); +function onErrorCaptured(hook, target = currentInstance) { + injectHook("ec", hook, target); +} +function validateDirectiveName(name) { + if (isBuiltInDirective(name)) { + warn("Do not use built-in directive ids as custom directive id: " + name); + } +} +const getPublicInstance = (i2) => { + if (!i2) + return null; + if (isStatefulComponent(i2)) + return getExposeProxy(i2) || i2.proxy; + return getPublicInstance(i2.parent); +}; +const publicPropertiesMap = ( + // Move PURE marker to new line to workaround compiler discarding it + // due to type annotation + /* @__PURE__ */ extend(/* @__PURE__ */ Object.create(null), { + $: (i2) => i2, + // fixed by xxxxxx vue-i18n 在 dev 模式，访问了 $el，故模拟一个假的 + // $el: i => i.vnode.el, + $el: (i2) => i2.__$el || (i2.__$el = {}), + $data: (i2) => i2.data, + $props: (i2) => shallowReadonly(i2.props), + $attrs: (i2) => shallowReadonly(i2.attrs), + $slots: (i2) => shallowReadonly(i2.slots), + $refs: (i2) => shallowReadonly(i2.refs), + $parent: (i2) => getPublicInstance(i2.parent), + $root: (i2) => getPublicInstance(i2.root), + $emit: (i2) => i2.emit, + $options: (i2) => resolveMergedOptions(i2), + $forceUpdate: (i2) => i2.f || (i2.f = () => queueJob(i2.update)), + // $nextTick: i => i.n || (i.n = nextTick.bind(i.proxy!)),// fixed by xxxxxx + $watch: (i2) => instanceWatch.bind(i2) + }) +); +const isReservedPrefix = (key) => key === "_" || key === "$"; +const hasSetupBinding = (state, key) => state !== EMPTY_OBJ && !state.__isScriptSetup && hasOwn$1(state, key); +const PublicInstanceProxyHandlers = { + get({ _: instance }, key) { + const { ctx, setupState, data, props, accessCache, type, appContext } = instance; + if (key === "__isVue") { + return true; + } + let normalizedProps; + if (key[0] !== "$") { + const n2 = accessCache[key]; + if (n2 !== void 0) { + switch (n2) { + case 1: + return setupState[key]; + case 2: + return data[key]; + case 4: + return ctx[key]; + case 3: + return props[key]; + } + } else if (hasSetupBinding(setupState, key)) { + accessCache[key] = 1; + return setupState[key]; + } else if (data !== EMPTY_OBJ && hasOwn$1(data, key)) { + accessCache[key] = 2; + return data[key]; + } else if ( + // only cache other properties when instance has declared (thus stable) + // props + (normalizedProps = instance.propsOptions[0]) && hasOwn$1(normalizedProps, key) + ) { + accessCache[key] = 3; + return props[key]; + } else if (ctx !== EMPTY_OBJ && hasOwn$1(ctx, key)) { + accessCache[key] = 4; + return ctx[key]; + } else if (shouldCacheAccess) { + accessCache[key] = 0; + } + } + const publicGetter = publicPropertiesMap[key]; + let cssModule, globalProperties; + if (publicGetter) { + if (key === "$attrs") { + track(instance, "get", key); + } + return publicGetter(instance); + } else if ( + // css module (injected by vue-loader) + (cssModule = type.__cssModules) && (cssModule = cssModule[key]) + ) { + return cssModule; + } else if (ctx !== EMPTY_OBJ && hasOwn$1(ctx, key)) { + accessCache[key] = 4; + return ctx[key]; + } else if ( + // global properties + globalProperties = appContext.config.globalProperties, hasOwn$1(globalProperties, key) + ) { + { + return globalProperties[key]; + } + } else if (currentRenderingInstance && (!isString(key) || // #1091 avoid internal isRef/isVNode checks on component instance leading + // to infinite warning loop + key.indexOf("__v") !== 0)) { + if (data !== EMPTY_OBJ && isReservedPrefix(key[0]) && hasOwn$1(data, key)) { + warn(`Property ${JSON.stringify(key)} must be accessed via $data because it starts with a reserved character ("$" or "_") and is not proxied on the render context.`); + } else if (instance === currentRenderingInstance) { + warn(`Property ${JSON.stringify(key)} was accessed during render but is not defined on instance.`); + } + } + }, + set({ _: instance }, key, value) { + const { data, setupState, ctx } = instance; + if (hasSetupBinding(setupState, key)) { + setupState[key] = value; + return true; + } else if (setupState.__isScriptSetup && hasOwn$1(setupState, key)) { + warn(`Cannot mutate