diff --git a/.hbuilderx/launch.json b/.hbuilderx/launch.json new file mode 100644 index 0000000..dd4ad0b --- /dev/null +++ b/.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/App.vue b/App.vue index b9168e8..b04c11b 100644 --- a/App.vue +++ b/App.vue @@ -1,4 +1,5 @@ - + \ No newline at end of file diff --git a/static/done.png b/static/done.png new file mode 100644 index 0000000..ee8747e Binary files /dev/null and b/static/done.png differ diff --git a/static/undone.png b/static/undone.png new file mode 100644 index 0000000..cbec11b Binary files /dev/null and b/static/undone.png differ diff --git a/uni_modules/uni-icons/changelog.md b/uni_modules/uni-icons/changelog.md new file mode 100644 index 0000000..6449885 --- /dev/null +++ b/uni_modules/uni-icons/changelog.md @@ -0,0 +1,22 @@ +## 1.3.5(2022-01-24) +- 优化 size 属性可以传入不带单位的字符串数值 +## 1.3.4(2022-01-24) +- 优化 size 支持其他单位 +## 1.3.3(2022-01-17) +- 修复 nvue 有些图标不显示的bug,兼容老版本图标 +## 1.3.2(2021-12-01) +- 优化 示例可复制图标名称 +## 1.3.1(2021-11-23) +- 优化 兼容旧组件 type 值 +## 1.3.0(2021-11-19) +- 新增 更多图标 +- 优化 自定义图标使用方式 +- 优化 组件UI,并提供设计资源,详见:[https://uniapp.dcloud.io/component/uniui/resource](https://uniapp.dcloud.io/component/uniui/resource) +- 文档迁移,详见:[https://uniapp.dcloud.io/component/uniui/uni-icons](https://uniapp.dcloud.io/component/uniui/uni-icons) +## 1.1.7(2021-11-08) +## 1.2.0(2021-07-30) +- 组件兼容 vue3,如何创建vue3项目,详见 [uni-app 项目支持 vue3 介绍](https://ask.dcloud.net.cn/article/37834) +## 1.1.5(2021-05-12) +- 新增 组件示例地址 +## 1.1.4(2021-02-05) +- 调整为uni_modules目录规范 diff --git a/uni_modules/uni-icons/components/uni-icons/icons.js b/uni_modules/uni-icons/components/uni-icons/icons.js new file mode 100644 index 0000000..7889936 --- /dev/null +++ b/uni_modules/uni-icons/components/uni-icons/icons.js @@ -0,0 +1,1169 @@ +export default { + "id": "2852637", + "name": "uniui图标库", + "font_family": "uniicons", + "css_prefix_text": "uniui-", + "description": "", + "glyphs": [ + { + "icon_id": "25027049", + "name": "yanse", + "font_class": "color", + "unicode": "e6cf", + "unicode_decimal": 59087 + }, + { + "icon_id": "25027048", + "name": "wallet", + "font_class": "wallet", + "unicode": "e6b1", + "unicode_decimal": 59057 + }, + { + "icon_id": "25015720", + "name": "settings-filled", + "font_class": "settings-filled", + "unicode": "e6ce", + "unicode_decimal": 59086 + }, + { + "icon_id": "25015434", + "name": "shimingrenzheng-filled", + "font_class": "auth-filled", + "unicode": "e6cc", + "unicode_decimal": 59084 + }, + { + "icon_id": "24934246", + "name": "shop-filled", + "font_class": "shop-filled", + "unicode": "e6cd", + "unicode_decimal": 59085 + }, + { + "icon_id": "24934159", + "name": "staff-filled-01", + "font_class": "staff-filled", + "unicode": "e6cb", + "unicode_decimal": 59083 + }, + { + "icon_id": "24932461", + "name": "VIP-filled", + "font_class": "vip-filled", + "unicode": "e6c6", + "unicode_decimal": 59078 + }, + { + "icon_id": "24932462", + "name": "plus_circle_fill", + "font_class": "plus-filled", + "unicode": "e6c7", + "unicode_decimal": 59079 + }, + { + "icon_id": "24932463", + "name": "folder_add-filled", + "font_class": "folder-add-filled", + "unicode": "e6c8", + "unicode_decimal": 59080 + }, + { + "icon_id": "24932464", + "name": "yanse-filled", + "font_class": "color-filled", + "unicode": "e6c9", + "unicode_decimal": 59081 + }, + { + "icon_id": "24932465", + "name": "tune-filled", + "font_class": "tune-filled", + "unicode": "e6ca", + "unicode_decimal": 59082 + }, + { + "icon_id": "24932455", + "name": "a-rilidaka-filled", + "font_class": "calendar-filled", + "unicode": "e6c0", + "unicode_decimal": 59072 + }, + { + "icon_id": "24932456", + "name": "notification-filled", + "font_class": "notification-filled", + "unicode": "e6c1", + "unicode_decimal": 59073 + }, + { + "icon_id": "24932457", + "name": "wallet-filled", + "font_class": "wallet-filled", + "unicode": "e6c2", + "unicode_decimal": 59074 + }, + { + "icon_id": "24932458", + "name": "paihangbang-filled", + "font_class": "medal-filled", + "unicode": "e6c3", + "unicode_decimal": 59075 + }, + { + "icon_id": "24932459", + "name": "gift-filled", + "font_class": "gift-filled", + "unicode": "e6c4", + "unicode_decimal": 59076 + }, + { + "icon_id": "24932460", + "name": "fire-filled", + "font_class": "fire-filled", + "unicode": "e6c5", + "unicode_decimal": 59077 + }, + { + "icon_id": "24928001", + "name": "refreshempty", + "font_class": "refreshempty", + "unicode": "e6bf", + "unicode_decimal": 59071 + }, + { + "icon_id": "24926853", + "name": "location-ellipse", + "font_class": "location-filled", + "unicode": "e6af", + "unicode_decimal": 59055 + }, + { + "icon_id": "24926735", + "name": "person-filled", + "font_class": "person-filled", + "unicode": "e69d", + "unicode_decimal": 59037 + }, + { + "icon_id": "24926703", + "name": "personadd-filled", + "font_class": "personadd-filled", + "unicode": "e698", + "unicode_decimal": 59032 + }, + { + "icon_id": "24923351", + "name": "back", + "font_class": "back", + "unicode": "e6b9", + "unicode_decimal": 59065 + }, + { + "icon_id": "24923352", + "name": "forward", + "font_class": "forward", + "unicode": "e6ba", + "unicode_decimal": 59066 + }, + { + "icon_id": "24923353", + "name": "arrowthinright", + "font_class": "arrow-right", + "unicode": "e6bb", + "unicode_decimal": 59067 + }, + { + "icon_id": "24923353", + "name": "arrowthinright", + "font_class": "arrowthinright", + "unicode": "e6bb", + "unicode_decimal": 59067 + }, + { + "icon_id": "24923354", + "name": "arrowthinleft", + "font_class": "arrow-left", + "unicode": "e6bc", + "unicode_decimal": 59068 + }, + { + "icon_id": "24923354", + "name": "arrowthinleft", + "font_class": "arrowthinleft", + "unicode": "e6bc", + "unicode_decimal": 59068 + }, + { + "icon_id": "24923355", + "name": "arrowthinup", + "font_class": "arrow-up", + "unicode": "e6bd", + "unicode_decimal": 59069 + }, + { + "icon_id": "24923355", + "name": "arrowthinup", + "font_class": "arrowthinup", + "unicode": "e6bd", + "unicode_decimal": 59069 + }, + { + "icon_id": "24923356", + "name": "arrowthindown", + "font_class": "arrow-down", + "unicode": "e6be", + "unicode_decimal": 59070 + },{ + "icon_id": "24923356", + "name": "arrowthindown", + "font_class": "arrowthindown", + "unicode": "e6be", + "unicode_decimal": 59070 + }, + { + "icon_id": "24923349", + "name": "arrowdown", + "font_class": "bottom", + "unicode": "e6b8", + "unicode_decimal": 59064 + },{ + "icon_id": "24923349", + "name": "arrowdown", + "font_class": "arrowdown", + "unicode": "e6b8", + "unicode_decimal": 59064 + }, + { + "icon_id": "24923346", + "name": "arrowright", + "font_class": "right", + "unicode": "e6b5", + "unicode_decimal": 59061 + }, + { + "icon_id": "24923346", + "name": "arrowright", + "font_class": "arrowright", + "unicode": "e6b5", + "unicode_decimal": 59061 + }, + { + "icon_id": "24923347", + "name": "arrowup", + "font_class": "top", + "unicode": "e6b6", + "unicode_decimal": 59062 + }, + { + "icon_id": "24923347", + "name": "arrowup", + "font_class": "arrowup", + "unicode": "e6b6", + "unicode_decimal": 59062 + }, + { + "icon_id": "24923348", + "name": "arrowleft", + "font_class": "left", + "unicode": "e6b7", + "unicode_decimal": 59063 + }, + { + "icon_id": "24923348", + "name": "arrowleft", + "font_class": "arrowleft", + "unicode": "e6b7", + "unicode_decimal": 59063 + }, + { + "icon_id": "24923334", + "name": "eye", + "font_class": "eye", + "unicode": "e651", + "unicode_decimal": 58961 + }, + { + "icon_id": "24923335", + "name": "eye-filled", + "font_class": "eye-filled", + "unicode": "e66a", + "unicode_decimal": 58986 + }, + { + "icon_id": "24923336", + "name": "eye-slash", + "font_class": "eye-slash", + "unicode": "e6b3", + "unicode_decimal": 59059 + }, + { + "icon_id": "24923337", + "name": "eye-slash-filled", + "font_class": "eye-slash-filled", + "unicode": "e6b4", + "unicode_decimal": 59060 + }, + { + "icon_id": "24923305", + "name": "info-filled", + "font_class": "info-filled", + "unicode": "e649", + "unicode_decimal": 58953 + }, + { + "icon_id": "24923299", + "name": "reload-01", + "font_class": "reload", + "unicode": "e6b2", + "unicode_decimal": 59058 + }, + { + "icon_id": "24923195", + "name": "mic_slash_fill", + "font_class": "micoff-filled", + "unicode": "e6b0", + "unicode_decimal": 59056 + }, + { + "icon_id": "24923165", + "name": "map-pin-ellipse", + "font_class": "map-pin-ellipse", + "unicode": "e6ac", + "unicode_decimal": 59052 + }, + { + "icon_id": "24923166", + "name": "map-pin", + "font_class": "map-pin", + "unicode": "e6ad", + "unicode_decimal": 59053 + }, + { + "icon_id": "24923167", + "name": "location", + "font_class": "location", + "unicode": "e6ae", + "unicode_decimal": 59054 + }, + { + "icon_id": "24923064", + "name": "starhalf", + "font_class": "starhalf", + "unicode": "e683", + "unicode_decimal": 59011 + }, + { + "icon_id": "24923065", + "name": "star", + "font_class": "star", + "unicode": "e688", + "unicode_decimal": 59016 + }, + { + "icon_id": "24923066", + "name": "star-filled", + "font_class": "star-filled", + "unicode": "e68f", + "unicode_decimal": 59023 + }, + { + "icon_id": "24899646", + "name": "a-rilidaka", + "font_class": "calendar", + "unicode": "e6a0", + "unicode_decimal": 59040 + }, + { + "icon_id": "24899647", + "name": "fire", + "font_class": "fire", + "unicode": "e6a1", + "unicode_decimal": 59041 + }, + { + "icon_id": "24899648", + "name": "paihangbang", + "font_class": "medal", + "unicode": "e6a2", + "unicode_decimal": 59042 + }, + { + "icon_id": "24899649", + "name": "font", + "font_class": "font", + "unicode": "e6a3", + "unicode_decimal": 59043 + }, + { + "icon_id": "24899650", + "name": "gift", + "font_class": "gift", + "unicode": "e6a4", + "unicode_decimal": 59044 + }, + { + "icon_id": "24899651", + "name": "link", + "font_class": "link", + "unicode": "e6a5", + "unicode_decimal": 59045 + }, + { + "icon_id": "24899652", + "name": "notification", + "font_class": "notification", + "unicode": "e6a6", + "unicode_decimal": 59046 + }, + { + "icon_id": "24899653", + "name": "staff", + "font_class": "staff", + "unicode": "e6a7", + "unicode_decimal": 59047 + }, + { + "icon_id": "24899654", + "name": "VIP", + "font_class": "vip", + "unicode": "e6a8", + "unicode_decimal": 59048 + }, + { + "icon_id": "24899655", + "name": "folder_add", + "font_class": "folder-add", + "unicode": "e6a9", + "unicode_decimal": 59049 + }, + { + "icon_id": "24899656", + "name": "tune", + "font_class": "tune", + "unicode": "e6aa", + "unicode_decimal": 59050 + }, + { + "icon_id": "24899657", + "name": "shimingrenzheng", + "font_class": "auth", + "unicode": "e6ab", + "unicode_decimal": 59051 + }, + { + "icon_id": "24899565", + "name": "person", + "font_class": "person", + "unicode": "e699", + "unicode_decimal": 59033 + }, + { + "icon_id": "24899566", + "name": "email-filled", + "font_class": "email-filled", + "unicode": "e69a", + "unicode_decimal": 59034 + }, + { + "icon_id": "24899567", + "name": "phone-filled", + "font_class": "phone-filled", + "unicode": "e69b", + "unicode_decimal": 59035 + }, + { + "icon_id": "24899568", + "name": "phone", + "font_class": "phone", + "unicode": "e69c", + "unicode_decimal": 59036 + }, + { + "icon_id": "24899570", + "name": "email", + "font_class": "email", + "unicode": "e69e", + "unicode_decimal": 59038 + }, + { + "icon_id": "24899571", + "name": "personadd", + "font_class": "personadd", + "unicode": "e69f", + "unicode_decimal": 59039 + }, + { + "icon_id": "24899558", + "name": "chatboxes-filled", + "font_class": "chatboxes-filled", + "unicode": "e692", + "unicode_decimal": 59026 + }, + { + "icon_id": "24899559", + "name": "contact", + "font_class": "contact", + "unicode": "e693", + "unicode_decimal": 59027 + }, + { + "icon_id": "24899560", + "name": "chatbubble-filled", + "font_class": "chatbubble-filled", + "unicode": "e694", + "unicode_decimal": 59028 + }, + { + "icon_id": "24899561", + "name": "contact-filled", + "font_class": "contact-filled", + "unicode": "e695", + "unicode_decimal": 59029 + }, + { + "icon_id": "24899562", + "name": "chatboxes", + "font_class": "chatboxes", + "unicode": "e696", + "unicode_decimal": 59030 + }, + { + "icon_id": "24899563", + "name": "chatbubble", + "font_class": "chatbubble", + "unicode": "e697", + "unicode_decimal": 59031 + }, + { + "icon_id": "24881290", + "name": "upload-filled", + "font_class": "upload-filled", + "unicode": "e68e", + "unicode_decimal": 59022 + }, + { + "icon_id": "24881292", + "name": "upload", + "font_class": "upload", + "unicode": "e690", + "unicode_decimal": 59024 + }, + { + "icon_id": "24881293", + "name": "weixin", + "font_class": "weixin", + "unicode": "e691", + "unicode_decimal": 59025 + }, + { + "icon_id": "24881274", + "name": "compose", + "font_class": "compose", + "unicode": "e67f", + "unicode_decimal": 59007 + }, + { + "icon_id": "24881275", + "name": "qq", + "font_class": "qq", + "unicode": "e680", + "unicode_decimal": 59008 + }, + { + "icon_id": "24881276", + "name": "download-filled", + "font_class": "download-filled", + "unicode": "e681", + "unicode_decimal": 59009 + }, + { + "icon_id": "24881277", + "name": "pengyouquan", + "font_class": "pyq", + "unicode": "e682", + "unicode_decimal": 59010 + }, + { + "icon_id": "24881279", + "name": "sound", + "font_class": "sound", + "unicode": "e684", + "unicode_decimal": 59012 + }, + { + "icon_id": "24881280", + "name": "trash-filled", + "font_class": "trash-filled", + "unicode": "e685", + "unicode_decimal": 59013 + }, + { + "icon_id": "24881281", + "name": "sound-filled", + "font_class": "sound-filled", + "unicode": "e686", + "unicode_decimal": 59014 + }, + { + "icon_id": "24881282", + "name": "trash", + "font_class": "trash", + "unicode": "e687", + "unicode_decimal": 59015 + }, + { + "icon_id": "24881284", + "name": "videocam-filled", + "font_class": "videocam-filled", + "unicode": "e689", + "unicode_decimal": 59017 + }, + { + "icon_id": "24881285", + "name": "spinner-cycle", + "font_class": "spinner-cycle", + "unicode": "e68a", + "unicode_decimal": 59018 + }, + { + "icon_id": "24881286", + "name": "weibo", + "font_class": "weibo", + "unicode": "e68b", + "unicode_decimal": 59019 + }, + { + "icon_id": "24881288", + "name": "videocam", + "font_class": "videocam", + "unicode": "e68c", + "unicode_decimal": 59020 + }, + { + "icon_id": "24881289", + "name": "download", + "font_class": "download", + "unicode": "e68d", + "unicode_decimal": 59021 + }, + { + "icon_id": "24879601", + "name": "help", + "font_class": "help", + "unicode": "e679", + "unicode_decimal": 59001 + }, + { + "icon_id": "24879602", + "name": "navigate-filled", + "font_class": "navigate-filled", + "unicode": "e67a", + "unicode_decimal": 59002 + }, + { + "icon_id": "24879603", + "name": "plusempty", + "font_class": "plusempty", + "unicode": "e67b", + "unicode_decimal": 59003 + }, + { + "icon_id": "24879604", + "name": "smallcircle", + "font_class": "smallcircle", + "unicode": "e67c", + "unicode_decimal": 59004 + }, + { + "icon_id": "24879605", + "name": "minus-filled", + "font_class": "minus-filled", + "unicode": "e67d", + "unicode_decimal": 59005 + }, + { + "icon_id": "24879606", + "name": "micoff", + "font_class": "micoff", + "unicode": "e67e", + "unicode_decimal": 59006 + }, + { + "icon_id": "24879588", + "name": "closeempty", + "font_class": "closeempty", + "unicode": "e66c", + "unicode_decimal": 58988 + }, + { + "icon_id": "24879589", + "name": "clear", + "font_class": "clear", + "unicode": "e66d", + "unicode_decimal": 58989 + }, + { + "icon_id": "24879590", + "name": "navigate", + "font_class": "navigate", + "unicode": "e66e", + "unicode_decimal": 58990 + }, + { + "icon_id": "24879591", + "name": "minus", + "font_class": "minus", + "unicode": "e66f", + "unicode_decimal": 58991 + }, + { + "icon_id": "24879592", + "name": "image", + "font_class": "image", + "unicode": "e670", + "unicode_decimal": 58992 + }, + { + "icon_id": "24879593", + "name": "mic", + "font_class": "mic", + "unicode": "e671", + "unicode_decimal": 58993 + }, + { + "icon_id": "24879594", + "name": "paperplane", + "font_class": "paperplane", + "unicode": "e672", + "unicode_decimal": 58994 + }, + { + "icon_id": "24879595", + "name": "close", + "font_class": "close", + "unicode": "e673", + "unicode_decimal": 58995 + }, + { + "icon_id": "24879596", + "name": "help-filled", + "font_class": "help-filled", + "unicode": "e674", + "unicode_decimal": 58996 + }, + { + "icon_id": "24879597", + "name": "plus-filled", + "font_class": "paperplane-filled", + "unicode": "e675", + "unicode_decimal": 58997 + }, + { + "icon_id": "24879598", + "name": "plus", + "font_class": "plus", + "unicode": "e676", + "unicode_decimal": 58998 + }, + { + "icon_id": "24879599", + "name": "mic-filled", + "font_class": "mic-filled", + "unicode": "e677", + "unicode_decimal": 58999 + }, + { + "icon_id": "24879600", + "name": "image-filled", + "font_class": "image-filled", + "unicode": "e678", + "unicode_decimal": 59000 + }, + { + "icon_id": "24855900", + "name": "locked-filled", + "font_class": "locked-filled", + "unicode": "e668", + "unicode_decimal": 58984 + }, + { + "icon_id": "24855901", + "name": "info", + "font_class": "info", + "unicode": "e669", + "unicode_decimal": 58985 + }, + { + "icon_id": "24855903", + "name": "locked", + "font_class": "locked", + "unicode": "e66b", + "unicode_decimal": 58987 + }, + { + "icon_id": "24855884", + "name": "camera-filled", + "font_class": "camera-filled", + "unicode": "e658", + "unicode_decimal": 58968 + }, + { + "icon_id": "24855885", + "name": "chat-filled", + "font_class": "chat-filled", + "unicode": "e659", + "unicode_decimal": 58969 + }, + { + "icon_id": "24855886", + "name": "camera", + "font_class": "camera", + "unicode": "e65a", + "unicode_decimal": 58970 + }, + { + "icon_id": "24855887", + "name": "circle", + "font_class": "circle", + "unicode": "e65b", + "unicode_decimal": 58971 + }, + { + "icon_id": "24855888", + "name": "checkmarkempty", + "font_class": "checkmarkempty", + "unicode": "e65c", + "unicode_decimal": 58972 + }, + { + "icon_id": "24855889", + "name": "chat", + "font_class": "chat", + "unicode": "e65d", + "unicode_decimal": 58973 + }, + { + "icon_id": "24855890", + "name": "circle-filled", + "font_class": "circle-filled", + "unicode": "e65e", + "unicode_decimal": 58974 + }, + { + "icon_id": "24855891", + "name": "flag", + "font_class": "flag", + "unicode": "e65f", + "unicode_decimal": 58975 + }, + { + "icon_id": "24855892", + "name": "flag-filled", + "font_class": "flag-filled", + "unicode": "e660", + "unicode_decimal": 58976 + }, + { + "icon_id": "24855893", + "name": "gear-filled", + "font_class": "gear-filled", + "unicode": "e661", + "unicode_decimal": 58977 + }, + { + "icon_id": "24855894", + "name": "home", + "font_class": "home", + "unicode": "e662", + "unicode_decimal": 58978 + }, + { + "icon_id": "24855895", + "name": "home-filled", + "font_class": "home-filled", + "unicode": "e663", + "unicode_decimal": 58979 + }, + { + "icon_id": "24855896", + "name": "gear", + "font_class": "gear", + "unicode": "e664", + "unicode_decimal": 58980 + }, + { + "icon_id": "24855897", + "name": "smallcircle-filled", + "font_class": "smallcircle-filled", + "unicode": "e665", + "unicode_decimal": 58981 + }, + { + "icon_id": "24855898", + "name": "map-filled", + "font_class": "map-filled", + "unicode": "e666", + "unicode_decimal": 58982 + }, + { + "icon_id": "24855899", + "name": "map", + "font_class": "map", + "unicode": "e667", + "unicode_decimal": 58983 + }, + { + "icon_id": "24855825", + "name": "refresh-filled", + "font_class": "refresh-filled", + "unicode": "e656", + "unicode_decimal": 58966 + }, + { + "icon_id": "24855826", + "name": "refresh", + "font_class": "refresh", + "unicode": "e657", + "unicode_decimal": 58967 + }, + { + "icon_id": "24855808", + "name": "cloud-upload", + "font_class": "cloud-upload", + "unicode": "e645", + "unicode_decimal": 58949 + }, + { + "icon_id": "24855809", + "name": "cloud-download-filled", + "font_class": "cloud-download-filled", + "unicode": "e646", + "unicode_decimal": 58950 + }, + { + "icon_id": "24855810", + "name": "cloud-download", + "font_class": "cloud-download", + "unicode": "e647", + "unicode_decimal": 58951 + }, + { + "icon_id": "24855811", + "name": "cloud-upload-filled", + "font_class": "cloud-upload-filled", + "unicode": "e648", + "unicode_decimal": 58952 + }, + { + "icon_id": "24855813", + "name": "redo", + "font_class": "redo", + "unicode": "e64a", + "unicode_decimal": 58954 + }, + { + "icon_id": "24855814", + "name": "images-filled", + "font_class": "images-filled", + "unicode": "e64b", + "unicode_decimal": 58955 + }, + { + "icon_id": "24855815", + "name": "undo-filled", + "font_class": "undo-filled", + "unicode": "e64c", + "unicode_decimal": 58956 + }, + { + "icon_id": "24855816", + "name": "more", + "font_class": "more", + "unicode": "e64d", + "unicode_decimal": 58957 + }, + { + "icon_id": "24855817", + "name": "more-filled", + "font_class": "more-filled", + "unicode": "e64e", + "unicode_decimal": 58958 + }, + { + "icon_id": "24855818", + "name": "undo", + "font_class": "undo", + "unicode": "e64f", + "unicode_decimal": 58959 + }, + { + "icon_id": "24855819", + "name": "images", + "font_class": "images", + "unicode": "e650", + "unicode_decimal": 58960 + }, + { + "icon_id": "24855821", + "name": "paperclip", + "font_class": "paperclip", + "unicode": "e652", + "unicode_decimal": 58962 + }, + { + "icon_id": "24855822", + "name": "settings", + "font_class": "settings", + "unicode": "e653", + "unicode_decimal": 58963 + }, + { + "icon_id": "24855823", + "name": "search", + "font_class": "search", + "unicode": "e654", + "unicode_decimal": 58964 + }, + { + "icon_id": "24855824", + "name": "redo-filled", + "font_class": "redo-filled", + "unicode": "e655", + "unicode_decimal": 58965 + }, + { + "icon_id": "24841702", + "name": "list", + "font_class": "list", + "unicode": "e644", + "unicode_decimal": 58948 + }, + { + "icon_id": "24841489", + "name": "mail-open-filled", + "font_class": "mail-open-filled", + "unicode": "e63a", + "unicode_decimal": 58938 + }, + { + "icon_id": "24841491", + "name": "hand-thumbsdown-filled", + "font_class": "hand-down-filled", + "unicode": "e63c", + "unicode_decimal": 58940 + }, + { + "icon_id": "24841492", + "name": "hand-thumbsdown", + "font_class": "hand-down", + "unicode": "e63d", + "unicode_decimal": 58941 + }, + { + "icon_id": "24841493", + "name": "hand-thumbsup-filled", + "font_class": "hand-up-filled", + "unicode": "e63e", + "unicode_decimal": 58942 + }, + { + "icon_id": "24841494", + "name": "hand-thumbsup", + "font_class": "hand-up", + "unicode": "e63f", + "unicode_decimal": 58943 + }, + { + "icon_id": "24841496", + "name": "heart-filled", + "font_class": "heart-filled", + "unicode": "e641", + "unicode_decimal": 58945 + }, + { + "icon_id": "24841498", + "name": "mail-open", + "font_class": "mail-open", + "unicode": "e643", + "unicode_decimal": 58947 + }, + { + "icon_id": "24841488", + "name": "heart", + "font_class": "heart", + "unicode": "e639", + "unicode_decimal": 58937 + }, + { + "icon_id": "24839963", + "name": "loop", + "font_class": "loop", + "unicode": "e633", + "unicode_decimal": 58931 + }, + { + "icon_id": "24839866", + "name": "pulldown", + "font_class": "pulldown", + "unicode": "e632", + "unicode_decimal": 58930 + }, + { + "icon_id": "24813798", + "name": "scan", + "font_class": "scan", + "unicode": "e62a", + "unicode_decimal": 58922 + }, + { + "icon_id": "24813786", + "name": "bars", + "font_class": "bars", + "unicode": "e627", + "unicode_decimal": 58919 + }, + { + "icon_id": "24813788", + "name": "cart-filled", + "font_class": "cart-filled", + "unicode": "e629", + "unicode_decimal": 58921 + }, + { + "icon_id": "24813790", + "name": "checkbox", + "font_class": "checkbox", + "unicode": "e62b", + "unicode_decimal": 58923 + }, + { + "icon_id": "24813791", + "name": "checkbox-filled", + "font_class": "checkbox-filled", + "unicode": "e62c", + "unicode_decimal": 58924 + }, + { + "icon_id": "24813794", + "name": "shop", + "font_class": "shop", + "unicode": "e62f", + "unicode_decimal": 58927 + }, + { + "icon_id": "24813795", + "name": "headphones", + "font_class": "headphones", + "unicode": "e630", + "unicode_decimal": 58928 + }, + { + "icon_id": "24813796", + "name": "cart", + "font_class": "cart", + "unicode": "e631", + "unicode_decimal": 58929 + } + ] +} diff --git a/uni_modules/uni-icons/components/uni-icons/uni-icons.vue b/uni_modules/uni-icons/components/uni-icons/uni-icons.vue new file mode 100644 index 0000000..a87f68e --- /dev/null +++ b/uni_modules/uni-icons/components/uni-icons/uni-icons.vue @@ -0,0 +1,96 @@ + + + + + diff --git a/uni_modules/uni-icons/components/uni-icons/uniicons.css b/uni_modules/uni-icons/components/uni-icons/uniicons.css new file mode 100644 index 0000000..2f56eab --- /dev/null +++ b/uni_modules/uni-icons/components/uni-icons/uniicons.css @@ -0,0 +1,663 @@ +.uniui-color:before { + content: "\e6cf"; +} + +.uniui-wallet:before { + content: "\e6b1"; +} + +.uniui-settings-filled:before { + content: "\e6ce"; +} + +.uniui-auth-filled:before { + content: "\e6cc"; +} + +.uniui-shop-filled:before { + content: "\e6cd"; +} + +.uniui-staff-filled:before { + content: "\e6cb"; +} + +.uniui-vip-filled:before { + content: "\e6c6"; +} + +.uniui-plus-filled:before { + content: "\e6c7"; +} + +.uniui-folder-add-filled:before { + content: "\e6c8"; +} + +.uniui-color-filled:before { + content: "\e6c9"; +} + +.uniui-tune-filled:before { + content: "\e6ca"; +} + +.uniui-calendar-filled:before { + content: "\e6c0"; +} + +.uniui-notification-filled:before { + content: "\e6c1"; +} + +.uniui-wallet-filled:before { + content: "\e6c2"; +} + +.uniui-medal-filled:before { + content: "\e6c3"; +} + +.uniui-gift-filled:before { + content: "\e6c4"; +} + +.uniui-fire-filled:before { + content: "\e6c5"; +} + +.uniui-refreshempty:before { + content: "\e6bf"; +} + +.uniui-location-filled:before { + content: "\e6af"; +} + +.uniui-person-filled:before { + content: "\e69d"; +} + +.uniui-personadd-filled:before { + content: "\e698"; +} + +.uniui-back:before { + content: "\e6b9"; +} + +.uniui-forward:before { + content: "\e6ba"; +} + +.uniui-arrow-right:before { + content: "\e6bb"; +} + +.uniui-arrowthinright:before { + content: "\e6bb"; +} + +.uniui-arrow-left:before { + content: "\e6bc"; +} + +.uniui-arrowthinleft:before { + content: "\e6bc"; +} + +.uniui-arrow-up:before { + content: "\e6bd"; +} + +.uniui-arrowthinup:before { + content: "\e6bd"; +} + +.uniui-arrow-down:before { + content: "\e6be"; +} + +.uniui-arrowthindown:before { + content: "\e6be"; +} + +.uniui-bottom:before { + content: "\e6b8"; +} + +.uniui-arrowdown:before { + content: "\e6b8"; +} + +.uniui-right:before { + content: "\e6b5"; +} + +.uniui-arrowright:before { + content: "\e6b5"; +} + +.uniui-top:before { + content: "\e6b6"; +} + +.uniui-arrowup:before { + content: "\e6b6"; +} + +.uniui-left:before { + content: "\e6b7"; +} + +.uniui-arrowleft:before { + content: "\e6b7"; +} + +.uniui-eye:before { + content: "\e651"; +} + +.uniui-eye-filled:before { + content: "\e66a"; +} + +.uniui-eye-slash:before { + content: "\e6b3"; +} + +.uniui-eye-slash-filled:before { + content: "\e6b4"; +} + +.uniui-info-filled:before { + content: "\e649"; +} + +.uniui-reload:before { + content: "\e6b2"; +} + +.uniui-micoff-filled:before { + content: "\e6b0"; +} + +.uniui-map-pin-ellipse:before { + content: "\e6ac"; +} + +.uniui-map-pin:before { + content: "\e6ad"; +} + +.uniui-location:before { + content: "\e6ae"; +} + +.uniui-starhalf:before { + content: "\e683"; +} + +.uniui-star:before { + content: "\e688"; +} + +.uniui-star-filled:before { + content: "\e68f"; +} + +.uniui-calendar:before { + content: "\e6a0"; +} + +.uniui-fire:before { + content: "\e6a1"; +} + +.uniui-medal:before { + content: "\e6a2"; +} + +.uniui-font:before { + content: "\e6a3"; +} + +.uniui-gift:before { + content: "\e6a4"; +} + +.uniui-link:before { + content: "\e6a5"; +} + +.uniui-notification:before { + content: "\e6a6"; +} + +.uniui-staff:before { + content: "\e6a7"; +} + +.uniui-vip:before { + content: "\e6a8"; +} + +.uniui-folder-add:before { + content: "\e6a9"; +} + +.uniui-tune:before { + content: "\e6aa"; +} + +.uniui-auth:before { + content: "\e6ab"; +} + +.uniui-person:before { + content: "\e699"; +} + +.uniui-email-filled:before { + content: "\e69a"; +} + +.uniui-phone-filled:before { + content: "\e69b"; +} + +.uniui-phone:before { + content: "\e69c"; +} + +.uniui-email:before { + content: "\e69e"; +} + +.uniui-personadd:before { + content: "\e69f"; +} + +.uniui-chatboxes-filled:before { + content: "\e692"; +} + +.uniui-contact:before { + content: "\e693"; +} + +.uniui-chatbubble-filled:before { + content: "\e694"; +} + +.uniui-contact-filled:before { + content: "\e695"; +} + +.uniui-chatboxes:before { + content: "\e696"; +} + +.uniui-chatbubble:before { + content: "\e697"; +} + +.uniui-upload-filled:before { + content: "\e68e"; +} + +.uniui-upload:before { + content: "\e690"; +} + +.uniui-weixin:before { + content: "\e691"; +} + +.uniui-compose:before { + content: "\e67f"; +} + +.uniui-qq:before { + content: "\e680"; +} + +.uniui-download-filled:before { + content: "\e681"; +} + +.uniui-pyq:before { + content: "\e682"; +} + +.uniui-sound:before { + content: "\e684"; +} + +.uniui-trash-filled:before { + content: "\e685"; +} + +.uniui-sound-filled:before { + content: "\e686"; +} + +.uniui-trash:before { + content: "\e687"; +} + +.uniui-videocam-filled:before { + content: "\e689"; +} + +.uniui-spinner-cycle:before { + content: "\e68a"; +} + +.uniui-weibo:before { + content: "\e68b"; +} + +.uniui-videocam:before { + content: "\e68c"; +} + +.uniui-download:before { + content: "\e68d"; +} + +.uniui-help:before { + content: "\e679"; +} + +.uniui-navigate-filled:before { + content: "\e67a"; +} + +.uniui-plusempty:before { + content: "\e67b"; +} + +.uniui-smallcircle:before { + content: "\e67c"; +} + +.uniui-minus-filled:before { + content: "\e67d"; +} + +.uniui-micoff:before { + content: "\e67e"; +} + +.uniui-closeempty:before { + content: "\e66c"; +} + +.uniui-clear:before { + content: "\e66d"; +} + +.uniui-navigate:before { + content: "\e66e"; +} + +.uniui-minus:before { + content: "\e66f"; +} + +.uniui-image:before { + content: "\e670"; +} + +.uniui-mic:before { + content: "\e671"; +} + +.uniui-paperplane:before { + content: "\e672"; +} + +.uniui-close:before { + content: "\e673"; +} + +.uniui-help-filled:before { + content: "\e674"; +} + +.uniui-paperplane-filled:before { + content: "\e675"; +} + +.uniui-plus:before { + content: "\e676"; +} + +.uniui-mic-filled:before { + content: "\e677"; +} + +.uniui-image-filled:before { + content: "\e678"; +} + +.uniui-locked-filled:before { + content: "\e668"; +} + +.uniui-info:before { + content: "\e669"; +} + +.uniui-locked:before { + content: "\e66b"; +} + +.uniui-camera-filled:before { + content: "\e658"; +} + +.uniui-chat-filled:before { + content: "\e659"; +} + +.uniui-camera:before { + content: "\e65a"; +} + +.uniui-circle:before { + content: "\e65b"; +} + +.uniui-checkmarkempty:before { + content: "\e65c"; +} + +.uniui-chat:before { + content: "\e65d"; +} + +.uniui-circle-filled:before { + content: "\e65e"; +} + +.uniui-flag:before { + content: "\e65f"; +} + +.uniui-flag-filled:before { + content: "\e660"; +} + +.uniui-gear-filled:before { + content: "\e661"; +} + +.uniui-home:before { + content: "\e662"; +} + +.uniui-home-filled:before { + content: "\e663"; +} + +.uniui-gear:before { + content: "\e664"; +} + +.uniui-smallcircle-filled:before { + content: "\e665"; +} + +.uniui-map-filled:before { + content: "\e666"; +} + +.uniui-map:before { + content: "\e667"; +} + +.uniui-refresh-filled:before { + content: "\e656"; +} + +.uniui-refresh:before { + content: "\e657"; +} + +.uniui-cloud-upload:before { + content: "\e645"; +} + +.uniui-cloud-download-filled:before { + content: "\e646"; +} + +.uniui-cloud-download:before { + content: "\e647"; +} + +.uniui-cloud-upload-filled:before { + content: "\e648"; +} + +.uniui-redo:before { + content: "\e64a"; +} + +.uniui-images-filled:before { + content: "\e64b"; +} + +.uniui-undo-filled:before { + content: "\e64c"; +} + +.uniui-more:before { + content: "\e64d"; +} + +.uniui-more-filled:before { + content: "\e64e"; +} + +.uniui-undo:before { + content: "\e64f"; +} + +.uniui-images:before { + content: "\e650"; +} + +.uniui-paperclip:before { + content: "\e652"; +} + +.uniui-settings:before { + content: "\e653"; +} + +.uniui-search:before { + content: "\e654"; +} + +.uniui-redo-filled:before { + content: "\e655"; +} + +.uniui-list:before { + content: "\e644"; +} + +.uniui-mail-open-filled:before { + content: "\e63a"; +} + +.uniui-hand-down-filled:before { + content: "\e63c"; +} + +.uniui-hand-down:before { + content: "\e63d"; +} + +.uniui-hand-up-filled:before { + content: "\e63e"; +} + +.uniui-hand-up:before { + content: "\e63f"; +} + +.uniui-heart-filled:before { + content: "\e641"; +} + +.uniui-mail-open:before { + content: "\e643"; +} + +.uniui-heart:before { + content: "\e639"; +} + +.uniui-loop:before { + content: "\e633"; +} + +.uniui-pulldown:before { + content: "\e632"; +} + +.uniui-scan:before { + content: "\e62a"; +} + +.uniui-bars:before { + content: "\e627"; +} + +.uniui-cart-filled:before { + content: "\e629"; +} + +.uniui-checkbox:before { + content: "\e62b"; +} + +.uniui-checkbox-filled:before { + content: "\e62c"; +} + +.uniui-shop:before { + content: "\e62f"; +} + +.uniui-headphones:before { + content: "\e630"; +} + +.uniui-cart:before { + content: "\e631"; +} diff --git a/uni_modules/uni-icons/components/uni-icons/uniicons.ttf b/uni_modules/uni-icons/components/uni-icons/uniicons.ttf new file mode 100644 index 0000000..835f33b Binary files /dev/null and b/uni_modules/uni-icons/components/uni-icons/uniicons.ttf differ diff --git a/uni_modules/uni-icons/package.json b/uni_modules/uni-icons/package.json new file mode 100644 index 0000000..d1c4e77 --- /dev/null +++ b/uni_modules/uni-icons/package.json @@ -0,0 +1,86 @@ +{ + "id": "uni-icons", + "displayName": "uni-icons 图标", + "version": "1.3.5", + "description": "图标组件,用于展示移动端常见的图标,可自定义颜色、大小。", + "keywords": [ + "uni-ui", + "uniui", + "icon", + "图标" +], + "repository": "https://github.com/dcloudio/uni-ui", + "engines": { + "HBuilderX": "^3.2.14" + }, + "directories": { + "example": "../../temps/example_temps" + }, + "dcloudext": { + "category": [ + "前端组件", + "通用组件" + ], + "sale": { + "regular": { + "price": "0.00" + }, + "sourcecode": { + "price": "0.00" + } + }, + "contact": { + "qq": "" + }, + "declaration": { + "ads": "无", + "data": "无", + "permissions": "无" + }, + "npmurl": "https://www.npmjs.com/package/@dcloudio/uni-ui" + }, + "uni_modules": { + "dependencies": ["uni-scss"], + "encrypt": [], + "platforms": { + "cloud": { + "tcb": "y", + "aliyun": "y" + }, + "client": { + "App": { + "app-vue": "y", + "app-nvue": "y" + }, + "H5-mobile": { + "Safari": "y", + "Android Browser": "y", + "微信浏览器(Android)": "y", + "QQ浏览器(Android)": "y" + }, + "H5-pc": { + "Chrome": "y", + "IE": "y", + "Edge": "y", + "Firefox": "y", + "Safari": "y" + }, + "小程序": { + "微信": "y", + "阿里": "y", + "百度": "y", + "字节跳动": "y", + "QQ": "y" + }, + "快应用": { + "华为": "u", + "联盟": "u" + }, + "Vue": { + "vue2": "y", + "vue3": "y" + } + } + } + } +} \ No newline at end of file diff --git a/uni_modules/uni-icons/readme.md b/uni_modules/uni-icons/readme.md new file mode 100644 index 0000000..86234ba --- /dev/null +++ b/uni_modules/uni-icons/readme.md @@ -0,0 +1,8 @@ +## Icons 图标 +> **组件名:uni-icons** +> 代码块: `uIcons` + +用于展示 icons 图标 。 + +### [查看文档](https://uniapp.dcloud.io/component/uniui/uni-icons) +#### 如使用过程中有任何问题,或者您对uni-ui有一些好的建议,欢迎加入 uni-ui 交流群:871950839 diff --git a/unpackage/dist/dev/mp-weixin/api/index.js b/unpackage/dist/dev/mp-weixin/api/index.js new file mode 100644 index 0000000..4f304a3 --- /dev/null +++ b/unpackage/dist/dev/mp-weixin/api/index.js @@ -0,0 +1,463 @@ +"use strict"; +const common_vendor = require("../common/vendor.js"); +const api_request = require("./request.js"); +const API = { + //微信登录 + getToken: (data) => api_request.net.POST("/login/token", data), + // 获取token + wx_login: (data, userId) => api_request.net.POST("/user/binding/wechat", data, true, { "userId": userId }), + // 微信登录 + /* + 首页信息 + */ + getIndexInfo: (data) => api_request.net.GET("/api/index/index"), + // 首页信息 + getIndexBanner: (data) => api_request.net.GET("/api/banner/index", data), + // 轮播图 + getIndexNotice: (data) => api_request.net.GET("/api/news/notice"), + // 公告 + getGoodsDetail: (data) => api_request.net.GET("/api/goods/detail", data), + // 商品详情(普通商品) + getSeckillGoodsDetail: (data) => api_request.net.GET("/api/seckill_goods/detail", data), + // 商品详情(秒杀) + getGroupGoodsDetail: (data) => api_request.net.GET("/api/group_goods/detail", data), + // 商品详情(团购) + getGoodsList: (data) => api_request.net.GET("/api/goods/lists", data), + // 商品列表(普通商品) + getSeckillGoodsList: (data) => api_request.net.GET("/api/seckill_goods/lists", data), + // 商品列表(限时) + getGroupGoodsList: (data) => api_request.net.GET("/api/group_goods/lists?page=&keyword=", data), + // 商品列表(团购) + getNewinfo: (data) => api_request.net.GET("/api/goods/getGoodsSpec", data), + // 根据商品规格更新数据 + getCategoryList: (data) => api_request.net.GET("/api/goods_category/lists"), + // 获取商品分类 + getCategory: (data) => api_request.net.GET("/api/goods/category", data), + // 根据分类Id获取分类商品 + getCartList: (data) => api_request.net.GET("/api/cart/lists", data), + // 获取购物车列表 + addCart: (data) => api_request.net.POST("/api/cart/add", data), + // 加入购物车 + delCart: (data) => api_request.net.POST("/api/cart/delete", data), + // 删除购物车 + updateCart: (data) => api_request.net.POST("/api/cart/edit", data), + // 更新购物车 + login: (data) => api_request.net.POST("/api/user/wechatLogin", data), + // 登录 + login_test: (data) => api_request.net.GET("/api/user/testLogin?id=1"), + // 登录 测试专用 + zhuce: (data) => api_request.net.POST("/api/user/profile", data), + // 注册 + getOrderList: (data) => api_request.net.GET("/api/order/lists", data), + //订单列表 + getOrderGroupList: (data) => api_request.net.GET("/api/group_order/lists", data), + //订单列表(团购) + getOrderSeckillList: (data) => api_request.net.GET("/api/seckill_order/lists", data), + //订单列表(秒杀) + pay: (data) => api_request.net.POST("/api/order/pay", data), + //支付 + payGroup: (data) => api_request.net.POST("/api/group_order/pay", data), + //支付(团购) + paySeckill: (data) => api_request.net.POST("/api/seckill_order/pay", data), + //支付(秒杀) + refund: (data) => api_request.net.POST("/api/order/refund", data), + //退款 + getOrderInviteList: (data) => api_request.net.GET("/api/invite/order", data), + //分销订单 + getOrderBaseinfo: (data) => api_request.net.POST("/api/order/preview", data), + //获取订单提交页面的基本信息 + getOrderGroupBaseinfo: (data) => api_request.net.POST("/api/group_order/preview", data), + //获取订单提交页面的基本信息(团购) + getOrderSeckillBaseinfo: (data) => api_request.net.POST("/api/seckill_order/preview", data), + //获取订单提交页面的基本信息(秒杀) + getOrderCartinfo: (data) => api_request.net.POST("/api/order/cartPreview", data), + //获取订单提交页面的基本信息(购物车来的) + getDelivery: (data) => api_request.net.GET("/api/index/delivery", data), + //获取配送相关的选项(普通商品) + staffApply: (data) => api_request.net.POST("/api/invite/apply", data), + //业务员申请 + deliveryApply: (data) => api_request.net.POST("/api/staff/apply", data), + //配送员申请 + getDeliveryArea: (data) => api_request.net.GET("/api/staff/getDeliveryArea"), + //获取配送区域 + getAddressList: (data) => api_request.net.GET("/api/address/lists"), + //地址列表 + getAddDetail: (data) => api_request.net.GET("/api/address/detail", data), + //地址详情 + addAddress: (data) => api_request.net.POST("/api/address/add", data), + //新增地址 + editAddress: (data) => api_request.net.POST("/api/address/edit", data), + //修改地址 + delAddress: (data) => api_request.net.GET("/api/address/delete", data), + //删除地址 + getDefaultAddress: (data) => api_request.net.GET("/api/address/getDefault"), + //获取默认地址 + orderSubmitFunc: (data) => api_request.net.POST("/api/order/order", data), + //提交订单(普通订单) + orderSubmitCartFunc: (data) => api_request.net.POST("/api/order/cartOrder", data), + //提交订单(购物车) + orderSubmitGroupFunc: (data) => api_request.net.POST("/api/group_order/order", data), + //提交订单(团购订单) + orderSubmitSeckillFunc: (data) => api_request.net.POST("/api/seckill_order/order", data), + //提交订单(秒杀订单) + orderDetail: (data) => api_request.net.GET("/api/order/detail", data), + //订单详情-普通订单 (顾客) + orderGroupDetail: (data) => api_request.net.GET("/api/group_order/detail", data), + //订单详情-团购订单 + orderSeckillDetail: (data) => api_request.net.GET("/api/seckill_order/detail", data), + //订单详情-秒杀订单 + orderStaffDetail: (data) => api_request.net.GET("/api/staff/orderDetail", data), + //订单详情-配送订单 + orderLeaderDetail: (data) => api_request.net.GET("/api/leader/orderDetail", data), + //订单详情-管理员订单 + orderCancel: (data) => api_request.net.POST("/api/order/cancle", data), + //取消订单 + orderCancelGroup: (data) => api_request.net.POST("/api/group_order/cancle", data), + //取消订单 (团购) + orderCancelSeckill: (data) => api_request.net.POST("/api/seckill_order/cancle", data), + //取消订单 (秒杀) + /* + 用户相关 + */ + getUserInfo: (data) => api_request.net.GET("/api/user/userInfo", data), + //获取用户信息 + updateUserInfo: (data) => api_request.net.POST("/api/user/profile", data), + //更新用户信息 + rechargeFunc: (data) => api_request.net.POST("/api/recharge/recharge", data), + //充值 + withdrawalFunc: (data) => api_request.net.POST("/api/withdrawl/submit", data), + //提现 + vipBuy: (data) => api_request.net.POST("/api/vip/order", data), + //购买VIP + vipConfig: (data) => api_request.net.GET("/api/vip/config"), + //会员说明 + /* + 优惠券 + */ + getCouponsList: (data) => api_request.net.GET("/api/coupon/userCoupons", data), + //优惠券 + getCouponsCenterList: (data) => api_request.net.GET("/api/coupon/lists", data), + //领券中心 + couponsCenterReceive: (data) => api_request.net.POST("/api/coupon/receive", data), + //领取优惠 + getMyStars: (data) => api_request.net.GET("/api/collect/lists", data), + //我的收藏 + /* + 推广中心 + */ + inviteCenter: (data) => api_request.net.GET("/api/invite/index", data), + //首页 + inviteCenterwithdrawl: (data) => api_request.net.POST("/api/withdrawl/submit", data), + //提现 + inviteCenterwithdrawlDetail: (data) => api_request.net.GET("/api/invite/withdrawlDetail", data), + //提现明细 + inviteCenterwithdrawlRecodes: (data) => api_request.net.GET("/api/invite/record", data), + //提现明细(佣金) + getShareQrcode: (data) => api_request.net.GET("/api/user/getShareQrcode"), + //用户分销二维码 + /* + 配置相关 + */ + getConfig: (data) => api_request.net.GET("/api/index/config"), + setDeliveryTime: (data) => api_request.net.POST("/api/staff/setDeliveryTime", data), + // 设置配送时间 + getDeliveryTime: (data) => api_request.net.GET("/api/staff/getDeliveryTime"), + // 获取配送时间 + getStaffOrder: (data) => api_request.net.GET("/api/staff/orderLists", data), + // 获取订单管理列表(配送员) + getManageOrder: (data) => api_request.net.GET("/api/leader/orderLists", data), + // 获取订单管理列表(团长) + deliveryPhoto: (data) => api_request.net.POST("/api/staff/deliveryPhoto", data), + // 送达拍照 + reveiceOrder: (data) => api_request.net.POST("/api/staff/reveiceOrder", data), + // 接单 + reveiceOrderOk: (data) => api_request.net.POST("/api/leader/assignOrder", data), + // 派单 + getStaffList: (data) => api_request.net.GET("/api/leader/staffList"), + // 配送员列表 + goodsBuyFunc: (data) => api_request.net.POST("/api/leader/goodsBuy", data), + // 商品申购 + getRecordList: (data) => api_request.net.GET("/api/leader/recordList", data), + // 货物入库 + /** + * + * 登录类信息 + * + */ + // 检查更新 + getUpdateVersion: (data) => api_request.net.GET("/api/v1/index/version"), + // 获取定位 + getLocationInfo: (data) => api_request.net.GET("/api/v1/index/ip", data), + // 验证码登陆 + codeLogin: (data) => api_request.net.POST("/code/login", data), + // H5扫码登录邀请接口 + inviteLogin: (data) => api_request.net.POST("/api/v1/invite/login", data), + // 发送手机验证码接口 + sendVerifyCode: (data) => api_request.net.POST("/api/v1/sms/send", { send_type: "student", ...data }), + // 注销账号 + unRegister: (data) => api_request.net.POST("/api/v1/student/delete", data), + // 授权登录 + accessLogin: (data, t = "wx") => api_request.net.POST(`/api/v1/${t}/login`, data), + // 退出登录 + logOut: (data) => api_request.net.POST("/api/v1/code/logout", data), + // 获取省份 + getProvince: (data) => api_request.net.GET("/api/v1/colleges/getProvince", data), + // 根据学员所选择的教学点获取院校列表接口 + collegesList: (data) => api_request.net.GET("/api/v1/colleges/list", data), + // 通过市反查省/自治区/直辖市 + getProvinceByCity: (data) => api_request.net.GET("/api/v1/region/getProvinceByCity", data), + /** + * + * 用户信息 + * + */ + // 学员个人信息接口 + selectUserInfo: (data) => api_request.net.GET("/api/v1/student/info", data), + // 登录成功后填写学员信息接口 + userUpdate: (data) => api_request.net.POST("/api/v1/student/update", data), + // 邀请二维码 + qrcode: (data) => api_request.net.POST("/api/v1/student/invite/qrcode", data), + uploadBase64: (data) => api_request.net.POST("/api/v1/student/uploadBase64", data), + // 获取被邀请人列表接口 + inviteList: (data) => api_request.net.GET("/api/v1/student/invite/list", data), + // 积分列表 + scoreList: (data) => api_request.net.GET("/point", data), + // 余额明细 + balanceList: (data) => api_request.net.POST("/api/v1/balance/detail/get/list", data), + // 模拟测试记录 + recordList: (data) => api_request.net.GET("/api/v1/test-record/mock/examination/record", data), + // 练习题错误集详情 + practiceList: (data) => api_request.net.GET("/api/v1/test-record/practice/list", data), + /** + * + * 首页数据 + * + */ + // 首页配置获取 + indexConfig: (data) => api_request.net.GET("/api/v1/index/config", data), + // 轮播 + // indexBanner: data => net.GET('/app/banner', data), + indexBanner: (data) => api_request.net.POST("/api/v1/index/lbt", data), + // 获取咨询文章列表 + // wzList: data => net.GET('/app/consult-wz', data), + wzList: (data) => api_request.net.POST("/api/v1/index/wz/list", data), + // 获取咨询文章 + // wzInfo: id => net.GET(`/app/consult-wz/${id}`), + wzInfo: (id) => api_request.net.GET(`/api/v1/index/wz/${id}`), + // 获取课程分页 + getCourseList: (data) => api_request.net.GET(`/app/course/page`, data), + // 获取推荐院校列表 + // recommendwzList: data => net.GET('/app/academy', data), + recommendwzList: (data) => api_request.net.POST("/api/v1/index/academy/list", data), + // 获取推荐院校文章 + // recommendwzInfo: id => net.GET(`/app/academy/${id}`), + recommendwzInfo: (id) => api_request.net.GET(`/api/v1/index/academy/${id}`), + // 推荐院校文章阅读量累计 + // recomendaddReadNumber: data => net.PUT('/app/academy/num',data), + recomendaddReadNumber: (data) => api_request.net.POST("/api/v1/index/academy/add/num", data), + //获取考试大纲列表 + syllabusList: (data) => api_request.net.POST("/api/v1/index/syllabus/list", data), + // 搜索 + search: (data) => api_request.net.POST("/api/v1/index/search", data), + // 阅读量累计 + addReadNumber: (data) => api_request.net.PUT("/app/consult-wz/num", data), + // 师资团队列表 + lecturerList: (data) => api_request.net.GET("/api/v1/index/lecturer", data), + // 师资详情 + lecturerDetail: (id) => api_request.net.GET(`/api/v1/index/lecturer/${id}`), + // 获取资料列表 + indexMaterial: (data) => api_request.net.GET("/api/v1/index/material", data), + // indexMaterial: data => net.GET('/app/material', data), + // 获取资料详情 + materialDetail: (data) => api_request.net.GET(`/api/v1/index/material/${data.id}`, { buyer_id: data.buyer_id }), + // 获取精品课程 + indexBoutiqueCourse: (data) => api_request.net.GET("/api/v1/index/boutique/course", data), + // 获取精品课程详情 + boutiqueCourseDetail: (id) => api_request.net.GET(`/api/v1/index/boutique/course/${id}`), + // 获取课程 + courseList: (data) => api_request.net.POST("/api/v1/course/get", data), + // 获取套餐 + comboList: (data) => api_request.net.POST("/api/v1/combo/course/get", data), + // courseList: data => net.GET('/app/course/page', data), + // 获取课程详情 + courseDetail: (id, data) => api_request.net.GET(`/api/v1/course/${id}`, data), + // courseDetail: (id, data) => net.GET(`/app/course`, {id}), + // 获取线下课程 + offlineCourseList: (data) => api_request.net.POST("/api/v1/offline/course/get", data), + // 获取线下课程详情 + offlineCourseDetail: (id) => api_request.net.GET(`/api/v1/offline/course/${id}`), + // 获取套餐课程详情 + getComboDetail: (data) => api_request.net.GET(`/api/v1/combo/course/${data.id}`, { buyer_id: data.buyer_id }), + // 获取直播课列表 + // liveCourseList: data => net.GET('/api/v1/sys-course-live', data), + liveCourseList: (data) => api_request.net.GET("/api/v1/api-live-course", data), + // 直播课详情 + viewCourse: (id, data) => api_request.net.GET("/api/v1/sys-course-live/" + id, { buyer_id: data.buyer_id }), + // 直播课详情 测试 + viewCourse_test: (id, data) => api_request.net.GET("/api/v1/api-live-course/" + id, { buyer_id: data.buyer_id }), + /*题库 管理*/ + //题库 + getQuestionExercise: (data) => api_request.net.GET("/exercises", data), + // 科目 + subjectList: (data) => api_request.net.GET("/api/v1/public/subject", data), + // subjectList: data => net.GET('/app/subject/list', data), + // 获取学员学习列表接口 + learningList: (data) => api_request.net.GET("/api/v1/learning", data), + // 学习课程详情 + learningDetail: (data) => api_request.net.GET(`/api/v1/learning/course/${data}`), + // 学习直播课程详情 + learningLiveDetail: (data) => api_request.net.GET(`/api/v1/learning/course/live/${data}`), + // 学员学习计时接口 + // "time_type": "stop" //计时类型 start-开始计时 stop-停止计时 + studyDuration: (data) => api_request.net.POST("/api/v1/learning/course/duration", data), + // 学习统计API + courseStatistics: (data) => api_request.net.POST("/api/v1/learning/course/statistics", data), + // 题型分类 + questionBankType: (data) => api_request.net.GET("/api/v1/questionBank/type", data), + // 网课、测试、题库详情 + exercisesDetails: (data) => api_request.net.GET(`/api/v1/exercises/detail/${data}`), + // 测试练习题列表 + testList: (data) => api_request.net.GET("/api/v1/exercises/test/list", data), + // 模拟试卷列表 + examinationList: (data) => api_request.net.GET("/api/v1/examination/list", data), + // 获取题库、网课题目列表接口 + exerciseSubjectList: (data) => api_request.net.GET("/api/v1/exercise/subject/list", data), + // 试题分类 + exercisesType: (data) => api_request.net.GET("/api/v1/exercises/type", data), + // 模拟题详情 + examinationDetail: (id) => api_request.net.GET(`/api/v1/examination/detail/${id}`), + // 开始答题 + startTest: (data) => api_request.net.POST("/api/v1/exercises/start/answer", data), + // question_bank_id + // 交卷 + submitTest: (data) => api_request.net.POST("/api/v1/exercises/submit", data), + // 下一题 + nextSubject: (data) => api_request.net.POST("/api/v1/exercises/next", data), + // 重新答题 + againAnswer: (data) => api_request.net.POST("/api/v1/exercises/againAnswer", data), + // 答题成绩报告 + scoreReport: (data) => api_request.net.GET("/api/v1/exercises/achievement/report", data), + // 获取团购列表 + getGroupList: (data) => api_request.net.GET("/api/v1/group/page", data), + // 获取团购详情 + getGroupPurchaseData: (data) => api_request.net.GET("/api/v1/group", data), + //发起拼团 + starGroupPurchase: (data) => api_request.net.POST("/api/v1/group", data), + //加入拼团 + joinGroupPurchase: (data) => api_request.net.POST("/api/v1/group/join", data), + /** + * + * 支付接口 + * + */ + // 支付接口 + wxOrAlipay: (data) => api_request.net.POST("/api/v1/pay", data), + // 获取openid + getOpenID: (data) => { + return common_vendor.index.request({ + url: "https://api.weixin.qq.com/sns/oauth2/access_token", + method: "GET", + // header: { + // ...header, + // ...headers + // }, + data + }); + }, + // 余额支付 + yuePay: (data) => api_request.net.POST("/api/v1/student/pay/balance", data), + //H5下单API + // v3_pay:data => net.POST('https://api.mch.weixin.qq.com/v3/pay/transactions/h5',data) + v3_pay: (data) => { + return common_vendor.index.request({ + url: "https://api.mch.weixin.qq.com/v3/pay/transactions/h5", + method: "POST", + header: { + "Content-Type": "application/json" + }, + data + }); + }, + //测试 + pay_check: (data) => api_request.net.POST("/api/v1/wxpay/check", data), + pay_callback: (data) => api_request.net.POST("/api/v1/wxpay/callback", data), + /** + * + * 地址接口 + * + */ + // 列表 + addressList: (data) => api_request.net.POST("/api/v1/address", data), + // student_id + // 新增/编辑 + addressAction: (data) => api_request.net.POST(`/api/v1/address/add`, data), + editaddressAction: (data) => api_request.net.PUT(`/api/v1/address`, data), + // 删除 + addressDelete: (data) => api_request.net.DELETE("/api/v1/address", data), + // id + /** + * + * 购物车接口 + * + */ + // 列表 + cartList: (data) => api_request.net.POST("/api/v1/shopping/cart", data), + // 添加 + cartAdd: (data) => api_request.net.POST("/api/v1/shopping/cart/add", data), + // 编辑 + cartUpdate: (data) => api_request.net.POST("/api/v1/shopping/cart/update", data), + // 删除 + cartDelete: (data) => api_request.net.POST("/api/v1/shopping/cart/delete", data), + // id + /** + * + * 订单接口 + * + */ + // 订单查询 + orderList: (data) => api_request.net.POST("/api/v1/api-order/get/my/order/list", data), + // 确认收货 + orderUpdate: (data) => api_request.net.POST("/api/v1/api-order/update/material/order", data), + // 删除 + orderDelete: (data) => api_request.net.POST("/api/v1/api-order/delete/order", data), + /** + * 商品价格合计 + * @param { order_count_list: [{ id: '', order_type: '', num: ''}] } + * + */ + orderCount: (data) => api_request.net.POST("/api/v1/api-order/order/count", data), + /** + * 资料,在线课程的立即购买/购物车 + * @param { goods: [{ id: '', order_type: '', num: ''}], student_id: '' } + * + */ + orderBuynow: (data) => api_request.net.POST("/api/v1/api-order/order/buynow", data), + // 新增资料订单 + orderMaterialAdd: (data) => api_request.net.POST("/api/v1/api-order/add/material/order", data), + // 新增在线课程订单 + orderOnlineAdd: (data) => api_request.net.POST("/api/v1/api-order/add/online/order", data), + // 直播课订单 + orderLiveAdd: (data) => api_request.net.POST("/api/v1/api-order/add/live/order", data), + // 新增套餐课程订单 + orderComboAdd: (data) => api_request.net.POST("/api/v1/api-order/add/combo/order", data), + // 新增线下订单==报名 + orderOfflineAdd: (data) => api_request.net.POST("/api/v1/api-order/add/offline/order", data), + // 新增团购订单 + orderGroupAdd: (data) => api_request.net.POST("/api/v1/api-order/add/group/order", data), + // 分享平台 + shareProvider: () => api_request.net.getShareProvider(), + // 支付方式 + paymentProvider: () => api_request.net.getPaymentProvider(), + // 物流查询 + queryKuaidi: (data) => api_request.net.POST("/api/v1/kuaidi/poll/query", data), + // SHARE: () => net.SHARE(), + // 提现 + transfer: (data) => api_request.net.POST("/api/v1/wxpay/transfer", data), + // 获取我的收藏分页列表 + getStarList: (data) => api_request.net.POST("/api/v1/favorite/get", data), + // 取消收藏 + cancelStar: (data) => api_request.net.DELETE("/api/v1/favorite", data), + //添加收藏 + addStar: (data) => api_request.net.POST("/api/v1/favorite", data) +}; +exports.API = API; diff --git a/unpackage/dist/dev/mp-weixin/api/request.js b/unpackage/dist/dev/mp-weixin/api/request.js new file mode 100644 index 0000000..0e6ce17 --- /dev/null +++ b/unpackage/dist/dev/mp-weixin/api/request.js @@ -0,0 +1,194 @@ +"use strict"; +const common_vendor = require("../common/vendor.js"); +const config_index = require("../config/index.js"); +const loginUrl = "pages/user/login"; +const net = { + REQUEST(url, method = "GET", data, checkLogin = true, header) { + let token = common_vendor.index.getStorageSync("access_token") || "Basic ZGV20mRldjEyMw=="; + const headers = { + "Content-Type": "application/json", + // "Content-Type": "application/x-www-form-urlencoded", + "Authorization": token, + "x-token": token, + "token": token + // "X-Forwarded-For":'client_ip' + // 'Referer':'twzxjy.com' + }; + var pages = getCurrentPages(); + var page = pages[pages.length - 1]; + if (!header) { + headers["Content-Type"] = "application/x-www-form-urlencode"; + } + console.log("headers :", headers); + return common_vendor.index.request({ + url: config_index.config.baseUrl + url, + method, + header: { + ...header, + ...headers + }, + data + }).then((res) => { + if (res.statusCode === 200 && res.data) { + if (res.data.code === 409) { + common_vendor.index.showModal({ + title: "提示", + content: "您的账号已在其他设备登录,已强制下线!", + confirmColor: "#006647", + showCancel: false, + success: (res2) => { + if (res2.confirm) { + common_vendor.index.removeStorageSync("access_token"); + common_vendor.index.removeStorageSync("user_info"); + if (checkLogin && page.route != loginUrl) { + common_vendor.index.navigateTo({ + url: "/" + loginUrl + }); + } + } + } + }); + return { + ...res.data + }; + } + if (res.data.code === 5) { + common_vendor.index.removeStorageSync("access_token"); + if (page.route != loginUrl && checkLogin) { + common_vendor.index.navigateTo({ + url: "/" + loginUrl + }); + } + } + return res.data; + } else { + const reg = /abort/; + let code = 0; + let msg = res[0] && res[0].errMsg || "未知错误"; + if (res[0] && res[0].errMsg && reg.test(res[0].errMsg)) { + msg = "网络请求中断"; + } + return { + code, + msg, + data: null + }; + } + }).catch((parmas) => { + return parmas; + }); + }, + GET(url, body, checkLogin = true, header) { + return this.REQUEST(url, "GET", body, checkLogin, header); + }, + POST(url, body, checkLogin = true, header) { + return this.REQUEST(url, "POST", body, checkLogin, header); + }, + PUT(url, body, header) { + return this.REQUEST(url, "PUT", body, header); + }, + DELETE(url, body, header) { + return this.REQUEST(url, "DELETE", body, header); + }, + UPLOAD(data) { + return new Promise((resolve, reject) => { + let token = common_vendor.index.getStorageSync("access_token") || ""; + common_vendor.index.uploadFile({ + ...data, + url: config_index.config.base_url + data.url, + header: { + "Access-Token": token + }, + success(res) { + res.data = JSON.parse(res.data); + if (res.data.code === 401) { + common_vendor.index.removeStorageSync("access_token"); + common_vendor.index.removeStorageSync("userInfo"); + common_vendor.index.navigateTo({ + url: "/pages/login/login" + }); + } + resolve(res); + }, + fail(e) { + console.log(e); + reject(e); + } + }); + }); + }, + getShareProvider: () => { + return common_vendor.index.getProvider({ + service: "share" + }).then((res) => { + let data = []; + for (let i = 0; i < res.provider.length; i++) { + switch (res.provider[i]) { + case "weixin": + data.push({ + name: "微信好友", + id: "weixin", + icon: "/static/wx.png" + }); + data.push({ + name: "朋友圈", + id: "weixin", + type: "WXSenceTimeline", + icon: "/static/pyq.png" + }); + break; + case "qq": + data.push({ + name: "QQ好友", + id: "qq", + icon: "/static/qq.png" + }); + break; + } + } + return data; + }).catch((parmas) => { + return Promise.reject(); + }); + }, + getPaymentProvider: () => { + return common_vendor.index.getProvider({ + service: "payment" + }).then((res) => { + let data = []; + const aliPay = { + name: "支付宝支付", + id: "alipay", + icon: "/static/order/zfbp@3x.png" + }; + const wxPay = { + name: "微信支付", + id: "wxpay", + icon: "/static/order/wxp@3x.png" + }; + const yuePay = { + name: "余额支付", + id: "yepay", + icon: "/static/order/yep@3x.png" + }; + for (let i = 0; i < res[1].provider.length; i++) { + switch (res[1].provider[i]) { + case "alipay": + data.push({ + ...aliPay + }); + break; + case "wxpay": + data.push({ + ...wxPay + }); + break; + } + } + return [...data, yuePay]; + }).catch((parmas) => { + return Promise.reject(); + }); + } +}; +exports.net = net; diff --git a/unpackage/dist/dev/mp-weixin/app.js b/unpackage/dist/dev/mp-weixin/app.js new file mode 100644 index 0000000..26f2973 --- /dev/null +++ b/unpackage/dist/dev/mp-weixin/app.js @@ -0,0 +1,29 @@ +"use strict"; +Object.defineProperty(exports, Symbol.toStringTag, { value: "Module" }); +const common_vendor = require("./common/vendor.js"); +if (!Math) { + "./pages/index/index.js"; + "./pages/wikipedia/index.js"; + "./pages/user/index.js"; +} +const _sfc_main = { + onLaunch: function() { + console.log("App Launch"); + }, + onShow: function() { + console.log("App Show"); + }, + onHide: function() { + console.log("App Hide"); + } +}; +const App = /* @__PURE__ */ common_vendor._export_sfc(_sfc_main, [["__scopeId", "data-v-f13b4d11"], ["__file", "F:/项目2023/视力表/vision-record/App.vue"]]); +function createApp() { + const app = common_vendor.createSSRApp(App); + app.use(common_vendor.createPinia()); + return { + app + }; +} +createApp().app.mount("#app"); +exports.createApp = createApp; diff --git a/unpackage/dist/dev/mp-weixin/app.json b/unpackage/dist/dev/mp-weixin/app.json new file mode 100644 index 0000000..8f785f9 --- /dev/null +++ b/unpackage/dist/dev/mp-weixin/app.json @@ -0,0 +1,40 @@ +{ + "pages": [ + "pages/index/index", + "pages/wikipedia/index", + "pages/user/index" + ], + "window": { + "navigationBarTextStyle": "black", + "navigationBarTitleText": "uni-app", + "navigationBarBackgroundColor": "#F8F8F8", + "backgroundColor": "#F8F8F8" + }, + "tabBar": { + "color": "#999999", + "selectedColor": "#26758d", + "borderStyle": "black", + "backgroundColor": "#ffffff", + "list": [ + { + "pagePath": "pages/index/index", + "iconPath": "static/tabs/home.png", + "selectedIconPath": "static/tabs/home2.png", + "text": "首页" + }, + { + "pagePath": "pages/wikipedia/index", + "iconPath": "static/tabs/order.png", + "selectedIconPath": "static/tabs/order2.png", + "text": "百科" + }, + { + "pagePath": "pages/user/index", + "iconPath": "static/tabs/user.png", + "selectedIconPath": "static/tabs/user2.png", + "text": "我的" + } + ] + }, + "usingComponents": {} +} \ No newline at end of file diff --git a/unpackage/dist/dev/mp-weixin/app.wxss b/unpackage/dist/dev/mp-weixin/app.wxss new file mode 100644 index 0000000..a7333f8 --- /dev/null +++ b/unpackage/dist/dev/mp-weixin/app.wxss @@ -0,0 +1,698 @@ +/** + * 这里是uni-app内置的常用样式变量 + * + * uni-app 官方扩展插件及插件市场(https://ext.dcloud.net.cn)上很多三方插件均使用了这些样式变量 + * 如果你是插件开发者,建议你使用scss预处理,并在插件代码中直接使用这些变量(无需 import 这个文件),方便用户通过搭积木的方式开发整体风格一致的App + * + */ +/** + * 如果你是App开发者(插件使用者),你可以通过修改这些变量来定制自己的插件主题,实现自定义主题功能 + * + * 如果你的项目同样使用了scss预处理,你也可以直接在你的 scss 代码中使用如下变量,同时无需 import 这个文件 + */ +/* 颜色变量 */ +/* 行为相关颜色 */ +/* 文字基本颜色 */ +/* 背景颜色 */ +/* 边框颜色 */ +/* 尺寸变量 */ +/* 文字尺寸 */ +/* 图片尺寸 */ +/* Border Radius */ +/* 水平间距 */ +/* 垂直间距 */ +/* 透明度 */ +/* 文章场景相关 */ +.uniui-color:before { + content: "\e6cf"; +} +.uniui-wallet:before { + content: "\e6b1"; +} +.uniui-settings-filled:before { + content: "\e6ce"; +} +.uniui-auth-filled:before { + content: "\e6cc"; +} +.uniui-shop-filled:before { + content: "\e6cd"; +} +.uniui-staff-filled:before { + content: "\e6cb"; +} +.uniui-vip-filled:before { + content: "\e6c6"; +} +.uniui-plus-filled:before { + content: "\e6c7"; +} +.uniui-folder-add-filled:before { + content: "\e6c8"; +} +.uniui-color-filled:before { + content: "\e6c9"; +} +.uniui-tune-filled:before { + content: "\e6ca"; +} +.uniui-calendar-filled:before { + content: "\e6c0"; +} +.uniui-notification-filled:before { + content: "\e6c1"; +} +.uniui-wallet-filled:before { + content: "\e6c2"; +} +.uniui-medal-filled:before { + content: "\e6c3"; +} +.uniui-gift-filled:before { + content: "\e6c4"; +} +.uniui-fire-filled:before { + content: "\e6c5"; +} +.uniui-refreshempty:before { + content: "\e6bf"; +} +.uniui-location-filled:before { + content: "\e6af"; +} +.uniui-person-filled:before { + content: "\e69d"; +} +.uniui-personadd-filled:before { + content: "\e698"; +} +.uniui-back:before { + content: "\e6b9"; +} +.uniui-forward:before { + content: "\e6ba"; +} +.uniui-arrow-right:before { + content: "\e6bb"; +} +.uniui-arrowthinright:before { + content: "\e6bb"; +} +.uniui-arrow-left:before { + content: "\e6bc"; +} +.uniui-arrowthinleft:before { + content: "\e6bc"; +} +.uniui-arrow-up:before { + content: "\e6bd"; +} +.uniui-arrowthinup:before { + content: "\e6bd"; +} +.uniui-arrow-down:before { + content: "\e6be"; +} +.uniui-arrowthindown:before { + content: "\e6be"; +} +.uniui-bottom:before { + content: "\e6b8"; +} +.uniui-arrowdown:before { + content: "\e6b8"; +} +.uniui-right:before { + content: "\e6b5"; +} +.uniui-arrowright:before { + content: "\e6b5"; +} +.uniui-top:before { + content: "\e6b6"; +} +.uniui-arrowup:before { + content: "\e6b6"; +} +.uniui-left:before { + content: "\e6b7"; +} +.uniui-arrowleft:before { + content: "\e6b7"; +} +.uniui-eye:before { + content: "\e651"; +} +.uniui-eye-filled:before { + content: "\e66a"; +} +.uniui-eye-slash:before { + content: "\e6b3"; +} +.uniui-eye-slash-filled:before { + content: "\e6b4"; +} +.uniui-info-filled:before { + content: "\e649"; +} +.uniui-reload:before { + content: "\e6b2"; +} +.uniui-micoff-filled:before { + content: "\e6b0"; +} +.uniui-map-pin-ellipse:before { + content: "\e6ac"; +} +.uniui-map-pin:before { + content: "\e6ad"; +} +.uniui-location:before { + content: "\e6ae"; +} +.uniui-starhalf:before { + content: "\e683"; +} +.uniui-star:before { + content: "\e688"; +} +.uniui-star-filled:before { + content: "\e68f"; +} +.uniui-calendar:before { + content: "\e6a0"; +} +.uniui-fire:before { + content: "\e6a1"; +} +.uniui-medal:before { + content: "\e6a2"; +} +.uniui-font:before { + content: "\e6a3"; +} +.uniui-gift:before { + content: "\e6a4"; +} +.uniui-link:before { + content: "\e6a5"; +} +.uniui-notification:before { + content: "\e6a6"; +} +.uniui-staff:before { + content: "\e6a7"; +} +.uniui-vip:before { + content: "\e6a8"; +} +.uniui-folder-add:before { + content: "\e6a9"; +} +.uniui-tune:before { + content: "\e6aa"; +} +.uniui-auth:before { + content: "\e6ab"; +} +.uniui-person:before { + content: "\e699"; +} +.uniui-email-filled:before { + content: "\e69a"; +} +.uniui-phone-filled:before { + content: "\e69b"; +} +.uniui-phone:before { + content: "\e69c"; +} +.uniui-email:before { + content: "\e69e"; +} +.uniui-personadd:before { + content: "\e69f"; +} +.uniui-chatboxes-filled:before { + content: "\e692"; +} +.uniui-contact:before { + content: "\e693"; +} +.uniui-chatbubble-filled:before { + content: "\e694"; +} +.uniui-contact-filled:before { + content: "\e695"; +} +.uniui-chatboxes:before { + content: "\e696"; +} +.uniui-chatbubble:before { + content: "\e697"; +} +.uniui-upload-filled:before { + content: "\e68e"; +} +.uniui-upload:before { + content: "\e690"; +} +.uniui-weixin:before { + content: "\e691"; +} +.uniui-compose:before { + content: "\e67f"; +} +.uniui-qq:before { + content: "\e680"; +} +.uniui-download-filled:before { + content: "\e681"; +} +.uniui-pyq:before { + content: "\e682"; +} +.uniui-sound:before { + content: "\e684"; +} +.uniui-trash-filled:before { + content: "\e685"; +} +.uniui-sound-filled:before { + content: "\e686"; +} +.uniui-trash:before { + content: "\e687"; +} +.uniui-videocam-filled:before { + content: "\e689"; +} +.uniui-spinner-cycle:before { + content: "\e68a"; +} +.uniui-weibo:before { + content: "\e68b"; +} +.uniui-videocam:before { + content: "\e68c"; +} +.uniui-download:before { + content: "\e68d"; +} +.uniui-help:before { + content: "\e679"; +} +.uniui-navigate-filled:before { + content: "\e67a"; +} +.uniui-plusempty:before { + content: "\e67b"; +} +.uniui-smallcircle:before { + content: "\e67c"; +} +.uniui-minus-filled:before { + content: "\e67d"; +} +.uniui-micoff:before { + content: "\e67e"; +} +.uniui-closeempty:before { + content: "\e66c"; +} +.uniui-clear:before { + content: "\e66d"; +} +.uniui-navigate:before { + content: "\e66e"; +} +.uniui-minus:before { + content: "\e66f"; +} +.uniui-image:before { + content: "\e670"; +} +.uniui-mic:before { + content: "\e671"; +} +.uniui-paperplane:before { + content: "\e672"; +} +.uniui-close:before { + content: "\e673"; +} +.uniui-help-filled:before { + content: "\e674"; +} +.uniui-paperplane-filled:before { + content: "\e675"; +} +.uniui-plus:before { + content: "\e676"; +} +.uniui-mic-filled:before { + content: "\e677"; +} +.uniui-image-filled:before { + content: "\e678"; +} +.uniui-locked-filled:before { + content: "\e668"; +} +.uniui-info:before { + content: "\e669"; +} +.uniui-locked:before { + content: "\e66b"; +} +.uniui-camera-filled:before { + content: "\e658"; +} +.uniui-chat-filled:before { + content: "\e659"; +} +.uniui-camera:before { + content: "\e65a"; +} +.uniui-circle:before { + content: "\e65b"; +} +.uniui-checkmarkempty:before { + content: "\e65c"; +} +.uniui-chat:before { + content: "\e65d"; +} +.uniui-circle-filled:before { + content: "\e65e"; +} +.uniui-flag:before { + content: "\e65f"; +} +.uniui-flag-filled:before { + content: "\e660"; +} +.uniui-gear-filled:before { + content: "\e661"; +} +.uniui-home:before { + content: "\e662"; +} +.uniui-home-filled:before { + content: "\e663"; +} +.uniui-gear:before { + content: "\e664"; +} +.uniui-smallcircle-filled:before { + content: "\e665"; +} +.uniui-map-filled:before { + content: "\e666"; +} +.uniui-map:before { + content: "\e667"; +} +.uniui-refresh-filled:before { + content: "\e656"; +} +.uniui-refresh:before { + content: "\e657"; +} +.uniui-cloud-upload:before { + content: "\e645"; +} +.uniui-cloud-download-filled:before { + content: "\e646"; +} +.uniui-cloud-download:before { + content: "\e647"; +} +.uniui-cloud-upload-filled:before { + content: "\e648"; +} +.uniui-redo:before { + content: "\e64a"; +} +.uniui-images-filled:before { + content: "\e64b"; +} +.uniui-undo-filled:before { + content: "\e64c"; +} +.uniui-more:before { + content: "\e64d"; +} +.uniui-more-filled:before { + content: "\e64e"; +} +.uniui-undo:before { + content: "\e64f"; +} +.uniui-images:before { + content: "\e650"; +} +.uniui-paperclip:before { + content: "\e652"; +} +.uniui-settings:before { + content: "\e653"; +} +.uniui-search:before { + content: "\e654"; +} +.uniui-redo-filled:before { + content: "\e655"; +} +.uniui-list:before { + content: "\e644"; +} +.uniui-mail-open-filled:before { + content: "\e63a"; +} +.uniui-hand-down-filled:before { + content: "\e63c"; +} +.uniui-hand-down:before { + content: "\e63d"; +} +.uniui-hand-up-filled:before { + content: "\e63e"; +} +.uniui-hand-up:before { + content: "\e63f"; +} +.uniui-heart-filled:before { + content: "\e641"; +} +.uniui-mail-open:before { + content: "\e643"; +} +.uniui-heart:before { + content: "\e639"; +} +.uniui-loop:before { + content: "\e633"; +} +.uniui-pulldown:before { + content: "\e632"; +} +.uniui-scan:before { + content: "\e62a"; +} +.uniui-bars:before { + content: "\e627"; +} +.uniui-cart-filled:before { + content: "\e629"; +} +.uniui-checkbox:before { + content: "\e62b"; +} +.uniui-checkbox-filled:before { + content: "\e62c"; +} +.uniui-shop:before { + content: "\e62f"; +} +.uniui-headphones:before { + content: "\e630"; +} +.uniui-cart:before { + content: "\e631"; +} +@font-face { + font-family: uniicons; + src: url("data:font/ttf;base64,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") format("truetype"); +} +.uni-icons { + font-family: uniicons; + text-decoration: none; + text-align: center; +} +/** + * 这里是uni-app内置的常用样式变量 + * + * uni-app 官方扩展插件及插件市场(https://ext.dcloud.net.cn)上很多三方插件均使用了这些样式变量 + * 如果你是插件开发者,建议你使用scss预处理,并在插件代码中直接使用这些变量(无需 import 这个文件),方便用户通过搭积木的方式开发整体风格一致的App + * + */ +/** + * 如果你是App开发者(插件使用者),你可以通过修改这些变量来定制自己的插件主题,实现自定义主题功能 + * + * 如果你的项目同样使用了scss预处理,你也可以直接在你的 scss 代码中使用如下变量,同时无需 import 这个文件 + */ +/* 颜色变量 */ +/* 行为相关颜色 */ +/* 文字基本颜色 */ +/* 背景颜色 */ +/* 边框颜色 */ +/* 尺寸变量 */ +/* 文字尺寸 */ +/* 图片尺寸 */ +/* Border Radius */ +/* 水平间距 */ +/* 垂直间距 */ +/* 透明度 */ +/* 文章场景相关 */ +/*每个页面公共css */ +.page-bg-gray.data-v-f13b4d11 { + background: #f8f8f8; +} +.page-box.data-v-f13b4d11 { + /* height: 100%; + overflow: scroll; */ + min-height: 100%; +} +uni-page-body.data-v-f13b4d11, page.data-v-f13b4d11 { + height: 100%; +} +page.data-v-f13b4d11 { + font-size: 28rpx; +} +.text-ellipsis-1.data-v-f13b4d11 { + /*超出部分省略号 单行*/ + overflow: hidden; + text-overflow: ellipsis; + -webkit-line-clamp: 1; + display: -webkit-box; + -webkit-box-orient: vertical; + /* min-height: 38rpx; */ +} +.icon-custom.data-v-f13b4d11 { + width: 32rpx; + height: 32rpx; +} +.small-text.data-v-f13b4d11 { + color: gray !important; + font-size: 24rpx; + font-weight: 100 !important; +} +.bold-text.data-v-f13b4d11 { + font-weight: 600; + font-size: 36rpx; +} +.margin-line.data-v-f13b4d11 { + height: 20rpx; + width: 100%; + background-color: #f8f8f8; +} +.clearCss.data-v-f13b4d11 { + opacity: 0 !important; +} +.shim.data-v-f13b4d11 { + /* 垫片 */ + width: 100%; + height: 140rpx; +} +.big-text.data-v-f13b4d11 { + font-size: 80rpx; + /* font-weight: 600; */ +} +.red-text.data-v-f13b4d11 { + color: red; +} +.line.data-v-f13b4d11 { + height: 2rpx; + width: 100%; + background-color: #e7e7e7; +} +.num-show.data-v-f13b4d11 { + position: absolute; + width: 40rpx; + height: 40rpx; + color: white; + background: #7cc4e8; + border-radius: 50%; + display: flex; + align-items: center; + justify-content: center; + top: -24rpx; + right: -10rpx; + border: 2rpx solid white; +} + +/* 通用卡片样式 */ +.u-card.data-v-f13b4d11 { + background-color: white; +} +.u-card .u-card-row.data-v-f13b4d11:last-child { + border-bottom: unset; +} +.u-card .u-card-row.data-v-f13b4d11 { + padding: 40rpx; + border-bottom: 2rpx solid #e7e7e7; +} +.u-card .u-card-row .u-card-row-btn.data-v-f13b4d11 { + color: #086EC7; +} +.u-card .u-card-row .u-card-row-top.data-v-f13b4d11, .u-card .u-card-row .u-card-row-content.data-v-f13b4d11 { + display: flex; + align-items: center; + justify-content: space-between; +} +.u-card .u-card-row .u-card-row-top.data-v-f13b4d11 { + padding-bottom: 40rpx; +} +.u-card .u-card-row .u-card-row-top .u-card-right .u-card-right-btn.data-v-f13b4d11 { + color: #7cc4e8; +} +.u-card .u-card-row .u-card-row-content .u-card-right.data-v-f13b4d11 { + display: flex; +} +.popup-content.data-v-f13b4d11 { + padding-top: 40rpx; + background-color: white; + border-radius: 20rpx 20rpx 0 0; + overflow: scroll; +} +.small-btn-css.data-v-f13b4d11 { + background: #7CC4E8; + color: white; + padding: 6rpx 40rpx; + border-radius: 40rpx; + font-size: 28rpx; + white-space: nowrap; + margin-left: 10rpx; + position: relative; +} +.cancel-btn.data-v-f13b4d11 { + display: block; + margin-top: 20rpx; +} +.cancel-btn .add-btn.data-v-f13b4d11 { + background: white !important; + color: black !important; + border: 2rpx solid #7cc4e8 !important; +} +.invalidCss.data-v-f13b4d11 { + background-color: #767676 !important; +} +.data-v-f13b4d11 .uni-popup__wrapper { + bottom: -34px; +} +.data-v-f13b4d11 .popup-content { + bottom: -34px; + padding-bottom: 34px; + background-color: white; +}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/unpackage/dist/dev/mp-weixin/common/vendor.js b/unpackage/dist/dev/mp-weixin/common/vendor.js new file mode 100644 index 0000000..8fb5b39 --- /dev/null +++ b/unpackage/dist/dev/mp-weixin/common/vendor.js @@ -0,0 +1,7477 @@ +"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 i = 0; i < list.length; i++) { + map[list[i]] = true; + } + return expectsLowerCase ? (val) => !!map[val.toLowerCase()] : (val) => !!map[val]; +} +function normalizeStyle(value) { + if (isArray(value)) { + const res = {}; + for (let i = 0; i < value.length; i++) { + const item = value[i]; + const normalized = isString(item) ? parseStringStyle(item) : normalizeStyle(item); + if (normalized) { + for (const key in normalized) { + res[key] = normalized[key]; + } + } + } + return res; + } else if (isString(value)) { + return value; + } else if (isObject(value)) { + return value; + } +} +const listDelimiterRE = /;(?![^(]*\))/g; +const propertyDelimiterRE = /:([^]+)/; +const styleCommentRE = /\/\*.*?\*\//gs; +function parseStringStyle(cssText) { + const ret = {}; + cssText.replace(styleCommentRE, "").split(listDelimiterRE).forEach((item) => { + if (item) { + const tmp = item.split(propertyDelimiterRE); + tmp.length > 1 && (ret[tmp[0].trim()] = tmp[1].trim()); + } + }); + return ret; +} +function normalizeClass(value) { + let res = ""; + if (isString(value)) { + res = value; + } else if (isArray(value)) { + for (let i = 0; i < value.length; i++) { + const normalized = normalizeClass(value[i]); + if (normalized) { + res += normalized + " "; + } + } + } else if (isObject(value)) { + for (const name in value) { + if (value[name]) { + res += name + " "; + } + } + } + return res.trim(); +} +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 i = arr.indexOf(el); + if (i > -1) { + arr.splice(i, 1); + } +}; +const hasOwnProperty$1 = Object.prototype.hasOwnProperty; +const hasOwn = (val, key) => hasOwnProperty$1.call(val, key); +const isArray = Array.isArray; +const isMap = (val) => toTypeString(val) === "[object Map]"; +const isSet = (val) => toTypeString(val) === "[object Set]"; +const isFunction = (val) => typeof val === "function"; +const isString = (val) => typeof val === "string"; +const isSymbol = (val) => typeof val === "symbol"; +const isObject = (val) => val !== null && typeof val === "object"; +const isPromise = (val) => { + return isObject(val) && isFunction(val.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$1 = (val) => toTypeString(val) === "[object Object]"; +const isIntegerKey = (key) => isString(key) && key !== "NaN" && key[0] !== "-" && "" + parseInt(key, 10) === key; +const isReservedProp = /* @__PURE__ */ makeMap( + // the leading comma is intentional so empty string "" is also included + ",key,ref,ref_for,ref_key,onVnodeBeforeMount,onVnodeMounted,onVnodeBeforeUpdate,onVnodeUpdated,onVnodeBeforeUnmount,onVnodeUnmounted" +); +const isBuiltInDirective = /* @__PURE__ */ makeMap("bind,cloak,else-if,else,for,html,if,model,on,once,pre,show,slot,text,memo"); +const cacheStringFunction = (fn) => { + const cache = /* @__PURE__ */ Object.create(null); + return (str) => { + const hit = cache[str]; + return hit || (cache[str] = fn(str)); + }; +}; +const camelizeRE = /-(\w)/g; +const camelize = cacheStringFunction((str) => { + return str.replace(camelizeRE, (_, c) => c ? c.toUpperCase() : ""); +}); +const hyphenateRE = /\B([A-Z])/g; +const hyphenate = cacheStringFunction((str) => str.replace(hyphenateRE, "-$1").toLowerCase()); +const capitalize = cacheStringFunction((str) => 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 i = 0; i < fns.length; i++) { + fns[i](arg); + } +}; +const def = (obj, key, value) => { + Object.defineProperty(obj, key, { + configurable: true, + enumerable: false, + value + }); +}; +const looseToNumber = (val) => { + const 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 i = 0; i < fns.length; i++) { + ret = fns[i](arg); + } + return ret; +}; +function once(fn, ctx = null) { + let res; + return (...args) => { + if (fn) { + res = fn.apply(ctx, args); + fn = null; + } + return res; + }; +} +function getValueByDataPath(obj, path) { + if (!isString(path)) { + return; + } + path = path.replace(/\[(\d+)\]/g, ".$1"); + const parts = path.split("."); + let key = parts[0]; + if (!obj) { + obj = {}; + } + if (parts.length === 1) { + return obj[key]; + } + return getValueByDataPath(obj[key], parts.slice(1).join(".")); +} +function sortObject(obj) { + let sortObj = {}; + if (isPlainObject$1(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$1(val)) { + val = JSON.stringify(val); + } + return encodeStr(key) + "=" + encodeStr(val); + }).filter((x) => x.length > 0).join("&") : null; + return res ? `?${res}` : ""; +} +const PAGE_HOOKS = [ + ON_INIT, + ON_LOAD, + ON_SHOW, + ON_HIDE, + ON_UNLOAD, + ON_BACK_PRESS, + ON_PAGE_SCROLL, + ON_TAB_ITEM_TAP, + ON_REACH_BOTTOM, + ON_PULL_DOWN_REFRESH, + ON_SHARE_TIMELINE, + ON_SHARE_APP_MESSAGE, + ON_ADD_TO_FAVORITES, + ON_SAVE_EXIT_STATE, + ON_NAVIGATION_BAR_BUTTON_TAP, + ON_NAVIGATION_BAR_SEARCH_INPUT_CLICKED, + ON_NAVIGATION_BAR_SEARCH_INPUT_CHANGED, + ON_NAVIGATION_BAR_SEARCH_INPUT_CONFIRMED, + ON_NAVIGATION_BAR_SEARCH_INPUT_FOCUS_CHANGED +]; +function isRootHook(name) { + return PAGE_HOOKS.indexOf(name) > -1; +} +const UniLifecycleHooks = [ + ON_SHOW, + ON_HIDE, + ON_LAUNCH, + ON_ERROR, + ON_THEME_CHANGE, + ON_PAGE_NOT_FOUND, + ON_UNHANDLE_REJECTION, + ON_INIT, + ON_LOAD, + ON_READY, + ON_UNLOAD, + ON_RESIZE, + ON_BACK_PRESS, + ON_PAGE_SCROLL, + ON_TAB_ITEM_TAP, + ON_REACH_BOTTOM, + ON_PULL_DOWN_REFRESH, + ON_SHARE_TIMELINE, + ON_ADD_TO_FAVORITES, + ON_SHARE_APP_MESSAGE, + ON_SAVE_EXIT_STATE, + ON_NAVIGATION_BAR_BUTTON_TAP, + ON_NAVIGATION_BAR_SEARCH_INPUT_CLICKED, + ON_NAVIGATION_BAR_SEARCH_INPUT_CHANGED, + ON_NAVIGATION_BAR_SEARCH_INPUT_CONFIRMED, + ON_NAVIGATION_BAR_SEARCH_INPUT_FOCUS_CHANGED +]; +const MINI_PROGRAM_PAGE_RUNTIME_HOOKS = /* @__PURE__ */ (() => { + return { + onPageScroll: 1, + onShareAppMessage: 1 << 1, + onShareTimeline: 1 << 2 + }; +})(); +function isUniLifecycleHook(name, value, checkType = true) { + if (checkType && !isFunction(value)) { + return false; + } + if (UniLifecycleHooks.indexOf(name) > -1) { + return true; + } else if (name.indexOf("on") === 0) { + return true; + } + return false; +} +let vueApp; +const createVueAppHooks = []; +function onCreateVueApp(hook) { + if (vueApp) { + return hook(vueApp); + } + createVueAppHooks.push(hook); +} +function invokeCreateVueAppHook(app) { + vueApp = app; + createVueAppHooks.forEach((hook) => hook(app)); +} +const invokeCreateErrorHandler = once((app, createErrorHandler2) => { + if (isFunction(app._component.onError)) { + return createErrorHandler2(app); + } +}); +const E = function() { +}; +E.prototype = { + on: function(name, callback, ctx) { + var 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 i = 0; + var len = evtArr.length; + for (i; i < len; i++) { + evtArr[i].fn.apply(evtArr[i].ctx, data); + } + return this; + }, + off: function(name, callback) { + var e2 = this.e || (this.e = {}); + var evts = e2[name]; + var liveEvents = []; + if (evts && callback) { + for (var i = 0, len = evts.length; i < len; i++) { + if (evts[i].fn !== callback && evts[i].fn._ !== callback) + liveEvents.push(evts[i]); + } + } + liveEvents.length ? e2[name] = liveEvents : delete e2[name]; + return this; + } +}; +var E$1 = E; +const LOCALE_ZH_HANS = "zh-Hans"; +const LOCALE_ZH_HANT = "zh-Hant"; +const LOCALE_EN = "en"; +const LOCALE_FR = "fr"; +const LOCALE_ES = "es"; +function include(str, parts) { + return !!parts.find((part) => str.indexOf(part) !== -1); +} +function startsWith(str, parts) { + return parts.find((part) => str.indexOf(part) === 0); +} +function normalizeLocale(locale, messages) { + if (!locale) { + return; + } + locale = locale.trim().replace(/_/g, "-"); + if (messages && messages[locale]) { + return locale; + } + locale = locale.toLowerCase(); + if (locale === "chinese") { + return LOCALE_ZH_HANS; + } + if (locale.indexOf("zh") === 0) { + if (locale.indexOf("-hans") > -1) { + return LOCALE_ZH_HANS; + } + if (locale.indexOf("-hant") > -1) { + return LOCALE_ZH_HANT; + } + if (include(locale, ["-tw", "-hk", "-mo", "-cht"])) { + return LOCALE_ZH_HANT; + } + return LOCALE_ZH_HANS; + } + let locales = [LOCALE_EN, LOCALE_FR, LOCALE_ES]; + if (messages && Object.keys(messages).length > 0) { + locales = Object.keys(messages); + } + const lang = startsWith(locale, locales); + if (lang) { + return lang; + } +} +function getBaseSystemInfo() { + return wx.getSystemInfoSync(); +} +function validateProtocolFail(name, msg) { + console.warn(`${name}: ${msg}`); +} +function validateProtocol(name, data, protocol, onFail) { + if (!onFail) { + onFail = validateProtocolFail; + } + for (const key in protocol) { + const errMsg = validateProp$1(key, data[key], protocol[key], !hasOwn(data, key)); + if (isString(errMsg)) { + onFail(name, errMsg); + } + } +} +function validateProtocols(name, args, protocol, onFail) { + if (!protocol) { + return; + } + if (!isArray(protocol)) { + return validateProtocol(name, args[0] || /* @__PURE__ */ Object.create(null), protocol, onFail); + } + const len = protocol.length; + const argsLen = args.length; + for (let i = 0; i < len; i++) { + const opts = protocol[i]; + const data = /* @__PURE__ */ Object.create(null); + if (argsLen > i) { + data[opts.name] = args[i]; + } + validateProtocol(name, data, { [opts.name]: opts }, onFail); + } +} +function validateProp$1(name, value, prop, isAbsent) { + if (!isPlainObject$1(prop)) { + prop = { type: prop }; + } + const { type, required, validator } = prop; + if (required && isAbsent) { + return 'Missing required args: "' + name + '"'; + } + if (value == null && !required) { + return; + } + if (type != null) { + let isValid = false; + const types = isArray(type) ? type : [type]; + const expectedTypes = []; + for (let i = 0; i < types.length && !isValid; i++) { + const { valid, expectedType } = assertType$1(value, types[i]); + expectedTypes.push(expectedType || ""); + isValid = valid; + } + if (!isValid) { + return getInvalidTypeMessage$1(name, value, expectedTypes); + } + } + if (validator) { + return validator(value); + } +} +const isSimpleType$1 = /* @__PURE__ */ makeMap("String,Number,Boolean,Function,Symbol"); +function assertType$1(value, type) { + let valid; + const expectedType = getType$1(type); + if (isSimpleType$1(expectedType)) { + const t = typeof value; + valid = t === expectedType.toLowerCase(); + if (!valid && t === "object") { + valid = value instanceof type; + } + } else if (expectedType === "Object") { + valid = isObject(value); + } else if (expectedType === "Array") { + valid = isArray(value); + } else { + { + valid = value instanceof type; + } + } + return { + valid, + expectedType + }; +} +function getInvalidTypeMessage$1(name, value, expectedTypes) { + let message = `Invalid args: type check failed for args "${name}". Expected ${expectedTypes.map(capitalize).join(", ")}`; + const expectedType = expectedTypes[0]; + const receivedType = toRawType(value); + const expectedValue = styleValue$1(value, expectedType); + const receivedValue = styleValue$1(value, receivedType); + if (expectedTypes.length === 1 && isExplicable$1(expectedType) && !isBoolean$1(expectedType, receivedType)) { + message += ` with value ${expectedValue}`; + } + message += `, got ${receivedType} `; + if (isExplicable$1(receivedType)) { + message += `with value ${receivedValue}.`; + } + return message; +} +function getType$1(ctor) { + const match = ctor && ctor.toString().match(/^\s*function (\w+)/); + return match ? match[1] : ""; +} +function styleValue$1(value, type) { + if (type === "String") { + return `"${value}"`; + } else if (type === "Number") { + return `${Number(value)}`; + } else { + return `${value}`; + } +} +function isExplicable$1(type) { + const explicitTypes = ["string", "number", "boolean"]; + return explicitTypes.some((elem) => type.toLowerCase() === elem); +} +function isBoolean$1(...args) { + return args.some((elem) => elem.toLowerCase() === "boolean"); +} +function tryCatch(fn) { + return function() { + try { + return fn.apply(fn, arguments); + } catch (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$1(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 i = 0; i < hooks.length; i++) { + const hook = hooks[i]; + if (promise) { + promise = Promise.resolve(wrapperHook(hook, params)); + } else { + const res = hook(data, params); + if (isPromise(res)) { + promise = Promise.resolve(res); + } + if (res === false) { + return { + then() { + }, + catch() { + } + }; + } + } + } + return promise || { + then(callback) { + return callback(data); + }, + catch() { + } + }; +} +function wrapperOptions(interceptors2, options = {}) { + [HOOK_SUCCESS, HOOK_FAIL, HOOK_COMPLETE].forEach((name) => { + const hooks = interceptors2[name]; + if (!isArray(hooks)) { + return; + } + const oldCallback = options[name]; + options[name] = function callbackInterceptor(res) { + queue$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$1(args) && [API_SUCCESS, API_FAIL, API_COMPLETE].find((cb) => isFunction(args[cb]))) { + return true; + } + return false; +} +function handlePromise(promise) { + return promise; +} +function promisify$1(name, fn) { + return (args = {}, ...rest) => { + if (hasCallback(args)) { + return wrapperReturnValue(name, invokeApi(name, fn, args, rest)); + } + return wrapperReturnValue(name, handlePromise(new Promise((resolve2, reject) => { + invokeApi(name, fn, extend(args, { success: resolve2, fail: reject }), rest); + }))); + }; +} +function formatApiArgs(args, options) { + const params = args[0]; + if (!options || !isPlainObject$1(options.formatArgs) && isPlainObject$1(params)) { + return; + } + const formatArgs = options.formatArgs; + const keys = Object.keys(formatArgs); + for (let i = 0; i < keys.length; i++) { + const name = keys[i]; + const formatterOrDefaultValue = formatArgs[name]; + if (isFunction(formatterOrDefaultValue)) { + const errMsg = formatterOrDefaultValue(args[0][name], params); + if (isString(errMsg)) { + return errMsg; + } + } else { + if (!hasOwn(params, name)) { + params[name] = formatterOrDefaultValue; + } + } + } +} +function invokeSuccess(id, name, res) { + 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 i = 0; i < hooks.length; i++) { + if (res.indexOf(hooks[i]) === -1) { + res.push(hooks[i]); + } + } + return res; +} +const addInterceptor = defineSyncApi(API_ADD_INTERCEPTOR, (method, interceptor) => { + if (isString(method) && isPlainObject$1(interceptor)) { + mergeInterceptorHook(scopedInterceptors[method] || (scopedInterceptors[method] = {}), interceptor); + } else if (isPlainObject$1(method)) { + mergeInterceptorHook(globalInterceptors, method); + } +}, AddInterceptorProtocol); +const removeInterceptor = defineSyncApi(API_REMOVE_INTERCEPTOR, (method, interceptor) => { + if (isString(method)) { + if (isPlainObject$1(interceptor)) { + removeInterceptorHook(scopedInterceptors[method], interceptor); + } else { + delete scopedInterceptors[method]; + } + } else if (isPlainObject$1(method)) { + removeInterceptorHook(globalInterceptors, method); + } +}, RemoveInterceptorProtocol); +const interceptors = {}; +const API_ON = "$on"; +const OnProtocol = [ + { + name: "event", + type: String, + required: true + }, + { + name: "callback", + type: Function, + required: true + } +]; +const API_ONCE = "$once"; +const OnceProtocol = OnProtocol; +const API_OFF = "$off"; +const OffProtocol = [ + { + name: "event", + type: [String, Array] + }, + { + name: "callback", + type: Function + } +]; +const API_EMIT = "$emit"; +const EmitProtocol = [ + { + name: "event", + type: String, + required: true + } +]; +const emitter = new E$1(); +const $on = defineSyncApi(API_ON, (name, callback) => { + emitter.on(name, callback); + return () => emitter.off(name, callback); +}, OnProtocol); +const $once = defineSyncApi(API_ONCE, (name, callback) => { + emitter.once(name, callback); + return () => emitter.off(name, callback); +}, OnceProtocol); +const $off = defineSyncApi(API_OFF, (name, callback) => { + if (!name) { + emitter.e = {}; + return; + } + if (!isArray(name)) + name = [name]; + name.forEach((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 i = 0; i < onPushMessageCallbacks.length; i++) { + const callback = onPushMessageCallbacks[i]; + callback(message); + if (message.stopped) { + break; + } + } + } else if (args.type === "click") { + onPushMessageCallbacks.forEach((callback) => { + callback({ + type: "click", + data: normalizePushMessage(args.message) + }); + }); + } +} +const getPushCidCallbacks = []; +function invokeGetPushCidCallbacks(cid2, errMsg) { + getPushCidCallbacks.forEach((callback) => { + callback(cid2, errMsg); + }); + getPushCidCallbacks.length = 0; +} +const API_GET_PUSH_CLIENT_ID = "getPushClientId"; +const getPushClientId = defineAsyncApi(API_GET_PUSH_CLIENT_ID, (_, { resolve: resolve2, reject }) => { + Promise.resolve().then(() => { + if (typeof enabled === "undefined") { + enabled = false; + cid = ""; + cidErrMsg = "uniPush is not enabled"; + } + getPushCidCallbacks.push((cid2, errMsg) => { + if (cid2) { + resolve2({ cid: cid2 }); + } else { + reject(errMsg); + } + }); + if (typeof cid !== "undefined") { + invokeGetPushCidCallbacks(cid, cidErrMsg); + } + }); +}); +const onPushMessageCallbacks = []; +const onPushMessage = (fn) => { + if (onPushMessageCallbacks.indexOf(fn) === -1) { + onPushMessageCallbacks.push(fn); + } +}; +const offPushMessage = (fn) => { + if (!fn) { + onPushMessageCallbacks.length = 0; + } else { + const index2 = onPushMessageCallbacks.indexOf(fn); + if (index2 > -1) { + onPushMessageCallbacks.splice(index2, 1); + } + } +}; +const SYNC_API_RE = /^\$|getLocale|setLocale|sendNativeEvent|restoreGlobal|requireGlobal|getCurrentSubNVue|getMenuButtonBoundingClientRect|^report|interceptors|Interceptor$|getSubNVueById|requireNativePlugin|upx2px|hideKeyboard|canIUse|^create|Sync$|Manager$|base64ToArrayBuffer|arrayBufferToBase64|getDeviceInfo|getAppBaseInfo|getWindowInfo|getSystemSetting|getAppAuthorizeSetting/; +const CONTEXT_API_RE = /^create|Manager$/; +const CONTEXT_API_RE_EXC = ["createBLEConnection"]; +const ASYNC_API = ["createBLEConnection"]; +const CALLBACK_API_RE = /^on|^off/; +function isContextApi(name) { + return CONTEXT_API_RE.test(name) && CONTEXT_API_RE_EXC.indexOf(name) === -1; +} +function isSyncApi(name) { + return SYNC_API_RE.test(name) && ASYNC_API.indexOf(name) === -1; +} +function isCallbackApi(name) { + return CALLBACK_API_RE.test(name) && name !== "onPush"; +} +function shouldPromise(name) { + if (isContextApi(name) || isSyncApi(name) || isCallbackApi(name)) { + return false; + } + return true; +} +if (!Promise.prototype.finally) { + Promise.prototype.finally = function(onfinally) { + const promise = this.constructor; + return this.then((value) => promise.resolve(onfinally && onfinally()).then(() => value), (reason) => promise.resolve(onfinally && onfinally()).then(() => { + throw reason; + })); + }; +} +function promisify(name, api) { + if (!shouldPromise(name)) { + return api; + } + if (!isFunction(api)) { + return api; + } + return function promiseApi(options = {}, ...rest) { + if (isFunction(options.success) || isFunction(options.fail) || isFunction(options.complete)) { + return wrapperReturnValue(name, invokeApi(name, api, options, rest)); + } + return wrapperReturnValue(name, handlePromise(new Promise((resolve2, reject) => { + invokeApi(name, api, extend({}, options, { + success: resolve2, + fail: reject + }), rest); + }))); + }; +} +const CALLBACKS = ["success", "fail", "cancel", "complete"]; +function initWrapper(protocols2) { + function processCallback(methodName, method, returnValue) { + return function(res) { + return method(processReturnValue(methodName, res, returnValue)); + }; + } + function processArgs(methodName, fromArgs, argsOption = {}, returnValue = {}, keepFromArgs = false) { + if (isPlainObject$1(fromArgs)) { + const toArgs = keepFromArgs === true ? fromArgs : {}; + if (isFunction(argsOption)) { + argsOption = argsOption(fromArgs, toArgs) || {}; + } + for (const key in fromArgs) { + if (hasOwn(argsOption, key)) { + let keyOption = argsOption[key]; + if (isFunction(keyOption)) { + keyOption = keyOption(fromArgs[key], fromArgs, toArgs); + } + if (!keyOption) { + console.warn(`微信小程序 ${methodName} 暂不支持 ${key}`); + } else if (isString(keyOption)) { + toArgs[keyOption] = fromArgs[key]; + } else if (isPlainObject$1(keyOption)) { + toArgs[keyOption.name ? keyOption.name : key] = keyOption.value; + } + } else if (CALLBACKS.indexOf(key) !== -1) { + const callback = fromArgs[key]; + if (isFunction(callback)) { + toArgs[key] = processCallback(methodName, callback, returnValue); + } + } else { + if (!keepFromArgs && !hasOwn(toArgs, key)) { + toArgs[key] = fromArgs[key]; + } + } + } + return toArgs; + } else if (isFunction(fromArgs)) { + fromArgs = processCallback(methodName, fromArgs, returnValue); + } + return fromArgs; + } + function processReturnValue(methodName, res, returnValue, keepReturnValue = false) { + if (isFunction(protocols2.returnValue)) { + res = protocols2.returnValue(methodName, res); + } + return processArgs(methodName, res, returnValue, {}, keepReturnValue); + } + return function wrapper(methodName, method) { + if (!hasOwn(protocols2, methodName)) { + return method; + } + const protocol = protocols2[methodName]; + if (!protocol) { + return function() { + console.error(`微信小程序 暂不支持${methodName}`); + }; + } + return function(arg1, arg2) { + let options = protocol; + if (isFunction(protocol)) { + options = protocol(arg1); + } + arg1 = processArgs(methodName, arg1, options.args, options.returnValue); + const args = [arg1]; + if (typeof arg2 !== "undefined") { + args.push(arg2); + } + const returnValue = wx[options.name || methodName].apply(wx, args); + if (isSyncApi(methodName)) { + return processReturnValue(methodName, returnValue, options.returnValue, isContextApi(methodName)); + } + return returnValue; + }; + }; +} +const getLocale = () => { + const app = isFunction(getApp) && getApp({ allowDefault: true }); + if (app && app.$vm) { + return app.$vm.$locale; + } + return normalizeLocale(wx.getSystemInfoSync().language) || LOCALE_EN; +}; +const setLocale = (locale) => { + const app = isFunction(getApp) && getApp(); + if (!app) { + return false; + } + const oldLocale = app.$vm.$locale; + if (oldLocale !== locale) { + app.$vm.$locale = locale; + onLocaleChangeCallbacks.forEach((fn) => fn({ locale })); + return true; + } + return false; +}; +const onLocaleChangeCallbacks = []; +const onLocaleChange = (fn) => { + if (onLocaleChangeCallbacks.indexOf(fn) === -1) { + onLocaleChangeCallbacks.push(fn); + } +}; +if (typeof global !== "undefined") { + global.getLocale = getLocale; +} +const UUID_KEY = "__DC_STAT_UUID"; +let deviceId; +function useDeviceId(global2 = wx) { + return function addDeviceId(_, toRes) { + deviceId = deviceId || global2.getStorageSync(UUID_KEY); + if (!deviceId) { + deviceId = Date.now() + "" + Math.floor(Math.random() * 1e7); + wx.setStorage({ + key: UUID_KEY, + data: deviceId + }); + } + toRes.deviceId = deviceId; + }; +} +function addSafeAreaInsets(fromRes, toRes) { + if (fromRes.safeArea) { + const safeArea = fromRes.safeArea; + toRes.safeAreaInsets = { + top: safeArea.top, + left: safeArea.left, + right: fromRes.windowWidth - safeArea.right, + bottom: fromRes.screenHeight - safeArea.bottom + }; + } +} +function populateParameters(fromRes, toRes) { + const { brand = "", model = "", system = "", language = "", theme, version: version2, platform, fontSizeSetting, SDKVersion, pixelRatio, deviceOrientation } = fromRes; + let osName = ""; + let osVersion = ""; + { + osName = system.split(" ")[0] || ""; + osVersion = system.split(" ")[1] || ""; + } + let hostVersion = version2; + let deviceType = getGetDeviceType(fromRes, model); + let deviceBrand = getDeviceBrand(brand); + let _hostName = getHostName(fromRes); + let _deviceOrientation = deviceOrientation; + let _devicePixelRatio = pixelRatio; + let _SDKVersion = SDKVersion; + const hostLanguage = language.replace(/_/g, "-"); + const parameters = { + appId: "__UNI__A2B2065", + appName: "vision-record", + 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__A2B2065", + appName: "vision-record", + appVersion: "1.0.0", + appVersionCode: "100", + appLanguage: getAppLanguage(hostLanguage) + })); + } +}; +const getWindowInfo = { + returnValue: (fromRes, toRes) => { + addSafeAreaInsets(fromRes, toRes); + toRes = sortObject(extend(toRes, { + windowTop: 0, + windowBottom: 0 + })); + } +}; +const getAppAuthorizeSetting = { + returnValue: function(fromRes, toRes) { + const { locationReducedAccuracy } = fromRes; + toRes.locationAccuracy = "unsupported"; + if (locationReducedAccuracy === true) { + toRes.locationAccuracy = "reduced"; + } else if (locationReducedAccuracy === false) { + toRes.locationAccuracy = "full"; + } + } +}; +const baseApis = { + $on, + $off, + $once, + $emit, + upx2px, + interceptors, + addInterceptor, + removeInterceptor, + onCreateVueApp, + invokeCreateVueAppHook, + getLocale, + setLocale, + onLocaleChange, + getPushClientId, + onPushMessage, + offPushMessage, + invokePushCallback +}; +function initUni(api, protocols2, platform = wx) { + const wrapper = initWrapper(protocols2); + const UniProxyHandlers = { + get(target, key) { + if (hasOwn(target, key)) { + return target[key]; + } + if (hasOwn(api, key)) { + return promisify(key, api[key]); + } + if (hasOwn(baseApis, key)) { + return promisify(key, baseApis[key]); + } + return promisify(key, wrapper(key, platform[key])); + } + }; + return new Proxy({}, UniProxyHandlers); +} +function initGetProvider(providers) { + return function getProvider2({ service, success, fail, complete }) { + let res; + if (providers[service]) { + res = { + errMsg: "getProvider:ok", + service, + provider: providers[service] + }; + isFunction(success) && success(res); + } else { + res = { + errMsg: "getProvider:fail:服务[" + service + "]不存在" + }; + isFunction(fail) && fail(res); + } + isFunction(complete) && complete(res); + }; +} +const objectKeys = [ + "qy", + "env", + "error", + "version", + "lanDebug", + "cloud", + "serviceMarket", + "router", + "worklet", + "__webpack_require_UNI_MP_PLUGIN__" +]; +const singlePageDisableKey = ["lanDebug", "router", "worklet"]; +const launchOption = wx.getLaunchOptionsSync ? wx.getLaunchOptionsSync() : null; +function isWxKey(key) { + if (launchOption && launchOption.scene === 1154 && singlePageDisableKey.includes(key)) { + return false; + } + return objectKeys.indexOf(key) > -1 || typeof wx[key] === "function"; +} +function initWx() { + const newWx = {}; + for (const key in wx) { + if (isWxKey(key)) { + newWx[key] = wx[key]; + } + } + if (typeof globalThis !== "undefined" && typeof requireMiniProgram === "undefined") { + globalThis.wx = newWx; + } + return newWx; +} +const mocks$1 = ["__route__", "__wxExparserNodeId__", "__wxWebviewId__"]; +const getProvider = initGetProvider({ + oauth: ["weixin"], + share: ["weixin"], + payment: ["wxpay"], + push: ["weixin"] +}); +function initComponentMocks(component) { + const res = /* @__PURE__ */ Object.create(null); + mocks$1.forEach((name) => { + res[name] = component[name]; + }); + return res; +} +function createSelectorQuery() { + const query = wx$2.createSelectorQuery(); + const oldIn = query.in; + query.in = function newIn(component) { + return oldIn.call(this, initComponentMocks(component)); + }; + return query; +} +const wx$2 = initWx(); +let baseInfo = wx$2.getAppBaseInfo && wx$2.getAppBaseInfo(); +if (!baseInfo) { + baseInfo = wx$2.getSystemInfoSync(); +} +const host = baseInfo ? baseInfo.host : null; +const shareVideoMessage = host && host.env === "SAAASDK" ? wx$2.miniapp.shareVideoMessage : wx$2.shareVideoMessage; +var shims = /* @__PURE__ */ Object.freeze({ + __proto__: null, + createSelectorQuery, + getProvider, + shareVideoMessage +}); +const compressImage = { + args(fromArgs, toArgs) { + if (fromArgs.compressedHeight && !toArgs.compressHeight) { + toArgs.compressHeight = fromArgs.compressedHeight; + } + if (fromArgs.compressedWidth && !toArgs.compressWidth) { + toArgs.compressWidth = fromArgs.compressedWidth; + } + } +}; +var protocols = /* @__PURE__ */ Object.freeze({ + __proto__: null, + compressImage, + getAppAuthorizeSetting, + getAppBaseInfo, + getDeviceInfo, + getSystemInfo, + getSystemInfoSync, + getWindowInfo, + previewImage, + redirectTo, + showActionSheet +}); +const wx$1 = initWx(); +var index = initUni(shims, protocols, wx$1); +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 i, l; + for (i = 0, l = this.effects.length; i < l; i++) { + this.effects[i].stop(); + } + for (i = 0, l = this.cleanups.length; i < l; i++) { + this.cleanups[i](); + } + if (this.scopes) { + for (i = 0, l = this.scopes.length; i < l; i++) { + this.scopes[i].stop(true); + } + } + if (!this.detached && this.parent && !fromParent) { + const last = this.parent.scopes.pop(); + if (last && last !== this) { + this.parent.scopes[this.index] = last; + last.index = this.index; + } + } + this.parent = void 0; + this._active = false; + } + } +} +function effectScope(detached) { + return new EffectScope(detached); +} +function recordEffectScope(effect, scope = activeEffectScope) { + if (scope && scope.active) { + scope.effects.push(effect); + } +} +function getCurrentScope() { + return activeEffectScope; +} +function onScopeDispose(fn) { + if (activeEffectScope) { + activeEffectScope.cleanups.push(fn); + } else { + warn$1(`onScopeDispose() is called when there is no active effect scope to be associated with.`); + } +} +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 i = 0; i < deps.length; i++) { + deps[i].w |= trackOpBit; + } + } +}; +const finalizeDepMarkers = (effect) => { + const { deps } = effect; + if (deps.length) { + let ptr = 0; + for (let i = 0; i < deps.length; i++) { + const dep = deps[i]; + 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 i = 0; i < deps.length; i++) { + deps[i].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(); + } + } +} +function getDepFromReactive(object, key) { + var _a2; + return (_a2 = targetMap.get(object)) === null || _a2 === void 0 ? void 0 : _a2.get(key); +} +const isNonTrackableKeys = /* @__PURE__ */ makeMap(`__proto__,__v_isRef,__isVue`); +const builtInSymbols = new Set( + /* @__PURE__ */ Object.getOwnPropertyNames(Symbol).filter((key) => key !== "arguments" && key !== "caller").map((key) => Symbol[key]).filter(isSymbol) +); +const 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 i = 0, l = this.length; i < l; i++) { + track(arr, "get", i + ""); + } + const res = arr[key](...args); + if (res === -1 || res === false) { + return arr[key](...args.map(toRaw)); + } else { + return res; + } + }; + }); + ["push", "pop", "shift", "unshift", "splice"].forEach((key) => { + instrumentations[key] = function(...args) { + pauseTracking(); + 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(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(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(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(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 = (v) => Reflect.getPrototypeOf(v); +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(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(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 isProxy(value) { + return isReactive(value) || isReadonly(value); +} +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(value) ? reactive(value) : value; +const toReadonly = (value) => isObject(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(r) { + return !!(r && r.__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); +} +function toRefs(object) { + if (!isProxy(object)) { + console.warn(`toRefs() expects a reactive object but received a plain one.`); + } + const ret = isArray(object) ? new Array(object.length) : {}; + for (const key in object) { + ret[key] = toRef(object, key); + } + return ret; +} +class ObjectRefImpl { + constructor(_object, _key, _defaultValue) { + this._object = _object; + this._key = _key; + this._defaultValue = _defaultValue; + this.__v_isRef = true; + } + get value() { + const val = this._object[this._key]; + return val === void 0 ? this._defaultValue : val; + } + set value(newVal) { + this._object[this._key] = newVal; + } + get dep() { + return getDepFromReactive(toRaw(this._object), this._key); + } +} +function toRef(object, key, defaultValue) { + const val = object[key]; + return isRef(val) ? val : new ObjectRefImpl(object, key, defaultValue); +} +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, i) => { + logs.push(...i === 0 ? [] : [` +`], ...formatTraceEntry(entry)); + }); + return logs; +} +function formatTraceEntry({ vnode, recurseCount }) { + const postfix = recurseCount > 0 ? `... (${recurseCount} recursive calls)` : ``; + const isRoot = vnode.component ? vnode.component.parent == null : false; + const open = ` at <${formatComponentName(vnode.component, vnode.type, isRoot)}`; + const close = `>` + postfix; + return vnode.props ? [open, ...formatProps(vnode.props), close] : [open + close]; +} +function formatProps(props) { + const res = []; + const keys = Object.keys(props); + keys.slice(0, 3).forEach((key) => { + res.push(...formatProp(key, props[key])); + }); + if (keys.length > 3) { + res.push(` ...`); + } + return res; +} +function formatProp(key, value, raw) { + if (isString(value)) { + value = JSON.stringify(value); + return raw ? value : [`${key}=${value}`]; + } else if (typeof value === "number" || typeof value === "boolean" || value == null) { + return raw ? value : [`${key}=${value}`]; + } else if (isRef(value)) { + value = formatProp(key, toRaw(value.value), true); + return raw ? value : [`${key}=Ref<`, value, `>`]; + } else if (isFunction(value)) { + return [`${key}=fn${value.name ? `<${value.name}>` : ``}`]; + } else { + value = toRaw(value); + return raw ? value : [`${key}=`, value]; + } +} +const ErrorTypeStrings = { + [ + "sp" + /* 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 i = 0; i < fn.length; i++) { + values.push(callWithAsyncErrorHandling(fn[i], instance, type, args)); + } + return values; +} +function handleError(err, instance, type, throwInDev = true) { + const contextVNode = instance ? instance.vnode : null; + if (instance) { + let cur = instance.parent; + const exposedInstance = instance.proxy; + const errorInfo = ErrorTypeStrings[type] || type; + while (cur) { + const errorCapturedHooks = cur.ec; + if (errorCapturedHooks) { + for (let i = 0; i < errorCapturedHooks.length; i++) { + if (errorCapturedHooks[i](err, exposedInstance, errorInfo) === false) { + return; + } + } + } + cur = cur.parent; + } + const appErrorHandler = instance.appContext.config.errorHandler; + if (appErrorHandler) { + callWithErrorHandling(appErrorHandler, null, 10, [err, exposedInstance, errorInfo]); + return; + } + } + logError(err, type, contextVNode, throwInDev); +} +function logError(err, type, contextVNode, throwInDev = true) { + { + const info = ErrorTypeStrings[type] || type; + if (contextVNode) { + pushWarningContext(contextVNode); + } + warn(`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 i = queue.indexOf(job); + if (i > flushIndex) { + queue.splice(i, 1); + } +} +function queuePostFlushCb(cb) { + if (!isArray(cb)) { + if (!activePostFlushCbs || !activePostFlushCbs.includes(cb, cb.allowRecurse ? postFlushIndex + 1 : postFlushIndex)) { + pendingPostFlushCbs.push(cb); + } + } else { + pendingPostFlushCbs.push(...cb); + } + queueFlush(); +} +function flushPreFlushCbs(seen, i = isFlushing ? flushIndex + 1 : 0) { + { + seen = seen || /* @__PURE__ */ new Map(); + } + for (; i < queue.length; i++) { + const cb = queue[i]; + if (cb && cb.pre) { + if (checkRecursiveUpdates(seen, cb)) { + continue; + } + queue.splice(i, 1); + i--; + 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((a, b) => getId(a) - getId(b)); + for (postFlushIndex = 0; postFlushIndex < activePostFlushCbs.length; postFlushIndex++) { + if (checkRecursiveUpdates(seen, activePostFlushCbs[postFlushIndex])) { + continue; + } + activePostFlushCbs[postFlushIndex](); + } + activePostFlushCbs = null; + postFlushIndex = 0; + } +} +const getId = (job) => job.id == null ? Infinity : job.id; +const comparator = (a, b) => { + const diff2 = getId(a) - getId(b); + if (diff2 === 0) { + if (a.pre && !b.pre) + return -1; + if (b.pre && !a.pre) + return 1; + } + return diff2; +}; +function flushJobs(seen) { + isFlushPending = false; + isFlushing = true; + { + seen = seen || /* @__PURE__ */ new Map(); + } + queue.sort(comparator); + const check = (job) => checkRecursiveUpdates(seen, job); + try { + for (flushIndex = 0; flushIndex < queue.length; flushIndex++) { + const job = queue[flushIndex]; + if (job && job.active !== false) { + if (check(job)) { + continue; + } + callWithErrorHandling( + job, + null, + 14 + /* 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((a) => isString(a) ? a.trim() : a); + } + if (number) { + args = rawArgs.map(looseToNumber); + } + } + { + devtoolsComponentEmit(instance, event, args); + } + { + const lowerCaseEvent = event.toLowerCase(); + if (lowerCaseEvent !== event && props[toHandlerKey(lowerCaseEvent)]) { + warn(`Event "${lowerCaseEvent}" is emitted in component ${formatComponentName(instance, instance.type)} but the handler is registered for "${event}". Note that HTML attributes are case-insensitive and you cannot use v-on to listen to camelCase events when using in-DOM templates. You should probably use "${hyphenate(event)}" instead of "${event}".`); + } + } + let handlerName; + let handler = props[handlerName = toHandlerKey(event)] || // also try camelCase event handler (#2249) + props[handlerName = toHandlerKey(camelize(event))]; + if (!handler && isModelListener2) { + handler = props[handlerName = toHandlerKey(hyphenate(event))]; + } + if (handler) { + callWithAsyncErrorHandling(handler, instance, 6, args); + } + const onceHandler = props[handlerName + `Once`]; + if (onceHandler) { + if (!instance.emitted) { + instance.emitted = {}; + } else if (instance.emitted[handlerName]) { + return; + } + instance.emitted[handlerName] = true; + callWithAsyncErrorHandling(onceHandler, instance, 6, args); + } +} +function normalizeEmitsOptions(comp, appContext, asMixin = false) { + const cache = appContext.emitsCache; + const cached = cache.get(comp); + if (cached !== void 0) { + return cached; + } + const raw = comp.emits; + let normalized = {}; + let hasExtends = false; + if (!isFunction(comp)) { + const extendEmits = (raw2) => { + const normalizedFromExtend = normalizeEmitsOptions(raw2, appContext, true); + if (normalizedFromExtend) { + hasExtends = true; + extend(normalized, normalizedFromExtend); + } + }; + if (!asMixin && appContext.mixins.length) { + appContext.mixins.forEach(extendEmits); + } + if (comp.extends) { + extendEmits(comp.extends); + } + if (comp.mixins) { + comp.mixins.forEach(extendEmits); + } + } + if (!raw && !hasExtends) { + if (isObject(comp)) { + cache.set(comp, null); + } + return null; + } + if (isArray(raw)) { + raw.forEach((key) => normalized[key] = null); + } else { + extend(normalized, raw); + } + if (isObject(comp)) { + cache.set(comp, normalized); + } + return normalized; +} +function isEmitListener(options, key) { + if (!options || !isOn(key)) { + return false; + } + key = key.slice(2).replace(/Once$/, ""); + return hasOwn(options, key[0].toLowerCase() + key.slice(1)) || hasOwn(options, hyphenate(key)) || hasOwn(options, key); +} +let currentRenderingInstance = null; +function setCurrentRenderingInstance(instance) { + const prev = currentRenderingInstance; + currentRenderingInstance = instance; + instance && instance.type.__scopeId || null; + return prev; +} +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((v, i) => hasChanged(v, oldValue[i])) : hasChanged(newValue, oldValue)) || false) { + if (cleanup) { + cleanup(); + } + callWithAsyncErrorHandling(cb, instance, 3, [ + newValue, + // pass undefined as the old value when it's changed for the first time + oldValue === INITIAL_WATCHER_VALUE ? void 0 : isMultiSource && oldValue[0] === INITIAL_WATCHER_VALUE ? [] : oldValue, + onCleanup + ]); + oldValue = newValue; + } + } else { + effect.run(); + } + }; + job.allowRecurse = !!cb; + let scheduler; + if (flush === "sync") { + scheduler = job; + } else if (flush === "post") { + scheduler = () => queuePostRenderEffect$1(job, instance && instance.suspense); + } else { + job.pre = true; + if (instance) + job.id = instance.uid; + scheduler = () => queueJob(job); + } + const effect = new ReactiveEffect(getter, 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 i = 0; i < segments.length && cur; i++) { + cur = cur[segments[i]]; + } + return cur; + }; +} +function traverse(value, seen) { + if (!isObject(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 i = 0; i < value.length; i++) { + traverse(value[i], seen); + } + } else if (isSet(value) || isMap(value)) { + value.forEach((v) => { + traverse(v, seen); + }); + } else if (isPlainObject$1(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$1 = (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$1( + "bm" + /* LifecycleHooks.BEFORE_MOUNT */ +); +const onMounted = createHook$1( + "m" + /* LifecycleHooks.MOUNTED */ +); +const onBeforeUpdate = createHook$1( + "bu" + /* LifecycleHooks.BEFORE_UPDATE */ +); +const onUpdated = createHook$1( + "u" + /* LifecycleHooks.UPDATED */ +); +const onBeforeUnmount = createHook$1( + "bum" + /* LifecycleHooks.BEFORE_UNMOUNT */ +); +const onUnmounted = createHook$1( + "um" + /* LifecycleHooks.UNMOUNTED */ +); +const onServerPrefetch = createHook$1( + "sp" + /* LifecycleHooks.SERVER_PREFETCH */ +); +const onRenderTriggered = createHook$1( + "rtg" + /* LifecycleHooks.RENDER_TRIGGERED */ +); +const onRenderTracked = createHook$1( + "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 COMPONENTS = "components"; +function resolveComponent(name, maybeSelfReference) { + return resolveAsset(COMPONENTS, name, true, maybeSelfReference) || name; +} +function resolveAsset(type, name, warnMissing = true, maybeSelfReference = false) { + const instance = currentRenderingInstance || currentInstance; + if (instance) { + const Component2 = instance.type; + if (type === COMPONENTS) { + const selfName = getComponentName( + Component2, + false + /* do not include inferred name to avoid breaking existing code */ + ); + if (selfName && (selfName === name || selfName === camelize(name) || selfName === capitalize(camelize(name)))) { + return Component2; + } + } + const res = ( + // local registration + // check instance[type] first which is resolved for options API + resolve(instance[type] || Component2[type], name) || // global registration + resolve(instance.appContext[type], name) + ); + if (!res && maybeSelfReference) { + return Component2; + } + if (warnMissing && !res) { + const extra = type === COMPONENTS ? ` +If this is a native custom element, make sure to exclude it from component resolution via compilerOptions.isCustomElement.` : ``; + warn(`Failed to resolve ${type.slice(0, -1)}: ${name}${extra}`); + } + return res; + } else { + warn(`resolve${capitalize(type.slice(0, -1))} can only be used in render() or setup().`); + } +} +function resolve(registry, name) { + return registry && (registry[name] || registry[camelize(name)] || registry[capitalize(camelize(name))]); +} +const getPublicInstance = (i) => { + if (!i) + return null; + if (isStatefulComponent(i)) + return getExposeProxy(i) || i.proxy; + return getPublicInstance(i.parent); +}; +const publicPropertiesMap = ( + // Move PURE marker to new line to workaround compiler discarding it + // due to type annotation + /* @__PURE__ */ extend(/* @__PURE__ */ Object.create(null), { + $: (i) => i, + // fixed by xxxxxx vue-i18n 在 dev 模式,访问了 $el,故模拟一个假的 + // $el: i => i.vnode.el, + $el: (i) => i.__$el || (i.__$el = {}), + $data: (i) => i.data, + $props: (i) => shallowReadonly(i.props), + $attrs: (i) => shallowReadonly(i.attrs), + $slots: (i) => shallowReadonly(i.slots), + $refs: (i) => shallowReadonly(i.refs), + $parent: (i) => getPublicInstance(i.parent), + $root: (i) => getPublicInstance(i.root), + $emit: (i) => i.emit, + $options: (i) => resolveMergedOptions(i), + $forceUpdate: (i) => i.f || (i.f = () => queueJob(i.update)), + // $nextTick: i => i.n || (i.n = nextTick.bind(i.proxy!)),// fixed by xxxxxx + $watch: (i) => instanceWatch.bind(i) + }) +); +const isReservedPrefix = (key) => key === "_" || key === "$"; +const hasSetupBinding = (state, key) => state !== EMPTY_OBJ && !state.__isScriptSetup && hasOwn(state, key); +const PublicInstanceProxyHandlers = { + get({ _: instance }, key) { + const { ctx, setupState, data, props, accessCache, type, appContext } = instance; + if (key === "__isVue") { + return true; + } + let normalizedProps; + if (key[0] !== "$") { + const n2 = accessCache[key]; + if (n2 !== void 0) { + switch (n2) { + case 1: + return setupState[key]; + case 2: + return data[key]; + case 4: + return ctx[key]; + case 3: + return props[key]; + } + } else if (hasSetupBinding(setupState, key)) { + accessCache[key] = 1; + return setupState[key]; + } else if (data !== EMPTY_OBJ && hasOwn(data, key)) { + accessCache[key] = 2; + return data[key]; + } else if ( + // only cache other properties when instance has declared (thus stable) + // props + (normalizedProps = instance.propsOptions[0]) && hasOwn(normalizedProps, key) + ) { + accessCache[key] = 3; + return props[key]; + } else if (ctx !== EMPTY_OBJ && hasOwn(ctx, key)) { + accessCache[key] = 4; + return ctx[key]; + } else if (shouldCacheAccess) { + accessCache[key] = 0; + } + } + const publicGetter = publicPropertiesMap[key]; + let cssModule, globalProperties; + if (publicGetter) { + if (key === "$attrs") { + track(instance, "get", key); + } + return publicGetter(instance); + } else if ( + // css module (injected by vue-loader) + (cssModule = type.__cssModules) && (cssModule = cssModule[key]) + ) { + return cssModule; + } else if (ctx !== EMPTY_OBJ && hasOwn(ctx, key)) { + accessCache[key] = 4; + return ctx[key]; + } else if ( + // global properties + globalProperties = appContext.config.globalProperties, hasOwn(globalProperties, key) + ) { + { + return globalProperties[key]; + } + } else if (currentRenderingInstance && (!isString(key) || // #1091 avoid internal isRef/isVNode checks on component instance leading + // to infinite warning loop + key.indexOf("__v") !== 0)) { + if (data !== EMPTY_OBJ && isReservedPrefix(key[0]) && hasOwn(data, key)) { + warn(`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(setupState, key)) { + warn(`Cannot mutate