diff --git a/.eslintrc.js b/.eslintrc.js index 9c8957ed18e396c0fb8189c10726929740878bf0..884dc6c3a9ee267331573ddd6925b69a6769a858 100644 --- a/.eslintrc.js +++ b/.eslintrc.js @@ -35,7 +35,7 @@ module.exports = { // Packages targeting DOM { files: [ - 'packages/{uni-api,uni-app,uni-components,uni-core,uni-h5,uni-h5-vue,uni-i18n,uni-shared,uni-vue}/**', + 'packages/{uni-api,uni-app,uni-components,uni-core,uni-h5,uni-h5-vue,uni-i18n,uni-shared,uni-vue,uni-app-plus}/**', ], rules: { 'no-restricted-globals': ['error', ...NodeGlobals], diff --git a/packages/uni-app-plus/build.json b/packages/uni-app-plus/build.json new file mode 100644 index 0000000000000000000000000000000000000000..a5c4b54dd794d755df1547afe9a1712d1b4c6433 --- /dev/null +++ b/packages/uni-app-plus/build.json @@ -0,0 +1,12 @@ +{ + "input": { + "src/service/index.ts": "dist/uni-app-service.es.js" + }, + "output": { + "name": "serviceContext", + "format": "iife", + "banner": "export function createServiceContext(Vue, weex, plus, UniServiceJSBridge,instanceContext){\nconst setTimeout = instanceContext.setTimeout;\nconst clearTimeout = instanceContext.clearTimeout;\nconst setInterval = instanceContext.setInterval;\nconst clearInterval = instanceContext.clearInterval;\nconst __uniConfig = instanceContext.__uniConfig;\nconst __uniRoutes = instanceContext.__uniRoutes;\n", + "footer": "const uni = serviceContext.uni;\nconst getApp = serviceContext.getApp;\nconst getCurrentPages = serviceContext.getCurrentPages;\nconst __definePage = serviceContext.__definePage;\nconst __registerPage = serviceContext.__registerPage;\nreturn serviceContext;\n}" + }, + "external": false +} diff --git a/packages/uni-app-plus/dist/style.css b/packages/uni-app-plus/dist/style.css new file mode 100644 index 0000000000000000000000000000000000000000..c65dcaa31a30ac2bca15b15f3a6c4b7809bbb681 --- /dev/null +++ b/packages/uni-app-plus/dist/style.css @@ -0,0 +1,264 @@ +uni-button { + position: relative; + display: block; + margin-left: auto; + margin-right: auto; + padding-left: 14px; + padding-right: 14px; + box-sizing: border-box; + font-size: 18px; + text-align: center; + text-decoration: none; + line-height: 2.55555556; + border-radius: 5px; + -webkit-tap-highlight-color: transparent; + overflow: hidden; + color: #000000; + background-color: #f8f8f8; + cursor: pointer; +} + +uni-button[hidden] { + display: none !important; +} + +uni-button:after { + content: ' '; + width: 200%; + height: 200%; + position: absolute; + top: 0; + left: 0; + border: 1px solid rgba(0, 0, 0, 0.2); + transform: scale(0.5); + transform-origin: 0 0; + box-sizing: border-box; + border-radius: 10px; +} + +uni-button[native] { + padding-left: 0; + padding-right: 0; +} + +uni-button[native] .uni-button-cover-view-wrapper { + border: inherit; + border-color: inherit; + border-radius: inherit; + background-color: inherit; +} + +uni-button[native] .uni-button-cover-view-inner { + padding-left: 14px; + padding-right: 14px; +} + +uni-button uni-cover-view { + line-height: inherit; + white-space: inherit; +} + +uni-button[type='default'] { + color: #000000; + background-color: #f8f8f8; +} + +uni-button[type='primary'] { + color: #ffffff; + background-color: #007aff; +} + +uni-button[type='warn'] { + color: #ffffff; + background-color: #e64340; +} + +uni-button[disabled] { + color: rgba(255, 255, 255, 0.6); + cursor: not-allowed; +} + +uni-button[disabled][type='default'], +uni-button[disabled]:not([type]) { + color: rgba(0, 0, 0, 0.3); + background-color: #f7f7f7; +} + +uni-button[disabled][type='primary'] { + background-color: rgba(0, 122, 255, 0.6); +} + +uni-button[disabled][type='warn'] { + background-color: #ec8b89; +} + +uni-button[type='primary'][plain] { + color: #007aff; + border: 1px solid #007aff; + background-color: transparent; +} + +uni-button[type='primary'][plain][disabled] { + color: rgba(0, 0, 0, 0.2); + border-color: rgba(0, 0, 0, 0.2); +} + +uni-button[type='primary'][plain]:after { + border-width: 0; +} + +uni-button[type='default'][plain] { + color: #353535; + border: 1px solid #353535; + background-color: transparent; +} + +uni-button[type='default'][plain][disabled] { + color: rgba(0, 0, 0, 0.2); + border-color: rgba(0, 0, 0, 0.2); +} + +uni-button[type='default'][plain]:after { + border-width: 0; +} + +uni-button[plain] { + color: #353535; + border: 1px solid #353535; + background-color: transparent; +} + +uni-button[plain][disabled] { + color: rgba(0, 0, 0, 0.2); + border-color: rgba(0, 0, 0, 0.2); +} + +uni-button[plain]:after { + border-width: 0; +} + +uni-button[plain][native] .uni-button-cover-view-inner { + padding: 0; +} + +uni-button[type='warn'][plain] { + color: #e64340; + border: 1px solid #e64340; + background-color: transparent; +} + +uni-button[type='warn'][plain][disabled] { + color: rgba(0, 0, 0, 0.2); + border-color: rgba(0, 0, 0, 0.2); +} + +uni-button[type='warn'][plain]:after { + border-width: 0; +} + +uni-button[size='mini'] { + display: inline-block; + line-height: 2.3; + font-size: 13px; + padding: 0 1.34em; +} + +uni-button[size='mini'][native] { + padding: 0; +} + +uni-button[size='mini'][native] .uni-button-cover-view-inner { + padding: 0 1.34em; +} + +uni-button[loading]:not([disabled]) { + cursor: progress; +} + +uni-button[loading]:before { + content: ' '; + display: inline-block; + width: 18px; + height: 18px; + vertical-align: middle; + animation: uni-loading 1s steps(12, end) infinite; + background-size: 100%; +} + +uni-button[loading][type='primary'] { + color: rgba(255, 255, 255, 0.6); + background-color: #0062cc; +} + +uni-button[loading][type='primary'][plain] { + color: #007aff; + background-color: transparent; +} + +uni-button[loading][type='default'] { + color: rgba(0, 0, 0, 0.6); + background-color: #dedede; +} + +uni-button[loading][type='default'][plain] { + color: #353535; + background-color: transparent; +} + +uni-button[loading][type='warn'] { + color: rgba(255, 255, 255, 0.6); + background-color: #ce3c39; +} + +uni-button[loading][type='warn'][plain] { + color: #e64340; + background-color: transparent; +} + +uni-button[loading][native]:before { + content: none; +} + +.button-hover { + color: rgba(0, 0, 0, 0.6); + background-color: #dedede; +} + +.button-hover[plain] { + color: rgba(53, 53, 53, 0.6); + border-color: rgba(53, 53, 53, 0.6); + background-color: transparent; +} + +.button-hover[type='primary'] { + color: rgba(255, 255, 255, 0.6); + background-color: #0062cc; +} + +.button-hover[type='primary'][plain] { + color: rgba(26, 173, 25, 0.6); + border-color: rgba(26, 173, 25, 0.6); + background-color: transparent; +} + +.button-hover[type='default'] { + color: rgba(0, 0, 0, 0.6); + background-color: #dedede; +} + +.button-hover[type='default'][plain] { + color: rgba(53, 53, 53, 0.6); + border-color: rgba(53, 53, 53, 0.6); + background-color: transparent; +} + +.button-hover[type='warn'] { + color: rgba(255, 255, 255, 0.6); + background-color: #ce3c39; +} + +.button-hover[type='warn'][plain] { + color: rgba(230, 67, 64, 0.6); + border-color: rgba(230, 67, 64, 0.6); + background-color: transparent; +} diff --git a/packages/uni-app-plus/dist/uni-app-service.es.js b/packages/uni-app-plus/dist/uni-app-service.es.js new file mode 100644 index 0000000000000000000000000000000000000000..a396fc597f329c75abc1c129c653169560e9c3e9 --- /dev/null +++ b/packages/uni-app-plus/dist/uni-app-service.es.js @@ -0,0 +1,497 @@ +export function createServiceContext(Vue, weex, plus, UniServiceJSBridge,instanceContext){ +const setTimeout = instanceContext.setTimeout; +const clearTimeout = instanceContext.clearTimeout; +const setInterval = instanceContext.setInterval; +const clearInterval = instanceContext.clearInterval; +const __uniConfig = instanceContext.__uniConfig; +const __uniRoutes = instanceContext.__uniRoutes; + +var serviceContext = (function () { + 'use strict'; + + /** + * Make a map and return a function for checking if a key + * is in that map. + * IMPORTANT: all calls of this function must be prefixed with + * \/\*#\_\_PURE\_\_\*\/ + * So that rollup can tree-shake them if necessary. + */ + (process.env.NODE_ENV !== 'production') + ? Object.freeze({}) + : {}; + (process.env.NODE_ENV !== 'production') ? Object.freeze([]) : []; + const extend = Object.assign; + const isString = (val) => typeof val === 'string'; + + let isInitEntryPage = false; + function initEntry() { + if (isInitEntryPage) { + return; + } + isInitEntryPage = true; + let entryPagePath; + let entryPageQuery; + const weexPlus = weex.requireModule('plus'); + if (weexPlus.getRedirectInfo) { + const info = weexPlus.getRedirectInfo() || {}; + entryPagePath = info.path; + entryPageQuery = info.query ? '?' + info.query : ''; + } + else { + const argsJsonStr = plus.runtime.arguments; + if (!argsJsonStr) { + return; + } + try { + const args = JSON.parse(argsJsonStr); + entryPagePath = args.path || args.pathName; + entryPageQuery = args.query ? '?' + args.query : ''; + } + catch (e) { } + } + if (!entryPagePath || entryPagePath === __uniConfig.entryPagePath) { + if (entryPageQuery) { + __uniConfig.entryPageQuery = entryPageQuery; + } + return; + } + const entryRoute = '/' + entryPagePath; + const routeOptions = __uniRoutes.find((route) => route.path === entryRoute); + if (!routeOptions) { + return; + } + if (!routeOptions.meta.isTabBar) { + __uniConfig.realEntryPagePath = + __uniConfig.realEntryPagePath || __uniConfig.entryPagePath; + } + __uniConfig.entryPagePath = entryPagePath; + __uniConfig.entryPageQuery = entryPageQuery; + } + + const cacheStringFunction = (fn) => { + const cache = Object.create(null); + return ((str) => { + const hit = cache[str]; + return hit || (cache[str] = fn(str)); + }); + }; + const invokeArrayFns = (fns, arg) => { + let ret; + for (let i = 0; i < fns.length; i++) { + ret = fns[i](arg); + } + return ret; + }; + const TABBAR_HEIGHT = 50; + const SCHEME_RE = /^([a-z-]+:)?\/\//i; + const DATA_RE = /^data:.*,.*/; + const WEB_INVOKE_APPSERVICE = 'WEB_INVOKE_APPSERVICE'; + + function getRealRoute(fromRoute, toRoute) { + if (toRoute.indexOf('/') === 0) { + return toRoute; + } + if (toRoute.indexOf('./') === 0) { + return getRealRoute(fromRoute, toRoute.substr(2)); + } + const toRouteArray = toRoute.split('/'); + const toRouteLength = toRouteArray.length; + let i = 0; + for (; i < toRouteLength && toRouteArray[i] === '..'; i++) { + // noop + } + toRouteArray.splice(0, i); + toRoute = toRouteArray.join('/'); + const fromRouteArray = fromRoute.length > 0 ? fromRoute.split('/') : []; + fromRouteArray.splice(fromRouteArray.length - i - 1, i + 1); + return '/' + fromRouteArray.concat(toRouteArray).join('/'); + } + + function getCurrentPage() { + const pages = getCurrentPages(); + const len = pages.length; + if (len) { + return pages[len - 1]; + } + } + function getCurrentPageVm() { + const page = getCurrentPage(); + if (page) { + return page.$vm; + } + } + function invokeHook(vm, name, args) { + if (isString(vm)) { + args = name; + name = vm; + vm = getCurrentPageVm(); + } + else if (typeof vm === 'number') { + const page = getCurrentPages().find((page) => page.$page.id === vm); + if (page) { + vm = page.$vm; + } + else { + vm = getCurrentPageVm(); + } + } + if (!vm) { + return; + } + const hooks = vm.$[name]; + return hooks && invokeArrayFns(hooks, args); + } + + function getRealPath(filepath) { + // 无协议的情况补全 https + if (filepath.indexOf('//') === 0) { + return 'https:' + filepath; + } + // 网络资源或base64 + if (SCHEME_RE.test(filepath) || DATA_RE.test(filepath)) { + return filepath; + } + if (isSystemURL(filepath)) { + return 'file://' + normalizeLocalPath(filepath); + } + const wwwPath = 'file://' + normalizeLocalPath('_www'); + // 绝对路径转换为本地文件系统路径 + if (filepath.indexOf('/') === 0) { + // 平台绝对路径 安卓、iOS + if (filepath.startsWith('/storage/') || + filepath.includes('/Containers/Data/Application/')) { + return 'file://' + filepath; + } + return wwwPath + filepath; + } + // 相对资源 + if (filepath.indexOf('../') === 0 || filepath.indexOf('./') === 0) { + // @ts-expect-error app-view + if (typeof __id__ === 'string') { + // @ts-expect-error app-view + return wwwPath + getRealRoute('/' + __id__, filepath); + } + else { + const pages = getCurrentPages(); + if (pages.length) { + return (wwwPath + getRealRoute('/' + pages[pages.length - 1].route, filepath)); + } + } + } + return filepath; + } + const normalizeLocalPath = cacheStringFunction((filepath) => { + return plus.io + .convertLocalFileSystemURL(filepath) + .replace(/^\/?apps\//, '/android_asset/apps/') + .replace(/\/$/, ''); + }); + function isSystemURL(filepath) { + if (filepath.indexOf('_www') === 0 || + filepath.indexOf('_doc') === 0 || + filepath.indexOf('_documents') === 0 || + filepath.indexOf('_downloads') === 0) { + return true; + } + return false; + } + + const isIOS = plus.os.name === 'iOS'; + let config; + /** + * tabbar显示状态 + */ + let visible = true; + let tabBar; + /** + * 设置角标 + * @param {string} type + * @param {number} index + * @param {string} text + */ + function setTabBarBadge(type, index, text) { + if (!tabBar) { + return; + } + if (type === 'none') { + tabBar.hideTabBarRedDot({ + index, + }); + tabBar.removeTabBarBadge({ + index, + }); + } + else if (type === 'text') { + tabBar.setTabBarBadge({ + index, + text, + }); + } + else if (type === 'redDot') { + tabBar.showTabBarRedDot({ + index, + }); + } + } + /** + * 动态设置 tabBar 某一项的内容 + */ + function setTabBarItem(index, text, iconPath, selectedIconPath) { + const item = { + index, + }; + if (text !== undefined) { + item.text = text; + } + if (iconPath) { + item.iconPath = getRealPath(iconPath); + } + if (selectedIconPath) { + item.selectedIconPath = getRealPath(selectedIconPath); + } + tabBar && tabBar.setTabBarItem(item); + } + /** + * 动态设置 tabBar 的整体样式 + * @param {Object} style 样式 + */ + function setTabBarStyle(style) { + tabBar && tabBar.setTabBarStyle(style); + } + /** + * 隐藏 tabBar + * @param {boolean} animation 是否需要动画效果 + */ + function hideTabBar(animation) { + visible = false; + tabBar && + tabBar.hideTabBar({ + animation, + }); + } + /** + * 显示 tabBar + * @param {boolean} animation 是否需要动画效果 + */ + function showTabBar(animation) { + visible = true; + tabBar && + tabBar.showTabBar({ + animation, + }); + } + const maskClickCallback = []; + var tabBar$1 = { + id: '0', + init(options, clickCallback) { + if (options && options.list.length) { + config = options; + } + try { + tabBar = weex.requireModule('uni-tabview'); + } + catch (error) { + console.log(`uni.requireNativePlugin("uni-tabview") error ${error}`); + } + tabBar.onMaskClick(() => { + maskClickCallback.forEach((callback) => { + callback(); + }); + }); + tabBar && + tabBar.onClick(({ index }) => { + clickCallback(config.list[index], index); + }); + tabBar && + tabBar.onMidButtonClick(() => { + // publish('onTabBarMidButtonTap', {}) + }); + }, + indexOf(page) { + const itemLength = config && config.list && config.list.length; + if (itemLength) { + for (let i = 0; i < itemLength; i++) { + if (config.list[i].pagePath === page || + config.list[i].pagePath === `${page}.html`) { + return i; + } + } + } + return -1; + }, + switchTab(page) { + const index = this.indexOf(page); + if (index >= 0) { + tabBar && + tabBar.switchSelect({ + index, + }); + return true; + } + return false; + }, + setTabBarBadge, + setTabBarItem, + setTabBarStyle, + hideTabBar, + showTabBar, + append(webview) { + tabBar && + tabBar.append({ + id: webview.id, + }, ({ code }) => { + if (code !== 0) { + setTimeout(() => { + this.append(webview); + }, 20); + } + }); + }, + get visible() { + return visible; + }, + get height() { + return ((config && config.height ? parseFloat(config.height) : TABBAR_HEIGHT) + + plus.navigator.getSafeAreaInsets().deviceBottom); + }, + // tabBar是否遮挡内容区域 + get cover() { + const array = ['extralight', 'light', 'dark']; + return isIOS && array.indexOf(config.blurEffect) >= 0; + }, + setStyle({ mask }) { + tabBar.setMask({ + color: mask, + }); + }, + addEventListener(_name, callback) { + maskClickCallback.push(callback); + }, + removeEventListener(_name, callback) { + const callbackIndex = maskClickCallback.indexOf(callback); + maskClickCallback.splice(callbackIndex, 1); + }, + }; + + function initTabBar() { + const len = __uniConfig.tabBar?.list?.length; + if (!len) { + return; + } + __uniConfig.tabBar.selectedIndex = 0; + const selected = __uniConfig.tabBar.list.findIndex((page) => page.pagePath === __uniConfig.entryPagePath); + tabBar$1.init(__uniConfig.tabBar, (item, index) => { + uni.switchTab({ + url: '/' + item.pagePath, + openType: 'switchTab', + from: 'tabBar', + success() { + invokeHook('onTabItemTap', { + index, + text: item.text, + pagePath: item.pagePath, + }); + }, + }); + }); + if (selected !== -1) { + // 取当前 tab 索引值 + __uniConfig.tabBar.selectedIndex = selected; + selected !== 0 && tabBar$1.switchTab(__uniConfig.entryPagePath); + } + } + + const callbacks = {}; + // 简单处理 view 层与 service 层的通知系统 + /** + * 消费 view 层通知 + */ + function consumePlusMessage(type, args) { + // 处理 web-view 组件发送的通知 + if (type === WEB_INVOKE_APPSERVICE) { + UniServiceJSBridge.emit('onWebInvokeAppService', args.data, args.webviewIds); + return true; + } + const callback = callbacks[type]; + if (callback) { + callback(args); + if (!callback.keepAlive) { + delete callbacks[type]; + } + return true; + } + return false; + } + + function backbuttonListener() { + uni.navigateBack({ + from: 'backbutton', + }); + } + + function initGlobalEvent() { + const plusGlobalEvent = plus.weexGlobalEvent; + const weexGlobalEvent = weex.requireModule('weexGlobalEvent'); + const emit = UniServiceJSBridge.emit; + if (weex.config.preload) { + plus.key.addEventListener('backbutton', backbuttonListener); + } + else { + plusGlobalEvent.addEventListener('splashclosed', () => { + plus.key.addEventListener('backbutton', backbuttonListener); + }); + } + plusGlobalEvent.addEventListener('pause', () => { + emit('onAppEnterBackground'); + }); + plusGlobalEvent.addEventListener('resume', () => { + emit('onAppEnterForeground'); + }); + weexGlobalEvent.addEventListener('uistylechange', function (event) { + const args = { + theme: event.uistyle, + }; + emit('onThemeChange', args); + }); + plusGlobalEvent.addEventListener('plusMessage', onPlusMessage); + // nvue webview post message + plusGlobalEvent.addEventListener('WebviewPostMessage', onPlusMessage); + } + function onPlusMessage(e) { + if (e.data && e.data.type) { + const type = e.data.type; + consumePlusMessage(type, e.data.args || {}); + } + } + + let appCtx; + const defaultApp = { + globalData: {}, + }; + function registerApp(appVm) { + appCtx = appVm; + appCtx.$vm = appVm; + extend(appCtx, defaultApp); // 拷贝默认实现 + const { $options } = appVm; + if ($options) { + appCtx.globalData = extend($options.globalData || {}, appCtx.globalData); + } + initEntry(); + initTabBar(); + initGlobalEvent(); + } + + var index = { + __registerApp: registerApp, + }; + + return index; + +}()); +const uni = serviceContext.uni; +const getApp = serviceContext.getApp; +const getCurrentPages = serviceContext.getCurrentPages; +const __definePage = serviceContext.__definePage; +const __registerPage = serviceContext.__registerPage; +return serviceContext; +} diff --git a/packages/uni-app-plus/dist/uni-app-view.umd.js b/packages/uni-app-plus/dist/uni-app-view.umd.js new file mode 100644 index 0000000000000000000000000000000000000000..5c9fb6d287786b6c9fad84cf559d9c1bf95c554e --- /dev/null +++ b/packages/uni-app-plus/dist/uni-app-view.umd.js @@ -0,0 +1,1551 @@ +(function(global, factory) { + typeof exports === "object" && typeof module !== "undefined" ? factory(require("vue")) : typeof define === "function" && define.amd ? define(["vue"], factory) : (global = typeof globalThis !== "undefined" ? globalThis : global || self, factory(global.Vue)); +})(this, function(vue) { + "use strict"; + var commonjsGlobal = typeof globalThis !== "undefined" ? globalThis : typeof window !== "undefined" ? window : typeof window !== "undefined" ? window : typeof self !== "undefined" ? self : {}; + function getDefaultExportFromCjs(x) { + return x && x.__esModule && Object.prototype.hasOwnProperty.call(x, "default") ? x["default"] : x; + } + var dist = { exports: {} }; + (function(module2, exports2) { + !function(t, e) { + module2.exports = e(); + }(typeof self != "undefined" ? self : commonjsGlobal, function() { + return function(t) { + var e = {}; + function n(r) { + if (e[r]) + return e[r].exports; + var o = e[r] = { i: r, l: false, exports: {} }; + return t[r].call(o.exports, o, o.exports, n), o.l = true, o.exports; + } + return n.m = t, n.c = e, n.d = function(t2, e2, r) { + n.o(t2, e2) || Object.defineProperty(t2, e2, { enumerable: true, get: r }); + }, n.r = function(t2) { + typeof Symbol != "undefined" && Symbol.toStringTag && Object.defineProperty(t2, Symbol.toStringTag, { value: "Module" }), Object.defineProperty(t2, "__esModule", { value: true }); + }, n.t = function(t2, e2) { + if (1 & e2 && (t2 = n(t2)), 8 & e2) + return t2; + if (4 & e2 && typeof t2 == "object" && t2 && t2.__esModule) + return t2; + var r = Object.create(null); + if (n.r(r), Object.defineProperty(r, "default", { enumerable: true, value: t2 }), 2 & e2 && typeof t2 != "string") + for (var o in t2) + n.d(r, o, function(e3) { + return t2[e3]; + }.bind(null, o)); + return r; + }, n.n = function(t2) { + var e2 = t2 && t2.__esModule ? function() { + return t2.default; + } : function() { + return t2; + }; + return n.d(e2, "a", e2), e2; + }, n.o = function(t2, e2) { + return Object.prototype.hasOwnProperty.call(t2, e2); + }, n.p = "", n(n.s = 1); + }([function(t, e, n) { + (function(t2) { + n.d(e, "a", function() { + return c; + }); + const r = (t3) => { + const e2 = Object.create(null); + return (n2) => e2[n2] || (e2[n2] = t3(n2)); + }, u = r((t3) => t3.charAt(0).toUpperCase() + t3.slice(1)), c = r((t3) => t3 ? "on" + u(t3) : ""); + }).call(this, n(2)); + }, function(t, e, n) { + t.exports = n(3); + }, function(t, e) { + var n; + n = function() { + return this; + }(); + try { + n = n || new Function("return this")(); + } catch (t2) { + typeof window == "object" && (n = window); + } + t.exports = n; + }, function(t, e, n) { + n.r(e), n.d(e, "default", function() { + return j; + }); + var r = n(0), o = /-(\w)/g, i = function(t2) { + return t2.replace(o, function(t3, e2) { + return e2 ? e2.toUpperCase() : ""; + }); + }, u = /\B([A-Z])/g, c = function(t2) { + return t2.replace(u, "-$1").toLowerCase(); + }; + function a(t2, e2) { + if (t2) { + var n2 = t2.$options[e2] || []; + Array.isArray(n2) || (n2 = [n2]), n2.forEach(function(e3) { + e3.call(t2); + }); + } + } + function f(t2, e2) { + return new CustomEvent(t2, { bubbles: false, cancelable: false, detail: e2.length === 1 ? e2[0] : e2 }); + } + var s = function(t2) { + return /function Boolean/.test(String(t2)); + }, l = function(t2) { + return /function Number/.test(String(t2)); + }; + function p(t2, e2) { + if (t2.nodeType === 3) + return t2.data.trim() ? t2.data : null; + if (t2.nodeType === 1) { + var n2 = { attrs: d(t2), domProps: { innerHTML: t2.innerHTML } }; + return n2.attrs.slot && (n2.slot = n2.attrs.slot, delete n2.attrs.slot), e2(t2.tagName, n2); + } + return null; + } + function d(t2) { + for (var e2 = {}, n2 = 0, r2 = t2.attributes.length; n2 < r2; n2++) { + var o2 = t2.attributes[n2]; + e2[o2.nodeName] = o2.nodeValue; + } + return e2; + } + function y(t2) { + return (y = typeof Symbol == "function" && typeof Symbol.iterator == "symbol" ? function(t3) { + return typeof t3; + } : function(t3) { + return t3 && typeof Symbol == "function" && t3.constructor === Symbol && t3 !== Symbol.prototype ? "symbol" : typeof t3; + })(t2); + } + function b(t2, e2) { + for (var n2 = 0; n2 < e2.length; n2++) { + var r2 = e2[n2]; + r2.enumerable = r2.enumerable || false, r2.configurable = true, "value" in r2 && (r2.writable = true), Object.defineProperty(t2, r2.key, r2); + } + } + function v(t2, e2) { + return !e2 || y(e2) !== "object" && typeof e2 != "function" ? h(t2) : e2; + } + function h(t2) { + if (t2 === void 0) + throw new ReferenceError("this hasn't been initialised - super() hasn't been called"); + return t2; + } + function m(t2) { + var e2 = typeof Map == "function" ? new Map() : void 0; + return (m = function(t3) { + if (t3 === null || (n2 = t3, Function.toString.call(n2).indexOf("[native code]") === -1)) + return t3; + var n2; + if (typeof t3 != "function") + throw new TypeError("Super expression must either be null or a function"); + if (e2 !== void 0) { + if (e2.has(t3)) + return e2.get(t3); + e2.set(t3, r2); + } + function r2() { + return _(t3, arguments, O(this).constructor); + } + return r2.prototype = Object.create(t3.prototype, { constructor: { value: r2, enumerable: false, writable: true, configurable: true } }), w(r2, t3); + })(t2); + } + function _(t2, e2, n2) { + return (_ = g() ? Reflect.construct : function(t3, e3, n3) { + var r2 = [null]; + r2.push.apply(r2, e3); + var o2 = new (Function.bind.apply(t3, r2))(); + return n3 && w(o2, n3.prototype), o2; + }).apply(null, arguments); + } + function g() { + if (typeof Reflect == "undefined" || !Reflect.construct) + return false; + if (Reflect.construct.sham) + return false; + if (typeof Proxy == "function") + return true; + try { + return Date.prototype.toString.call(Reflect.construct(Date, [], function() { + })), true; + } catch (t2) { + return false; + } + } + function w(t2, e2) { + return (w = Object.setPrototypeOf || function(t3, e3) { + return t3.__proto__ = e3, t3; + })(t2, e2); + } + function O(t2) { + return (O = Object.setPrototypeOf ? Object.getPrototypeOf : function(t3) { + return t3.__proto__ || Object.getPrototypeOf(t3); + })(t2); + } + function j(t2, e2, n2, o2) { + var u2, d2, y2, _2 = t2, j2 = false; + var x = function(t3) { + !function(t4, e3) { + if (typeof e3 != "function" && e3 !== null) + throw new TypeError("Super expression must either be null or a function"); + t4.prototype = Object.create(e3 && e3.prototype, { constructor: { value: t4, writable: true, configurable: true } }), e3 && w(t4, e3); + }(C, t3); + var c2, m2, x2, A, P = (c2 = C, m2 = g(), function() { + var t4, e3 = O(c2); + if (m2) { + var n3 = O(this).constructor; + t4 = Reflect.construct(e3, arguments, n3); + } else + t4 = e3.apply(this, arguments); + return v(this, t4); + }); + function C() { + var t4; + !function(t5, e3) { + if (!(t5 instanceof e3)) + throw new TypeError("Cannot call a class as a function"); + }(this, C), (t4 = P.call(this))._wrapper = void 0, t4._component = void 0, t4._props = void 0, t4._slotChildren = void 0, t4._mounted = false; + var r2 = t4.createEventProxies(_2.emits); + t4._props = {}, t4._slotChildren = []; + var o3 = h(t4); + return t4._wrapper = e2({ render: function() { + var t5 = Object.assign({}, o3._props, r2); + return delete t5.dataVApp, n2(_2, t5, function() { + return o3._slotChildren; + }); + }, mounted: function() { + o3._mounted = true; + }, unmounted: function() { + o3._mounted = false; + } }), new MutationObserver(function(e3) { + for (var n3 = 0; n3 < e3.length; n3++) { + var r3 = e3[n3]; + j2 && r3.type === "attributes" && r3.target === h(t4) ? r3.attributeName && t4.syncAttribute(r3.attributeName) : true; + } + }).observe(h(t4), { childList: true, subtree: true, characterData: true, attributes: true }), t4; + } + return x2 = C, (A = [{ key: "createEventProxies", value: function(t4) { + var e3 = this, n3 = {}; + return t4 && t4.forEach(function(t5) { + var o3 = Object(r.a)(i(t5)); + n3[o3] = function() { + for (var n4 = arguments.length, r2 = new Array(n4), o4 = 0; o4 < n4; o4++) + r2[o4] = arguments[o4]; + e3.dispatchEvent(f(t5, r2)); + }; + }), n3; + } }, { key: "syncAttribute", value: function(t4) { + var e3, n3 = i(t4), r2 = void 0; + this.hasOwnProperty(t4) ? r2 = this[t4] : this.hasAttribute(t4) && (r2 = this.getAttribute(t4)), this._props[n3] = function(t5, e4) { + var n4 = arguments.length > 2 && arguments[2] !== void 0 ? arguments[2] : {}, r3 = n4.type; + if (s(r3)) + return t5 === "true" || t5 === "false" ? t5 === "true" : t5 === "" || t5 === e4 || t5 != null; + if (l(r3)) { + var o3 = parseFloat(t5); + return isNaN(o3) ? t5 : o3; + } + return t5; + }(r2, t4, y2[n3]), (e3 = this._component) === null || e3 === void 0 || e3.$forceUpdate(); + } }, { key: "syncSlots", value: function() { + var t4; + this._slotChildren = function(t5, e3) { + for (var n3 = [], r2 = 0, o3 = t5.length; r2 < o3; r2++) + n3.push(p(t5[r2], e3)); + return n3; + }(this.childNodes, n2), (t4 = this._component) === null || t4 === void 0 || t4.$forceUpdate(); + } }, { key: "syncInitialAttributes", value: function() { + var t4, e3 = this; + this._props = (t4 = {}, d2.forEach(function(e4) { + t4[e4] = void 0; + }), t4), u2.forEach(function(t5) { + e3.syncAttribute(t5); + }); + } }, { key: "connectedCallback", value: function() { + this._component && this._mounted ? a(this._component, "mounted") : (j2 && this.syncInitialAttributes(), this.syncSlots(), this._component = this._wrapper.mount(this)), (o2 == null ? void 0 : o2.connectedCallback) && o2.connectedCallback.bind(this)(); + } }, { key: "disconnectedCallback", value: function() { + a(this._component, "unmounted"); + } }]) && b(x2.prototype, A), C; + }(m(HTMLElement)); + return function() { + if (!j2) { + var t3 = Array.isArray(_2.props) ? _2.props : Object.keys(_2.props || {}); + u2 = t3.map(c), d2 = t3.map(i); + var e3 = Array.isArray(_2.props) ? {} : _2.props || {}; + y2 = d2.reduce(function(n3, r2, o3) { + return n3[r2] = e3[t3[o3]], n3; + }, {}), j2 = true; + } + }(), x; + } + }]).default; + }); + })(dist); + var wrapper = /* @__PURE__ */ getDefaultExportFromCjs(dist.exports); + var button = "uni-button {\n position: relative;\n display: block;\n margin-left: auto;\n margin-right: auto;\n padding-left: 14px;\n padding-right: 14px;\n box-sizing: border-box;\n font-size: 18px;\n text-align: center;\n text-decoration: none;\n line-height: 2.55555556;\n border-radius: 5px;\n -webkit-tap-highlight-color: transparent;\n overflow: hidden;\n color: #000000;\n background-color: #f8f8f8;\n cursor: pointer;\n}\n\nuni-button[hidden] {\n display: none !important;\n}\n\nuni-button:after {\n content: ' ';\n width: 200%;\n height: 200%;\n position: absolute;\n top: 0;\n left: 0;\n border: 1px solid rgba(0, 0, 0, 0.2);\n transform: scale(0.5);\n transform-origin: 0 0;\n box-sizing: border-box;\n border-radius: 10px;\n}\n\nuni-button[native] {\n padding-left: 0;\n padding-right: 0;\n}\n\nuni-button[native] .uni-button-cover-view-wrapper {\n border: inherit;\n border-color: inherit;\n border-radius: inherit;\n background-color: inherit;\n}\n\nuni-button[native] .uni-button-cover-view-inner {\n padding-left: 14px;\n padding-right: 14px;\n}\n\nuni-button uni-cover-view {\n line-height: inherit;\n white-space: inherit;\n}\n\nuni-button[type='default'] {\n color: #000000;\n background-color: #f8f8f8;\n}\n\nuni-button[type='primary'] {\n color: #ffffff;\n background-color: #007aff;\n}\n\nuni-button[type='warn'] {\n color: #ffffff;\n background-color: #e64340;\n}\n\nuni-button[disabled] {\n color: rgba(255, 255, 255, 0.6);\n cursor: not-allowed;\n}\n\nuni-button[disabled][type='default'],\nuni-button[disabled]:not([type]) {\n color: rgba(0, 0, 0, 0.3);\n background-color: #f7f7f7;\n}\n\nuni-button[disabled][type='primary'] {\n background-color: rgba(0, 122, 255, 0.6);\n}\n\nuni-button[disabled][type='warn'] {\n background-color: #ec8b89;\n}\n\nuni-button[type='primary'][plain] {\n color: #007aff;\n border: 1px solid #007aff;\n background-color: transparent;\n}\n\nuni-button[type='primary'][plain][disabled] {\n color: rgba(0, 0, 0, 0.2);\n border-color: rgba(0, 0, 0, 0.2);\n}\n\nuni-button[type='primary'][plain]:after {\n border-width: 0;\n}\n\nuni-button[type='default'][plain] {\n color: #353535;\n border: 1px solid #353535;\n background-color: transparent;\n}\n\nuni-button[type='default'][plain][disabled] {\n color: rgba(0, 0, 0, 0.2);\n border-color: rgba(0, 0, 0, 0.2);\n}\n\nuni-button[type='default'][plain]:after {\n border-width: 0;\n}\n\nuni-button[plain] {\n color: #353535;\n border: 1px solid #353535;\n background-color: transparent;\n}\n\nuni-button[plain][disabled] {\n color: rgba(0, 0, 0, 0.2);\n border-color: rgba(0, 0, 0, 0.2);\n}\n\nuni-button[plain]:after {\n border-width: 0;\n}\n\nuni-button[plain][native] .uni-button-cover-view-inner {\n padding: 0;\n}\n\nuni-button[type='warn'][plain] {\n color: #e64340;\n border: 1px solid #e64340;\n background-color: transparent;\n}\n\nuni-button[type='warn'][plain][disabled] {\n color: rgba(0, 0, 0, 0.2);\n border-color: rgba(0, 0, 0, 0.2);\n}\n\nuni-button[type='warn'][plain]:after {\n border-width: 0;\n}\n\nuni-button[size='mini'] {\n display: inline-block;\n line-height: 2.3;\n font-size: 13px;\n padding: 0 1.34em;\n}\n\nuni-button[size='mini'][native] {\n padding: 0;\n}\n\nuni-button[size='mini'][native] .uni-button-cover-view-inner {\n padding: 0 1.34em;\n}\n\nuni-button[loading]:not([disabled]) {\n cursor: progress;\n}\n\nuni-button[loading]:before {\n content: ' ';\n display: inline-block;\n width: 18px;\n height: 18px;\n vertical-align: middle;\n animation: uni-loading 1s steps(12, end) infinite;\n background-size: 100%;\n}\n\nuni-button[loading][type='primary'] {\n color: rgba(255, 255, 255, 0.6);\n background-color: #0062cc;\n}\n\nuni-button[loading][type='primary'][plain] {\n color: #007aff;\n background-color: transparent;\n}\n\nuni-button[loading][type='default'] {\n color: rgba(0, 0, 0, 0.6);\n background-color: #dedede;\n}\n\nuni-button[loading][type='default'][plain] {\n color: #353535;\n background-color: transparent;\n}\n\nuni-button[loading][type='warn'] {\n color: rgba(255, 255, 255, 0.6);\n background-color: #ce3c39;\n}\n\nuni-button[loading][type='warn'][plain] {\n color: #e64340;\n background-color: transparent;\n}\n\nuni-button[loading][native]:before {\n content: none;\n}\n\n.button-hover {\n color: rgba(0, 0, 0, 0.6);\n background-color: #dedede;\n}\n\n.button-hover[plain] {\n color: rgba(53, 53, 53, 0.6);\n border-color: rgba(53, 53, 53, 0.6);\n background-color: transparent;\n}\n\n.button-hover[type='primary'] {\n color: rgba(255, 255, 255, 0.6);\n background-color: #0062cc;\n}\n\n.button-hover[type='primary'][plain] {\n color: rgba(26, 173, 25, 0.6);\n border-color: rgba(26, 173, 25, 0.6);\n background-color: transparent;\n}\n\n.button-hover[type='default'] {\n color: rgba(0, 0, 0, 0.6);\n background-color: #dedede;\n}\n\n.button-hover[type='default'][plain] {\n color: rgba(53, 53, 53, 0.6);\n border-color: rgba(53, 53, 53, 0.6);\n background-color: transparent;\n}\n\n.button-hover[type='warn'] {\n color: rgba(255, 255, 255, 0.6);\n background-color: #ce3c39;\n}\n\n.button-hover[type='warn'][plain] {\n color: rgba(230, 67, 64, 0.6);\n border-color: rgba(230, 67, 64, 0.6);\n background-color: transparent;\n}\n"; + const extend = Object.assign; + const isString = (val) => typeof val === "string"; + const objectToString = Object.prototype.toString; + const toTypeString = (value) => objectToString.call(value); + const isPlainObject = (val) => toTypeString(val) === "[object Object]"; + function getCustomDataset(el) { + return extend({}, el.dataset, el.__uniDataset); + } + function normalizeTarget(el) { + const { id, offsetTop, offsetLeft } = el; + return { + id, + dataset: getCustomDataset(el), + offsetTop, + offsetLeft + }; + } + const PRIMARY_COLOR = "#007aff"; + const isObject = (val) => val !== null && typeof val === "object"; + class BaseFormatter { + constructor() { + this._caches = Object.create(null); + } + interpolate(message, values) { + if (!values) { + return [message]; + } + let tokens = this._caches[message]; + if (!tokens) { + tokens = parse(message); + this._caches[message] = tokens; + } + return compile(tokens, values); + } + } + const RE_TOKEN_LIST_VALUE = /^(?:\d)+/; + const RE_TOKEN_NAMED_VALUE = /^(?:\w)+/; + function parse(format) { + const tokens = []; + let position = 0; + let text = ""; + while (position < format.length) { + let char = format[position++]; + if (char === "{") { + if (text) { + tokens.push({ type: "text", value: text }); + } + text = ""; + let sub = ""; + char = format[position++]; + while (char !== void 0 && char !== "}") { + sub += char; + char = format[position++]; + } + const isClosed = char === "}"; + const type = RE_TOKEN_LIST_VALUE.test(sub) ? "list" : isClosed && RE_TOKEN_NAMED_VALUE.test(sub) ? "named" : "unknown"; + tokens.push({ value: sub, type }); + } else if (char === "%") { + if (format[position] !== "{") { + text += char; + } + } else { + text += char; + } + } + text && tokens.push({ type: "text", value: text }); + return tokens; + } + function compile(tokens, values) { + const compiled = []; + let index = 0; + const mode = Array.isArray(values) ? "list" : isObject(values) ? "named" : "unknown"; + if (mode === "unknown") { + return compiled; + } + while (index < tokens.length) { + const token = tokens[index]; + switch (token.type) { + case "text": + compiled.push(token.value); + break; + case "list": + compiled.push(values[parseInt(token.value, 10)]); + break; + case "named": + if (mode === "named") { + compiled.push(values[token.value]); + } + break; + } + index++; + } + return compiled; + } + const LOCALE_ZH_HANS = "zh-Hans"; + const LOCALE_ZH_HANT = "zh-Hant"; + const LOCALE_EN = "en"; + const LOCALE_FR = "fr"; + const LOCALE_ES = "es"; + const hasOwnProperty = Object.prototype.hasOwnProperty; + const hasOwn = (val, key) => hasOwnProperty.call(val, key); + const defaultFormatter = new BaseFormatter(); + function include(str, parts) { + return !!parts.find((part) => str.indexOf(part) !== -1); + } + function startsWith(str, parts) { + return parts.find((part) => str.indexOf(part) === 0); + } + function normalizeLocale(locale, messages) { + if (!locale) { + return; + } + locale = locale.trim().replace(/_/g, "-"); + if (messages[locale]) { + return locale; + } + locale = locale.toLowerCase(); + 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; + } + const lang = startsWith(locale, [LOCALE_EN, LOCALE_FR, LOCALE_ES]); + if (lang) { + return lang; + } + } + class I18n { + constructor({ locale, fallbackLocale, messages, watcher, formater }) { + this.locale = LOCALE_EN; + this.fallbackLocale = LOCALE_EN; + this.message = {}; + this.messages = {}; + this.watchers = []; + if (fallbackLocale) { + this.fallbackLocale = fallbackLocale; + } + this.formater = formater || defaultFormatter; + this.messages = messages || {}; + this.setLocale(locale); + if (watcher) { + this.watchLocale(watcher); + } + } + setLocale(locale) { + const oldLocale = this.locale; + this.locale = normalizeLocale(locale, this.messages) || this.fallbackLocale; + if (!this.messages[this.locale]) { + this.messages[this.locale] = {}; + } + this.message = this.messages[this.locale]; + this.watchers.forEach((watcher) => { + watcher(this.locale, oldLocale); + }); + } + getLocale() { + return this.locale; + } + watchLocale(fn) { + const index = this.watchers.push(fn) - 1; + return () => { + this.watchers.splice(index, 1); + }; + } + add(locale, message) { + if (this.messages[locale]) { + Object.assign(this.messages[locale], message); + } else { + this.messages[locale] = message; + } + } + t(key, locale, values) { + let message = this.message; + if (typeof locale === "string") { + locale = normalizeLocale(locale, this.messages); + locale && (message = this.messages[locale]); + } else { + values = locale; + } + if (!hasOwn(message, key)) { + console.warn(`Cannot translate the value of keypath ${key}. Use the value of keypath as default.`); + return key; + } + return this.formater.interpolate(message[key], values).join(""); + } + } + function initLocaleWatcher(appVm, i18n2) { + appVm.$i18n && appVm.$i18n.vm.$watch("locale", (newLocale) => { + i18n2.setLocale(newLocale); + }, { + immediate: true + }); + } + function initVueI18n(locale = LOCALE_EN, messages = {}, fallbackLocale = LOCALE_EN) { + if (typeof locale !== "string") { + [locale, messages] = [messages, locale]; + } + if (typeof locale !== "string") { + locale = fallbackLocale; + } + const i18n2 = new I18n({ + locale: locale || fallbackLocale, + fallbackLocale, + messages + }); + let t = (key, values) => { + if (typeof getApp !== "function") { + t = function(key2, values2) { + return i18n2.t(key2, values2); + }; + } else { + const appVm = getApp().$vm; + if (!appVm.$t || !appVm.$i18n) { + t = function(key2, values2) { + return i18n2.t(key2, values2); + }; + } else { + initLocaleWatcher(appVm, i18n2); + t = function(key2, values2) { + const $i18n = appVm.$i18n; + const silentTranslationWarn = $i18n.silentTranslationWarn; + $i18n.silentTranslationWarn = true; + const msg = appVm.$t(key2, values2); + $i18n.silentTranslationWarn = silentTranslationWarn; + if (msg !== key2) { + return msg; + } + return i18n2.t(key2, $i18n.locale, values2); + }; + } + } + return t(key, values); + }; + return { + i18n: i18n2, + t(key, values) { + return t(key, values); + }, + add(locale2, message) { + return i18n2.add(locale2, message); + }, + getLocale() { + return i18n2.getLocale(); + }, + setLocale(newLocale) { + return i18n2.setLocale(newLocale); + } + }; + } + let i18n; + function useI18n() { + if (!i18n) { + let language; + { + { + language = navigator.language; + } + } + i18n = initVueI18n(language); + } + return i18n; + } + const E = function() { + }; + E.prototype = { + on: function(name, callback, ctx) { + var e = this.e || (this.e = {}); + (e[name] || (e[name] = [])).push({ + fn: callback, + ctx + }); + return this; + }, + once: function(name, callback, ctx) { + var self2 = this; + function listener() { + self2.off(name, listener); + callback.apply(ctx, arguments); + } + listener._ = callback; + return this.on(name, listener, ctx); + }, + emit: function(name) { + var data = [].slice.call(arguments, 1); + var evtArr = ((this.e || (this.e = {}))[name] || []).slice(); + var i = 0; + var len = evtArr.length; + for (i; i < len; i++) { + evtArr[i].fn.apply(evtArr[i].ctx, data); + } + return this; + }, + off: function(name, callback) { + var e = this.e || (this.e = {}); + var evts = e[name]; + var liveEvents = []; + if (evts && callback) { + for (var i = 0, len = evts.length; i < len; i++) { + if (evts[i].fn !== callback && evts[i].fn._ !== callback) + liveEvents.push(evts[i]); + } + } + liveEvents.length ? e[name] = liveEvents : delete e[name]; + return this; + } + }; + function initBridge(namespace) { + const emitter = new E(); + return extend(emitter, { + subscribe(event, callback) { + emitter.on(`${namespace}.${event}`, callback); + }, + unsubscribe(event, callback) { + emitter.off(`${namespace}.${event}`, callback); + }, + subscribeHandler(event, args, pageId) { + { + console.log(`[${namespace}][subscribeHandler][${Date.now()}]:${event}, ${JSON.stringify(args)}, ${pageId}`); + } + emitter.emit(`${namespace}.${event}`, args, pageId); + } + }); + } + function PolySymbol(name) { + return Symbol("[uni-app]: " + name); + } + function rpx2px(str) { + if (typeof str === "string") { + const res = parseInt(str) || 0; + if (str.indexOf("rpx") !== -1 || str.indexOf("upx") !== -1) { + return uni.upx2px(res); + } + return res; + } + return str; + } + const ICON_PATH_CANCEL = "M20.928 10.176l-4.928 4.928-4.928-4.928-0.896 0.896 4.928 4.928-4.928 4.928 0.896 0.896 4.928-4.928 4.928 4.928 0.896-0.896-4.928-4.928 4.928-4.928-0.896-0.896zM16 2.080q-3.776 0-7.040 1.888-3.136 1.856-4.992 4.992-1.888 3.264-1.888 7.040t1.888 7.040q1.856 3.136 4.992 4.992 3.264 1.888 7.040 1.888t7.040-1.888q3.136-1.856 4.992-4.992 1.888-3.264 1.888-7.040t-1.888-7.040q-1.856-3.136-4.992-4.992-3.264-1.888-7.040-1.888zM16 28.64q-3.424 0-6.4-1.728-2.848-1.664-4.512-4.512-1.728-2.976-1.728-6.4t1.728-6.4q1.664-2.848 4.512-4.512 2.976-1.728 6.4-1.728t6.4 1.728q2.848 1.664 4.512 4.512 1.728 2.976 1.728 6.4t-1.728 6.4q-1.664 2.848-4.512 4.512-2.976 1.728-6.4 1.728z"; + const ICON_PATH_CLEAR = "M16 0q-4.352 0-8.064 2.176-3.616 2.144-5.76 5.76-2.176 3.712-2.176 8.064t2.176 8.064q2.144 3.616 5.76 5.76 3.712 2.176 8.064 2.176t8.064-2.176q3.616-2.144 5.76-5.76 2.176-3.712 2.176-8.064t-2.176-8.064q-2.144-3.616-5.76-5.76-3.712-2.176-8.064-2.176zM22.688 21.408q0.32 0.32 0.304 0.752t-0.336 0.736-0.752 0.304-0.752-0.32l-5.184-5.376-5.376 5.184q-0.32 0.32-0.752 0.304t-0.736-0.336-0.304-0.752 0.32-0.752l5.376-5.184-5.184-5.376q-0.32-0.32-0.304-0.752t0.336-0.752 0.752-0.304 0.752 0.336l5.184 5.376 5.376-5.184q0.32-0.32 0.752-0.304t0.752 0.336 0.304 0.752-0.336 0.752l-5.376 5.184 5.184 5.376z"; + const ICON_PATH_DOWNLOAD = "M15.808 1.696q-3.776 0-7.072 1.984-3.2 1.888-5.088 5.152-1.952 3.392-1.952 7.36 0 3.776 1.952 7.072 1.888 3.2 5.088 5.088 3.296 1.952 7.072 1.952 3.968 0 7.36-1.952 3.264-1.888 5.152-5.088 1.984-3.296 1.984-7.072 0-4-1.984-7.36-1.888-3.264-5.152-5.152-3.36-1.984-7.36-1.984zM20.864 18.592l-3.776 4.928q-0.448 0.576-1.088 0.576t-1.088-0.576l-3.776-4.928q-0.448-0.576-0.24-0.992t0.944-0.416h2.976v-8.928q0-0.256 0.176-0.432t0.4-0.176h1.216q0.224 0 0.4 0.176t0.176 0.432v8.928h2.976q0.736 0 0.944 0.416t-0.24 0.992z"; + const ICON_PATH_INFO = "M15.808 0.128q-4.224 0-7.872 2.176-3.552 2.112-5.632 5.728-2.176 3.776-2.176 8.16 0 4.224 2.176 7.872 2.080 3.552 5.632 5.632 3.648 2.176 7.872 2.176 4.384 0 8.16-2.176 3.616-2.080 5.728-5.632 2.176-3.648 2.176-7.872 0-4.416-2.176-8.16-2.112-3.616-5.728-5.728-3.744-2.176-8.16-2.176zM16.864 23.776q0 0.064-0.064 0.064h-1.568q-0.096 0-0.096-0.064l-0.256-11.328q0-0.064 0.064-0.064h2.112q0.096 0 0.064 0.064l-0.256 11.328zM16 10.88q-0.576 0-0.976-0.4t-0.4-0.96 0.4-0.96 0.976-0.4 0.976 0.4 0.4 0.96-0.4 0.96-0.976 0.4z"; + const ICON_PATH_SEARCH = "M20.928 22.688q-1.696 1.376-3.744 2.112-2.112 0.768-4.384 0.768-3.488 0-6.464-1.728-2.88-1.696-4.576-4.608-1.76-2.976-1.76-6.464t1.76-6.464q1.696-2.88 4.576-4.576 2.976-1.76 6.464-1.76t6.464 1.76q2.912 1.696 4.608 4.576 1.728 2.976 1.728 6.464 0 2.272-0.768 4.384-0.736 2.048-2.112 3.744l9.312 9.28-1.824 1.824-9.28-9.312zM12.8 23.008q2.784 0 5.184-1.376 2.304-1.376 3.68-3.68 1.376-2.4 1.376-5.184t-1.376-5.152q-1.376-2.336-3.68-3.68-2.4-1.408-5.184-1.408t-5.152 1.408q-2.336 1.344-3.68 3.68-1.408 2.368-1.408 5.152t1.408 5.184q1.344 2.304 3.68 3.68 2.368 1.376 5.152 1.376zM12.8 23.008v0z"; + const ICON_PATH_SUCCESS_NO_CIRCLE = "M1.952 18.080q-0.32-0.352-0.416-0.88t0.128-0.976l0.16-0.352q0.224-0.416 0.64-0.528t0.8 0.176l6.496 4.704q0.384 0.288 0.912 0.272t0.88-0.336l17.312-14.272q0.352-0.288 0.848-0.256t0.848 0.352l-0.416-0.416q0.32 0.352 0.32 0.816t-0.32 0.816l-18.656 18.912q-0.32 0.352-0.8 0.352t-0.8-0.32l-7.936-8.064z"; + const ICON_PATH_SUCCESS = "M15.808 0.16q-4.224 0-7.872 2.176-3.552 2.112-5.632 5.728-2.144 3.744-2.144 8.128 0 4.192 2.144 7.872 2.112 3.52 5.632 5.632 3.68 2.144 7.872 2.144 4.384 0 8.128-2.144 3.616-2.080 5.728-5.632 2.176-3.648 2.176-7.872 0-4.384-2.176-8.128-2.112-3.616-5.728-5.728-3.744-2.176-8.128-2.176zM24.832 11.328l-11.264 11.104q-0.032 0.032-0.112 0.032t-0.112-0.032l-5.216-5.376q-0.096-0.128 0-0.288l0.704-0.96q0.032-0.064 0.112-0.064t0.112 0.032l4.256 3.264q0.064 0.032 0.144 0.032t0.112-0.032l10.336-8.608q0.064-0.064 0.144-0.064t0.112 0.064l0.672 0.672q0.128 0.128 0 0.224z"; + const ICON_PATH_WAITING = "M15.84 0.096q-4.224 0-7.872 2.176-3.552 2.112-5.632 5.728-2.144 3.744-2.144 8.128 0 4.192 2.144 7.872 2.112 3.52 5.632 5.632 3.68 2.144 7.872 2.144 4.384 0 8.128-2.144 3.616-2.080 5.728-5.632 2.176-3.648 2.176-7.872 0-4.384-2.176-8.128-2.112-3.616-5.728-5.728-3.744-2.176-8.128-2.176zM23.008 21.92l-0.512 0.896q-0.096 0.128-0.224 0.064l-8-3.808q-0.096-0.064-0.16-0.128-0.128-0.096-0.128-0.288l0.512-12.096q0-0.064 0.048-0.112t0.112-0.048h1.376q0.064 0 0.112 0.048t0.048 0.112l0.448 10.848 6.304 4.256q0.064 0.064 0.080 0.128t-0.016 0.128z"; + const ICON_PATH_WARN = "M15.808 0.16q-4.224 0-7.872 2.176-3.552 2.112-5.632 5.728-2.144 3.744-2.144 8.128 0 4.192 2.144 7.872 2.112 3.52 5.632 5.632 3.68 2.144 7.872 2.144 4.384 0 8.128-2.144 3.616-2.080 5.728-5.632 2.176-3.648 2.176-7.872 0-4.384-2.176-8.128-2.112-3.616-5.728-5.728-3.744-2.176-8.128-2.176zM15.136 8.672h1.728q0.128 0 0.224 0.096t0.096 0.256l-0.384 10.24q0 0.064-0.048 0.112t-0.112 0.048h-1.248q-0.096 0-0.144-0.048t-0.048-0.112l-0.384-10.24q0-0.16 0.096-0.256t0.224-0.096zM16 23.328q-0.48 0-0.832-0.352t-0.352-0.848 0.352-0.848 0.832-0.352 0.832 0.352 0.352 0.848-0.352 0.848-0.832 0.352z"; + function createSvgIconVNode(path, color = "#000", size = 27) { + return vue.createVNode("svg", { + width: size, + height: size, + viewBox: "0 0 32 32" + }, [ + vue.createVNode("path", { + d: path, + fill: color + }, null, 8, ["d", "fill"]) + ], 8, ["width", "height"]); + } + function useCurrentPageId() { + return vue.getCurrentInstance().root.proxy.$page.id; + } + const callbacks = {}; + function createCallbacks(namespace) { + let scopedCallbacks = callbacks[namespace]; + if (!scopedCallbacks) { + scopedCallbacks = { + id: 1, + callbacks: Object.create(null) + }; + callbacks[namespace] = scopedCallbacks; + } + return { + get(id) { + return scopedCallbacks.callbacks[id]; + }, + pop(id) { + const callback = scopedCallbacks.callbacks[id]; + if (callback) { + delete scopedCallbacks.callbacks[id]; + } + return callback; + }, + push(callback) { + const id = scopedCallbacks.id++; + scopedCallbacks.callbacks[id] = callback; + return id; + } + }; + } + const ServiceJSBridge = /* @__PURE__ */ extend(initBridge("service"), { + invokeOnCallback(name, res) { + return UniServiceJSBridge.emit("api." + name, res); + } + }); + function converPx(value) { + if (/^-?\d+[ur]px$/i.test(value)) { + return value.replace(/(^-?\d+)[ur]px$/i, (text, num) => { + return `${uni.upx2px(parseFloat(num))}px`; + }); + } else if (/^-?[\d\.]+$/.test(value)) { + return `${value}px`; + } + return value || ""; + } + function converType(type) { + return type.replace(/[A-Z]/g, (text) => { + return `-${text.toLowerCase()}`; + }).replace("webkit", "-webkit"); + } + function getStyle(action) { + const animateTypes1 = [ + "matrix", + "matrix3d", + "scale", + "scale3d", + "rotate3d", + "skew", + "translate", + "translate3d" + ]; + const animateTypes2 = [ + "scaleX", + "scaleY", + "scaleZ", + "rotate", + "rotateX", + "rotateY", + "rotateZ", + "skewX", + "skewY", + "translateX", + "translateY", + "translateZ" + ]; + const animateTypes3 = ["opacity", "background-color"]; + const animateTypes4 = ["width", "height", "left", "right", "top", "bottom"]; + const animates = action.animates; + const option = action.option; + const transition = option.transition; + const style = {}; + const transform = []; + animates.forEach((animate) => { + let type = animate.type; + let args = [...animate.args]; + if (animateTypes1.concat(animateTypes2).includes(type)) { + if (type.startsWith("rotate") || type.startsWith("skew")) { + args = args.map((value) => parseFloat(value) + "deg"); + } else if (type.startsWith("translate")) { + args = args.map(converPx); + } + if (animateTypes2.indexOf(type) >= 0) { + args.length = 1; + } + transform.push(`${type}(${args.join(",")})`); + } else if (animateTypes3.concat(animateTypes4).includes(args[0])) { + type = args[0]; + const value = args[1]; + style[type] = animateTypes4.includes(type) ? converPx(value) : value; + } + }); + style.transform = style.webkitTransform = transform.join(" "); + style.transition = style.webkitTransition = Object.keys(style).map((type) => `${converType(type)} ${transition.duration}ms ${transition.timingFunction} ${transition.delay}ms`).join(","); + style.transformOrigin = style.webkitTransformOrigin = option.transformOrigin; + return style; + } + function startAnimation(context) { + const animation2 = context.animation; + if (!animation2 || !animation2.actions || !animation2.actions.length) { + return; + } + let index = 0; + const actions = animation2.actions; + const length = animation2.actions.length; + function animate() { + const action = actions[index]; + const transition = action.option.transition; + const style = getStyle(action); + Object.keys(style).forEach((key) => { + context.$el.style[key] = style[key]; + }); + index += 1; + if (index < length) { + setTimeout(animate, transition.duration + transition.delay); + } + } + setTimeout(() => { + animate(); + }, 0); + } + var animation = { + props: ["animation"], + watch: { + animation: { + deep: true, + handler() { + startAnimation(this); + } + } + }, + mounted() { + startAnimation(this); + } + }; + const defineBuiltInComponent = (options) => { + const { props: props2, mixins } = options; + if (!props2 || !props2.animation) { + (mixins || (options.mixins = [])).push(animation); + } + return defineSystemComponent(options); + }; + const defineSystemComponent = (options) => { + options.compatConfig = { + MODE: 3 + }; + return vue.defineComponent(options); + }; + const hoverProps = { + hoverClass: { + type: String, + default: "none" + }, + hoverStopPropagation: { + type: Boolean, + default: false + }, + hoverStartTime: { + type: [Number, String], + default: 50 + }, + hoverStayTime: { + type: [Number, String], + default: 400 + } + }; + function useHover(props2) { + const hovering = vue.ref(false); + let hoverTouch = false; + let hoverStartTimer; + let hoverStayTimer; + function hoverReset() { + requestAnimationFrame(() => { + clearTimeout(hoverStayTimer); + hoverStayTimer = setTimeout(() => { + hovering.value = false; + }, parseInt(props2.hoverStayTime)); + }); + } + function onTouchstartPassive(evt) { + if (evt._hoverPropagationStopped) { + return; + } + if (!props2.hoverClass || props2.hoverClass === "none" || props2.disabled) { + return; + } + if (evt.touches.length > 1) { + return; + } + if (props2.hoverStopPropagation) { + evt._hoverPropagationStopped = true; + } + hoverTouch = true; + hoverStartTimer = setTimeout(() => { + hovering.value = true; + if (!hoverTouch) { + hoverReset(); + } + }, parseInt(props2.hoverStartTime)); + } + function onTouchend() { + hoverTouch = false; + if (hovering.value) { + hoverReset(); + } + } + function onTouchcancel() { + hoverTouch = false; + hovering.value = false; + clearTimeout(hoverStartTimer); + } + return { + hovering, + binding: { + onTouchstartPassive, + onTouchend, + onTouchcancel + } + }; + } + function useBooleanAttr(props2, keys) { + if (isString(keys)) { + keys = [keys]; + } + return keys.reduce((res, key) => { + if (props2[key]) { + res[key] = true; + } + return res; + }, Object.create(null)); + } + function withWebEvent(fn) { + return fn.__wwe = true, fn; + } + function useCustomEvent(ref, emit) { + return (name, evt, detail) => { + if (ref.value) { + emit(name, normalizeCustomEvent(name, evt, ref.value, detail || {})); + } + }; + } + function normalizeCustomEvent(name, domEvt, el, detail) { + const target = normalizeTarget(el); + return { + type: detail.type || name, + timeStamp: domEvt.timeStamp || 0, + target, + currentTarget: target, + detail + }; + } + const uniFormKey = PolySymbol("uniForm"); + const uniLabelKey = PolySymbol("uniLabel"); + function useListeners(props2, listeners) { + _addListeners(props2.id, listeners); + vue.watch(() => props2.id, (newId, oldId) => { + _removeListeners(oldId, listeners, true); + _addListeners(newId, listeners, true); + }); + vue.onUnmounted(() => { + _removeListeners(props2.id, listeners); + }); + } + function _addListeners(id, listeners, watch2) { + const pageId = useCurrentPageId(); + if (watch2 && !id) { + return; + } + if (!isPlainObject(listeners)) { + return; + } + Object.keys(listeners).forEach((name) => { + if (watch2) { + if (name.indexOf("@") !== 0 && name.indexOf("uni-") !== 0) { + UniViewJSBridge.on(`uni-${name}-${pageId}-${id}`, listeners[name]); + } + } else { + if (name.indexOf("uni-") === 0) { + UniViewJSBridge.on(name, listeners[name]); + } else if (id) { + UniViewJSBridge.on(`uni-${name}-${pageId}-${id}`, listeners[name]); + } + } + }); + } + function _removeListeners(id, listeners, watch2) { + const pageId = useCurrentPageId(); + if (watch2 && !id) { + return; + } + if (!isPlainObject(listeners)) { + return; + } + Object.keys(listeners).forEach((name) => { + if (watch2) { + if (name.indexOf("@") !== 0 && name.indexOf("uni-") !== 0) { + UniViewJSBridge.off(`uni-${name}-${pageId}-${id}`, listeners[name]); + } + } else { + if (name.indexOf("uni-") === 0) { + UniViewJSBridge.off(name, listeners[name]); + } else if (id) { + UniViewJSBridge.off(`uni-${name}-${pageId}-${id}`, listeners[name]); + } + } + }); + } + var Button = /* @__PURE__ */ defineBuiltInComponent({ + name: "Button", + props: { + id: { + type: String, + default: "" + }, + hoverClass: { + type: String, + default: "button-hover" + }, + hoverStartTime: { + type: [Number, String], + default: 20 + }, + hoverStayTime: { + type: [Number, String], + default: 70 + }, + hoverStopPropagation: { + type: Boolean, + default: false + }, + disabled: { + type: [Boolean, String], + default: false + }, + formType: { + type: String, + default: "" + }, + openType: { + type: String, + default: "" + }, + loading: { + type: [Boolean, String], + default: false + } + }, + setup(props2, { + slots + }) { + const rootRef = vue.ref(null); + const uniForm = vue.inject(uniFormKey, false); + const { + hovering, + binding + } = useHover(props2); + useI18n(); + const onClick = withWebEvent((e, isLabelClick) => { + if (props2.disabled) { + return e.stopImmediatePropagation(); + } + if (isLabelClick) { + rootRef.value.click(); + } + const formType = props2.formType; + if (formType) { + if (!uniForm) { + return; + } + if (formType === "submit") { + uniForm.submit(); + } else if (formType === "reset") { + uniForm.reset(); + } + return; + } + }); + const uniLabel = vue.inject(uniLabelKey, false); + if (uniLabel) { + uniLabel.addHandler(onClick); + vue.onBeforeUnmount(() => { + uniLabel.removeHandler(onClick); + }); + } + useListeners(props2, { + "label-click": onClick + }); + return () => { + const hoverClass = props2.hoverClass; + const booleanAttrs = useBooleanAttr(props2, "disabled"); + const loadingAttrs = useBooleanAttr(props2, "loading"); + const hasHoverClass = hoverClass && hoverClass !== "none"; + return vue.createVNode("uni-button", vue.mergeProps({ + "ref": rootRef, + "onClick": onClick, + "class": hasHoverClass && hovering.value ? hoverClass : "" + }, hasHoverClass && binding, booleanAttrs, loadingAttrs), { + default: () => [slots.default && slots.default()] + }, 16, ["onClick", "class"]); + }; + } + }); + function getRealPath() { + } + var ResizeSensor = /* @__PURE__ */ defineBuiltInComponent({ + name: "ResizeSensor", + props: { + initial: { + type: Boolean, + default: false + } + }, + emits: ["resize"], + setup(props2, { + emit + }) { + const rootRef = vue.ref(null); + const reset = useResizeSensorReset(rootRef); + const update = useResizeSensorUpdate(rootRef, emit, reset); + useResizeSensorLifecycle(rootRef, props2, update, reset); + return () => vue.createVNode("uni-resize-sensor", { + "ref": rootRef, + "onAnimationstartOnce": update + }, { + default: () => [vue.createVNode("div", { + "onScroll": update + }, [vue.createVNode("div", null, null)], 40, ["onScroll"]), vue.createVNode("div", { + "onScroll": update + }, [vue.createVNode("div", null, null)], 40, ["onScroll"])], + _: 1 + }, 8, ["onAnimationstartOnce"]); + } + }); + function useResizeSensorUpdate(rootRef, emit, reset) { + const size = vue.reactive({ + width: -1, + height: -1 + }); + vue.watch(() => extend({}, size), (value) => emit("resize", value)); + return () => { + const { + width, + height + } = rootRef.value.getBoundingClientRect(); + size.width = width; + size.height = height; + reset(); + }; + } + function useResizeSensorReset(rootRef) { + return () => { + const { + firstElementChild, + lastElementChild + } = rootRef.value; + firstElementChild.scrollLeft = 1e5; + firstElementChild.scrollTop = 1e5; + lastElementChild.scrollLeft = 1e5; + lastElementChild.scrollTop = 1e5; + }; + } + function useResizeSensorLifecycle(rootRef, props2, update, reset) { + vue.onActivated(reset); + vue.onMounted(() => { + if (props2.initial) { + vue.nextTick(update); + } + const rootEl = rootRef.value; + if (rootEl.offsetParent !== rootEl.parentElement) { + rootEl.parentElement.style.position = "relative"; + } + if (!("AnimationEvent" in window)) { + reset(); + } + }); + } + const INFO_COLOR = "#10aeff"; + const WARN_COLOR = "#f76260"; + const GREY_COLOR = "#b2b2b2"; + const CANCEL_COLOR = "#f43530"; + const ICONS = { + success: { + d: ICON_PATH_SUCCESS, + c: PRIMARY_COLOR + }, + success_no_circle: { + d: ICON_PATH_SUCCESS_NO_CIRCLE, + c: PRIMARY_COLOR + }, + info: { + d: ICON_PATH_INFO, + c: INFO_COLOR + }, + warn: { + d: ICON_PATH_WARN, + c: WARN_COLOR + }, + waiting: { + d: ICON_PATH_WAITING, + c: INFO_COLOR + }, + cancel: { + d: ICON_PATH_CANCEL, + c: CANCEL_COLOR + }, + download: { + d: ICON_PATH_DOWNLOAD, + c: PRIMARY_COLOR + }, + search: { + d: ICON_PATH_SEARCH, + c: GREY_COLOR + }, + clear: { + d: ICON_PATH_CLEAR, + c: GREY_COLOR + } + }; + var Icon = /* @__PURE__ */ defineBuiltInComponent({ + name: "Icon", + props: { + type: { + type: String, + required: true, + default: "" + }, + size: { + type: [String, Number], + default: 23 + }, + color: { + type: String, + default: "" + } + }, + setup(props2) { + const path = vue.computed(() => ICONS[props2.type]); + return () => { + const { + value + } = path; + return vue.createVNode("uni-icon", null, { + default: () => [value && value.d && createSvgIconVNode(value.d, props2.color || value.c, rpx2px(props2.size))] + }); + }; + } + }); + const props = { + src: { + type: String, + default: "" + }, + mode: { + type: String, + default: "scaleToFill" + }, + lazyLoad: { + type: [Boolean, String], + default: false + }, + draggable: { + type: Boolean, + default: true + } + }; + const FIX_MODES = { + widthFix: ["width", "height"], + heightFix: ["height", "width"] + }; + const IMAGE_MODES = { + aspectFit: ["center center", "contain"], + aspectFill: ["center center", "cover"], + widthFix: [, "100% 100%"], + heightFix: [, "100% 100%"], + top: ["center top"], + bottom: ["center bottom"], + center: ["center center"], + left: ["left center"], + right: ["right center"], + "top left": ["left top"], + "top right": ["right top"], + "bottom left": ["left bottom"], + "bottom right": ["right bottom"] + }; + var Image$1 = /* @__PURE__ */ defineBuiltInComponent({ + name: "Image", + props, + setup(props2, { + emit + }) { + const rootRef = vue.ref(null); + const state = useImageState(rootRef, props2); + const trigger = useCustomEvent(rootRef, emit); + const { + fixSize + } = useImageSize(rootRef, props2, state); + useImageLoader(state, { + trigger, + fixSize + }); + return () => { + const { + mode + } = props2; + const { + imgSrc, + modeStyle + } = state; + return vue.createVNode("uni-image", { + "ref": rootRef + }, { + default: () => [vue.createVNode("div", { + "style": modeStyle + }, null, 4), imgSrc ? vue.createVNode("img", { + "src": imgSrc, + "draggable": props2.draggable + }, null, 8, ["src", "draggable"]) : vue.createVNode("img", null, null), FIX_MODES[mode] ? vue.createVNode(ResizeSensor, { + "onResize": fixSize + }, null, 8, ["onResize"]) : vue.createVNode("span", null, null)], + _: 1 + }, 512); + }; + } + }); + function useImageState(rootRef, props2) { + const imgSrc = vue.ref(""); + const modeStyleRef = vue.computed(() => { + let size = "auto"; + let position = ""; + const opts = IMAGE_MODES[props2.mode]; + if (!opts) { + position = "0% 0%"; + size = "100% 100%"; + } else { + opts[0] && (position = opts[0]); + opts[1] && (size = opts[1]); + } + const srcVal = imgSrc.value; + return `background-image:${srcVal ? 'url("' + srcVal + '")' : "none"};background-position:${position};background-size:${size};background-repeat:no-repeat;`; + }); + const state = vue.reactive({ + rootEl: rootRef, + src: vue.computed(() => props2.src ? getRealPath(props2.src) : ""), + origWidth: 0, + origHeight: 0, + origStyle: { + width: "", + height: "" + }, + modeStyle: modeStyleRef, + imgSrc + }); + vue.onMounted(() => { + const rootEl = rootRef.value; + const style = rootEl.style; + state.origWidth = Number(style.width) || 0; + state.origHeight = Number(style.height) || 0; + }); + return state; + } + function useImageLoader(state, { + trigger, + fixSize + }) { + let img; + const setState = (width = 0, height = 0, imgSrc = "") => { + state.origWidth = width; + state.origHeight = height; + state.imgSrc = imgSrc; + }; + const loadImage = (src) => { + if (!src) { + resetImage(); + setState(); + return; + } + if (!img) { + img = new Image(); + } + img.onload = (evt) => { + const { + width, + height + } = img; + setState(width, height, src); + fixSize(); + resetImage(); + trigger("load", evt, { + width, + height + }); + }; + img.onerror = (evt) => { + setState(); + resetImage(); + trigger("error", evt, { + errMsg: `GET ${state.src} 404 (Not Found)` + }); + }; + img.src = src; + }; + const resetImage = () => { + if (img) { + img.onload = null; + img.onerror = null; + img = null; + } + }; + vue.watch(() => state.src, (value) => loadImage(value)); + vue.onMounted(() => loadImage(state.src)); + vue.onBeforeUnmount(() => resetImage()); + } + const isChrome = navigator.vendor === "Google Inc."; + function fixNumber(num) { + if (isChrome && num > 10) { + num = Math.round(num / 2) * 2; + } + return num; + } + function useImageSize(rootRef, props2, state) { + const fixSize = () => { + const { + mode + } = props2; + const names = FIX_MODES[mode]; + if (!names) { + return; + } + const { + origWidth, + origHeight + } = state; + const ratio = origWidth && origHeight ? origWidth / origHeight : 0; + if (!ratio) { + return; + } + const rootEl = rootRef.value; + const rect = rootEl.getBoundingClientRect(); + const value = rect[names[0]]; + if (value) { + rootEl.style[names[1]] = fixNumber(value / ratio) + "px"; + } + }; + const resetSize = () => { + const { + style + } = rootRef.value; + const { + origStyle: { + width, + height + } + } = state; + style.width = width; + style.height = height; + }; + vue.watch(() => props2.mode, (value, oldValue) => { + if (FIX_MODES[oldValue]) { + resetSize(); + } + if (FIX_MODES[value]) { + fixSize(); + } + }); + return { + fixSize, + resetSize + }; + } + const canvasEventCallbacks = createCallbacks("canvasEvent"); + ServiceJSBridge.subscribe("onCanvasMethodCallback", ({ callbackId, data }) => { + const callback = canvasEventCallbacks.pop(callbackId); + if (callback) { + callback(data); + } + }); + const getSelectedTextRangeEventCallbacks = createCallbacks("getSelectedTextRangeEvent"); + ServiceJSBridge.subscribe && ServiceJSBridge.subscribe("onGetSelectedTextRange", ({ callbackId, data }) => { + const callback = getSelectedTextRangeEventCallbacks.pop(callbackId); + if (callback) { + callback(data); + } + }); + function _isSlot(s) { + return typeof s === "function" || Object.prototype.toString.call(s) === "[object Object]" && !vue.isVNode(s); + } + const SPACE_UNICODE = { + ensp: "\u2002", + emsp: "\u2003", + nbsp: "\xA0" + }; + function normalizeText(text, { + space, + decode + }) { + if (space && SPACE_UNICODE[space]) { + text = text.replace(/ /g, SPACE_UNICODE[space]); + } + if (!decode) { + return text; + } + return text.replace(/ /g, SPACE_UNICODE.nbsp).replace(/ /g, SPACE_UNICODE.ensp).replace(/ /g, SPACE_UNICODE.emsp).replace(/</g, "<").replace(/>/g, ">").replace(/&/g, "&").replace(/"/g, '"').replace(/'/g, "'"); + } + var Text = /* @__PURE__ */ defineBuiltInComponent({ + name: "Text", + props: { + selectable: { + type: [Boolean, String], + default: false + }, + space: { + type: String, + default: "" + }, + decode: { + type: [Boolean, String], + default: false + } + }, + setup(props2, { + slots + }) { + return () => { + let _slot; + const children = []; + if (slots.default) { + slots.default().forEach((vnode) => { + if (vnode.shapeFlag & 8) { + const lines = vnode.children.replace(/\\n/g, "\n").split("\n"); + const len = lines.length - 1; + lines.forEach((text, index) => { + if (index === 0 && !text) + ; + else { + children.push(vue.createTextVNode(normalizeText(text, { + space: props2.space, + decode: props2.decode + }))); + } + if (index !== len) { + children.push(vue.createVNode("br")); + } + }); + } else { + if (vnode.shapeFlag & 6 && vnode.type.name !== "Text") { + console.warn("Do not nest other components in the text component, as there may be display differences on different platforms."); + } + children.push(vnode); + } + }); + } + return vue.createVNode("uni-text", { + "selectable": props2.selectable ? true : null + }, _isSlot(_slot = vue.createVNode("span", null, children)) ? _slot : { + default: () => [_slot], + _: 1 + }, 8, ["selectable"]); + }; + } + }); + var View = /* @__PURE__ */ defineBuiltInComponent({ + name: "View", + props: extend({}, hoverProps), + setup(props2, { + slots + }) { + const { + hovering, + binding + } = useHover(props2); + return () => { + const hoverClass = props2.hoverClass; + if (hoverClass && hoverClass !== "none") { + return vue.createVNode("uni-view", vue.mergeProps({ + "class": hovering.value ? hoverClass : "" + }, binding), { + default: () => [slots.default && slots.default()] + }, 16, ["class"]); + } + return vue.createVNode("uni-view", null, { + default: () => [slots.default && slots.default()] + }); + }; + } + }); + const { customElements } = window; + customElements.define("v-uni-button", wrapper(Button, vue.createApp, vue.h)); + customElements.define("v-uni-icon", wrapper(Icon, vue.createApp, vue.h)); + customElements.define("v-uni-image", wrapper(Image$1, vue.createApp, vue.h)); + customElements.define("v-uni-text", wrapper(Text, vue.createApp, vue.h)); + customElements.define("v-uni-view", wrapper(View, vue.createApp, vue.h)); +}); diff --git a/packages/uni-app-plus/package.json b/packages/uni-app-plus/package.json new file mode 100644 index 0000000000000000000000000000000000000000..f784591eea8b57815f108f335e89205f8f42bdf6 --- /dev/null +++ b/packages/uni-app-plus/package.json @@ -0,0 +1,26 @@ +{ + "name": "@dcloudio/uni-app-plus", + "version": "3.0.0-alpha-3000020210524001", + "description": "@dcloudio/uni-app-plus", + "files": [ + "dist", + "style" + ], + "sideEffects": false, + "repository": { + "type": "git", + "url": "git+https://github.com/dcloudio/uni-app.git", + "directory": "packages/uni-app-plus" + }, + "license": "Apache-2.0", + "bugs": { + "url": "https://github.com/dcloudio/uni-app/issues" + }, + "uni-app": { + "name": "uni-app", + "apply": "app" + }, + "dependencies": { + "vue3-webcomponent-wrapper": "^0.1.4" + } +} diff --git a/packages/uni-app-plus/src/platform/getRealPath.ts b/packages/uni-app-plus/src/platform/getRealPath.ts new file mode 100644 index 0000000000000000000000000000000000000000..f9bedb444f1c9803d3af2a5eafa2fae433923ec4 --- /dev/null +++ b/packages/uni-app-plus/src/platform/getRealPath.ts @@ -0,0 +1,65 @@ +import { getRealRoute } from '@dcloudio/uni-core' +import { DATA_RE, SCHEME_RE, cacheStringFunction } from '@dcloudio/uni-shared' +export function getRealPath(filepath: string) { + // 无协议的情况补全 https + if (filepath.indexOf('//') === 0) { + return 'https:' + filepath + } + + // 网络资源或base64 + if (SCHEME_RE.test(filepath) || DATA_RE.test(filepath)) { + return filepath + } + + if (isSystemURL(filepath)) { + return 'file://' + normalizeLocalPath(filepath) + } + + const wwwPath = 'file://' + normalizeLocalPath('_www') + // 绝对路径转换为本地文件系统路径 + if (filepath.indexOf('/') === 0) { + // 平台绝对路径 安卓、iOS + if ( + filepath.startsWith('/storage/') || + filepath.includes('/Containers/Data/Application/') + ) { + return 'file://' + filepath + } + return wwwPath + filepath + } + // 相对资源 + if (filepath.indexOf('../') === 0 || filepath.indexOf('./') === 0) { + // @ts-expect-error app-view + if (typeof __id__ === 'string') { + // @ts-expect-error app-view + return wwwPath + getRealRoute('/' + __id__, filepath) + } else { + const pages = getCurrentPages() + if (pages.length) { + return ( + wwwPath + getRealRoute('/' + pages[pages.length - 1].route, filepath) + ) + } + } + } + return filepath +} + +const normalizeLocalPath = cacheStringFunction((filepath: string) => { + return plus.io + .convertLocalFileSystemURL(filepath as any) + .replace(/^\/?apps\//, '/android_asset/apps/') + .replace(/\/$/, '') +}) + +function isSystemURL(filepath: string) { + if ( + filepath.indexOf('_www') === 0 || + filepath.indexOf('_doc') === 0 || + filepath.indexOf('_documents') === 0 || + filepath.indexOf('_downloads') === 0 + ) { + return true + } + return false +} diff --git a/packages/uni-app-plus/src/platform/index.ts b/packages/uni-app-plus/src/platform/index.ts new file mode 100644 index 0000000000000000000000000000000000000000..8f3dfa5355977ef30b6541c6a492ccd6658cf362 --- /dev/null +++ b/packages/uni-app-plus/src/platform/index.ts @@ -0,0 +1,14 @@ +export function getBaseSystemInfo() { + return {} +} +export function getRealPath() {} +export function operateVideoPlayer() {} +export function operateMap() {} +export function requestComponentInfo() {} +export function addIntersectionObserver() {} +export function removeIntersectionObserver() {} +export function addMediaQueryObserver() {} +export function removeMediaQueryObserver() {} +export function saveImage() {} +export function getSameOriginUrl() {} +export const TEMP_PATH = '' diff --git a/packages/uni-app-plus/src/service/api/constants.ts b/packages/uni-app-plus/src/service/api/constants.ts new file mode 100644 index 0000000000000000000000000000000000000000..2d5899fad16c0724f01f52d17aa8889ad671771d --- /dev/null +++ b/packages/uni-app-plus/src/service/api/constants.ts @@ -0,0 +1,16 @@ +export const DEVICE_FREQUENCY = 200 +export const NETWORK_TYPES = [ + 'unknown', + 'none', + 'ethernet', + 'wifi', + '2g', + '3g', + '4g', + '5g', +] + +export const MAP_ID = '__UNIAPP_MAP' + +export const TEMP_PATH_BASE = '_doc/uniapp_temp' +export const TEMP_PATH = `${TEMP_PATH_BASE}_${Date.now()}` diff --git a/packages/uni-app-plus/src/service/framework/app/index.ts b/packages/uni-app-plus/src/service/framework/app/index.ts new file mode 100644 index 0000000000000000000000000000000000000000..c7e0e46ed2ab230ec3de55873f442eeb6e2e6af4 --- /dev/null +++ b/packages/uni-app-plus/src/service/framework/app/index.ts @@ -0,0 +1,26 @@ +import { ComponentPublicInstance } from 'vue' +import { extend } from '@vue/shared' + +import { initEntry } from './initEntry' +import { initTabBar } from './initTabBar' +import { initGlobalEvent } from './initGlobalEvent' + +let appCtx: ComponentPublicInstance +const defaultApp = { + globalData: {}, +} +export function registerApp(appVm: ComponentPublicInstance) { + appCtx = appVm + appCtx.$vm = appVm + + extend(appCtx, defaultApp) // 拷贝默认实现 + + const { $options } = appVm + if ($options) { + appCtx.globalData = extend($options.globalData || {}, appCtx.globalData) + } + + initEntry() + initTabBar() + initGlobalEvent() +} diff --git a/packages/uni-app-plus/src/service/framework/app/initEntry.ts b/packages/uni-app-plus/src/service/framework/app/initEntry.ts new file mode 100644 index 0000000000000000000000000000000000000000..a88405c58dd5477a6961423a479674a3cf11720b --- /dev/null +++ b/packages/uni-app-plus/src/service/framework/app/initEntry.ts @@ -0,0 +1,50 @@ +let isInitEntryPage = false + +export function initEntry() { + if (isInitEntryPage) { + return + } + isInitEntryPage = true + + let entryPagePath + let entryPageQuery + + const weexPlus = weex.requireModule('plus') + + if (weexPlus.getRedirectInfo) { + const info = weexPlus.getRedirectInfo() || {} + entryPagePath = info.path + entryPageQuery = info.query ? '?' + info.query : '' + } else { + const argsJsonStr = plus.runtime.arguments + if (!argsJsonStr) { + return + } + try { + const args = JSON.parse(argsJsonStr) + entryPagePath = args.path || args.pathName + entryPageQuery = args.query ? '?' + args.query : '' + } catch (e) {} + } + + if (!entryPagePath || entryPagePath === __uniConfig.entryPagePath) { + if (entryPageQuery) { + __uniConfig.entryPageQuery = entryPageQuery + } + return + } + + const entryRoute = '/' + entryPagePath + const routeOptions = __uniRoutes.find((route) => route.path === entryRoute) + if (!routeOptions) { + return + } + + if (!routeOptions.meta.isTabBar) { + __uniConfig.realEntryPagePath = + __uniConfig.realEntryPagePath || __uniConfig.entryPagePath + } + + __uniConfig.entryPagePath = entryPagePath + __uniConfig.entryPageQuery = entryPageQuery +} diff --git a/packages/uni-app-plus/src/service/framework/app/initGlobalEvent.ts b/packages/uni-app-plus/src/service/framework/app/initGlobalEvent.ts new file mode 100644 index 0000000000000000000000000000000000000000..b90748b9944b5245bfbf9f1bf7924e680c246874 --- /dev/null +++ b/packages/uni-app-plus/src/service/framework/app/initGlobalEvent.ts @@ -0,0 +1,47 @@ +import { consumePlusMessage } from './plusMessage' +import { backbuttonListener } from './utils' + +export function initGlobalEvent() { + const plusGlobalEvent = (plus as any).weexGlobalEvent + const weexGlobalEvent = weex.requireModule('weexGlobalEvent') + const emit = UniServiceJSBridge.emit + + if (weex.config.preload) { + plus.key.addEventListener('backbutton', backbuttonListener) + } else { + plusGlobalEvent.addEventListener('splashclosed', () => { + plus.key.addEventListener('backbutton', backbuttonListener) + }) + } + + plusGlobalEvent.addEventListener('pause', () => { + emit('onAppEnterBackground') + }) + + plusGlobalEvent.addEventListener('resume', () => { + emit('onAppEnterForeground') + }) + + weexGlobalEvent.addEventListener( + 'uistylechange', + function (event: { uistyle: string }) { + const args = { + theme: event.uistyle, + } + emit('onThemeChange', args) + } + ) + + plusGlobalEvent.addEventListener('plusMessage', onPlusMessage) + // nvue webview post message + plusGlobalEvent.addEventListener('WebviewPostMessage', onPlusMessage) +} + +function onPlusMessage(e: { + data: { type: string; args: Record } +}) { + if (e.data && e.data.type) { + const type = e.data.type + consumePlusMessage(type, e.data.args || {}) + } +} diff --git a/packages/uni-app-plus/src/service/framework/app/initTabBar.ts b/packages/uni-app-plus/src/service/framework/app/initTabBar.ts new file mode 100644 index 0000000000000000000000000000000000000000..2f8087d7e31914752ecfeb68eddb70d1a9516d5d --- /dev/null +++ b/packages/uni-app-plus/src/service/framework/app/initTabBar.ts @@ -0,0 +1,39 @@ +import { invokeHook } from '@dcloudio/uni-core' +import tabBar from './tabBar' + +export function initTabBar() { + const len = __uniConfig.tabBar?.list?.length + if (!len) { + return + } + + __uniConfig.tabBar!.selectedIndex = 0 + + const selected = __uniConfig.tabBar!.list.findIndex( + (page) => page.pagePath === __uniConfig.entryPagePath + ) + + tabBar.init( + __uniConfig.tabBar!, + (item: UniApp.TabBarItemOptions, index: number) => { + uni.switchTab({ + url: '/' + item.pagePath, + openType: 'switchTab', + from: 'tabBar', + success() { + invokeHook('onTabItemTap', { + index, + text: item.text, + pagePath: item.pagePath, + }) + }, + } as UniApp.SwitchTabOptions) + } + ) + + if (selected !== -1) { + // 取当前 tab 索引值 + __uniConfig.tabBar!.selectedIndex = selected + selected !== 0 && tabBar.switchTab(__uniConfig.entryPagePath!) + } +} diff --git a/packages/uni-app-plus/src/service/framework/app/plusMessage.ts b/packages/uni-app-plus/src/service/framework/app/plusMessage.ts new file mode 100644 index 0000000000000000000000000000000000000000..1dd04aef510eb0bb67c7788b3d92075a1d219bee --- /dev/null +++ b/packages/uni-app-plus/src/service/framework/app/plusMessage.ts @@ -0,0 +1,43 @@ +import { WEB_INVOKE_APPSERVICE } from '@dcloudio/uni-shared' + +interface PlusMessageCallback { + (args: Record): void + keepAlive: boolean +} + +const callbacks: Record = {} + +// 简单处理 view 层与 service 层的通知系统 +/** + * 消费 view 层通知 + */ +export function consumePlusMessage(type: string, args: Record) { + // 处理 web-view 组件发送的通知 + if (type === WEB_INVOKE_APPSERVICE) { + UniServiceJSBridge.emit('onWebInvokeAppService', args.data, args.webviewIds) + return true + } + const callback = callbacks[type] + if (callback) { + callback(args) + if (!callback.keepAlive) { + delete callbacks[type] + } + return true + } + return false +} +/** + * 注册 view 层通知 service 层事件处理 + */ +export function registerPlusMessage( + type: string, + callback: PlusMessageCallback, + keepAlive = true +) { + if (callbacks[type]) { + return console.warn(`'${type}' registered: ` + callbacks[type].toString()) + } + callback.keepAlive = !!keepAlive + callbacks[type] = callback +} diff --git a/packages/uni-app-plus/src/service/framework/app/tabBar.ts b/packages/uni-app-plus/src/service/framework/app/tabBar.ts new file mode 100644 index 0000000000000000000000000000000000000000..e6579624c804c8a9b4ec3e55e79d86a70a537fef --- /dev/null +++ b/packages/uni-app-plus/src/service/framework/app/tabBar.ts @@ -0,0 +1,199 @@ +import { TABBAR_HEIGHT } from '@dcloudio/uni-shared' + +import { getRealPath } from '../../../platform/getRealPath' + +const isIOS = plus.os.name === 'iOS' + +let config: UniApp.TabBarOptions + +/** + * tabbar显示状态 + */ +let visible = true + +let tabBar: any + +/** + * 设置角标 + * @param {string} type + * @param {number} index + * @param {string} text + */ +function setTabBarBadge( + type: 'none' | 'text' | 'redDot', + index: number, + text: string +) { + if (!tabBar) { + return + } + if (type === 'none') { + tabBar.hideTabBarRedDot({ + index, + }) + tabBar.removeTabBarBadge({ + index, + }) + } else if (type === 'text') { + tabBar.setTabBarBadge({ + index, + text, + }) + } else if (type === 'redDot') { + tabBar.showTabBarRedDot({ + index, + }) + } +} +/** + * 动态设置 tabBar 某一项的内容 + */ +function setTabBarItem( + index: number, + text?: string, + iconPath?: string, + selectedIconPath?: string +) { + const item: Record = { + index, + } + if (text !== undefined) { + item.text = text + } + if (iconPath) { + item.iconPath = getRealPath(iconPath) + } + if (selectedIconPath) { + item.selectedIconPath = getRealPath(selectedIconPath) + } + tabBar && tabBar.setTabBarItem(item) +} +/** + * 动态设置 tabBar 的整体样式 + * @param {Object} style 样式 + */ +function setTabBarStyle(style: unknown) { + tabBar && tabBar.setTabBarStyle(style) +} +/** + * 隐藏 tabBar + * @param {boolean} animation 是否需要动画效果 + */ +function hideTabBar(animation: boolean) { + visible = false + tabBar && + tabBar.hideTabBar({ + animation, + }) +} +/** + * 显示 tabBar + * @param {boolean} animation 是否需要动画效果 + */ +function showTabBar(animation: boolean) { + visible = true + tabBar && + tabBar.showTabBar({ + animation, + }) +} + +const maskClickCallback: Function[] = [] + +export default { + id: '0', + init(options: UniApp.TabBarOptions, clickCallback: Function) { + if (options && options.list.length) { + config = options + } + try { + tabBar = weex.requireModule('uni-tabview') + } catch (error) { + console.log(`uni.requireNativePlugin("uni-tabview") error ${error}`) + } + tabBar.onMaskClick(() => { + maskClickCallback.forEach((callback) => { + callback() + }) + }) + tabBar && + tabBar.onClick(({ index }: { index: number }) => { + clickCallback(config.list[index], index) + }) + tabBar && + tabBar.onMidButtonClick(() => { + // publish('onTabBarMidButtonTap', {}) + }) + }, + indexOf(page: string) { + const itemLength = config && config.list && config.list.length + if (itemLength) { + for (let i = 0; i < itemLength; i++) { + if ( + config.list[i].pagePath === page || + config.list[i].pagePath === `${page}.html` + ) { + return i + } + } + } + return -1 + }, + switchTab(page: string) { + const index = this.indexOf(page) + if (index >= 0) { + tabBar && + tabBar.switchSelect({ + index, + }) + return true + } + return false + }, + setTabBarBadge, + setTabBarItem, + setTabBarStyle, + hideTabBar, + showTabBar, + append(webview: PlusWebviewWebviewObject) { + tabBar && + tabBar.append( + { + id: webview.id, + }, + ({ code }: { code: number }) => { + if (code !== 0) { + setTimeout(() => { + this.append(webview) + }, 20) + } + } + ) + }, + get visible() { + return visible + }, + get height() { + return ( + (config && config.height ? parseFloat(config.height) : TABBAR_HEIGHT) + + plus.navigator.getSafeAreaInsets().deviceBottom! + ) + }, + // tabBar是否遮挡内容区域 + get cover() { + const array = ['extralight', 'light', 'dark'] + return isIOS && array.indexOf(config.blurEffect as string) >= 0 + }, + setStyle({ mask }: { mask: string }) { + tabBar.setMask({ + color: mask, + }) + }, + addEventListener(_name: string, callback: Function) { + maskClickCallback.push(callback) + }, + removeEventListener(_name: string, callback: Function) { + const callbackIndex = maskClickCallback.indexOf(callback) + maskClickCallback.splice(callbackIndex, 1) + }, +} diff --git a/packages/uni-app-plus/src/service/framework/app/utils.ts b/packages/uni-app-plus/src/service/framework/app/utils.ts new file mode 100644 index 0000000000000000000000000000000000000000..894c066020911736b10dd795198a1a824a5ed038 --- /dev/null +++ b/packages/uni-app-plus/src/service/framework/app/utils.ts @@ -0,0 +1,5 @@ +export function backbuttonListener() { + uni.navigateBack({ + from: 'backbutton', + } as UniApp.NavigateBackOptions) +} diff --git a/packages/uni-app-plus/src/service/index.ts b/packages/uni-app-plus/src/service/index.ts new file mode 100644 index 0000000000000000000000000000000000000000..8aeabb5f893a0fda66e8c810d3c3b1759160d58a --- /dev/null +++ b/packages/uni-app-plus/src/service/index.ts @@ -0,0 +1,5 @@ +import { registerApp as __registerApp } from './framework/app' + +export default { + __registerApp, +} diff --git a/packages/uni-app-plus/src/view/components/index.ts b/packages/uni-app-plus/src/view/components/index.ts new file mode 100644 index 0000000000000000000000000000000000000000..f4216867521b37e006b9d81c2c209f0f2eeefed6 --- /dev/null +++ b/packages/uni-app-plus/src/view/components/index.ts @@ -0,0 +1,41 @@ +import { createApp, h } from 'vue' +import wrapper from 'vue3-webcomponent-wrapper' +import '@dcloudio/uni-components/style/button.css' +import { + // Audio, + Button, + // Canvas, + // Checkbox, + // CheckboxGroup, + // Editor, + // Form, + Icon, + Image, + // Input, + // Label, + // MovableArea, + // MovableView, + // Navigator, + // PickerView, + // PickerViewColumn, + // Progress, + // Radio, + // RadioGroup, + // ResizeSensor, + // RichText, + // ScrollView, + // Slider, + // Swiper, + // SwiperItem, + // Switch, + Text, + // Textarea, + View, +} from '@dcloudio/uni-components' + +const { customElements } = window +customElements.define('v-uni-button', wrapper(Button, createApp, h)) +customElements.define('v-uni-icon', wrapper(Icon, createApp, h)) +customElements.define('v-uni-image', wrapper(Image, createApp, h)) +customElements.define('v-uni-text', wrapper(Text, createApp, h)) +customElements.define('v-uni-view', wrapper(View, createApp, h)) diff --git a/packages/uni-app-plus/src/view/index.ts b/packages/uni-app-plus/src/view/index.ts new file mode 100644 index 0000000000000000000000000000000000000000..8658e507698f542e105cfd3114a3ae984b607828 --- /dev/null +++ b/packages/uni-app-plus/src/view/index.ts @@ -0,0 +1 @@ +import { initView } from '@dcloudio/uni-core' diff --git a/packages/uni-app-plus/vite.config.ts b/packages/uni-app-plus/vite.config.ts new file mode 100644 index 0000000000000000000000000000000000000000..86d8c67e41c2a0519d6e56e7ac50490bdeabe9bd --- /dev/null +++ b/packages/uni-app-plus/vite.config.ts @@ -0,0 +1,115 @@ +import path from 'path' + +import { defineConfig } from 'vite' + +import jscc from 'rollup-plugin-jscc' +import replace from '@rollup/plugin-replace' +import vue from '@vitejs/plugin-vue' +import vueJsx from '@vitejs/plugin-vue-jsx' + +import { isCustomElement } from '@dcloudio/uni-shared' + +function resolve(file: string) { + return path.resolve(__dirname, file) +} + +const rollupPlugins = [ + replace({ + values: { + defineOnApi: `/*#__PURE__*/ defineOnApi`, + defineOffApi: `/*#__PURE__*/ defineOffApi`, + defineTaskApi: `/*#__PURE__*/ defineTaskApi`, + defineSyncApi: `/*#__PURE__*/ defineSyncApi`, + defineAsyncApi: `/*#__PURE__*/ defineAsyncApi`, + __IMPORT_META_ENV_BASE_URL__: 'import.meta.env.BASE_URL', //直接使用import.meta.env.BASE_URL会被vite替换成'/' + }, + preventAssignment: true, + }), + + jscc({ + values: { + // 该插件限制了不能以__开头 + _NODE_JS_: 0, + }, + // 忽略 pako 内部条件编译 + exclude: [resolve('../../node_modules/pako/**')], + }), +] + +export default defineConfig({ + root: __dirname, + define: { + global: 'window', + __DEV__: true, + __TEST__: false, + __PLATFORM__: JSON.stringify('h5'), + __NODE_JS__: false, + }, + resolve: { + alias: [ + { + find: '@dcloudio/uni-api', + replacement: resolve('../uni-api/src/index.ts'), + }, + { + find: '@dcloudio/uni-vue', + replacement: resolve('../uni-vue/src/index.ts'), + }, + { + find: '@dcloudio/uni-core', + replacement: resolve('../uni-core/src'), + }, + { + find: '@dcloudio/uni-components/style', + replacement: resolve('../uni-components/style'), + }, + { + find: '@dcloudio/uni-components', + replacement: resolve('../uni-components/src/index.ts'), + }, + { + find: '@dcloudio/uni-platform', + replacement: resolve('./src/platform/index.ts'), + }, + ], + }, + plugins: [ + vue({ + template: { + compilerOptions: { + isCustomElement, + }, + }, + }), + vueJsx({ optimize: true, isCustomElement }), + ], + build: { + minify: false, + lib: { + name: 'uni-app-view', + fileName: 'uni-app-view', + entry: path.resolve(__dirname, 'src/view/components/index.ts'), + formats: ['umd'], + }, + assetsDir: '.', + rollupOptions: { + output: { + globals: { + vue: 'Vue', + }, + }, + external(source) { + if (['vue'].includes(source)) { + return true + } + }, + preserveEntrySignatures: 'strict', + plugins: rollupPlugins, + onwarn: (msg, warn) => { + if (!String(msg).includes('external module "vue" but never used')) { + warn(msg) + } + }, + }, + }, +}) diff --git a/packages/uni-app-vite/LICENSE b/packages/uni-app-vite/LICENSE new file mode 100755 index 0000000000000000000000000000000000000000..7a4a3ea2424c09fbe48d455aed1eaa94d9124835 --- /dev/null +++ b/packages/uni-app-vite/LICENSE @@ -0,0 +1,202 @@ + + Apache License + Version 2.0, January 2004 + http://www.apache.org/licenses/ + + TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION + + 1. Definitions. + + "License" shall mean the terms and conditions for use, reproduction, + and distribution as defined by Sections 1 through 9 of this document. + + "Licensor" shall mean the copyright owner or entity authorized by + the copyright owner that is granting the License. + + "Legal Entity" shall mean the union of the acting entity and all + other entities that control, are controlled by, or are under common + control with that entity. For the purposes of this definition, + "control" means (i) the power, direct or indirect, to cause the + direction or management of such entity, whether by contract or + otherwise, or (ii) ownership of fifty percent (50%) or more of the + outstanding shares, or (iii) beneficial ownership of such entity. + + "You" (or "Your") shall mean an individual or Legal Entity + exercising permissions granted by this License. + + "Source" form shall mean the preferred form for making modifications, + including but not limited to software source code, documentation + source, and configuration files. + + "Object" form shall mean any form resulting from mechanical + transformation or translation of a Source form, including but + not limited to compiled object code, generated documentation, + and conversions to other media types. + + "Work" shall mean the work of authorship, whether in Source or + Object form, made available under the License, as indicated by a + copyright notice that is included in or attached to the work + (an example is provided in the Appendix below). + + "Derivative Works" shall mean any work, whether in Source or Object + form, that is based on (or derived from) the Work and for which the + editorial revisions, annotations, elaborations, or other modifications + represent, as a whole, an original work of authorship. For the purposes + of this License, Derivative Works shall not include works that remain + separable from, or merely link (or bind by name) to the interfaces of, + the Work and Derivative Works thereof. + + "Contribution" shall mean any work of authorship, including + the original version of the Work and any modifications or additions + to that Work or Derivative Works thereof, that is intentionally + submitted to Licensor for inclusion in the Work by the copyright owner + or by an individual or Legal Entity authorized to submit on behalf of + the copyright owner. For the purposes of this definition, "submitted" + means any form of electronic, verbal, or written communication sent + to the Licensor or its representatives, including but not limited to + communication on electronic mailing lists, source code control systems, + and issue tracking systems that are managed by, or on behalf of, the + Licensor for the purpose of discussing and improving the Work, but + excluding communication that is conspicuously marked or otherwise + designated in writing by the copyright owner as "Not a Contribution." + + "Contributor" shall mean Licensor and any individual or Legal Entity + on behalf of whom a Contribution has been received by Licensor and + subsequently incorporated within the Work. + + 2. Grant of Copyright License. Subject to the terms and conditions of + this License, each Contributor hereby grants to You a perpetual, + worldwide, non-exclusive, no-charge, royalty-free, irrevocable + copyright license to reproduce, prepare Derivative Works of, + publicly display, publicly perform, sublicense, and distribute the + Work and such Derivative Works in Source or Object form. + + 3. Grant of Patent License. Subject to the terms and conditions of + this License, each Contributor hereby grants to You a perpetual, + worldwide, non-exclusive, no-charge, royalty-free, irrevocable + (except as stated in this section) patent license to make, have made, + use, offer to sell, sell, import, and otherwise transfer the Work, + where such license applies only to those patent claims licensable + by such Contributor that are necessarily infringed by their + Contribution(s) alone or by combination of their Contribution(s) + with the Work to which such Contribution(s) was submitted. If You + institute patent litigation against any entity (including a + cross-claim or counterclaim in a lawsuit) alleging that the Work + or a Contribution incorporated within the Work constitutes direct + or contributory patent infringement, then any patent licenses + granted to You under this License for that Work shall terminate + as of the date such litigation is filed. + + 4. Redistribution. You may reproduce and distribute copies of the + Work or Derivative Works thereof in any medium, with or without + modifications, and in Source or Object form, provided that You + meet the following conditions: + + (a) You must give any other recipients of the Work or + Derivative Works a copy of this License; and + + (b) You must cause any modified files to carry prominent notices + stating that You changed the files; and + + (c) You must retain, in the Source form of any Derivative Works + that You distribute, all copyright, patent, trademark, and + attribution notices from the Source form of the Work, + excluding those notices that do not pertain to any part of + the Derivative Works; and + + (d) If the Work includes a "NOTICE" text file as part of its + distribution, then any Derivative Works that You distribute must + include a readable copy of the attribution notices contained + within such NOTICE file, excluding those notices that do not + pertain to any part of the Derivative Works, in at least one + of the following places: within a NOTICE text file distributed + as part of the Derivative Works; within the Source form or + documentation, if provided along with the Derivative Works; or, + within a display generated by the Derivative Works, if and + wherever such third-party notices normally appear. The contents + of the NOTICE file are for informational purposes only and + do not modify the License. You may add Your own attribution + notices within Derivative Works that You distribute, alongside + or as an addendum to the NOTICE text from the Work, provided + that such additional attribution notices cannot be construed + as modifying the License. + + You may add Your own copyright statement to Your modifications and + may provide additional or different license terms and conditions + for use, reproduction, or distribution of Your modifications, or + for any such Derivative Works as a whole, provided Your use, + reproduction, and distribution of the Work otherwise complies with + the conditions stated in this License. + + 5. Submission of Contributions. Unless You explicitly state otherwise, + any Contribution intentionally submitted for inclusion in the Work + by You to the Licensor shall be under the terms and conditions of + this License, without any additional terms or conditions. + Notwithstanding the above, nothing herein shall supersede or modify + the terms of any separate license agreement you may have executed + with Licensor regarding such Contributions. + + 6. Trademarks. This License does not grant permission to use the trade + names, trademarks, service marks, or product names of the Licensor, + except as required for reasonable and customary use in describing the + origin of the Work and reproducing the content of the NOTICE file. + + 7. Disclaimer of Warranty. Unless required by applicable law or + agreed to in writing, Licensor provides the Work (and each + Contributor provides its Contributions) on an "AS IS" BASIS, + WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or + implied, including, without limitation, any warranties or conditions + of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A + PARTICULAR PURPOSE. You are solely responsible for determining the + appropriateness of using or redistributing the Work and assume any + risks associated with Your exercise of permissions under this License. + + 8. Limitation of Liability. In no event and under no legal theory, + whether in tort (including negligence), contract, or otherwise, + unless required by applicable law (such as deliberate and grossly + negligent acts) or agreed to in writing, shall any Contributor be + liable to You for damages, including any direct, indirect, special, + incidental, or consequential damages of any character arising as a + result of this License or out of the use or inability to use the + Work (including but not limited to damages for loss of goodwill, + work stoppage, computer failure or malfunction, or any and all + other commercial damages or losses), even if such Contributor + has been advised of the possibility of such damages. + + 9. Accepting Warranty or Additional Liability. While redistributing + the Work or Derivative Works thereof, You may choose to offer, + and charge a fee for, acceptance of support, warranty, indemnity, + or other liability obligations and/or rights consistent with this + License. However, in accepting such obligations, You may act only + on Your own behalf and on Your sole responsibility, not on behalf + of any other Contributor, and only if You agree to indemnify, + defend, and hold each Contributor harmless for any liability + incurred by, or claims asserted against, such Contributor by reason + of your accepting any such warranty or additional liability. + + END OF TERMS AND CONDITIONS + + APPENDIX: How to apply the Apache License to your work. + + To apply the Apache License to your work, attach the following + boilerplate notice, with the fields enclosed by brackets "[]" + replaced with your own identifying information. (Don't include + the brackets!) The text should be enclosed in the appropriate + comment syntax for the file format. We also recommend that a + file or class name and description of purpose be included on the + same "printed page" as the copyright notice for easier + identification within third-party archives. + + Copyright [yyyy] [name of copyright owner] + + Licensed under the Apache License, Version 2.0 (the "License"); + you may not use this file except in compliance with the License. + You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + + Unless required by applicable law or agreed to in writing, software + distributed under the License is distributed on an "AS IS" BASIS, + WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + See the License for the specific language governing permissions and + limitations under the License. \ No newline at end of file diff --git a/packages/uni-app-vite/dist/index.js b/packages/uni-app-vite/dist/index.js new file mode 100644 index 0000000000000000000000000000000000000000..837f1144a803b73d7c25ba10483e1e376e42b300 --- /dev/null +++ b/packages/uni-app-vite/dist/index.js @@ -0,0 +1,21 @@ +"use strict"; +Object.defineProperty(exports, "__esModule", { value: true }); +const mainJs_1 = require("./plugins/mainJs"); +const manifestJson_1 = require("./plugins/manifestJson"); +const pagesJson_1 = require("./plugins/pagesJson"); +const resolveId_1 = require("./plugins/resolveId"); +const UniAppPlugin = { + name: 'vite:uni-app', + uni: { + transformEvent: { + tap: 'click', + }, + }, +}; +exports.default = [ + resolveId_1.uniResolveIdPlugin(), + mainJs_1.uniMainJsPlugin(), + manifestJson_1.uniManifestJsonPlugin(), + pagesJson_1.uniPagesJsonPlugin(), + UniAppPlugin, +]; diff --git a/packages/uni-app-vite/dist/plugins/mainJs.js b/packages/uni-app-vite/dist/plugins/mainJs.js new file mode 100644 index 0000000000000000000000000000000000000000..adcbcf8ffa0d40cd31f4728dcc76e1c324df657f --- /dev/null +++ b/packages/uni-app-vite/dist/plugins/mainJs.js @@ -0,0 +1,30 @@ +"use strict"; +Object.defineProperty(exports, "__esModule", { value: true }); +exports.uniMainJsPlugin = void 0; +const uni_cli_shared_1 = require("@dcloudio/uni-cli-shared"); +function uniMainJsPlugin() { + return uni_cli_shared_1.defineUniMainJsPlugin((opts) => { + return { + name: 'vite:uni-app-main-js', + enforce: 'pre', + transform(code, id) { + if (opts.filter(id)) { + code = code.includes('createSSRApp') + ? createApp(code) + : createLegacyApp(code); + return { + code, + map: this.getCombinedSourcemap(), + }; + } + }, + }; + }); +} +exports.uniMainJsPlugin = uniMainJsPlugin; +function createApp(code) { + return `createApp().app.mount("#app");${code.replace('createSSRApp', 'createVueApp as createSSRApp')}`; +} +function createLegacyApp(code) { + return `function createApp(rootComponent,rootProps){return createVueApp(rootComponent, rootProps)};${code.replace('createApp', 'createVueApp')}`; +} diff --git a/packages/uni-app-vite/dist/plugins/manifestJson.js b/packages/uni-app-vite/dist/plugins/manifestJson.js new file mode 100644 index 0000000000000000000000000000000000000000..016a6b43a28444a15609532e45f02b4f2b273182 --- /dev/null +++ b/packages/uni-app-vite/dist/plugins/manifestJson.js @@ -0,0 +1,69 @@ +"use strict"; +Object.defineProperty(exports, "__esModule", { value: true }); +exports.uniManifestJsonPlugin = void 0; +const uni_cli_shared_1 = require("@dcloudio/uni-cli-shared"); +const defaultRouter = { + mode: 'hash', + base: '/', +}; +const defaultAsync = { + loading: 'AsyncLoading', + error: 'AsyncError', + delay: 200, + timeout: 60000, + suspensible: true, +}; +const defaultNetworkTimeout = { + request: 60000, + connectSocket: 60000, + uploadFile: 60000, + downloadFile: 60000, +}; +const defaultQQMapKey = 'XVXBZ-NDMC4-JOGUS-XGIEE-QVHDZ-AMFV2'; +function uniManifestJsonPlugin() { + return uni_cli_shared_1.defineUniManifestJsonPlugin((opts) => { + return { + name: 'vite:uni-app-manifest-json', + enforce: 'pre', + transform(code, id) { + if (!opts.filter(id)) { + return; + } + const manifest = JSON.parse(code); + const { debug, h5 } = manifest; + const appid = (manifest.appid || '').replace('__UNI__', ''); + const router = Object.assign(Object.assign({}, defaultRouter), ((h5 && h5.router) || {})); + if (!router.base) { + router.base = '/'; + } + const async = Object.assign(Object.assign({}, defaultAsync), ((h5 && h5.async) || {})); + const networkTimeout = Object.assign(Object.assign({}, defaultNetworkTimeout), (manifest.networkTimeout || {})); + const sdkConfigs = (h5 && h5.sdkConfigs) || {}; + const qqMapKey = (sdkConfigs.maps && + sdkConfigs.maps.qqmap && + sdkConfigs.maps.qqmap.key) || + defaultQQMapKey; + const flexDirection = (manifest['app'] && + manifest['app'].nvue && + manifest['app'].nvue['flex-direction']) || + 'column'; + return { + code: `export const appid = '${appid || ''}' + export const debug = ${!!debug} + export const nvue = ${JSON.stringify({ + 'flex-direction': flexDirection, + })} + export const networkTimeout = ${JSON.stringify(networkTimeout)} + // h5 + export const router = ${JSON.stringify(router)} + export const async = ${JSON.stringify(async)} + export const qqMapKey = '${qqMapKey}' + export const sdkConfigs = ${JSON.stringify(sdkConfigs)} + `, + map: { mappings: '' }, + }; + }, + }; + }); +} +exports.uniManifestJsonPlugin = uniManifestJsonPlugin; diff --git a/packages/uni-app-vite/dist/plugins/pagesJson.js b/packages/uni-app-vite/dist/plugins/pagesJson.js new file mode 100644 index 0000000000000000000000000000000000000000..9f59c7fc8790bee4e73ca5a4de21b348ed783619 --- /dev/null +++ b/packages/uni-app-vite/dist/plugins/pagesJson.js @@ -0,0 +1,227 @@ +"use strict"; +var __importDefault = (this && this.__importDefault) || function (mod) { + return (mod && mod.__esModule) ? mod : { "default": mod }; +}; +Object.defineProperty(exports, "__esModule", { value: true }); +exports.uniPagesJsonPlugin = void 0; +const fs_1 = __importDefault(require("fs")); +const path_1 = __importDefault(require("path")); +const slash_1 = __importDefault(require("slash")); +const shared_1 = require("@vue/shared"); +const uni_cli_shared_1 = require("@dcloudio/uni-cli-shared"); +const pkg = require('@dcloudio/vite-plugin-uni/package.json'); +function uniPagesJsonPlugin() { + return uni_cli_shared_1.defineUniPagesJsonPlugin((opts) => { + return { + name: 'vite:uni-app-pages-json', + enforce: 'pre', + transform(code, id, ssr) { + if (opts.filter(id)) { + const { resolvedConfig } = opts; + return { + code: (resolvedConfig.command === 'serve' || + (resolvedConfig.command === 'build' && ssr) + ? registerGlobalCode(resolvedConfig, ssr) + : '') + generatePagesJsonCode(ssr, code, resolvedConfig), + map: { mappings: '' }, + }; + } + }, + }; + }); +} +exports.uniPagesJsonPlugin = uniPagesJsonPlugin; +function generatePagesJsonCode(ssr, jsonStr, config) { + const globalName = getGlobal(ssr); + const pagesJson = uni_cli_shared_1.normalizePagesJson(jsonStr, process.env.UNI_INPUT_DIR, process.env.UNI_PLATFORM); + const { importLayoutComponentsCode, defineLayoutComponentsCode } = generateLayoutComponentsCode(globalName, pagesJson); + const definePagesCode = generatePagesDefineCode(pagesJson, config); + const uniRoutesCode = generateRoutes(globalName, pagesJson, config); + const uniConfigCode = generateConfig(globalName, pagesJson, config); + const manifestJsonPath = slash_1.default(path_1.default.resolve(process.env.UNI_INPUT_DIR, 'manifest.json.js')); + const cssCode = generateCssCode(config); + return ` +import { defineAsyncComponent, resolveComponent, createVNode, withCtx, openBlock, createBlock } from 'vue' +import { PageComponent, AsyncLoadingComponent, AsyncErrorComponent } from '@dcloudio/uni-h5' +import { appid, debug, networkTimeout, router, async, sdkConfigs, qqMapKey, nvue } from '${manifestJsonPath}' +${importLayoutComponentsCode} +const extend = Object.assign +${cssCode} +${uniConfigCode} +${defineLayoutComponentsCode} +${definePagesCode} +${uniRoutesCode} +${config.command === 'serve' ? hmrCode : ''} +export {} +`; +} +const hmrCode = `if(import.meta.hot){ + import.meta.hot.on('invalidate', (data) => { + import.meta.hot.invalidate() + }) +}`; +function getGlobal(ssr) { + return ssr ? 'global' : 'window'; +} +function registerGlobalCode(config, ssr) { + const name = getGlobal(ssr); + const rpx2pxCode = !ssr && config.define.__UNI_FEATURE_RPX__ + ? `import {upx2px} from '@dcloudio/uni-h5' + ${name}.rpx2px = upx2px +` + : ''; + return `${rpx2pxCode} +import {uni,getCurrentPages,getApp,UniServiceJSBridge,UniViewJSBridge} from '@dcloudio/uni-h5' +${name}.getApp = getApp +${name}.getCurrentPages = getCurrentPages +${name}.uni = uni +${name}.UniViewJSBridge = UniViewJSBridge +${name}.UniServiceJSBridge = UniServiceJSBridge +`; +} +function normalizePageIdentifier(path) { + return shared_1.capitalize(shared_1.camelize(path.replace(/\//g, '-'))); +} +function generateCssCode(config) { + const define = config.define; + const cssFiles = [uni_cli_shared_1.H5_FRAMEWORK_STYLE_PATH + 'base.css']; + // if (define.__UNI_FEATURE_PAGES__) { + cssFiles.push(uni_cli_shared_1.H5_FRAMEWORK_STYLE_PATH + 'async.css'); + // } + if (define.__UNI_FEATURE_RESPONSIVE__) { + cssFiles.push(uni_cli_shared_1.H5_FRAMEWORK_STYLE_PATH + 'layout.css'); + } + if (define.__UNI_FEATURE_NAVIGATIONBAR__) { + cssFiles.push(uni_cli_shared_1.H5_FRAMEWORK_STYLE_PATH + 'pageHead.css'); + } + if (define.__UNI_FEATURE_TABBAR__) { + cssFiles.push(uni_cli_shared_1.H5_FRAMEWORK_STYLE_PATH + 'tabBar.css'); + } + if (define.__UNI_FEATURE_NVUE__) { + cssFiles.push(uni_cli_shared_1.H5_FRAMEWORK_STYLE_PATH + 'nvue.css'); + } + if (define.__UNI_FEATURE_PULL_DOWN_REFRESH__) { + cssFiles.push(uni_cli_shared_1.H5_FRAMEWORK_STYLE_PATH + 'pageRefresh.css'); + } + if (define.__UNI_FEATURE_NAVIGATIONBAR_SEARCHINPUT__) { + cssFiles.push(uni_cli_shared_1.BASE_COMPONENTS_STYLE_PATH + 'input.css'); + } + if (config.command === 'serve') { + // 开发模式，自动添加所有API相关css + Object.keys(uni_cli_shared_1.API_DEPS_CSS).forEach((name) => { + const styles = uni_cli_shared_1.API_DEPS_CSS[name]; + styles.forEach((style) => { + if (!cssFiles.includes(style)) { + cssFiles.push(style); + } + }); + }); + } + return cssFiles.map((file) => `import '${file}'`).join('\n'); +} +function generateLayoutComponentsCode(globalName, pagesJson) { + const windowNames = [ + 'topWindow', + 'leftWindow', + 'rightWindow', + ]; + let importLayoutComponentsCode = ''; + let defineLayoutComponentsCode = `${globalName}.__uniLayout = ${globalName}.__uniLayout || {}\n`; + windowNames.forEach((name) => { + const windowConfig = pagesJson[name]; + if (windowConfig && windowConfig.path) { + importLayoutComponentsCode += `import ${name} from './${windowConfig.path}'\n`; + defineLayoutComponentsCode += `${globalName}.__uniConfig.${name}.component = ${name}\n`; + } + }); + return { + importLayoutComponentsCode, + defineLayoutComponentsCode, + }; +} +function generatePageDefineCode(pageOptions) { + const pageIdent = normalizePageIdentifier(pageOptions.path); + return `const ${pageIdent}Loader = ()=>import('./${pageOptions.path}?mpType=page') +const ${pageIdent} = defineAsyncComponent(extend({loader:${pageIdent}Loader},AsyncComponentOptions))`; +} +function generatePagesDefineCode(pagesJson, _config) { + const { pages } = pagesJson; + return (`const AsyncComponentOptions = { + loadingComponent: AsyncLoadingComponent, + errorComponent: AsyncErrorComponent, + delay: async.delay, + timeout: async.timeout, + suspensible: async.suspensible +} +` + pages.map((pageOptions) => generatePageDefineCode(pageOptions)).join('\n')); +} +function normalizePagesRoute(pagesJson) { + const firstPagePath = pagesJson.pages[0].path; + const tabBarList = (pagesJson.tabBar && pagesJson.tabBar.list) || []; + return pagesJson.pages.map((pageOptions) => { + const pagePath = pageOptions.path; + const name = normalizePageIdentifier(pagePath); + const isEntry = firstPagePath === pagePath ? true : undefined; + const tabBarIndex = tabBarList.findIndex((tabBarPage) => tabBarPage.pagePath === pagePath); + const isTabBar = tabBarIndex !== -1 ? true : undefined; + const isNVue = fs_1.default.existsSync(path_1.default.join(process.env.UNI_INPUT_DIR, pagePath + '.nvue')); + let windowTop = 0; + const meta = shared_1.extend({ + route: pageOptions.path, + isNVue: isNVue ? true : undefined, + isQuit: isEntry || isTabBar ? true : undefined, + isEntry, + isTabBar, + tabBarIndex, + windowTop, + }, pageOptions.style); + return { + name, + path: pageOptions.path, + meta, + }; + }); +} +function generatePageRoute({ name, path, meta }, config) { + const { isEntry } = meta; + const alias = isEntry ? `\n alias:'/${path}',` : ''; + return `{ + path:'/${isEntry ? '' : path}',${alias} + component:{setup(){return ()=>renderPage(${name})}}, + loader: ${normalizePageIdentifier(path)}Loader, + meta: ${JSON.stringify(meta)} +}`; +} +function generatePagesRoute(pagesRouteOptions, config) { + return pagesRouteOptions.map((pageOptions) => generatePageRoute(pageOptions, config)); +} +function generateRoutes(globalName, pagesJson, config) { + return ` +function renderPage(component){ + return (openBlock(), createBlock(PageComponent, null, {page: withCtx(() => [createVNode(component, { ref: "page" }, null, 512 /* NEED_PATCH */)]), _: 1 /* STABLE */})) +} +${globalName}.__uniRoutes=[${[ + ...generatePagesRoute(normalizePagesRoute(pagesJson), config), + ].join(',')}]`; +} +function generateConfig(globalName, pagesJson, config) { + delete pagesJson.pages; + delete pagesJson.subPackages; + delete pagesJson.subpackages; + pagesJson.compilerVersion = pkg['uni-app'].compilerVersion; + return ((config.command === 'serve' + ? '' + : `${globalName}['____'+appid+'____']=true +delete ${globalName}['____'+appid+'____'] +`) + + `${globalName}.__uniConfig=extend(${JSON.stringify(pagesJson)},{ + async, + debug, + networkTimeout, + sdkConfigs, + qqMapKey, + nvue, + router +}) +`); +} diff --git a/packages/uni-app-vite/dist/plugins/resolveId.js b/packages/uni-app-vite/dist/plugins/resolveId.js new file mode 100644 index 0000000000000000000000000000000000000000..04bf602ef694d739249bcf38fb7cc8f6ad6970b6 --- /dev/null +++ b/packages/uni-app-vite/dist/plugins/resolveId.js @@ -0,0 +1,37 @@ +"use strict"; +var __importDefault = (this && this.__importDefault) || function (mod) { + return (mod && mod.__esModule) ? mod : { "default": mod }; +}; +Object.defineProperty(exports, "__esModule", { value: true }); +exports.uniResolveIdPlugin = void 0; +const path_1 = __importDefault(require("path")); +const debug_1 = __importDefault(require("debug")); +const uni_cli_shared_1 = require("@dcloudio/uni-cli-shared"); +const debugResolve = debug_1.default('vite:uni:resolve'); +function uniResolveIdPlugin() { + const resolveCache = {}; + return { + name: 'vite:uni-app-resolve-id', + enforce: 'pre', + configResolved() { + const { MODE } = uni_cli_shared_1.parseCompatConfigOnce(process.env.UNI_INPUT_DIR); + resolveCache['@dcloudio/uni-h5'] = uni_cli_shared_1.resolveBuiltIn(path_1.default.join('@dcloudio/uni-h5', 'dist/uni-h5.es.js')); + resolveCache['@dcloudio/uni-h5-vue'] = uni_cli_shared_1.resolveBuiltIn(path_1.default.join('@dcloudio/uni-h5-vue', `dist/vue.runtime.${MODE === 2 ? 'compat.' : ''}esm.js`)); + }, + resolveId(id) { + if (id === 'vue') { + id = '@dcloudio/uni-h5-vue'; + } + const cache = resolveCache[id]; + if (cache) { + debugResolve('cache', id, cache); + return cache; + } + if (id.startsWith('@dcloudio/uni-h5/style') || + id.startsWith('@dcloudio/uni-components/style')) { + return (resolveCache[id] = uni_cli_shared_1.resolveBuiltIn(id)); + } + }, + }; +} +exports.uniResolveIdPlugin = uniResolveIdPlugin; diff --git a/packages/uni-app-vite/package.json b/packages/uni-app-vite/package.json new file mode 100644 index 0000000000000000000000000000000000000000..1151d8dc6f597d9401551d5181bd32fe9ee87f3d --- /dev/null +++ b/packages/uni-app-vite/package.json @@ -0,0 +1,25 @@ +{ + "name": "@dcloudio/uni-app-vite", + "version": "3.0.0-alpha-3000020210528002", + "description": "uni-app-vite", + "main": "dist/index.js", + "types": "dist/index.d.ts", + "files": [ + "dist/**/*.js", + "dist/**/*.d.ts" + ], + "repository": { + "type": "git", + "url": "git+https://github.com/dcloudio/uni-app.git", + "directory": "packages/uni-app-vite" + }, + "scripts": { + "test": "echo \"Error: no test specified\" && exit 1" + }, + "uni-app": { + "name": "uni-app-plus", + "apply": "app", + "main": "dist/index.js" + }, + "license": "Apache-2.0" +} diff --git a/packages/uni-app-vite/src/index.ts b/packages/uni-app-vite/src/index.ts new file mode 100644 index 0000000000000000000000000000000000000000..535af8a4c1a38c3cffe4aea3655cd88602196452 --- /dev/null +++ b/packages/uni-app-vite/src/index.ts @@ -0,0 +1,22 @@ +import { UniVitePlugin } from '@dcloudio/uni-cli-shared' +import { uniMainJsPlugin } from './plugins/mainJs' +import { uniManifestJsonPlugin } from './plugins/manifestJson' +import { uniPagesJsonPlugin } from './plugins/pagesJson' +import { uniResolveIdPlugin } from './plugins/resolveId' + +const UniAppPlugin: UniVitePlugin = { + name: 'vite:uni-app', + uni: { + transformEvent: { + tap: 'click', + }, + }, +} + +export default [ + uniResolveIdPlugin(), + uniMainJsPlugin(), + uniManifestJsonPlugin(), + uniPagesJsonPlugin(), + UniAppPlugin, +] diff --git a/packages/uni-app-vite/src/plugins/mainJs.ts b/packages/uni-app-vite/src/plugins/mainJs.ts new file mode 100644 index 0000000000000000000000000000000000000000..251763a445a1728de0400013804bc5e6741d99e6 --- /dev/null +++ b/packages/uni-app-vite/src/plugins/mainJs.ts @@ -0,0 +1,35 @@ +import { defineUniMainJsPlugin } from '@dcloudio/uni-cli-shared' + +export function uniMainJsPlugin() { + return defineUniMainJsPlugin((opts) => { + return { + name: 'vite:uni-app-main-js', + enforce: 'pre', + transform(code, id) { + if (opts.filter(id)) { + code = code.includes('createSSRApp') + ? createApp(code) + : createLegacyApp(code) + return { + code, + map: this.getCombinedSourcemap(), + } + } + }, + } + }) +} + +function createApp(code: string) { + return `createApp().app.mount("#app");${code.replace( + 'createSSRApp', + 'createVueApp as createSSRApp' + )}` +} + +function createLegacyApp(code: string) { + return `function createApp(rootComponent,rootProps){return createVueApp(rootComponent, rootProps)};${code.replace( + 'createApp', + 'createVueApp' + )}` +} diff --git a/packages/uni-app-vite/src/plugins/manifestJson.ts b/packages/uni-app-vite/src/plugins/manifestJson.ts new file mode 100644 index 0000000000000000000000000000000000000000..15ed50a3875b50b7591031aa6bf79ebb0370c8a7 --- /dev/null +++ b/packages/uni-app-vite/src/plugins/manifestJson.ts @@ -0,0 +1,82 @@ +import { Plugin } from 'vite' + +import { defineUniManifestJsonPlugin } from '@dcloudio/uni-cli-shared' + +const defaultRouter = { + mode: 'hash', + base: '/', +} + +const defaultAsync = { + loading: 'AsyncLoading', + error: 'AsyncError', + delay: 200, + timeout: 60000, + suspensible: true, +} + +const defaultNetworkTimeout = { + request: 60000, + connectSocket: 60000, + uploadFile: 60000, + downloadFile: 60000, +} + +const defaultQQMapKey = 'XVXBZ-NDMC4-JOGUS-XGIEE-QVHDZ-AMFV2' + +export function uniManifestJsonPlugin(): Plugin { + return defineUniManifestJsonPlugin((opts) => { + return { + name: 'vite:uni-app-manifest-json', + enforce: 'pre', + transform(code, id) { + if (!opts.filter(id)) { + return + } + const manifest = JSON.parse(code) + const { debug, h5 } = manifest + const appid = (manifest.appid || '').replace('__UNI__', '') + const router = { ...defaultRouter, ...((h5 && h5.router) || {}) } + if (!router.base) { + router.base = '/' + } + const async = { ...defaultAsync, ...((h5 && h5.async) || {}) } + + const networkTimeout = { + ...defaultNetworkTimeout, + ...(manifest.networkTimeout || {}), + } + + const sdkConfigs = (h5 && h5.sdkConfigs) || {} + + const qqMapKey = + (sdkConfigs.maps && + sdkConfigs.maps.qqmap && + sdkConfigs.maps.qqmap.key) || + defaultQQMapKey + + const flexDirection = + (manifest['app'] && + manifest['app'].nvue && + manifest['app'].nvue['flex-direction']) || + 'column' + + return { + code: `export const appid = '${appid || ''}' + export const debug = ${!!debug} + export const nvue = ${JSON.stringify({ + 'flex-direction': flexDirection, + })} + export const networkTimeout = ${JSON.stringify(networkTimeout)} + // h5 + export const router = ${JSON.stringify(router)} + export const async = ${JSON.stringify(async)} + export const qqMapKey = '${qqMapKey}' + export const sdkConfigs = ${JSON.stringify(sdkConfigs)} + `, + map: { mappings: '' }, + } + }, + } + }) +} diff --git a/packages/uni-app-vite/src/plugins/pagesJson.ts b/packages/uni-app-vite/src/plugins/pagesJson.ts new file mode 100644 index 0000000000000000000000000000000000000000..3b1147d6edbe4c72fac1a5fe575844158bfed6d0 --- /dev/null +++ b/packages/uni-app-vite/src/plugins/pagesJson.ts @@ -0,0 +1,298 @@ +import fs from 'fs' +import path from 'path' +import slash from 'slash' +import { Plugin, ResolvedConfig } from 'vite' +import { extend, camelize, capitalize } from '@vue/shared' +import { + API_DEPS_CSS, + FEATURE_DEFINES, + H5_FRAMEWORK_STYLE_PATH, + BASE_COMPONENTS_STYLE_PATH, + normalizePagesJson, + defineUniPagesJsonPlugin, +} from '@dcloudio/uni-cli-shared' + +const pkg = require('@dcloudio/vite-plugin-uni/package.json') + +export function uniPagesJsonPlugin(): Plugin { + return defineUniPagesJsonPlugin((opts) => { + return { + name: 'vite:uni-app-pages-json', + enforce: 'pre', + transform(code, id, ssr) { + if (opts.filter(id)) { + const { resolvedConfig } = opts + return { + code: + (resolvedConfig.command === 'serve' || + (resolvedConfig.command === 'build' && ssr) + ? registerGlobalCode(resolvedConfig, ssr) + : '') + generatePagesJsonCode(ssr, code, resolvedConfig), + map: { mappings: '' }, + } + } + }, + } + }) +} + +interface PageRouteOptions { + name: string + path: string + meta: Partial +} + +function generatePagesJsonCode( + ssr: boolean | undefined, + jsonStr: string, + config: ResolvedConfig +) { + const globalName = getGlobal(ssr) + const pagesJson = normalizePagesJson( + jsonStr, + process.env.UNI_INPUT_DIR, + process.env.UNI_PLATFORM + ) + const { importLayoutComponentsCode, defineLayoutComponentsCode } = + generateLayoutComponentsCode(globalName, pagesJson) + const definePagesCode = generatePagesDefineCode(pagesJson, config) + const uniRoutesCode = generateRoutes(globalName, pagesJson, config) + const uniConfigCode = generateConfig(globalName, pagesJson, config) + const manifestJsonPath = slash( + path.resolve(process.env.UNI_INPUT_DIR, 'manifest.json.js') + ) + const cssCode = generateCssCode(config) + + return ` +import { defineAsyncComponent, resolveComponent, createVNode, withCtx, openBlock, createBlock } from 'vue' +import { PageComponent, AsyncLoadingComponent, AsyncErrorComponent } from '@dcloudio/uni-h5' +import { appid, debug, networkTimeout, router, async, sdkConfigs, qqMapKey, nvue } from '${manifestJsonPath}' +${importLayoutComponentsCode} +const extend = Object.assign +${cssCode} +${uniConfigCode} +${defineLayoutComponentsCode} +${definePagesCode} +${uniRoutesCode} +${config.command === 'serve' ? hmrCode : ''} +export {} +` +} + +const hmrCode = `if(import.meta.hot){ + import.meta.hot.on('invalidate', (data) => { + import.meta.hot.invalidate() + }) +}` + +function getGlobal(ssr?: boolean) { + return ssr ? 'global' : 'window' +} + +function registerGlobalCode(config: ResolvedConfig, ssr?: boolean) { + const name = getGlobal(ssr) + const rpx2pxCode = + !ssr && config.define!.__UNI_FEATURE_RPX__ + ? `import {upx2px} from '@dcloudio/uni-h5' + ${name}.rpx2px = upx2px +` + : '' + return `${rpx2pxCode} +import {uni,getCurrentPages,getApp,UniServiceJSBridge,UniViewJSBridge} from '@dcloudio/uni-h5' +${name}.getApp = getApp +${name}.getCurrentPages = getCurrentPages +${name}.uni = uni +${name}.UniViewJSBridge = UniViewJSBridge +${name}.UniServiceJSBridge = UniServiceJSBridge +` +} + +function normalizePageIdentifier(path: string) { + return capitalize(camelize(path.replace(/\//g, '-'))) +} + +function generateCssCode(config: ResolvedConfig) { + const define = config.define! as FEATURE_DEFINES + const cssFiles = [H5_FRAMEWORK_STYLE_PATH + 'base.css'] + // if (define.__UNI_FEATURE_PAGES__) { + cssFiles.push(H5_FRAMEWORK_STYLE_PATH + 'async.css') + // } + if (define.__UNI_FEATURE_RESPONSIVE__) { + cssFiles.push(H5_FRAMEWORK_STYLE_PATH + 'layout.css') + } + if (define.__UNI_FEATURE_NAVIGATIONBAR__) { + cssFiles.push(H5_FRAMEWORK_STYLE_PATH + 'pageHead.css') + } + if (define.__UNI_FEATURE_TABBAR__) { + cssFiles.push(H5_FRAMEWORK_STYLE_PATH + 'tabBar.css') + } + if (define.__UNI_FEATURE_NVUE__) { + cssFiles.push(H5_FRAMEWORK_STYLE_PATH + 'nvue.css') + } + if (define.__UNI_FEATURE_PULL_DOWN_REFRESH__) { + cssFiles.push(H5_FRAMEWORK_STYLE_PATH + 'pageRefresh.css') + } + if (define.__UNI_FEATURE_NAVIGATIONBAR_SEARCHINPUT__) { + cssFiles.push(BASE_COMPONENTS_STYLE_PATH + 'input.css') + } + if (config.command === 'serve') { + // 开发模式，自动添加所有API相关css + Object.keys(API_DEPS_CSS).forEach((name) => { + const styles = API_DEPS_CSS[name as keyof typeof API_DEPS_CSS] + styles.forEach((style) => { + if (!cssFiles.includes(style)) { + cssFiles.push(style) + } + }) + }) + } + return cssFiles.map((file) => `import '${file}'`).join('\n') +} + +function generateLayoutComponentsCode( + globalName: string, + pagesJson: UniApp.PagesJson +) { + const windowNames: Array<'topWindow' | 'leftWindow' | 'rightWindow'> = [ + 'topWindow', + 'leftWindow', + 'rightWindow', + ] + let importLayoutComponentsCode = '' + let defineLayoutComponentsCode = `${globalName}.__uniLayout = ${globalName}.__uniLayout || {}\n` + windowNames.forEach((name) => { + const windowConfig = pagesJson[name] + if (windowConfig && windowConfig.path) { + importLayoutComponentsCode += `import ${name} from './${windowConfig.path}'\n` + defineLayoutComponentsCode += `${globalName}.__uniConfig.${name}.component = ${name}\n` + } + }) + + return { + importLayoutComponentsCode, + defineLayoutComponentsCode, + } +} + +function generatePageDefineCode(pageOptions: UniApp.PagesJsonPageOptions) { + const pageIdent = normalizePageIdentifier(pageOptions.path) + return `const ${pageIdent}Loader = ()=>import('./${pageOptions.path}?mpType=page') +const ${pageIdent} = defineAsyncComponent(extend({loader:${pageIdent}Loader},AsyncComponentOptions))` +} + +function generatePagesDefineCode( + pagesJson: UniApp.PagesJson, + _config: ResolvedConfig +) { + const { pages } = pagesJson + return ( + `const AsyncComponentOptions = { + loadingComponent: AsyncLoadingComponent, + errorComponent: AsyncErrorComponent, + delay: async.delay, + timeout: async.timeout, + suspensible: async.suspensible +} +` + pages.map((pageOptions) => generatePageDefineCode(pageOptions)).join('\n') + ) +} + +function normalizePagesRoute(pagesJson: UniApp.PagesJson): PageRouteOptions[] { + const firstPagePath = pagesJson.pages[0].path + const tabBarList = (pagesJson.tabBar && pagesJson.tabBar.list) || [] + return pagesJson.pages.map((pageOptions) => { + const pagePath = pageOptions.path + const name = normalizePageIdentifier(pagePath) + const isEntry = firstPagePath === pagePath ? true : undefined + const tabBarIndex = tabBarList.findIndex( + (tabBarPage: { pagePath: string }) => tabBarPage.pagePath === pagePath + ) + const isTabBar = tabBarIndex !== -1 ? true : undefined + const isNVue = fs.existsSync( + path.join(process.env.UNI_INPUT_DIR, pagePath + '.nvue') + ) + let windowTop = 0 + const meta = extend( + { + route: pageOptions.path, + isNVue: isNVue ? true : undefined, + isQuit: isEntry || isTabBar ? true : undefined, + isEntry, + isTabBar, + tabBarIndex, + windowTop, + }, + pageOptions.style + ) + return { + name, + path: pageOptions.path, + meta, + } + }) +} + +function generatePageRoute( + { name, path, meta }: PageRouteOptions, + config: ResolvedConfig +) { + const { isEntry } = meta + const alias = isEntry ? `\n alias:'/${path}',` : '' + return `{ + path:'/${isEntry ? '' : path}',${alias} + component:{setup(){return ()=>renderPage(${name})}}, + loader: ${normalizePageIdentifier(path)}Loader, + meta: ${JSON.stringify(meta)} +}` +} + +function generatePagesRoute( + pagesRouteOptions: PageRouteOptions[], + config: ResolvedConfig +) { + return pagesRouteOptions.map((pageOptions) => + generatePageRoute(pageOptions, config) + ) +} + +function generateRoutes( + globalName: string, + pagesJson: UniApp.PagesJson, + config: ResolvedConfig +) { + return ` +function renderPage(component){ + return (openBlock(), createBlock(PageComponent, null, {page: withCtx(() => [createVNode(component, { ref: "page" }, null, 512 /* NEED_PATCH */)]), _: 1 /* STABLE */})) +} +${globalName}.__uniRoutes=[${[ + ...generatePagesRoute(normalizePagesRoute(pagesJson), config), + ].join(',')}]` +} + +function generateConfig( + globalName: string, + pagesJson: Record, + config: ResolvedConfig +) { + delete pagesJson.pages + delete pagesJson.subPackages + delete pagesJson.subpackages + pagesJson.compilerVersion = pkg['uni-app'].compilerVersion + return ( + (config.command === 'serve' + ? '' + : `${globalName}['____'+appid+'____']=true +delete ${globalName}['____'+appid+'____'] +`) + + `${globalName}.__uniConfig=extend(${JSON.stringify(pagesJson)},{ + async, + debug, + networkTimeout, + sdkConfigs, + qqMapKey, + nvue, + router +}) +` + ) +} diff --git a/packages/uni-app-vite/src/plugins/resolveId.ts b/packages/uni-app-vite/src/plugins/resolveId.ts new file mode 100644 index 0000000000000000000000000000000000000000..3ea76cbe4d4a60a6c14c5c1510f0c993c07f6215 --- /dev/null +++ b/packages/uni-app-vite/src/plugins/resolveId.ts @@ -0,0 +1,43 @@ +import path from 'path' +import debug from 'debug' +import { Plugin } from 'vite' + +import { resolveBuiltIn, parseCompatConfigOnce } from '@dcloudio/uni-cli-shared' + +const debugResolve = debug('vite:uni:resolve') + +export function uniResolveIdPlugin(): Plugin { + const resolveCache: Record = {} + return { + name: 'vite:uni-app-resolve-id', + enforce: 'pre', + configResolved() { + const { MODE } = parseCompatConfigOnce(process.env.UNI_INPUT_DIR) + resolveCache['@dcloudio/uni-h5'] = resolveBuiltIn( + path.join('@dcloudio/uni-h5', 'dist/uni-h5.es.js') + ) + resolveCache['@dcloudio/uni-h5-vue'] = resolveBuiltIn( + path.join( + '@dcloudio/uni-h5-vue', + `dist/vue.runtime.${MODE === 2 ? 'compat.' : ''}esm.js` + ) + ) + }, + resolveId(id) { + if (id === 'vue') { + id = '@dcloudio/uni-h5-vue' + } + const cache = resolveCache[id] + if (cache) { + debugResolve('cache', id, cache) + return cache + } + if ( + id.startsWith('@dcloudio/uni-h5/style') || + id.startsWith('@dcloudio/uni-components/style') + ) { + return (resolveCache[id] = resolveBuiltIn(id)) + } + }, + } +} diff --git a/packages/uni-app-vite/tsconfig.json b/packages/uni-app-vite/tsconfig.json new file mode 100644 index 0000000000000000000000000000000000000000..7de50e34ab83adea59378cbeb54e3751aa236822 --- /dev/null +++ b/packages/uni-app-vite/tsconfig.json @@ -0,0 +1,7 @@ +{ + "extends": "../../tsconfig.node.json", + "compilerOptions": { + "outDir": "dist" + }, + "include": ["src", "../shims-node.d.ts", "../shims-uni-app.d.ts"] +} diff --git a/packages/uni-app-vue/LICENSE b/packages/uni-app-vue/LICENSE new file mode 100755 index 0000000000000000000000000000000000000000..7a4a3ea2424c09fbe48d455aed1eaa94d9124835 --- /dev/null +++ b/packages/uni-app-vue/LICENSE @@ -0,0 +1,202 @@ + + Apache License + Version 2.0, January 2004 + http://www.apache.org/licenses/ + + TERMS AND CONDITIONS FOR USE, REPRODUCTION, AND DISTRIBUTION + + 1. Definitions. + + "License" shall mean the terms and conditions for use, reproduction, + and distribution as defined by Sections 1 through 9 of this document. + + "Licensor" shall mean the copyright owner or entity authorized by + the copyright owner that is granting the License. + + "Legal Entity" shall mean the union of the acting entity and all + other entities that control, are controlled by, or are under common + control with that entity. For the purposes of this definition, + "control" means (i) the power, direct or indirect, to cause the + direction or management of such entity, whether by contract or + otherwise, or (ii) ownership of fifty percent (50%) or more of the + outstanding shares, or (iii) beneficial ownership of such entity. + + "You" (or "Your") shall mean an individual or Legal Entity + exercising permissions granted by this License. + + "Source" form shall mean the preferred form for making modifications, + including but not limited to software source code, documentation + source, and configuration files. + + "Object" form shall mean any form resulting from mechanical + transformation or translation of a Source form, including but + not limited to compiled object code, generated documentation, + and conversions to other media types. + + "Work" shall mean the work of authorship, whether in Source or + Object form, made available under the License, as indicated by a + copyright notice that is included in or attached to the work + (an example is provided in the Appendix below). + + "Derivative Works" shall mean any work, whether in Source or Object + form, that is based on (or derived from) the Work and for which the + editorial revisions, annotations, elaborations, or other modifications + represent, as a whole, an original work of authorship. For the purposes + of this License, Derivative Works shall not include works that remain + separable from, or merely link (or bind by name) to the interfaces of, + the Work and Derivative Works thereof. + + "Contribution" shall mean any work of authorship, including + the original version of the Work and any modifications or additions + to that Work or Derivative Works thereof, that is intentionally + submitted to Licensor for inclusion in the Work by the copyright owner + or by an individual or Legal Entity authorized to submit on behalf of + the copyright owner. For the purposes of this definition, "submitted" + means any form of electronic, verbal, or written communication sent + to the Licensor or its representatives, including but not limited to + communication on electronic mailing lists, source code control systems, + and issue tracking systems that are managed by, or on behalf of, the + Licensor for the purpose of discussing and improving the Work, but + excluding communication that is conspicuously marked or otherwise + designated in writing by the copyright owner as "Not a Contribution." + + "Contributor" shall mean Licensor and any individual or Legal Entity + on behalf of whom a Contribution has been received by Licensor and + subsequently incorporated within the Work. + + 2. Grant of Copyright License. Subject to the terms and conditions of + this License, each Contributor hereby grants to You a perpetual, + worldwide, non-exclusive, no-charge, royalty-free, irrevocable + copyright license to reproduce, prepare Derivative Works of, + publicly display, publicly perform, sublicense, and distribute the + Work and such Derivative Works in Source or Object form. + + 3. Grant of Patent License. Subject to the terms and conditions of + this License, each Contributor hereby grants to You a perpetual, + worldwide, non-exclusive, no-charge, royalty-free, irrevocable + (except as stated in this section) patent license to make, have made, + use, offer to sell, sell, import, and otherwise transfer the Work, + where such license applies only to those patent claims licensable + by such Contributor that are necessarily infringed by their + Contribution(s) alone or by combination of their Contribution(s) + with the Work to which such Contribution(s) was submitted. If You + institute patent litigation against any entity (including a + cross-claim or counterclaim in a lawsuit) alleging that the Work + or a Contribution incorporated within the Work constitutes direct + or contributory patent infringement, then any patent licenses + granted to You under this License for that Work shall terminate + as of the date such litigation is filed. + + 4. Redistribution. You may reproduce and distribute copies of the + Work or Derivative Works thereof in any medium, with or without + modifications, and in Source or Object form, provided that You + meet the following conditions: + + (a) You must give any other recipients of the Work or + Derivative Works a copy of this License; and + + (b) You must cause any modified files to carry prominent notices + stating that You changed the files; and + + (c) You must retain, in the Source form of any Derivative Works + that You distribute, all copyright, patent, trademark, and + attribution notices from the Source form of the Work, + excluding those notices that do not pertain to any part of + the Derivative Works; and + + (d) If the Work includes a "NOTICE" text file as part of its + distribution, then any Derivative Works that You distribute must + include a readable copy of the attribution notices contained + within such NOTICE file, excluding those notices that do not + pertain to any part of the Derivative Works, in at least one + of the following places: within a NOTICE text file distributed + as part of the Derivative Works; within the Source form or + documentation, if provided along with the Derivative Works; or, + within a display generated by the Derivative Works, if and + wherever such third-party notices normally appear. The contents + of the NOTICE file are for informational purposes only and + do not modify the License. You may add Your own attribution + notices within Derivative Works that You distribute, alongside + or as an addendum to the NOTICE text from the Work, provided + that such additional attribution notices cannot be construed + as modifying the License. + + You may add Your own copyright statement to Your modifications and + may provide additional or different license terms and conditions + for use, reproduction, or distribution of Your modifications, or + for any such Derivative Works as a whole, provided Your use, + reproduction, and distribution of the Work otherwise complies with + the conditions stated in this License. + + 5. Submission of Contributions. Unless You explicitly state otherwise, + any Contribution intentionally submitted for inclusion in the Work + by You to the Licensor shall be under the terms and conditions of + this License, without any additional terms or conditions. + Notwithstanding the above, nothing herein shall supersede or modify + the terms of any separate license agreement you may have executed + with Licensor regarding such Contributions. + + 6. Trademarks. This License does not grant permission to use the trade + names, trademarks, service marks, or product names of the Licensor, + except as required for reasonable and customary use in describing the + origin of the Work and reproducing the content of the NOTICE file. + + 7. Disclaimer of Warranty. Unless required by applicable law or + agreed to in writing, Licensor provides the Work (and each + Contributor provides its Contributions) on an "AS IS" BASIS, + WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or + implied, including, without limitation, any warranties or conditions + of TITLE, NON-INFRINGEMENT, MERCHANTABILITY, or FITNESS FOR A + PARTICULAR PURPOSE. You are solely responsible for determining the + appropriateness of using or redistributing the Work and assume any + risks associated with Your exercise of permissions under this License. + + 8. Limitation of Liability. In no event and under no legal theory, + whether in tort (including negligence), contract, or otherwise, + unless required by applicable law (such as deliberate and grossly + negligent acts) or agreed to in writing, shall any Contributor be + liable to You for damages, including any direct, indirect, special, + incidental, or consequential damages of any character arising as a + result of this License or out of the use or inability to use the + Work (including but not limited to damages for loss of goodwill, + work stoppage, computer failure or malfunction, or any and all + other commercial damages or losses), even if such Contributor + has been advised of the possibility of such damages. + + 9. Accepting Warranty or Additional Liability. While redistributing + the Work or Derivative Works thereof, You may choose to offer, + and charge a fee for, acceptance of support, warranty, indemnity, + or other liability obligations and/or rights consistent with this + License. However, in accepting such obligations, You may act only + on Your own behalf and on Your sole responsibility, not on behalf + of any other Contributor, and only if You agree to indemnify, + defend, and hold each Contributor harmless for any liability + incurred by, or claims asserted against, such Contributor by reason + of your accepting any such warranty or additional liability. + + END OF TERMS AND CONDITIONS + + APPENDIX: How to apply the Apache License to your work. + + To apply the Apache License to your work, attach the following + boilerplate notice, with the fields enclosed by brackets "[]" + replaced with your own identifying information. (Don't include + the brackets!) The text should be enclosed in the appropriate + comment syntax for the file format. We also recommend that a + file or class name and description of purpose be included on the + same "printed page" as the copyright notice for easier + identification within third-party archives. + + Copyright [yyyy] [name of copyright owner] + + Licensed under the Apache License, Version 2.0 (the "License"); + you may not use this file except in compliance with the License. + You may obtain a copy of the License at + + http://www.apache.org/licenses/LICENSE-2.0 + + Unless required by applicable law or agreed to in writing, software + distributed under the License is distributed on an "AS IS" BASIS, + WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. + See the License for the specific language governing permissions and + limitations under the License. \ No newline at end of file diff --git a/packages/uni-app-vue/build.json b/packages/uni-app-vue/build.json new file mode 100644 index 0000000000000000000000000000000000000000..e14f13a56903289a93adb9bc4a01ed0cf68b3026 --- /dev/null +++ b/packages/uni-app-vue/build.json @@ -0,0 +1,5 @@ +{ + "input": { + "src/index.ts": ["dist/vue.runtime.esm.js"] + } +} diff --git a/packages/uni-app-vue/dist/vue.runtime.esm.js b/packages/uni-app-vue/dist/vue.runtime.esm.js new file mode 100644 index 0000000000000000000000000000000000000000..0544ed6ad6bf4beb144522c48dbe2443e25a6b66 --- /dev/null +++ b/packages/uni-app-vue/dist/vue.runtime.esm.js @@ -0,0 +1,9580 @@ +import { extend, capitalize, camelize, isSymbol, isMap, isObject, toRawType, def, isArray, isString, isFunction, isPromise, remove, EMPTY_OBJ, toHandlerKey, getGlobalThis, EMPTY_ARR, normalizeClass, normalizeStyle, isOn, NOOP, isGloballyWhitelisted, NO, toNumber, invokeArrayFns, hyphenate, isHTMLTag, isSVGTag, isIntegerKey, hasOwn, hasChanged, isReservedProp, makeMap, isModelListener, isSet, isPlainObject } from '@vue/shared'; +export { camelize, capitalize, toDisplayString, toHandlerKey } from '@vue/shared'; + +class DOMException extends Error { + constructor(message) { + super(message); + this.name = 'DOMException'; + } +} + +function normalizeEventType(type) { + return `on${capitalize(camelize(type))}`; +} +class UniEventTarget { + constructor() { + this._listeners = {}; + } + dispatchEvent(evt) { + const listeners = this._listeners[evt.type]; + if (!listeners) { + return false; + } + const len = listeners.length; + for (let i = 0; i < len; i++) { + listeners[i].call(this, evt); + if (evt._end) { + break; + } + } + return evt.cancelable && evt.defaultPrevented; + } + addEventListener(type, listener, options) { + const isOnce = options && options.once; + if (isOnce) { + const wrapper = function (evt) { + listener.apply(this, [evt]); + this.removeEventListener(type, wrapper, options); + }; + return this.addEventListener(type, wrapper, extend(options, { once: false })); + } + (this._listeners[type] || (this._listeners[type] = [])).push(listener); + } + removeEventListener(type, callback, options) { + const listeners = this._listeners[type.toLowerCase()]; + if (!listeners) { + return; + } + const index = listeners.indexOf(callback); + if (index > -1) { + listeners.splice(index, 1); + } + } +} + +class UniCSSStyleDeclaration { + constructor() { + this._cssText = null; + this._value = null; + } + setProperty(property, value) { + if (value === null || value === '') { + this.removeProperty(property); + } + else { + if (!this._value) { + this._value = {}; + } + this._value[property] = value; + } + } + getPropertyValue(property) { + if (!this._value) { + return ''; + } + return this._value[property] || ''; + } + removeProperty(property) { + if (!this._value) { + return ''; + } + const value = this._value[property]; + delete this._value[property]; + return value; + } + get cssText() { + return this._cssText || ''; + } + set cssText(cssText) { + this._cssText = cssText; + } + toJSON() { + const { _cssText, _value } = this; + const hasCssText = _cssText !== null; + const hasValue = _value !== null; + if (hasCssText && hasValue) { + return [_cssText, _value]; + } + if (hasCssText) { + return _cssText; + } + if (hasValue) { + return _value; + } + } +} +const STYLE_PROPS = [ + '_value', + '_cssText', + 'cssText', + 'getPropertyValue', + 'setProperty', + 'removeProperty', + 'toJSON', +]; +function proxyStyle(uniCssStyle) { + return new Proxy(uniCssStyle, { + get(target, key, receiver) { + if (STYLE_PROPS.indexOf(key) === -1) { + return target.getPropertyValue(key); + } + return Reflect.get(target, key, receiver); + }, + set(target, key, value, receiver) { + if (STYLE_PROPS.indexOf(key) === -1) { + target.setProperty(key, value); + return true; + } + return Reflect.set(target, key, value, receiver); + }, + }); +} + +const ATTR_MAP = { + class: '.c', + style: '.s', + onClick: '.e0', + onChange: '.e1', + onInput: '.e2', + onLoad: '.e3', + onError: '.e4', + onTouchstart: '.e5', + onTouchmove: '.e6', + onTouchcancel: '.e7', + onTouchend: '.e8', + onLongpress: '.e9', + onTransitionend: '.ea', + onAnimationstart: '.eb', + onAnimationiteration: '.ec', + onAnimationend: '.ed', + onTouchforcechange: '.ee', +}; +function encodeAttr(name) { + return ATTR_MAP[name] || name; +} +const COMPONENT_MAP = { + VIEW: 1, + IMAGE: 2, + TEXT: 3, + '#text': 4, + '#comment': 5, + NAVIGATOR: 6, + FORM: 7, + BUTTON: 8, + INPUT: 9, + LABEL: 10, + RADIO: 11, + CHECKBOX: 12, + 'CHECKBOX-GROUP': 13, + AD: 14, + AUDIO: 15, + CAMERA: 16, + CANVAS: 17, + 'COVER-IMAGE': 18, + 'COVER-VIEW': 19, + EDITOR: 20, + 'FUNCTIONAL-PAGE-NAVIGATOR': 21, + ICON: 22, + 'RADIO-GROUP': 23, + 'LIVE-PLAYER': 24, + 'LIVE-PUSHER': 25, + MAP: 26, + 'MOVABLE-AREA': 27, + 'MOVABLE-VIEW': 28, + 'OFFICIAL-ACCOUNT': 29, + 'OPEN-DATA': 30, + PICKER: 31, + 'PICKER-VIEW': 32, + 'PICKER-VIEW-COLUMN': 33, + PROGRESS: 34, + 'RICH-TEXT': 35, + 'SCROLL-VIEW': 36, + SLIDER: 37, + SWIPER: 38, + 'SWIPER-ITEM': 39, + SWITCH: 40, + TEXTAREA: 41, + VIDEO: 42, + 'WEB-VIEW': 43, +}; +function encodeTag(tag) { + return COMPONENT_MAP[tag] || tag; +} + +const NODE_TYPE_PAGE = 0; +const NODE_TYPE_ELEMENT = 1; +const NODE_TYPE_TEXT = 3; +const NODE_TYPE_COMMENT = 8; +function sibling(node, type) { + const { parentNode } = node; + if (!parentNode) { + return null; + } + const { childNodes } = parentNode; + return childNodes[childNodes.indexOf(node) + (type === 'n' ? 1 : -1)] || null; +} +function removeNode(node) { + const { parentNode } = node; + if (parentNode) { + parentNode.removeChild(node); + } +} +function checkNodeId(node) { + if (!node.nodeId) { + node.nodeId = node.pageNode.genId(); + } +} +// 为优化性能，各平台不使用proxy来实现node的操作拦截，而是直接通过pageNode定制 +class UniNode extends UniEventTarget { + constructor(nodeType, nodeName, container) { + super(); + this.pageNode = null; + this.parentNode = null; + this._text = null; + if (container) { + const { pageNode } = container; + this.pageNode = pageNode; + this.nodeId = pageNode.genId(); + pageNode.onCreate(this, encodeTag(nodeName)); + } + this.nodeType = nodeType; + this.nodeName = nodeName; + this.childNodes = []; + } + get firstChild() { + return this.childNodes[0] || null; + } + get lastChild() { + const { childNodes } = this; + const length = childNodes.length; + return length ? childNodes[length - 1] : null; + } + get nextSibling() { + return sibling(this, 'n'); + } + get nodeValue() { + return null; + } + set nodeValue(_val) { } + get textContent() { + return this._text || ''; + } + set textContent(text) { + this._text = text; + if (this.pageNode) { + this.pageNode.onTextContent(this, text); + } + } + get parentElement() { + const { parentNode } = this; + if (parentNode && parentNode.nodeType === NODE_TYPE_ELEMENT) { + return parentNode; + } + return null; + } + get previousSibling() { + return sibling(this, 'p'); + } + appendChild(newChild) { + return this.insertBefore(newChild, null); + } + cloneNode(deep) { + const cloned = extend(Object.create(Object.getPrototypeOf(this)), this); + const { attributes } = cloned; + if (attributes) { + cloned.attributes = extend({}, attributes); + } + if (deep) { + cloned.childNodes = cloned.childNodes.map((childNode) => childNode.cloneNode(true)); + } + return cloned; + } + insertBefore(newChild, refChild) { + removeNode(newChild); + newChild.pageNode = this.pageNode; + newChild.parentNode = this; + checkNodeId(newChild); + const { childNodes } = this; + let index; + if (refChild) { + index = childNodes.indexOf(refChild); + if (index === -1) { + throw new DOMException(`Failed to execute 'insertBefore' on 'Node': The node before which the new node is to be inserted is not a child of this node.`); + } + childNodes.splice(index, 0, newChild); + } + else { + index = childNodes.length; + childNodes.push(newChild); + } + return this.pageNode + ? this.pageNode.onInsertBefore(this, newChild, index) + : newChild; + } + removeChild(oldChild) { + const { childNodes } = this; + const index = childNodes.indexOf(oldChild); + if (index === -1) { + throw new DOMException(`Failed to execute 'removeChild' on 'Node': The node to be removed is not a child of this node.`); + } + oldChild.parentNode = null; + childNodes.splice(index, 1); + return this.pageNode + ? this.pageNode.onRemoveChild(this, oldChild) + : oldChild; + } +} +class UniBaseNode extends UniNode { + constructor(nodeType, nodeName, container) { + super(nodeType, nodeName, container); + this.attributes = Object.create(null); + this._html = null; + this.style = proxyStyle(new UniCSSStyleDeclaration()); + } + get className() { + return (this.attributes['class'] || ''); + } + set className(val) { + this.setAttribute('class', val); + } + get innerHTML() { + return ''; + } + set innerHTML(html) { + this._html = html; + } + addEventListener(type, listener, options) { + super.addEventListener(type, listener, options); + const normalized = normalizeEventType(type); + if (!this.attributes[normalized]) { + this.setAttribute(normalized, 1); + } + } + removeEventListener(type, callback, options) { + super.removeEventListener(type, callback, options); + const normalized = normalizeEventType(type); + if (this.attributes[encodeAttr(normalized)]) { + this.removeAttribute(normalized); + } + } + getAttribute(qualifiedName) { + return this.attributes[encodeAttr(qualifiedName)]; + } + removeAttribute(qualifiedName) { + qualifiedName = encodeAttr(qualifiedName); + delete this.attributes[qualifiedName]; + if (this.pageNode) { + this.pageNode.onRemoveAttribute(this, qualifiedName); + } + } + setAttribute(qualifiedName, value) { + qualifiedName = encodeAttr(qualifiedName); + this.attributes[qualifiedName] = value; + if (this.pageNode) { + this.pageNode.onSetAttribute(this, qualifiedName, value); + } + } + toJSON(opts = {}) { + const res = { + a: this.attributes, + s: this.style.toJSON(), + }; + if (!opts.attr) { + res.i = this.nodeId; + res.n = encodeTag(this.nodeName); + } + if (this._text !== null) { + res.t = this._text; + } + return res; + } +} + +class UniCommentNode extends UniNode { + constructor(text, container) { + super(NODE_TYPE_COMMENT, '#comment', container); + this._text = text; + } + toJSON(opts = {}) { + return opts.attr + ? { t: this._text } + : { + i: this.nodeId, + t: this._text, + }; + } +} + +class UniElement extends UniBaseNode { + constructor(nodeName, container) { + super(NODE_TYPE_ELEMENT, nodeName.toUpperCase(), container); + this.tagName = this.nodeName; + } +} + +class UniTextNode extends UniBaseNode { + constructor(text, container) { + super(NODE_TYPE_TEXT, '#text', container); + this._text = text; + } + get nodeValue() { + return this._text || ''; + } + set nodeValue(text) { + this._text = text; + if (this.pageNode) { + this.pageNode.onNodeValue(this, text); + } + } +} +const DECODED_COMPONENT_ARR = /*#__PURE__*/ Object.keys(COMPONENT_MAP).reduce((arr, name) => { + arr.push(name.toLowerCase()); + return arr; +}, ['']); +function decodeTag(tag) { + return DECODED_COMPONENT_ARR[tag] || tag; +} + +const targetMap = new WeakMap(); +const effectStack = []; +let activeEffect; +const ITERATE_KEY = Symbol((process.env.NODE_ENV !== 'production') ? 'iterate' : ''); +const MAP_KEY_ITERATE_KEY = Symbol((process.env.NODE_ENV !== 'production') ? 'Map key iterate' : ''); +function isEffect(fn) { + return fn && fn._isEffect === true; +} +function effect(fn, options = EMPTY_OBJ) { + if (isEffect(fn)) { + fn = fn.raw; + } + const effect = createReactiveEffect(fn, options); + if (!options.lazy) { + effect(); + } + return effect; +} +function stop(effect) { + if (effect.active) { + cleanup(effect); + if (effect.options.onStop) { + effect.options.onStop(); + } + effect.active = false; + } +} +let uid = 0; +function createReactiveEffect(fn, options) { + const effect = function reactiveEffect() { + if (!effect.active) { + return fn(); + } + if (!effectStack.includes(effect)) { + cleanup(effect); + try { + enableTracking(); + effectStack.push(effect); + activeEffect = effect; + return fn(); + } + finally { + effectStack.pop(); + resetTracking(); + activeEffect = effectStack[effectStack.length - 1]; + } + } + }; + effect.id = uid++; + effect.allowRecurse = !!options.allowRecurse; + effect._isEffect = true; + effect.active = true; + effect.raw = fn; + effect.deps = []; + effect.options = options; + return effect; +} +function cleanup(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 enableTracking() { + trackStack.push(shouldTrack); + shouldTrack = true; +} +function resetTracking() { + const last = trackStack.pop(); + shouldTrack = last === undefined ? true : last; +} +function track(target, type, key) { + if (!shouldTrack || activeEffect === undefined) { + return; + } + let depsMap = targetMap.get(target); + if (!depsMap) { + targetMap.set(target, (depsMap = new Map())); + } + let dep = depsMap.get(key); + if (!dep) { + depsMap.set(key, (dep = new Set())); + } + if (!dep.has(activeEffect)) { + dep.add(activeEffect); + activeEffect.deps.push(dep); + if ((process.env.NODE_ENV !== 'production') && activeEffect.options.onTrack) { + activeEffect.options.onTrack({ + effect: activeEffect, + target, + type, + key + }); + } + } +} +function trigger(target, type, key, newValue, oldValue, oldTarget) { + const depsMap = targetMap.get(target); + if (!depsMap) { + // never been tracked + return; + } + const effects = new Set(); + const add = (effectsToAdd) => { + if (effectsToAdd) { + effectsToAdd.forEach(effect => { + if (effect !== activeEffect || effect.allowRecurse) { + effects.add(effect); + } + }); + } + }; + if (type === "clear" /* CLEAR */) { + // collection being cleared + // trigger all effects for target + depsMap.forEach(add); + } + else if (key === 'length' && isArray(target)) { + depsMap.forEach((dep, key) => { + if (key === 'length' || key >= newValue) { + add(dep); + } + }); + } + else { + // schedule runs for SET | ADD | DELETE + if (key !== void 0) { + add(depsMap.get(key)); + } + // also run for iteration key on ADD | DELETE | Map.SET + switch (type) { + case "add" /* ADD */: + if (!isArray(target)) { + add(depsMap.get(ITERATE_KEY)); + if (isMap(target)) { + add(depsMap.get(MAP_KEY_ITERATE_KEY)); + } + } + else if (isIntegerKey(key)) { + // new index added to array -> length changes + add(depsMap.get('length')); + } + break; + case "delete" /* DELETE */: + if (!isArray(target)) { + add(depsMap.get(ITERATE_KEY)); + if (isMap(target)) { + add(depsMap.get(MAP_KEY_ITERATE_KEY)); + } + } + break; + case "set" /* SET */: + if (isMap(target)) { + add(depsMap.get(ITERATE_KEY)); + } + break; + } + } + const run = (effect) => { + if ((process.env.NODE_ENV !== 'production') && effect.options.onTrigger) { + effect.options.onTrigger({ + effect, + target, + key, + type, + newValue, + oldValue, + oldTarget + }); + } + if (effect.options.scheduler) { + effect.options.scheduler(effect); + } + else { + effect(); + } + }; + effects.forEach(run); +} + +const isNonTrackableKeys = /*#__PURE__*/ makeMap(`__proto__,__v_isRef,__isVue`); +const builtInSymbols = new Set(Object.getOwnPropertyNames(Symbol) + .map(key => Symbol[key]) + .filter(isSymbol)); +const get = /*#__PURE__*/ createGetter(); +const shallowGet = /*#__PURE__*/ createGetter(false, true); +const readonlyGet = /*#__PURE__*/ createGetter(true); +const shallowReadonlyGet = /*#__PURE__*/ createGetter(true, true); +const arrayInstrumentations = {}; +['includes', 'indexOf', 'lastIndexOf'].forEach(key => { + const method = Array.prototype[key]; + arrayInstrumentations[key] = function (...args) { + const arr = toRaw(this); + for (let i = 0, l = this.length; i < l; i++) { + track(arr, "get" /* GET */, i + ''); + } + // we run the method using the original args first (which may be reactive) + const res = method.apply(arr, args); + if (res === -1 || res === false) { + // if that didn't work, run it again using raw values. + return method.apply(arr, args.map(toRaw)); + } + else { + return res; + } + }; +}); +['push', 'pop', 'shift', 'unshift', 'splice'].forEach(key => { + const method = Array.prototype[key]; + arrayInstrumentations[key] = function (...args) { + pauseTracking(); + const res = method.apply(this, args); + resetTracking(); + return res; + }; +}); +function createGetter(isReadonly = false, shallow = false) { + return function get(target, key, receiver) { + if (key === "__v_isReactive" /* IS_REACTIVE */) { + return !isReadonly; + } + else if (key === "__v_isReadonly" /* IS_READONLY */) { + return isReadonly; + } + else if (key === "__v_raw" /* RAW */ && + receiver === + (isReadonly + ? shallow + ? shallowReadonlyMap + : readonlyMap + : shallow + ? shallowReactiveMap + : reactiveMap).get(target)) { + return target; + } + const targetIsArray = isArray(target); + if (!isReadonly && targetIsArray && hasOwn(arrayInstrumentations, key)) { + return Reflect.get(arrayInstrumentations, key, receiver); + } + const res = Reflect.get(target, key, receiver); + if (isSymbol(key) ? builtInSymbols.has(key) : isNonTrackableKeys(key)) { + return res; + } + if (!isReadonly) { + track(target, "get" /* GET */, key); + } + if (shallow) { + return res; + } + if (isRef(res)) { + // ref unwrapping - does not apply for Array + integer key. + const shouldUnwrap = !targetIsArray || !isIntegerKey(key); + return shouldUnwrap ? res.value : res; + } + if (isObject(res)) { + // Convert returned value into a proxy as well. we do the isObject check + // here to avoid invalid value warning. Also need to lazy access readonly + // and reactive here to avoid circular dependency. + return isReadonly ? readonly(res) : reactive(res); + } + return res; + }; +} +const set = /*#__PURE__*/ createSetter(); +const shallowSet = /*#__PURE__*/ createSetter(true); +function createSetter(shallow = false) { + return function set(target, key, value, receiver) { + let oldValue = target[key]; + if (!shallow) { + value = toRaw(value); + oldValue = toRaw(oldValue); + 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); + // don't trigger if target is something up in the prototype chain of original + if (target === toRaw(receiver)) { + if (!hadKey) { + trigger(target, "add" /* ADD */, key, value); + } + else if (hasChanged(value, oldValue)) { + trigger(target, "set" /* 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" /* DELETE */, key, undefined, oldValue); + } + return result; +} +function has(target, key) { + const result = Reflect.has(target, key); + if (!isSymbol(key) || !builtInSymbols.has(key)) { + track(target, "has" /* HAS */, key); + } + return result; +} +function ownKeys(target) { + track(target, "iterate" /* ITERATE */, isArray(target) ? 'length' : ITERATE_KEY); + return Reflect.ownKeys(target); +} +const mutableHandlers = { + get, + set, + deleteProperty, + has, + ownKeys +}; +const readonlyHandlers = { + get: readonlyGet, + set(target, key) { + if ((process.env.NODE_ENV !== 'production')) { + console.warn(`Set operation on key "${String(key)}" failed: target is readonly.`, target); + } + return true; + }, + deleteProperty(target, key) { + if ((process.env.NODE_ENV !== 'production')) { + console.warn(`Delete operation on key "${String(key)}" failed: target is readonly.`, target); + } + return true; + } +}; +const shallowReactiveHandlers = extend({}, mutableHandlers, { + get: shallowGet, + set: shallowSet +}); +// Props handlers are special in the sense that it should not unwrap top-level +// refs (in order to allow refs to be explicitly passed down), but should +// retain the reactivity of the normal readonly object. +const shallowReadonlyHandlers = extend({}, readonlyHandlers, { + get: shallowReadonlyGet +}); + +const toReactive = (value) => isObject(value) ? reactive(value) : value; +const toReadonly = (value) => isObject(value) ? readonly(value) : value; +const toShallow = (value) => value; +const getProto = (v) => Reflect.getPrototypeOf(v); +function get$1(target, key, isReadonly = false, isShallow = false) { + // #1772: readonly(reactive(Map)) should return readonly + reactive version + // of the value + target = target["__v_raw" /* RAW */]; + const rawTarget = toRaw(target); + const rawKey = toRaw(key); + if (key !== rawKey) { + !isReadonly && track(rawTarget, "get" /* GET */, key); + } + !isReadonly && track(rawTarget, "get" /* GET */, rawKey); + const { has } = getProto(rawTarget); + const wrap = isShallow ? toShallow : isReadonly ? toReadonly : toReactive; + if (has.call(rawTarget, key)) { + return wrap(target.get(key)); + } + else if (has.call(rawTarget, rawKey)) { + return wrap(target.get(rawKey)); + } + else if (target !== rawTarget) { + // #3602 readonly(reactive(Map)) + // ensure that the nested reactive `Map` can do tracking for itself + target.get(key); + } +} +function has$1(key, isReadonly = false) { + const target = this["__v_raw" /* RAW */]; + const rawTarget = toRaw(target); + const rawKey = toRaw(key); + if (key !== rawKey) { + !isReadonly && track(rawTarget, "has" /* HAS */, key); + } + !isReadonly && track(rawTarget, "has" /* HAS */, rawKey); + return key === rawKey + ? target.has(key) + : target.has(key) || target.has(rawKey); +} +function size(target, isReadonly = false) { + target = target["__v_raw" /* RAW */]; + !isReadonly && track(toRaw(target), "iterate" /* 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" /* ADD */, value, value); + } + return this; +} +function set$1(key, value) { + value = toRaw(value); + const target = toRaw(this); + const { has, get } = getProto(target); + let hadKey = has.call(target, key); + if (!hadKey) { + key = toRaw(key); + hadKey = has.call(target, key); + } + else if ((process.env.NODE_ENV !== 'production')) { + checkIdentityKeys(target, has, key); + } + const oldValue = get.call(target, key); + target.set(key, value); + if (!hadKey) { + trigger(target, "add" /* ADD */, key, value); + } + else if (hasChanged(value, oldValue)) { + trigger(target, "set" /* SET */, key, value, oldValue); + } + return this; +} +function deleteEntry(key) { + const target = toRaw(this); + const { has, get } = getProto(target); + let hadKey = has.call(target, key); + if (!hadKey) { + key = toRaw(key); + hadKey = has.call(target, key); + } + else if ((process.env.NODE_ENV !== 'production')) { + checkIdentityKeys(target, has, key); + } + const oldValue = get ? get.call(target, key) : undefined; + // forward the operation before queueing reactions + const result = target.delete(key); + if (hadKey) { + trigger(target, "delete" /* DELETE */, key, undefined, oldValue); + } + return result; +} +function clear() { + const target = toRaw(this); + const hadItems = target.size !== 0; + const oldTarget = (process.env.NODE_ENV !== 'production') + ? isMap(target) + ? new Map(target) + : new Set(target) + : undefined; + // forward the operation before queueing reactions + const result = target.clear(); + if (hadItems) { + trigger(target, "clear" /* CLEAR */, undefined, undefined, oldTarget); + } + return result; +} +function createForEach(isReadonly, isShallow) { + return function forEach(callback, thisArg) { + const observed = this; + const target = observed["__v_raw" /* RAW */]; + const rawTarget = toRaw(target); + const wrap = isShallow ? toShallow : isReadonly ? toReadonly : toReactive; + !isReadonly && track(rawTarget, "iterate" /* ITERATE */, ITERATE_KEY); + return target.forEach((value, key) => { + // important: make sure the callback is + // 1. invoked with the reactive map as `this` and 3rd arg + // 2. the value received should be a corresponding reactive/readonly. + return callback.call(thisArg, wrap(value), wrap(key), observed); + }); + }; +} +function createIterableMethod(method, isReadonly, isShallow) { + return function (...args) { + const target = this["__v_raw" /* 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 = isShallow ? toShallow : isReadonly ? toReadonly : toReactive; + !isReadonly && + track(rawTarget, "iterate" /* ITERATE */, isKeyOnly ? MAP_KEY_ITERATE_KEY : ITERATE_KEY); + // return a wrapped iterator which returns observed versions of the + // values emitted from the real iterator + 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) { + if ((process.env.NODE_ENV !== 'production')) { + const key = args[0] ? `on key "${args[0]}" ` : ``; + console.warn(`${capitalize(type)} operation ${key}failed: target is readonly.`, toRaw(this)); + } + return type === "delete" /* DELETE */ ? false : this; + }; +} +const mutableInstrumentations = { + get(key) { + return get$1(this, key); + }, + get size() { + return size(this); + }, + has: has$1, + add, + set: set$1, + delete: deleteEntry, + clear, + forEach: createForEach(false, false) +}; +const shallowInstrumentations = { + get(key) { + return get$1(this, key, false, true); + }, + get size() { + return size(this); + }, + has: has$1, + add, + set: set$1, + delete: deleteEntry, + clear, + forEach: createForEach(false, true) +}; +const readonlyInstrumentations = { + get(key) { + return get$1(this, key, true); + }, + get size() { + return size(this, true); + }, + has(key) { + return has$1.call(this, key, true); + }, + add: createReadonlyMethod("add" /* ADD */), + set: createReadonlyMethod("set" /* SET */), + delete: createReadonlyMethod("delete" /* DELETE */), + clear: createReadonlyMethod("clear" /* CLEAR */), + forEach: createForEach(true, false) +}; +const shallowReadonlyInstrumentations = { + get(key) { + return get$1(this, key, true, true); + }, + get size() { + return size(this, true); + }, + has(key) { + return has$1.call(this, key, true); + }, + add: createReadonlyMethod("add" /* ADD */), + set: createReadonlyMethod("set" /* SET */), + delete: createReadonlyMethod("delete" /* DELETE */), + clear: createReadonlyMethod("clear" /* CLEAR */), + forEach: createForEach(true, true) +}; +const iteratorMethods = ['keys', 'values', 'entries', Symbol.iterator]; +iteratorMethods.forEach(method => { + mutableInstrumentations[method] = createIterableMethod(method, false, false); + readonlyInstrumentations[method] = createIterableMethod(method, true, false); + shallowInstrumentations[method] = createIterableMethod(method, false, true); + shallowReadonlyInstrumentations[method] = createIterableMethod(method, true, true); +}); +function createInstrumentationGetter(isReadonly, shallow) { + const instrumentations = shallow + ? isReadonly + ? shallowReadonlyInstrumentations + : shallowInstrumentations + : isReadonly + ? readonlyInstrumentations + : mutableInstrumentations; + return (target, key, receiver) => { + if (key === "__v_isReactive" /* IS_REACTIVE */) { + return !isReadonly; + } + else if (key === "__v_isReadonly" /* IS_READONLY */) { + return isReadonly; + } + else if (key === "__v_raw" /* RAW */) { + return target; + } + return Reflect.get(hasOwn(instrumentations, key) && key in target + ? instrumentations + : target, key, receiver); + }; +} +const mutableCollectionHandlers = { + get: createInstrumentationGetter(false, false) +}; +const shallowCollectionHandlers = { + get: createInstrumentationGetter(false, true) +}; +const readonlyCollectionHandlers = { + get: createInstrumentationGetter(true, false) +}; +const shallowReadonlyCollectionHandlers = { + get: createInstrumentationGetter(true, true) +}; +function checkIdentityKeys(target, has, key) { + const rawKey = toRaw(key); + if (rawKey !== key && has.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 = new WeakMap(); +const shallowReactiveMap = new WeakMap(); +const readonlyMap = new WeakMap(); +const shallowReadonlyMap = new WeakMap(); +function targetTypeMap(rawType) { + switch (rawType) { + case 'Object': + case 'Array': + return 1 /* COMMON */; + case 'Map': + case 'Set': + case 'WeakMap': + case 'WeakSet': + return 2 /* COLLECTION */; + default: + return 0 /* INVALID */; + } +} +function getTargetType(value) { + return value["__v_skip" /* SKIP */] || !Object.isExtensible(value) + ? 0 /* INVALID */ + : targetTypeMap(toRawType(value)); +} +function reactive(target) { + // if trying to observe a readonly proxy, return the readonly version. + if (target && target["__v_isReadonly" /* IS_READONLY */]) { + return target; + } + return createReactiveObject(target, false, mutableHandlers, mutableCollectionHandlers, reactiveMap); +} +/** + * Return a shallowly-reactive copy of the original object, where only the root + * level properties are reactive. It also does not auto-unwrap refs (even at the + * root level). + */ +function shallowReactive(target) { + return createReactiveObject(target, false, shallowReactiveHandlers, shallowCollectionHandlers, shallowReactiveMap); +} +/** + * Creates a readonly copy of the original object. Note the returned copy is not + * made reactive, but `readonly` can be called on an already reactive object. + */ +function readonly(target) { + return createReactiveObject(target, true, readonlyHandlers, readonlyCollectionHandlers, readonlyMap); +} +/** + * Returns a reactive-copy of the original object, where only the root level + * properties are readonly, and does NOT unwrap refs nor recursively convert + * returned properties. + * This is used for creating the props proxy object for stateful components. + */ +function shallowReadonly(target) { + return createReactiveObject(target, true, shallowReadonlyHandlers, shallowReadonlyCollectionHandlers, shallowReadonlyMap); +} +function createReactiveObject(target, isReadonly, baseHandlers, collectionHandlers, proxyMap) { + if (!isObject(target)) { + if ((process.env.NODE_ENV !== 'production')) { + console.warn(`value cannot be made reactive: ${String(target)}`); + } + return target; + } + // target is already a Proxy, return it. + // exception: calling readonly() on a reactive object + if (target["__v_raw" /* RAW */] && + !(isReadonly && target["__v_isReactive" /* IS_REACTIVE */])) { + return target; + } + // target already has corresponding Proxy + const existingProxy = proxyMap.get(target); + if (existingProxy) { + return existingProxy; + } + // only a whitelist of value types can be observed. + const targetType = getTargetType(target); + if (targetType === 0 /* INVALID */) { + return target; + } + const proxy = new Proxy(target, targetType === 2 /* COLLECTION */ ? collectionHandlers : baseHandlers); + proxyMap.set(target, proxy); + return proxy; +} +function isReactive(value) { + if (isReadonly(value)) { + return isReactive(value["__v_raw" /* RAW */]); + } + return !!(value && value["__v_isReactive" /* IS_REACTIVE */]); +} +function isReadonly(value) { + return !!(value && value["__v_isReadonly" /* IS_READONLY */]); +} +function isProxy(value) { + return isReactive(value) || isReadonly(value); +} +function toRaw(observed) { + return ((observed && toRaw(observed["__v_raw" /* RAW */])) || observed); +} +function markRaw(value) { + def(value, "__v_skip" /* SKIP */, true); + return value; +} + +const convert = (val) => isObject(val) ? reactive(val) : val; +function isRef(r) { + return Boolean(r && r.__v_isRef === true); +} +function ref(value) { + return createRef(value); +} +function shallowRef(value) { + return createRef(value, true); +} +class RefImpl { + constructor(_rawValue, _shallow) { + this._rawValue = _rawValue; + this._shallow = _shallow; + this.__v_isRef = true; + this._value = _shallow ? _rawValue : convert(_rawValue); + } + get value() { + track(toRaw(this), "get" /* GET */, 'value'); + return this._value; + } + set value(newVal) { + if (hasChanged(toRaw(newVal), this._rawValue)) { + this._rawValue = newVal; + this._value = this._shallow ? newVal : convert(newVal); + trigger(toRaw(this), "set" /* SET */, 'value', newVal); + } + } +} +function createRef(rawValue, shallow = false) { + if (isRef(rawValue)) { + return rawValue; + } + return new RefImpl(rawValue, shallow); +} +function triggerRef(ref) { + trigger(toRaw(ref), "set" /* SET */, 'value', (process.env.NODE_ENV !== 'production') ? ref.value : void 0); +} +function unref(ref) { + return isRef(ref) ? ref.value : ref; +} +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); +} +class CustomRefImpl { + constructor(factory) { + this.__v_isRef = true; + const { get, set } = factory(() => track(this, "get" /* GET */, 'value'), () => trigger(this, "set" /* SET */, 'value')); + this._get = get; + this._set = set; + } + get value() { + return this._get(); + } + set value(newVal) { + this._set(newVal); + } +} +function customRef(factory) { + return new CustomRefImpl(factory); +} +function toRefs(object) { + if ((process.env.NODE_ENV !== 'production') && !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) { + this._object = _object; + this._key = _key; + this.__v_isRef = true; + } + get value() { + return this._object[this._key]; + } + set value(newVal) { + this._object[this._key] = newVal; + } +} +function toRef(object, key) { + return isRef(object[key]) + ? object[key] + : new ObjectRefImpl(object, key); +} + +class ComputedRefImpl { + constructor(getter, _setter, isReadonly) { + this._setter = _setter; + this._dirty = true; + this.__v_isRef = true; + this.effect = effect(getter, { + lazy: true, + scheduler: () => { + if (!this._dirty) { + this._dirty = true; + trigger(toRaw(this), "set" /* SET */, 'value'); + } + } + }); + this["__v_isReadonly" /* IS_READONLY */] = isReadonly; + } + get value() { + // the computed ref may get wrapped by other proxies e.g. readonly() #3376 + const self = toRaw(this); + if (self._dirty) { + self._value = this.effect(); + self._dirty = false; + } + track(self, "get" /* GET */, 'value'); + return self._value; + } + set value(newValue) { + this._setter(newValue); + } +} +function computed(getterOrOptions) { + let getter; + let setter; + if (isFunction(getterOrOptions)) { + getter = getterOrOptions; + setter = (process.env.NODE_ENV !== 'production') + ? () => { + console.warn('Write operation failed: computed value is readonly'); + } + : NOOP; + } + else { + getter = getterOrOptions.get; + setter = getterOrOptions.set; + } + return new ComputedRefImpl(getter, setter, isFunction(getterOrOptions) || !getterOrOptions.set); +} + +const stack = []; +function pushWarningContext(vnode) { + stack.push(vnode); +} +function popWarningContext() { + stack.pop(); +} +function warn(msg, ...args) { + // avoid props formatting or warn handler tracking deps that might be mutated + // during patch, leading to infinite recursion. + 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 /* APP_WARN_HANDLER */, [ + msg + args.join(''), + instance && instance.proxy, + trace + .map(({ vnode }) => `at <${formatComponentName(instance, vnode.type)}>`) + .join('\n'), + trace + ]); + } + else { + const warnArgs = [`[Vue warn]: ${msg}`, ...args]; + /* istanbul ignore if */ + if (trace.length && + // avoid spamming console during tests + !false) { + warnArgs.push(`\n`, ...formatTrace(trace)); + } + console.warn(...warnArgs); + } + resetTracking(); +} +function getComponentTrace() { + let currentVNode = stack[stack.length - 1]; + if (!currentVNode) { + return []; + } + // we can't just use the stack because it will be incomplete during updates + // that did not start from the root. Re-construct the parent chain using + // instance parent pointers. + 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; +} +/* istanbul ignore next */ +function formatTrace(trace) { + const logs = []; + trace.forEach((entry, i) => { + logs.push(...(i === 0 ? [] : [`\n`]), ...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]; +} +/* istanbul ignore next */ +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; +} +/* istanbul ignore next */ +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 = { + ["bc" /* BEFORE_CREATE */]: 'beforeCreate hook', + ["c" /* CREATED */]: 'created hook', + ["bm" /* BEFORE_MOUNT */]: 'beforeMount hook', + ["m" /* MOUNTED */]: 'mounted hook', + ["bu" /* BEFORE_UPDATE */]: 'beforeUpdate hook', + ["u" /* UPDATED */]: 'updated', + ["bum" /* BEFORE_UNMOUNT */]: 'beforeUnmount hook', + ["um" /* UNMOUNTED */]: 'unmounted hook', + ["a" /* ACTIVATED */]: 'activated hook', + ["da" /* DEACTIVATED */]: 'deactivated hook', + ["ec" /* ERROR_CAPTURED */]: 'errorCaptured hook', + ["rtc" /* RENDER_TRACKED */]: 'renderTracked hook', + ["rtg" /* RENDER_TRIGGERED */]: 'renderTriggered hook', + [0 /* SETUP_FUNCTION */]: 'setup function', + [1 /* RENDER_FUNCTION */]: 'render function', + [2 /* WATCH_GETTER */]: 'watcher getter', + [3 /* WATCH_CALLBACK */]: 'watcher callback', + [4 /* WATCH_CLEANUP */]: 'watcher cleanup function', + [5 /* NATIVE_EVENT_HANDLER */]: 'native event handler', + [6 /* COMPONENT_EVENT_HANDLER */]: 'component event handler', + [7 /* VNODE_HOOK */]: 'vnode hook', + [8 /* DIRECTIVE_HOOK */]: 'directive hook', + [9 /* TRANSITION_HOOK */]: 'transition hook', + [10 /* APP_ERROR_HANDLER */]: 'app errorHandler', + [11 /* APP_WARN_HANDLER */]: 'app warnHandler', + [12 /* FUNCTION_REF */]: 'ref function', + [13 /* ASYNC_COMPONENT_LOADER */]: 'async component loader', + [14 /* SCHEDULER */]: 'scheduler flush. This is likely a Vue internals bug. ' + + 'Please open an issue at https://new-issue.vuejs.org/?repo=vuejs/vue-next' +}; +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; + // the exposed instance is the render proxy to keep it consistent with 2.x + const exposedInstance = instance.proxy; + // in production the hook receives only the error code + const errorInfo = (process.env.NODE_ENV !== 'production') ? 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; + } + // app-level handling + const appErrorHandler = instance.appContext.config.errorHandler; + if (appErrorHandler) { + callWithErrorHandling(appErrorHandler, null, 10 /* APP_ERROR_HANDLER */, [err, exposedInstance, errorInfo]); + return; + } + } + logError(err, type, contextVNode, throwInDev); +} +function logError(err, type, contextVNode, throwInDev = true) { + if ((process.env.NODE_ENV !== 'production')) { + const info = ErrorTypeStrings[type]; + if (contextVNode) { + pushWarningContext(contextVNode); + } + warn(`Unhandled error${info ? ` during execution of ${info}` : ``}`); + if (contextVNode) { + popWarningContext(); + } + // crash in dev by default so it's more noticeable + if (throwInDev) { + throw err; + } + else { + console.error(err); + } + } + else { + // recover in prod to reduce the impact on end-user + console.error(err); + } +} + +let isFlushing = false; +let isFlushPending = false; +const queue = []; +let flushIndex = 0; +const pendingPreFlushCbs = []; +let activePreFlushCbs = null; +let preFlushIndex = 0; +const pendingPostFlushCbs = []; +let activePostFlushCbs = null; +let postFlushIndex = 0; +const resolvedPromise = Promise.resolve(); +let currentFlushPromise = null; +let currentPreFlushParentJob = null; +const RECURSION_LIMIT = 100; +function nextTick(fn) { + const p = currentFlushPromise || resolvedPromise; + return fn ? p.then(this ? fn.bind(this) : fn) : p; +} +// #2768 +// Use binary-search to find a suitable position in the queue, +// so that the queue maintains the increasing order of job's id, +// which can prevent the job from being skipped and also can avoid repeated patching. +function findInsertionIndex(job) { + // the start index should be `flushIndex + 1` + let start = flushIndex + 1; + let end = queue.length; + const jobId = getId(job); + while (start < end) { + const middle = (start + end) >>> 1; + const middleJobId = getId(queue[middle]); + middleJobId < jobId ? (start = middle + 1) : (end = middle); + } + return start; +} +function queueJob(job) { + // the dedupe search uses the startIndex argument of Array.includes() + // by default the search index includes the current job that is being run + // so it cannot recursively trigger itself again. + // if the job is a watch() callback, the search will start with a +1 index to + // allow it recursively trigger itself - it is the user's responsibility to + // ensure it doesn't end up in an infinite loop. + if ((!queue.length || + !queue.includes(job, isFlushing && job.allowRecurse ? flushIndex + 1 : flushIndex)) && + job !== currentPreFlushParentJob) { + const pos = findInsertionIndex(job); + if (pos > -1) { + queue.splice(pos, 0, job); + } + else { + queue.push(job); + } + queueFlush(); + } +} +function queueFlush() { + if (!isFlushing && !isFlushPending) { + isFlushPending = true; + currentFlushPromise = resolvedPromise.then(flushJobs); + } +} +function invalidateJob(job) { + const i = queue.indexOf(job); + if (i > flushIndex) { + queue.splice(i, 1); + } +} +function queueCb(cb, activeQueue, pendingQueue, index) { + if (!isArray(cb)) { + if (!activeQueue || + !activeQueue.includes(cb, cb.allowRecurse ? index + 1 : index)) { + pendingQueue.push(cb); + } + } + else { + // if cb is an array, it is a component lifecycle hook which can only be + // triggered by a job, which is already deduped in the main queue, so + // we can skip duplicate check here to improve perf + pendingQueue.push(...cb); + } + queueFlush(); +} +function queuePreFlushCb(cb) { + queueCb(cb, activePreFlushCbs, pendingPreFlushCbs, preFlushIndex); +} +function queuePostFlushCb(cb) { + queueCb(cb, activePostFlushCbs, pendingPostFlushCbs, postFlushIndex); +} +function flushPreFlushCbs(seen, parentJob = null) { + if (pendingPreFlushCbs.length) { + currentPreFlushParentJob = parentJob; + activePreFlushCbs = [...new Set(pendingPreFlushCbs)]; + pendingPreFlushCbs.length = 0; + if ((process.env.NODE_ENV !== 'production')) { + seen = seen || new Map(); + } + for (preFlushIndex = 0; preFlushIndex < activePreFlushCbs.length; preFlushIndex++) { + if ((process.env.NODE_ENV !== 'production') && + checkRecursiveUpdates(seen, activePreFlushCbs[preFlushIndex])) { + continue; + } + activePreFlushCbs[preFlushIndex](); + } + activePreFlushCbs = null; + preFlushIndex = 0; + currentPreFlushParentJob = null; + // recursively flush until it drains + flushPreFlushCbs(seen, parentJob); + } +} +function flushPostFlushCbs(seen) { + if (pendingPostFlushCbs.length) { + const deduped = [...new Set(pendingPostFlushCbs)]; + pendingPostFlushCbs.length = 0; + // #1947 already has active queue, nested flushPostFlushCbs call + if (activePostFlushCbs) { + activePostFlushCbs.push(...deduped); + return; + } + activePostFlushCbs = deduped; + if ((process.env.NODE_ENV !== 'production')) { + seen = seen || new Map(); + } + activePostFlushCbs.sort((a, b) => getId(a) - getId(b)); + for (postFlushIndex = 0; postFlushIndex < activePostFlushCbs.length; postFlushIndex++) { + if ((process.env.NODE_ENV !== 'production') && + checkRecursiveUpdates(seen, activePostFlushCbs[postFlushIndex])) { + continue; + } + activePostFlushCbs[postFlushIndex](); + } + activePostFlushCbs = null; + postFlushIndex = 0; + } +} +const getId = (job) => job.id == null ? Infinity : job.id; +function flushJobs(seen) { + isFlushPending = false; + isFlushing = true; + if ((process.env.NODE_ENV !== 'production')) { + seen = seen || new Map(); + } + flushPreFlushCbs(seen); + // Sort queue before flush. + // This ensures that: + // 1. Components are updated from parent to child. (because parent is always + // created before the child so its render effect will have smaller + // priority number) + // 2. If a component is unmounted during a parent component's update, + // its update can be skipped. + queue.sort((a, b) => getId(a) - getId(b)); + try { + for (flushIndex = 0; flushIndex < queue.length; flushIndex++) { + const job = queue[flushIndex]; + if (job && job.active !== false) { + if ((process.env.NODE_ENV !== 'production') && checkRecursiveUpdates(seen, job)) { + continue; + } + callWithErrorHandling(job, null, 14 /* SCHEDULER */); + } + } + } + finally { + flushIndex = 0; + queue.length = 0; + flushPostFlushCbs(seen); + isFlushing = false; + currentFlushPromise = null; + // some postFlushCb queued jobs! + // keep flushing until it drains. + if (queue.length || + pendingPreFlushCbs.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); + } + } +} + +/* eslint-disable no-restricted-globals */ +let isHmrUpdating = false; +const hmrDirtyComponents = new Set(); +// Expose the HMR runtime on the window object +// This makes it entirely tree-shakable without polluting the exports and makes +// it easier to be used in toolings like vue-loader +// Note: for a component to be eligible for HMR it also needs the __hmrId option +// to be set so that its instances can be registered / removed. +if ((process.env.NODE_ENV !== 'production')) { + const globalObject = typeof window !== 'undefined' + ? window + : typeof self !== 'undefined' + ? self + : typeof window !== 'undefined' + ? window + : {}; + globalObject.__VUE_HMR_RUNTIME__ = { + createRecord: tryWrap(createRecord), + rerender: tryWrap(rerender), + reload: tryWrap(reload) + }; +} +const map = new Map(); +function registerHMR(instance) { + const id = instance.type.__hmrId; + let record = map.get(id); + if (!record) { + createRecord(id, instance.type); + record = map.get(id); + } + record.instances.add(instance); +} +function unregisterHMR(instance) { + map.get(instance.type.__hmrId).instances.delete(instance); +} +function createRecord(id, component) { + if (!component) { + warn(`HMR API usage is out of date.\n` + + `Please upgrade vue-loader/vite/rollup-plugin-vue or other relevant ` + + `dependency that handles Vue SFC compilation.`); + component = {}; + } + if (map.has(id)) { + return false; + } + map.set(id, { + component: isClassComponent(component) ? component.__vccOpts : component, + instances: new Set() + }); + return true; +} +function rerender(id, newRender) { + const record = map.get(id); + if (!record) + return; + if (newRender) + record.component.render = newRender; + // Array.from creates a snapshot which avoids the set being mutated during + // updates + Array.from(record.instances).forEach(instance => { + if (newRender) { + instance.render = newRender; + } + instance.renderCache = []; + // this flag forces child components with slot content to update + isHmrUpdating = true; + instance.update(); + isHmrUpdating = false; + }); +} +function reload(id, newComp) { + const record = map.get(id); + if (!record) + return; + // Array.from creates a snapshot which avoids the set being mutated during + // updates + const { component, instances } = record; + if (!hmrDirtyComponents.has(component)) { + // 1. Update existing comp definition to match new one + newComp = isClassComponent(newComp) ? newComp.__vccOpts : newComp; + extend(component, newComp); + for (const key in component) { + if (key !== '__file' && !(key in newComp)) { + delete component[key]; + } + } + // 2. Mark component dirty. This forces the renderer to replace the component + // on patch. + hmrDirtyComponents.add(component); + // 3. Make sure to unmark the component after the reload. + queuePostFlushCb(() => { + hmrDirtyComponents.delete(component); + }); + } + Array.from(instances).forEach(instance => { + if (instance.parent) { + // 4. Force the parent instance to re-render. This will cause all updated + // components to be unmounted and re-mounted. Queue the update so that we + // don't end up forcing the same parent to re-render multiple times. + queueJob(instance.parent.update); + } + else if (instance.appContext.reload) { + // root instance mounted via createApp() has a reload method + instance.appContext.reload(); + } + else if (typeof window !== 'undefined') { + // root instance inside tree created via raw render(). Force reload. + window.location.reload(); + } + else { + console.warn('[HMR] Root or manually mounted instance modified. Full reload required.'); + } + }); +} +function tryWrap(fn) { + return (id, arg) => { + try { + return fn(id, arg); + } + catch (e) { + console.error(e); + console.warn(`[HMR] Something went wrong during Vue component hot-reload. ` + + `Full reload required.`); + } + }; +} + +let devtools; +function setDevtoolsHook(hook) { + devtools = hook; +} +function devtoolsInitApp(app, version) { + // TODO queue if devtools is undefined + if (!devtools) + return; + devtools.emit("app:init" /* APP_INIT */, app, version, { + Fragment, + Text, + Comment: Comment$1, + Static + }); +} +function devtoolsUnmountApp(app) { + if (!devtools) + return; + devtools.emit("app:unmount" /* APP_UNMOUNT */, app); +} +const devtoolsComponentAdded = /*#__PURE__*/ createDevtoolsComponentHook("component:added" /* COMPONENT_ADDED */); +const devtoolsComponentUpdated = /*#__PURE__*/ createDevtoolsComponentHook("component:updated" /* COMPONENT_UPDATED */); +const devtoolsComponentRemoved = /*#__PURE__*/ createDevtoolsComponentHook("component:removed" /* COMPONENT_REMOVED */); +function createDevtoolsComponentHook(hook) { + return (component) => { + if (!devtools) + return; + devtools.emit(hook, component.appContext.app, component.uid, component.parent ? component.parent.uid : undefined, component); + }; +} +const devtoolsPerfStart = /*#__PURE__*/ createDevtoolsPerformanceHook("perf:start" /* PERFORMANCE_START */); +const devtoolsPerfEnd = /*#__PURE__*/ createDevtoolsPerformanceHook("perf:end" /* PERFORMANCE_END */); +function createDevtoolsPerformanceHook(hook) { + return (component, type, time) => { + if (!devtools) + return; + devtools.emit(hook, component.appContext.app, component.uid, component, type, time); + }; +} +function devtoolsComponentEmit(component, event, params) { + if (!devtools) + return; + devtools.emit("component:emit" /* COMPONENT_EMIT */, component.appContext.app, component, event, params); +} +const globalCompatConfig = { + MODE: 2 +}; +function getCompatConfigForKey(key, instance) { + const instanceConfig = instance && instance.type.compatConfig; + if (instanceConfig && key in instanceConfig) { + return instanceConfig[key]; + } + return globalCompatConfig[key]; +} +function isCompatEnabled(key, instance, enableForBuiltIn = false) { + // skip compat for built-in components + if (!enableForBuiltIn && instance && instance.type.__isBuiltIn) { + return false; + } + const rawMode = getCompatConfigForKey('MODE', instance) || 2; + const val = getCompatConfigForKey(key, instance); + const mode = isFunction(rawMode) + ? rawMode(instance && instance.type) + : rawMode; + if (mode === 2) { + return val !== false; + } + else { + return val === true || val === 'suppress-warning'; + } +} + +function emit(instance, event, ...rawArgs) { + const props = instance.vnode.props || EMPTY_OBJ; + if ((process.env.NODE_ENV !== 'production')) { + const { emitsOptions, propsOptions: [propsOptions] } = instance; + if (emitsOptions) { + if (!(event in emitsOptions) && + !(false )) { + 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 isModelListener = event.startsWith('update:'); + // for v-model update:xxx events, apply modifiers on args + const modelArg = isModelListener && 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 => a.trim()); + } + else if (number) { + args = rawArgs.map(toNumber); + } + } + if ((process.env.NODE_ENV !== 'production') || __VUE_PROD_DEVTOOLS__) { + devtoolsComponentEmit(instance, event, args); + } + if ((process.env.NODE_ENV !== 'production')) { + 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)))]; + // for v-model update:xxx events, also trigger kebab-case equivalent + // for props passed via kebab-case + if (!handler && isModelListener) { + handler = props[(handlerName = toHandlerKey(hyphenate(event)))]; + } + if (handler) { + callWithAsyncErrorHandling(handler, instance, 6 /* COMPONENT_EVENT_HANDLER */, 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 /* COMPONENT_EVENT_HANDLER */, args); + } +} +function normalizeEmitsOptions(comp, appContext, asMixin = false) { + const cache = appContext.emitsCache; + const cached = cache.get(comp); + if (cached !== undefined) { + return cached; + } + const raw = comp.emits; + let normalized = {}; + // apply mixin/extends props + let hasExtends = false; + if (__VUE_OPTIONS_API__ && !isFunction(comp)) { + const extendEmits = (raw) => { + const normalizedFromExtend = normalizeEmitsOptions(raw, 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) { + cache.set(comp, null); + return null; + } + if (isArray(raw)) { + raw.forEach(key => (normalized[key] = null)); + } + else { + extend(normalized, raw); + } + cache.set(comp, normalized); + return normalized; +} +// Check if an incoming prop key is a declared emit event listener. +// e.g. With `emits: { click: null }`, props named `onClick` and `onclick` are +// both considered matched listeners. +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)); +} + +/** + * mark the current rendering instance for asset resolution (e.g. + * resolveComponent, resolveDirective) during render + */ +let currentRenderingInstance = null; +let currentScopeId = null; +/** + * Note: rendering calls maybe nested. The function returns the parent rendering + * instance if present, which should be restored after the render is done: + * + * ```js + * const prev = setCurrentRenderingInstance(i) + * // ...render + * setCurrentRenderingInstance(prev) + * ``` + */ +function setCurrentRenderingInstance(instance) { + const prev = currentRenderingInstance; + currentRenderingInstance = instance; + currentScopeId = (instance && instance.type.__scopeId) || null; + return prev; +} +/** + * Set scope id when creating hoisted vnodes. + * @private compiler helper + */ +function pushScopeId(id) { + currentScopeId = id; +} +/** + * Technically we no longer need this after 3.0.8 but we need to keep the same + * API for backwards compat w/ code generated by compilers. + * @private + */ +function popScopeId() { + currentScopeId = null; +} +/** + * Only for backwards compat + * @private + */ +const withScopeId = (_id) => withCtx; +/** + * Wrap a slot function to memoize current rendering instance + * @private compiler helper + */ +function withCtx(fn, ctx = currentRenderingInstance, isNonScopedSlot // false only +) { + if (!ctx) + return fn; + // already normalized + if (fn._n) { + return fn; + } + const renderFnWithContext = (...args) => { + // If a user calls a compiled slot inside a template expression (#1745), it + // can mess up block tracking, so by default we disable block tracking and + // force bail out when invoking a compiled slot (indicated by the ._d flag). + // This isn't necessary if rendering a compiled ``, so we flip the + // ._d flag off when invoking the wrapped fn inside `renderSlot`. + if (renderFnWithContext._d) { + setBlockTracking(-1); + } + const prevInstance = setCurrentRenderingInstance(ctx); + const res = fn(...args); + setCurrentRenderingInstance(prevInstance); + if (renderFnWithContext._d) { + setBlockTracking(1); + } + if ((process.env.NODE_ENV !== 'production') || __VUE_PROD_DEVTOOLS__) { + devtoolsComponentUpdated(ctx); + } + return res; + }; + // mark normalized to avoid duplicated wrapping + renderFnWithContext._n = true; + // mark this as compiled by default + // this is used in vnode.ts -> normalizeChildren() to set the slot + // rendering flag. + renderFnWithContext._c = true; + // disable block tracking by default + renderFnWithContext._d = true; + return renderFnWithContext; +} + +/** + * dev only flag to track whether $attrs was used during render. + * If $attrs was used during render then the warning for failed attrs + * fallthrough can be suppressed. + */ +let accessedAttrs = false; +function markAttrsAccessed() { + accessedAttrs = true; +} +function renderComponentRoot(instance) { + const { type: Component, vnode, proxy, withProxy, props, propsOptions: [propsOptions], slots, attrs, emit, render, renderCache, data, setupState, ctx, inheritAttrs } = instance; + let result; + const prev = setCurrentRenderingInstance(instance); + if ((process.env.NODE_ENV !== 'production')) { + accessedAttrs = false; + } + try { + let fallthroughAttrs; + if (vnode.shapeFlag & 4 /* STATEFUL_COMPONENT */) { + // withProxy is a proxy with a different `has` trap only for + // runtime-compiled render functions using `with` block. + const proxyToUse = withProxy || proxy; + result = normalizeVNode(render.call(proxyToUse, proxyToUse, renderCache, props, setupState, data, ctx)); + fallthroughAttrs = attrs; + } + else { + // functional + const render = Component; + // in dev, mark attrs accessed if optional props (attrs === props) + if ((process.env.NODE_ENV !== 'production') && attrs === props) { + markAttrsAccessed(); + } + result = normalizeVNode(render.length > 1 + ? render(props, (process.env.NODE_ENV !== 'production') + ? { + get attrs() { + markAttrsAccessed(); + return attrs; + }, + slots, + emit + } + : { attrs, slots, emit }) + : render(props, null /* we know it doesn't need it */)); + fallthroughAttrs = Component.props + ? attrs + : getFunctionalFallthrough(attrs); + } + // attr merging + // in dev mode, comments are preserved, and it's possible for a template + // to have comments along side the root element which makes it a fragment + let root = result; + let setRoot = undefined; + if ((process.env.NODE_ENV !== 'production') && + result.patchFlag > 0 && + result.patchFlag & 2048 /* DEV_ROOT_FRAGMENT */) { + ; + [root, setRoot] = getChildRoot(result); + } + if (fallthroughAttrs && inheritAttrs !== false) { + const keys = Object.keys(fallthroughAttrs); + const { shapeFlag } = root; + if (keys.length) { + if (shapeFlag & 1 /* ELEMENT */ || + shapeFlag & 6 /* COMPONENT */) { + if (propsOptions && keys.some(isModelListener)) { + // If a v-model listener (onUpdate:xxx) has a corresponding declared + // prop, it indicates this component expects to handle v-model and + // it should not fallthrough. + // related: #1543, #1643, #1989 + fallthroughAttrs = filterModelListeners(fallthroughAttrs, propsOptions); + } + root = cloneVNode(root, fallthroughAttrs); + } + else if ((process.env.NODE_ENV !== 'production') && !accessedAttrs && root.type !== Comment$1) { + const allAttrs = Object.keys(attrs); + const eventAttrs = []; + const extraAttrs = []; + for (let i = 0, l = allAttrs.length; i < l; i++) { + const key = allAttrs[i]; + if (isOn(key)) { + // ignore v-model handlers when they fail to fallthrough + if (!isModelListener(key)) { + // remove `on`, lowercase first letter to reflect event casing + // accurately + eventAttrs.push(key[2].toLowerCase() + key.slice(3)); + } + } + else { + extraAttrs.push(key); + } + } + if (extraAttrs.length) { + warn(`Extraneous non-props attributes (` + + `${extraAttrs.join(', ')}) ` + + `were passed to component but could not be automatically inherited ` + + `because component renders fragment or text root nodes.`); + } + if (eventAttrs.length) { + warn(`Extraneous non-emits event listeners (` + + `${eventAttrs.join(', ')}) ` + + `were passed to component but could not be automatically inherited ` + + `because component renders fragment or text root nodes. ` + + `If the listener is intended to be a component custom event listener only, ` + + `declare it using the "emits" option.`); + } + } + } + } + if (false && + isCompatEnabled("INSTANCE_ATTRS_CLASS_STYLE" /* INSTANCE_ATTRS_CLASS_STYLE */, instance) && + vnode.shapeFlag & 4 /* STATEFUL_COMPONENT */ && + (root.shapeFlag & 1 /* ELEMENT */ || + root.shapeFlag & 6 /* COMPONENT */)) ; + // inherit directives + if (vnode.dirs) { + if ((process.env.NODE_ENV !== 'production') && !isElementRoot(root)) { + warn(`Runtime directive used on component with non-element root node. ` + + `The directives will not function as intended.`); + } + root.dirs = root.dirs ? root.dirs.concat(vnode.dirs) : vnode.dirs; + } + // inherit transition data + if (vnode.transition) { + if ((process.env.NODE_ENV !== 'production') && !isElementRoot(root)) { + warn(`Component inside renders non-element root node ` + + `that cannot be animated.`); + } + root.transition = vnode.transition; + } + if ((process.env.NODE_ENV !== 'production') && setRoot) { + setRoot(root); + } + else { + result = root; + } + } + catch (err) { + blockStack.length = 0; + handleError(err, instance, 1 /* RENDER_FUNCTION */); + result = createVNode(Comment$1); + } + setCurrentRenderingInstance(prev); + return result; +} +/** + * dev only + * In dev mode, template root level comments are rendered, which turns the + * template into a fragment root, but we need to locate the single element + * root for attrs and scope id processing. + */ +const getChildRoot = (vnode) => { + const rawChildren = vnode.children; + const dynamicChildren = vnode.dynamicChildren; + const childRoot = filterSingleRoot(rawChildren); + if (!childRoot) { + return [vnode, undefined]; + } + const index = rawChildren.indexOf(childRoot); + const dynamicIndex = dynamicChildren ? dynamicChildren.indexOf(childRoot) : -1; + const setRoot = (updatedRoot) => { + rawChildren[index] = updatedRoot; + if (dynamicChildren) { + if (dynamicIndex > -1) { + dynamicChildren[dynamicIndex] = updatedRoot; + } + else if (updatedRoot.patchFlag > 0) { + vnode.dynamicChildren = [...dynamicChildren, updatedRoot]; + } + } + }; + return [normalizeVNode(childRoot), setRoot]; +}; +function filterSingleRoot(children) { + let singleRoot; + for (let i = 0; i < children.length; i++) { + const child = children[i]; + if (isVNode(child)) { + // ignore user comment + if (child.type !== Comment$1 || child.children === 'v-if') { + if (singleRoot) { + // has more than 1 non-comment child, return now + return; + } + else { + singleRoot = child; + } + } + } + else { + return; + } + } + return singleRoot; +} +const getFunctionalFallthrough = (attrs) => { + let res; + for (const key in attrs) { + if (key === 'class' || key === 'style' || isOn(key)) { + (res || (res = {}))[key] = attrs[key]; + } + } + return res; +}; +const filterModelListeners = (attrs, props) => { + const res = {}; + for (const key in attrs) { + if (!isModelListener(key) || !(key.slice(9) in props)) { + res[key] = attrs[key]; + } + } + return res; +}; +const isElementRoot = (vnode) => { + return (vnode.shapeFlag & 6 /* COMPONENT */ || + vnode.shapeFlag & 1 /* ELEMENT */ || + vnode.type === Comment$1 // potential v-if branch switch + ); +}; +function shouldUpdateComponent(prevVNode, nextVNode, optimized) { + const { props: prevProps, children: prevChildren, component } = prevVNode; + const { props: nextProps, children: nextChildren, patchFlag } = nextVNode; + const emits = component.emitsOptions; + // Parent component's render function was hot-updated. Since this may have + // caused the child component's slots content to have changed, we need to + // force the child to update as well. + if ((process.env.NODE_ENV !== 'production') && (prevChildren || nextChildren) && isHmrUpdating) { + return true; + } + // force child update for runtime directive or transition on component vnode. + if (nextVNode.dirs || nextVNode.transition) { + return true; + } + if (optimized && patchFlag >= 0) { + if (patchFlag & 1024 /* DYNAMIC_SLOTS */) { + // slot content that references values that might have changed, + // e.g. in a v-for + return true; + } + if (patchFlag & 16 /* FULL_PROPS */) { + if (!prevProps) { + return !!nextProps; + } + // presence of this flag indicates props are always non-null + return hasPropsChanged(prevProps, nextProps, emits); + } + else if (patchFlag & 8 /* PROPS */) { + const dynamicProps = nextVNode.dynamicProps; + for (let i = 0; i < dynamicProps.length; i++) { + const key = dynamicProps[i]; + if (nextProps[key] !== prevProps[key] && + !isEmitListener(emits, key)) { + return true; + } + } + } + } + else { + // this path is only taken by manually written render functions + // so presence of any children leads to a forced update + if (prevChildren || nextChildren) { + if (!nextChildren || !nextChildren.$stable) { + return true; + } + } + if (prevProps === nextProps) { + return false; + } + if (!prevProps) { + return !!nextProps; + } + if (!nextProps) { + return true; + } + return hasPropsChanged(prevProps, nextProps, emits); + } + return false; +} +function hasPropsChanged(prevProps, nextProps, emitsOptions) { + const nextKeys = Object.keys(nextProps); + if (nextKeys.length !== Object.keys(prevProps).length) { + return true; + } + for (let i = 0; i < nextKeys.length; i++) { + const key = nextKeys[i]; + if (nextProps[key] !== prevProps[key] && + !isEmitListener(emitsOptions, key)) { + return true; + } + } + return false; +} +function updateHOCHostEl({ vnode, parent }, el // HostNode +) { + while (parent && parent.subTree === vnode) { + (vnode = parent.vnode).el = el; + parent = parent.parent; + } +} + +const isSuspense = (type) => type.__isSuspense; +// Suspense exposes a component-like API, and is treated like a component +// in the compiler, but internally it's a special built-in type that hooks +// directly into the renderer. +const SuspenseImpl = { + name: 'Suspense', + // In order to make Suspense tree-shakable, we need to avoid importing it + // directly in the renderer. The renderer checks for the __isSuspense flag + // on a vnode's type and calls the `process` method, passing in renderer + // internals. + __isSuspense: true, + process(n1, n2, container, anchor, parentComponent, parentSuspense, isSVG, slotScopeIds, optimized, + // platform-specific impl passed from renderer + rendererInternals) { + if (n1 == null) { + mountSuspense(n2, container, anchor, parentComponent, parentSuspense, isSVG, slotScopeIds, optimized, rendererInternals); + } + else { + patchSuspense(n1, n2, container, anchor, parentComponent, isSVG, slotScopeIds, optimized, rendererInternals); + } + }, + hydrate: hydrateSuspense, + create: createSuspenseBoundary, + normalize: normalizeSuspenseChildren +}; +// Force-casted public typing for h and TSX props inference +const Suspense = (SuspenseImpl + ); +function mountSuspense(vnode, container, anchor, parentComponent, parentSuspense, isSVG, slotScopeIds, optimized, rendererInternals) { + const { p: patch, o: { createElement } } = rendererInternals; + const hiddenContainer = createElement('div', container); // fixed by xxxxxx + const suspense = (vnode.suspense = createSuspenseBoundary(vnode, parentSuspense, parentComponent, container, hiddenContainer, anchor, isSVG, slotScopeIds, optimized, rendererInternals)); + // start mounting the content subtree in an off-dom container + patch(null, (suspense.pendingBranch = vnode.ssContent), hiddenContainer, null, parentComponent, suspense, isSVG, slotScopeIds); + // now check if we have encountered any async deps + if (suspense.deps > 0) { + // has async + // mount the fallback tree + patch(null, vnode.ssFallback, container, anchor, parentComponent, null, // fallback tree will not have suspense context + isSVG, slotScopeIds); + setActiveBranch(suspense, vnode.ssFallback); + } + else { + // Suspense has no async deps. Just resolve. + suspense.resolve(); + } +} +function patchSuspense(n1, n2, container, anchor, parentComponent, isSVG, slotScopeIds, optimized, { p: patch, um: unmount, o: { createElement } }) { + const suspense = (n2.suspense = n1.suspense); + suspense.vnode = n2; + n2.el = n1.el; + const newBranch = n2.ssContent; + const newFallback = n2.ssFallback; + const { activeBranch, pendingBranch, isInFallback, isHydrating } = suspense; + if (pendingBranch) { + suspense.pendingBranch = newBranch; + if (isSameVNodeType(newBranch, pendingBranch)) { + // same root type but content may have changed. + patch(pendingBranch, newBranch, suspense.hiddenContainer, null, parentComponent, suspense, isSVG, slotScopeIds, optimized); + if (suspense.deps <= 0) { + suspense.resolve(); + } + else if (isInFallback) { + patch(activeBranch, newFallback, container, anchor, parentComponent, null, // fallback tree will not have suspense context + isSVG, slotScopeIds, optimized); + setActiveBranch(suspense, newFallback); + } + } + else { + // toggled before pending tree is resolved + suspense.pendingId++; + if (isHydrating) { + // if toggled before hydration is finished, the current DOM tree is + // no longer valid. set it as the active branch so it will be unmounted + // when resolved + suspense.isHydrating = false; + suspense.activeBranch = pendingBranch; + } + else { + unmount(pendingBranch, parentComponent, suspense); + } + // increment pending ID. this is used to invalidate async callbacks + // reset suspense state + suspense.deps = 0; + // discard effects from pending branch + suspense.effects.length = 0; + // discard previous container + suspense.hiddenContainer = createElement('div', container); // fixed by xxxxxx + if (isInFallback) { + // already in fallback state + patch(null, newBranch, suspense.hiddenContainer, null, parentComponent, suspense, isSVG, slotScopeIds, optimized); + if (suspense.deps <= 0) { + suspense.resolve(); + } + else { + patch(activeBranch, newFallback, container, anchor, parentComponent, null, // fallback tree will not have suspense context + isSVG, slotScopeIds, optimized); + setActiveBranch(suspense, newFallback); + } + } + else if (activeBranch && isSameVNodeType(newBranch, activeBranch)) { + // toggled "back" to current active branch + patch(activeBranch, newBranch, container, anchor, parentComponent, suspense, isSVG, slotScopeIds, optimized); + // force resolve + suspense.resolve(true); + } + else { + // switched to a 3rd branch + patch(null, newBranch, suspense.hiddenContainer, null, parentComponent, suspense, isSVG, slotScopeIds, optimized); + if (suspense.deps <= 0) { + suspense.resolve(); + } + } + } + } + else { + if (activeBranch && isSameVNodeType(newBranch, activeBranch)) { + // root did not change, just normal patch + patch(activeBranch, newBranch, container, anchor, parentComponent, suspense, isSVG, slotScopeIds, optimized); + setActiveBranch(suspense, newBranch); + } + else { + // root node toggled + // invoke @pending event + const onPending = n2.props && n2.props.onPending; + if (isFunction(onPending)) { + onPending(); + } + // mount pending branch in off-dom container + suspense.pendingBranch = newBranch; + suspense.pendingId++; + patch(null, newBranch, suspense.hiddenContainer, null, parentComponent, suspense, isSVG, slotScopeIds, optimized); + if (suspense.deps <= 0) { + // incoming branch has no async deps, resolve now. + suspense.resolve(); + } + else { + const { timeout, pendingId } = suspense; + if (timeout > 0) { + setTimeout(() => { + if (suspense.pendingId === pendingId) { + suspense.fallback(newFallback); + } + }, timeout); + } + else if (timeout === 0) { + suspense.fallback(newFallback); + } + } + } + } +} +let hasWarned = false; +function createSuspenseBoundary(vnode, parent, parentComponent, container, hiddenContainer, anchor, isSVG, slotScopeIds, optimized, rendererInternals, isHydrating = false) { + /* istanbul ignore if */ + if ((process.env.NODE_ENV !== 'production') && !false && !hasWarned) { + hasWarned = true; + // @ts-ignore `console.info` cannot be null error + console[console.info ? 'info' : 'log'](` is an experimental feature and its API will likely change.`); + } + const { p: patch, m: move, um: unmount, n: next, o: { parentNode, remove } } = rendererInternals; + const timeout = toNumber(vnode.props && vnode.props.timeout); + const suspense = { + vnode, + parent, + parentComponent, + isSVG, + container, + hiddenContainer, + anchor, + deps: 0, + pendingId: 0, + timeout: typeof timeout === 'number' ? timeout : -1, + activeBranch: null, + pendingBranch: null, + isInFallback: true, + isHydrating, + isUnmounted: false, + effects: [], + resolve(resume = false) { + if ((process.env.NODE_ENV !== 'production')) { + if (!resume && !suspense.pendingBranch) { + throw new Error(`suspense.resolve() is called without a pending branch.`); + } + if (suspense.isUnmounted) { + throw new Error(`suspense.resolve() is called on an already unmounted suspense boundary.`); + } + } + const { vnode, activeBranch, pendingBranch, pendingId, effects, parentComponent, container } = suspense; + if (suspense.isHydrating) { + suspense.isHydrating = false; + } + else if (!resume) { + const delayEnter = activeBranch && + pendingBranch.transition && + pendingBranch.transition.mode === 'out-in'; + if (delayEnter) { + activeBranch.transition.afterLeave = () => { + if (pendingId === suspense.pendingId) { + move(pendingBranch, container, anchor, 0 /* ENTER */); + } + }; + } + // this is initial anchor on mount + let { anchor } = suspense; + // unmount current active tree + if (activeBranch) { + // if the fallback tree was mounted, it may have been moved + // as part of a parent suspense. get the latest anchor for insertion + anchor = next(activeBranch); + unmount(activeBranch, parentComponent, suspense, true); + } + if (!delayEnter) { + // move content from off-dom container to actual container + move(pendingBranch, container, anchor, 0 /* ENTER */); + } + } + setActiveBranch(suspense, pendingBranch); + suspense.pendingBranch = null; + suspense.isInFallback = false; + // flush buffered effects + // check if there is a pending parent suspense + let parent = suspense.parent; + let hasUnresolvedAncestor = false; + while (parent) { + if (parent.pendingBranch) { + // found a pending parent suspense, merge buffered post jobs + // into that parent + parent.effects.push(...effects); + hasUnresolvedAncestor = true; + break; + } + parent = parent.parent; + } + // no pending parent suspense, flush all jobs + if (!hasUnresolvedAncestor) { + queuePostFlushCb(effects); + } + suspense.effects = []; + // invoke @resolve event + const onResolve = vnode.props && vnode.props.onResolve; + if (isFunction(onResolve)) { + onResolve(); + } + }, + fallback(fallbackVNode) { + if (!suspense.pendingBranch) { + return; + } + const { vnode, activeBranch, parentComponent, container, isSVG } = suspense; + // invoke @fallback event + const onFallback = vnode.props && vnode.props.onFallback; + if (isFunction(onFallback)) { + onFallback(); + } + const anchor = next(activeBranch); + const mountFallback = () => { + if (!suspense.isInFallback) { + return; + } + // mount the fallback tree + patch(null, fallbackVNode, container, anchor, parentComponent, null, // fallback tree will not have suspense context + isSVG, slotScopeIds, optimized); + setActiveBranch(suspense, fallbackVNode); + }; + const delayEnter = fallbackVNode.transition && fallbackVNode.transition.mode === 'out-in'; + if (delayEnter) { + activeBranch.transition.afterLeave = mountFallback; + } + // unmount current active branch + unmount(activeBranch, parentComponent, null, // no suspense so unmount hooks fire now + true // shouldRemove + ); + suspense.isInFallback = true; + if (!delayEnter) { + mountFallback(); + } + }, + move(container, anchor, type) { + suspense.activeBranch && + move(suspense.activeBranch, container, anchor, type); + suspense.container = container; + }, + next() { + return suspense.activeBranch && next(suspense.activeBranch); + }, + registerDep(instance, setupRenderEffect) { + const isInPendingSuspense = !!suspense.pendingBranch; + if (isInPendingSuspense) { + suspense.deps++; + } + const hydratedEl = instance.vnode.el; + instance + .asyncDep.catch(err => { + handleError(err, instance, 0 /* SETUP_FUNCTION */); + }) + .then(asyncSetupResult => { + // retry when the setup() promise resolves. + // component may have been unmounted before resolve. + if (instance.isUnmounted || + suspense.isUnmounted || + suspense.pendingId !== instance.suspenseId) { + return; + } + // retry from this component + instance.asyncResolved = true; + const { vnode } = instance; + if ((process.env.NODE_ENV !== 'production')) { + pushWarningContext(vnode); + } + handleSetupResult(instance, asyncSetupResult, false); + if (hydratedEl) { + // vnode may have been replaced if an update happened before the + // async dep is resolved. + vnode.el = hydratedEl; + } + const placeholder = !hydratedEl && instance.subTree.el; + setupRenderEffect(instance, vnode, + // component may have been moved before resolve. + // if this is not a hydration, instance.subTree will be the comment + // placeholder. + parentNode(hydratedEl || instance.subTree.el), + // anchor will not be used if this is hydration, so only need to + // consider the comment placeholder case. + hydratedEl ? null : next(instance.subTree), suspense, isSVG, optimized); + if (placeholder) { + remove(placeholder); + } + updateHOCHostEl(instance, vnode.el); + if ((process.env.NODE_ENV !== 'production')) { + popWarningContext(); + } + // only decrease deps count if suspense is not already resolved + if (isInPendingSuspense && --suspense.deps === 0) { + suspense.resolve(); + } + }); + }, + unmount(parentSuspense, doRemove) { + suspense.isUnmounted = true; + if (suspense.activeBranch) { + unmount(suspense.activeBranch, parentComponent, parentSuspense, doRemove); + } + if (suspense.pendingBranch) { + unmount(suspense.pendingBranch, parentComponent, parentSuspense, doRemove); + } + } + }; + return suspense; +} +function hydrateSuspense(node, vnode, parentComponent, parentSuspense, isSVG, slotScopeIds, optimized, rendererInternals, hydrateNode) { + /* eslint-disable no-restricted-globals */ + const suspense = (vnode.suspense = createSuspenseBoundary(vnode, parentSuspense, parentComponent, node.parentNode, document.createElement('div'), null, isSVG, slotScopeIds, optimized, rendererInternals, true /* hydrating */)); + // there are two possible scenarios for server-rendered suspense: + // - success: ssr content should be fully resolved + // - failure: ssr content should be the fallback branch. + // however, on the client we don't really know if it has failed or not + // attempt to hydrate the DOM assuming it has succeeded, but we still + // need to construct a suspense boundary first + const result = hydrateNode(node, (suspense.pendingBranch = vnode.ssContent), parentComponent, suspense, slotScopeIds, optimized); + if (suspense.deps === 0) { + suspense.resolve(); + } + return result; + /* eslint-enable no-restricted-globals */ +} +function normalizeSuspenseChildren(vnode) { + const { shapeFlag, children } = vnode; + const isSlotChildren = shapeFlag & 32 /* SLOTS_CHILDREN */; + vnode.ssContent = normalizeSuspenseSlot(isSlotChildren ? children.default : children); + vnode.ssFallback = isSlotChildren + ? normalizeSuspenseSlot(children.fallback) + : createVNode(Comment); +} +function normalizeSuspenseSlot(s) { + let block; + if (isFunction(s)) { + const isCompiledSlot = s._c; + if (isCompiledSlot) { + // disableTracking: false + // allow block tracking for compiled slots + // (see ./componentRenderContext.ts) + s._d = false; + openBlock(); + } + s = s(); + if (isCompiledSlot) { + s._d = true; + block = currentBlock; + closeBlock(); + } + } + if (isArray(s)) { + const singleChild = filterSingleRoot(s); + if ((process.env.NODE_ENV !== 'production') && !singleChild) { + warn(` slots expect a single root node.`); + } + s = singleChild; + } + s = normalizeVNode(s); + if (block) { + s.dynamicChildren = block.filter(c => c !== s); + } + return s; +} +function queueEffectWithSuspense(fn, suspense) { + if (suspense && suspense.pendingBranch) { + if (isArray(fn)) { + suspense.effects.push(...fn); + } + else { + suspense.effects.push(fn); + } + } + else { + queuePostFlushCb(fn); + } +} +function setActiveBranch(suspense, branch) { + suspense.activeBranch = branch; + const { vnode, parentComponent } = suspense; + const el = (vnode.el = branch.el); + // in case suspense is the root node of a component, + // recursively update the HOC el + if (parentComponent && parentComponent.subTree === vnode) { + parentComponent.vnode.el = el; + updateHOCHostEl(parentComponent, el); + } +} + +function provide(key, value) { + if (!currentInstance) { + if ((process.env.NODE_ENV !== 'production')) { + warn(`provide() can only be used inside setup().`); + } + } + else { + let provides = currentInstance.provides; + // by default an instance inherits its parent's provides object + // but when it needs to provide values of its own, it creates its + // own provides object using parent provides object as prototype. + // this way in `inject` we can simply look up injections from direct + // parent and let the prototype chain do the work. + const parentProvides = currentInstance.parent && currentInstance.parent.provides; + if (parentProvides === provides) { + provides = currentInstance.provides = Object.create(parentProvides); + } + // TS doesn't allow symbol as index type + provides[key] = value; + } +} +function inject(key, defaultValue, treatDefaultAsFactory = false) { + // fallback to `currentRenderingInstance` so that this can be called in + // a functional component + const instance = currentInstance || currentRenderingInstance; + if (instance) { + // #2400 + // to support `app.use` plugins, + // fallback to appContext's `provides` if the intance is at root + const provides = instance.parent == null + ? instance.vnode.appContext && instance.vnode.appContext.provides + : instance.parent.provides; + if (provides && key in provides) { + // TS doesn't allow symbol as index type + return provides[key]; + } + else if (arguments.length > 1) { + return treatDefaultAsFactory && isFunction(defaultValue) + ? defaultValue.call(instance.proxy) + : defaultValue; + } + else if ((process.env.NODE_ENV !== 'production')) { + warn(`injection "${String(key)}" not found.`); + } + } + else if ((process.env.NODE_ENV !== 'production')) { + warn(`inject() can only be used inside setup() or functional components.`); + } +} + +// Simple effect. +function watchEffect(effect, options) { + return doWatch(effect, null, options); +} +// initial value for watchers to trigger on undefined initial values +const INITIAL_WATCHER_VALUE = {}; +// implementation +function watch(source, cb, options) { + if ((process.env.NODE_ENV !== 'production') && !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, instance = currentInstance) { + if ((process.env.NODE_ENV !== 'production') && !cb) { + if (immediate !== undefined) { + warn(`watch() "immediate" option is only respected when using the ` + + `watch(source, callback, options?) signature.`); + } + if (deep !== undefined) { + warn(`watch() "deep" option is only respected when using the ` + + `watch(source, callback, options?) signature.`); + } + } + const warnInvalidSource = (s) => { + warn(`Invalid watch source: `, s, `A watch source can only be a getter/effect function, a ref, ` + + `a reactive object, or an array of these types.`); + }; + let getter; + let forceTrigger = false; + let isMultiSource = false; + if (isRef(source)) { + getter = () => source.value; + forceTrigger = !!source._shallow; + } + else if (isReactive(source)) { + getter = () => source; + deep = true; + } + else if (isArray(source)) { + isMultiSource = true; + forceTrigger = source.some(isReactive); + getter = () => source.map(s => { + if (isRef(s)) { + return s.value; + } + else if (isReactive(s)) { + return traverse(s); + } + else if (isFunction(s)) { + return callWithErrorHandling(s, instance, 2 /* WATCH_GETTER */); + } + else { + (process.env.NODE_ENV !== 'production') && warnInvalidSource(s); + } + }); + } + else if (isFunction(source)) { + if (cb) { + // getter with cb + getter = () => callWithErrorHandling(source, instance, 2 /* WATCH_GETTER */); + } + else { + // no cb -> simple effect + getter = () => { + if (instance && instance.isUnmounted) { + return; + } + if (cleanup) { + cleanup(); + } + return callWithAsyncErrorHandling(source, instance, 3 /* WATCH_CALLBACK */, [onInvalidate]); + }; + } + } + else { + getter = NOOP; + (process.env.NODE_ENV !== 'production') && warnInvalidSource(source); + } + if (cb && deep) { + const baseGetter = getter; + getter = () => traverse(baseGetter()); + } + let cleanup; + let onInvalidate = (fn) => { + cleanup = runner.options.onStop = () => { + callWithErrorHandling(fn, instance, 4 /* WATCH_CLEANUP */); + }; + }; + let oldValue = isMultiSource ? [] : INITIAL_WATCHER_VALUE; + const job = () => { + if (!runner.active) { + return; + } + if (cb) { + // watch(source, cb) + const newValue = runner(); + if (deep || + forceTrigger || + (isMultiSource + ? newValue.some((v, i) => hasChanged(v, oldValue[i])) + : hasChanged(newValue, oldValue)) || + (false )) { + // cleanup before running cb again + if (cleanup) { + cleanup(); + } + callWithAsyncErrorHandling(cb, instance, 3 /* WATCH_CALLBACK */, [ + newValue, + // pass undefined as the old value when it's changed for the first time + oldValue === INITIAL_WATCHER_VALUE ? undefined : oldValue, + onInvalidate + ]); + oldValue = newValue; + } + } + else { + // watchEffect + runner(); + } + }; + // important: mark the job as a watcher callback so that scheduler knows + // it is allowed to self-trigger (#1727) + job.allowRecurse = !!cb; + let scheduler; + if (flush === 'sync') { + scheduler = job; // the scheduler function gets called directly + } + else if (flush === 'post') { + scheduler = () => queuePostRenderEffect(job, instance && instance.suspense); + } + else { + // default: 'pre' + scheduler = () => { + if (!instance || instance.isMounted) { + queuePreFlushCb(job); + } + else { + // with 'pre' option, the first call must happen before + // the component is mounted so it is called synchronously. + job(); + } + }; + } + const runner = effect(getter, { + lazy: true, + onTrack, + onTrigger, + scheduler + }); + recordInstanceBoundEffect(runner, instance); + // initial run + if (cb) { + if (immediate) { + job(); + } + else { + oldValue = runner(); + } + } + else if (flush === 'post') { + queuePostRenderEffect(runner, instance && instance.suspense); + } + else { + runner(); + } + return () => { + stop(runner); + if (instance) { + remove(instance.effects, runner); + } + }; +} +// this.$watch +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; + } + return doWatch(getter, cb.bind(publicThis), options, this); +} +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 = new Set()) { + if (!isObject(value) || + seen.has(value) || + value["__v_skip" /* SKIP */]) { + 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(value)) { + for (const key in value) { + traverse(value[key], seen); + } + } + return value; +} + +function useTransitionState() { + const state = { + isMounted: false, + isLeaving: false, + isUnmounting: false, + leavingVNodes: new Map() + }; + onMounted(() => { + state.isMounted = true; + }); + onBeforeUnmount(() => { + state.isUnmounting = true; + }); + return state; +} +const TransitionHookValidator = [Function, Array]; +const BaseTransitionImpl = { + name: `BaseTransition`, + props: { + mode: String, + appear: Boolean, + persisted: Boolean, + // enter + onBeforeEnter: TransitionHookValidator, + onEnter: TransitionHookValidator, + onAfterEnter: TransitionHookValidator, + onEnterCancelled: TransitionHookValidator, + // leave + onBeforeLeave: TransitionHookValidator, + onLeave: TransitionHookValidator, + onAfterLeave: TransitionHookValidator, + onLeaveCancelled: TransitionHookValidator, + // appear + onBeforeAppear: TransitionHookValidator, + onAppear: TransitionHookValidator, + onAfterAppear: TransitionHookValidator, + onAppearCancelled: TransitionHookValidator + }, + setup(props, { slots }) { + const instance = getCurrentInstance(); + const state = useTransitionState(); + let prevTransitionKey; + return () => { + const children = slots.default && getTransitionRawChildren(slots.default(), true); + if (!children || !children.length) { + return; + } + // warn multiple elements + if ((process.env.NODE_ENV !== 'production') && children.length > 1) { + warn(' can only be used on a single element or component. Use ' + + ' for lists.'); + } + // there's no need to track reactivity for these props so use the raw + // props for a bit better perf + const rawProps = toRaw(props); + const { mode } = rawProps; + // check mode + if ((process.env.NODE_ENV !== 'production') && mode && !['in-out', 'out-in', 'default'].includes(mode)) { + warn(`invalid mode: ${mode}`); + } + // at this point children has a guaranteed length of 1. + const child = children[0]; + if (state.isLeaving) { + return emptyPlaceholder(child); + } + // in the case of , we need to + // compare the type of the kept-alive children. + const innerChild = getKeepAliveChild(child); + if (!innerChild) { + return emptyPlaceholder(child); + } + const enterHooks = resolveTransitionHooks(innerChild, rawProps, state, instance); + setTransitionHooks(innerChild, enterHooks); + const oldChild = instance.subTree; + const oldInnerChild = oldChild && getKeepAliveChild(oldChild); + let transitionKeyChanged = false; + const { getTransitionKey } = innerChild.type; + if (getTransitionKey) { + const key = getTransitionKey(); + if (prevTransitionKey === undefined) { + prevTransitionKey = key; + } + else if (key !== prevTransitionKey) { + prevTransitionKey = key; + transitionKeyChanged = true; + } + } + // handle mode + if (oldInnerChild && + oldInnerChild.type !== Comment$1 && + (!isSameVNodeType(innerChild, oldInnerChild) || transitionKeyChanged)) { + const leavingHooks = resolveTransitionHooks(oldInnerChild, rawProps, state, instance); + // update old tree's hooks in case of dynamic transition + setTransitionHooks(oldInnerChild, leavingHooks); + // switching between different views + if (mode === 'out-in') { + state.isLeaving = true; + // return placeholder node and queue update when leave finishes + leavingHooks.afterLeave = () => { + state.isLeaving = false; + instance.update(); + }; + return emptyPlaceholder(child); + } + else if (mode === 'in-out' && innerChild.type !== Comment$1) { + leavingHooks.delayLeave = (el, earlyRemove, delayedLeave) => { + const leavingVNodesCache = getLeavingNodesForType(state, oldInnerChild); + leavingVNodesCache[String(oldInnerChild.key)] = oldInnerChild; + // early removal callback + el._leaveCb = () => { + earlyRemove(); + el._leaveCb = undefined; + delete enterHooks.delayedLeave; + }; + enterHooks.delayedLeave = delayedLeave; + }; + } + } + return child; + }; + } +}; +// export the public type for h/tsx inference +// also to avoid inline import() in generated d.ts files +const BaseTransition = BaseTransitionImpl; +function getLeavingNodesForType(state, vnode) { + const { leavingVNodes } = state; + let leavingVNodesCache = leavingVNodes.get(vnode.type); + if (!leavingVNodesCache) { + leavingVNodesCache = Object.create(null); + leavingVNodes.set(vnode.type, leavingVNodesCache); + } + return leavingVNodesCache; +} +// The transition hooks are attached to the vnode as vnode.transition +// and will be called at appropriate timing in the renderer. +function resolveTransitionHooks(vnode, props, state, instance) { + const { appear, mode, persisted = false, onBeforeEnter, onEnter, onAfterEnter, onEnterCancelled, onBeforeLeave, onLeave, onAfterLeave, onLeaveCancelled, onBeforeAppear, onAppear, onAfterAppear, onAppearCancelled } = props; + const key = String(vnode.key); + const leavingVNodesCache = getLeavingNodesForType(state, vnode); + const callHook = (hook, args) => { + hook && + callWithAsyncErrorHandling(hook, instance, 9 /* TRANSITION_HOOK */, args); + }; + const hooks = { + mode, + persisted, + beforeEnter(el) { + let hook = onBeforeEnter; + if (!state.isMounted) { + if (appear) { + hook = onBeforeAppear || onBeforeEnter; + } + else { + return; + } + } + // for same element (v-show) + if (el._leaveCb) { + el._leaveCb(true /* cancelled */); + } + // for toggled element with same key (v-if) + const leavingVNode = leavingVNodesCache[key]; + if (leavingVNode && + isSameVNodeType(vnode, leavingVNode) && + leavingVNode.el._leaveCb) { + // force early removal (not cancelled) + leavingVNode.el._leaveCb(); + } + callHook(hook, [el]); + }, + enter(el) { + let hook = onEnter; + let afterHook = onAfterEnter; + let cancelHook = onEnterCancelled; + if (!state.isMounted) { + if (appear) { + hook = onAppear || onEnter; + afterHook = onAfterAppear || onAfterEnter; + cancelHook = onAppearCancelled || onEnterCancelled; + } + else { + return; + } + } + let called = false; + const done = (el._enterCb = (cancelled) => { + if (called) + return; + called = true; + if (cancelled) { + callHook(cancelHook, [el]); + } + else { + callHook(afterHook, [el]); + } + if (hooks.delayedLeave) { + hooks.delayedLeave(); + } + el._enterCb = undefined; + }); + if (hook) { + hook(el, done); + if (hook.length <= 1) { + done(); + } + } + else { + done(); + } + }, + leave(el, remove) { + const key = String(vnode.key); + if (el._enterCb) { + el._enterCb(true /* cancelled */); + } + if (state.isUnmounting) { + return remove(); + } + callHook(onBeforeLeave, [el]); + let called = false; + const done = (el._leaveCb = (cancelled) => { + if (called) + return; + called = true; + remove(); + if (cancelled) { + callHook(onLeaveCancelled, [el]); + } + else { + callHook(onAfterLeave, [el]); + } + el._leaveCb = undefined; + if (leavingVNodesCache[key] === vnode) { + delete leavingVNodesCache[key]; + } + }); + leavingVNodesCache[key] = vnode; + if (onLeave) { + onLeave(el, done); + if (onLeave.length <= 1) { + done(); + } + } + else { + done(); + } + }, + clone(vnode) { + return resolveTransitionHooks(vnode, props, state, instance); + } + }; + return hooks; +} +// the placeholder really only handles one special case: KeepAlive +// in the case of a KeepAlive in a leave phase we need to return a KeepAlive +// placeholder with empty content to avoid the KeepAlive instance from being +// unmounted. +function emptyPlaceholder(vnode) { + if (isKeepAlive(vnode)) { + vnode = cloneVNode(vnode); + vnode.children = null; + return vnode; + } +} +function getKeepAliveChild(vnode) { + return isKeepAlive(vnode) + ? vnode.children + ? vnode.children[0] + : undefined + : vnode; +} +function setTransitionHooks(vnode, hooks) { + if (vnode.shapeFlag & 6 /* COMPONENT */ && vnode.component) { + setTransitionHooks(vnode.component.subTree, hooks); + } + else if (vnode.shapeFlag & 128 /* SUSPENSE */) { + vnode.ssContent.transition = hooks.clone(vnode.ssContent); + vnode.ssFallback.transition = hooks.clone(vnode.ssFallback); + } + else { + vnode.transition = hooks; + } +} +function getTransitionRawChildren(children, keepComment = false) { + let ret = []; + let keyedFragmentCount = 0; + for (let i = 0; i < children.length; i++) { + const child = children[i]; + // handle fragment children case, e.g. v-for + if (child.type === Fragment) { + if (child.patchFlag & 128 /* KEYED_FRAGMENT */) + keyedFragmentCount++; + ret = ret.concat(getTransitionRawChildren(child.children, keepComment)); + } + // comment placeholders should be skipped, e.g. v-if + else if (keepComment || child.type !== Comment$1) { + ret.push(child); + } + } + // #1126 if a transition children list contains multiple sub fragments, these + // fragments will be merged into a flat children array. Since each v-for + // fragment may contain different static bindings inside, we need to de-op + // these children to force full diffs to ensure correct behavior. + if (keyedFragmentCount > 1) { + for (let i = 0; i < ret.length; i++) { + ret[i].patchFlag = -2 /* BAIL */; + } + } + return ret; +} + +// implementation, close to no-op +function defineComponent(options) { + return isFunction(options) ? { setup: options, name: options.name } : options; +} + +const isAsyncWrapper = (i) => !!i.type.__asyncLoader; +function defineAsyncComponent(source) { + if (isFunction(source)) { + source = { loader: source }; + } + const { loader, loadingComponent, errorComponent, delay = 200, timeout, // undefined = never times out + suspensible = true, onError: userOnError } = source; + let pendingRequest = null; + let resolvedComp; + let retries = 0; + const retry = () => { + retries++; + pendingRequest = null; + return load(); + }; + const load = () => { + let thisRequest; + return (pendingRequest || + (thisRequest = pendingRequest = loader() + .catch(err => { + err = err instanceof Error ? err : new Error(String(err)); + if (userOnError) { + return new Promise((resolve, reject) => { + const userRetry = () => resolve(retry()); + const userFail = () => reject(err); + userOnError(err, userRetry, userFail, retries + 1); + }); + } + else { + throw err; + } + }) + .then((comp) => { + if (thisRequest !== pendingRequest && pendingRequest) { + return pendingRequest; + } + if ((process.env.NODE_ENV !== 'production') && !comp) { + warn(`Async component loader resolved to undefined. ` + + `If you are using retry(), make sure to return its return value.`); + } + // interop module default + if (comp && + (comp.__esModule || comp[Symbol.toStringTag] === 'Module')) { + comp = comp.default; + } + if ((process.env.NODE_ENV !== 'production') && comp && !isObject(comp) && !isFunction(comp)) { + throw new Error(`Invalid async component load result: ${comp}`); + } + resolvedComp = comp; + return comp; + }))); + }; + return defineComponent({ + name: 'AsyncComponentWrapper', + __asyncLoader: load, + get __asyncResolved() { + return resolvedComp; + }, + setup() { + const instance = currentInstance; + // already resolved + if (resolvedComp) { + return () => createInnerComp(resolvedComp, instance); + } + const onError = (err) => { + pendingRequest = null; + handleError(err, instance, 13 /* ASYNC_COMPONENT_LOADER */, !errorComponent /* do not throw in dev if user provided error component */); + }; + // suspense-controlled or SSR. + if ((suspensible && instance.suspense) || + (false )) { + return load() + .then(comp => { + return () => createInnerComp(comp, instance); + }) + .catch(err => { + onError(err); + return () => errorComponent + ? createVNode(errorComponent, { + error: err + }) + : null; + }); + } + const loaded = ref(false); + const error = ref(); + const delayed = ref(!!delay); + if (delay) { + setTimeout(() => { + delayed.value = false; + }, delay); + } + if (timeout != null) { + setTimeout(() => { + if (!loaded.value && !error.value) { + const err = new Error(`Async component timed out after ${timeout}ms.`); + onError(err); + error.value = err; + } + }, timeout); + } + load() + .then(() => { + loaded.value = true; + if (instance.parent && isKeepAlive(instance.parent.vnode)) { + // parent is keep-alive, force update so the loaded component's + // name is taken into account + queueJob(instance.parent.update); + } + }) + .catch(err => { + onError(err); + error.value = err; + }); + return () => { + if (loaded.value && resolvedComp) { + return createInnerComp(resolvedComp, instance); + } + else if (error.value && errorComponent) { + return createVNode(errorComponent, { + error: error.value + }); + } + else if (loadingComponent && !delayed.value) { + return createVNode(loadingComponent); + } + }; + } + }); +} +function createInnerComp(comp, { vnode: { ref, props, children } }) { + const vnode = createVNode(comp, props, children); + // ensure inner component inherits the async wrapper's ref owner + vnode.ref = ref; + return vnode; +} + +const isKeepAlive = (vnode) => vnode.type.__isKeepAlive; +const KeepAliveImpl = { + name: `KeepAlive`, + // Marker for special handling inside the renderer. We are not using a === + // check directly on KeepAlive in the renderer, because importing it directly + // would prevent it from being tree-shaken. + __isKeepAlive: true, + props: { + include: [String, RegExp, Array], + exclude: [String, RegExp, Array], + max: [String, Number] + }, + setup(props, { slots }) { + const instance = getCurrentInstance(); + // KeepAlive communicates with the instantiated renderer via the + // ctx where the renderer passes in its internals, + // and the KeepAlive instance exposes activate/deactivate implementations. + // The whole point of this is to avoid importing KeepAlive directly in the + // renderer to facilitate tree-shaking. + const sharedContext = instance.ctx; + // if the internal renderer is not registered, it indicates that this is server-side rendering, + // for KeepAlive, we just need to render its children + if (!sharedContext.renderer) { + return slots.default; + } + const cache = new Map(); + const keys = new Set(); + let current = null; + if ((process.env.NODE_ENV !== 'production') || __VUE_PROD_DEVTOOLS__) { + instance.__v_cache = cache; + } + const parentSuspense = instance.suspense; + const { renderer: { p: patch, m: move, um: _unmount, o: { createElement } } } = sharedContext; + const storageContainer = createElement('div', null); // fixed by xxxxx + sharedContext.activate = (vnode, container, anchor, isSVG, optimized) => { + const instance = vnode.component; + move(vnode, container, anchor, 0 /* ENTER */, parentSuspense); + // in case props have changed + patch(instance.vnode, vnode, container, anchor, instance, parentSuspense, isSVG, vnode.slotScopeIds, optimized); + queuePostRenderEffect(() => { + instance.isDeactivated = false; + if (instance.a) { + invokeArrayFns(instance.a); + } + const vnodeHook = vnode.props && vnode.props.onVnodeMounted; + if (vnodeHook) { + invokeVNodeHook(vnodeHook, instance.parent, vnode); + } + }, parentSuspense); + if ((process.env.NODE_ENV !== 'production') || __VUE_PROD_DEVTOOLS__) { + // Update components tree + devtoolsComponentAdded(instance); + } + }; + sharedContext.deactivate = (vnode) => { + const instance = vnode.component; + move(vnode, storageContainer, null, 1 /* LEAVE */, parentSuspense); + queuePostRenderEffect(() => { + if (instance.da) { + invokeArrayFns(instance.da); + } + const vnodeHook = vnode.props && vnode.props.onVnodeUnmounted; + if (vnodeHook) { + invokeVNodeHook(vnodeHook, instance.parent, vnode); + } + instance.isDeactivated = true; + }, parentSuspense); + if ((process.env.NODE_ENV !== 'production') || __VUE_PROD_DEVTOOLS__) { + // Update components tree + devtoolsComponentAdded(instance); + } + }; + function unmount(vnode) { + // reset the shapeFlag so it can be properly unmounted + resetShapeFlag(vnode); + _unmount(vnode, instance, parentSuspense); + } + function pruneCache(filter) { + cache.forEach((vnode, key) => { + const name = getComponentName(vnode.type); + if (name && (!filter || !filter(name))) { + pruneCacheEntry(key); + } + }); + } + function pruneCacheEntry(key) { + const cached = cache.get(key); + if (!current || cached.type !== current.type) { + unmount(cached); + } + else if (current) { + // current active instance should no longer be kept-alive. + // we can't unmount it now but it might be later, so reset its flag now. + resetShapeFlag(current); + } + cache.delete(key); + keys.delete(key); + } + // prune cache on include/exclude prop change + watch(() => [props.include, props.exclude], ([include, exclude]) => { + include && pruneCache(name => matches(include, name)); + exclude && pruneCache(name => !matches(exclude, name)); + }, + // prune post-render after `current` has been updated + { flush: 'post', deep: true }); + // cache sub tree after render + let pendingCacheKey = null; + const cacheSubtree = () => { + // fix #1621, the pendingCacheKey could be 0 + if (pendingCacheKey != null) { + cache.set(pendingCacheKey, getInnerChild(instance.subTree)); + } + }; + onMounted(cacheSubtree); + onUpdated(cacheSubtree); + onBeforeUnmount(() => { + cache.forEach(cached => { + const { subTree, suspense } = instance; + const vnode = getInnerChild(subTree); + if (cached.type === vnode.type) { + // current instance will be unmounted as part of keep-alive's unmount + resetShapeFlag(vnode); + // but invoke its deactivated hook here + const da = vnode.component.da; + da && queuePostRenderEffect(da, suspense); + return; + } + unmount(cached); + }); + }); + return () => { + pendingCacheKey = null; + if (!slots.default) { + return null; + } + const children = slots.default(); + const rawVNode = children[0]; + if (children.length > 1) { + if ((process.env.NODE_ENV !== 'production')) { + warn(`KeepAlive should contain exactly one component child.`); + } + current = null; + return children; + } + else if (!isVNode(rawVNode) || + (!(rawVNode.shapeFlag & 4 /* STATEFUL_COMPONENT */) && + !(rawVNode.shapeFlag & 128 /* SUSPENSE */))) { + current = null; + return rawVNode; + } + let vnode = getInnerChild(rawVNode); + const comp = vnode.type; + // for async components, name check should be based in its loaded + // inner component if available + const name = getComponentName(isAsyncWrapper(vnode) + ? vnode.type.__asyncResolved || {} + : comp); + const { include, exclude, max } = props; + if ((include && (!name || !matches(include, name))) || + (exclude && name && matches(exclude, name))) { + current = vnode; + return rawVNode; + } + const key = vnode.key == null ? comp : vnode.key; + const cachedVNode = cache.get(key); + // clone vnode if it's reused because we are going to mutate it + if (vnode.el) { + vnode = cloneVNode(vnode); + if (rawVNode.shapeFlag & 128 /* SUSPENSE */) { + rawVNode.ssContent = vnode; + } + } + // #1513 it's possible for the returned vnode to be cloned due to attr + // fallthrough or scopeId, so the vnode here may not be the final vnode + // that is mounted. Instead of caching it directly, we store the pending + // key and cache `instance.subTree` (the normalized vnode) in + // beforeMount/beforeUpdate hooks. + pendingCacheKey = key; + if (cachedVNode) { + // copy over mounted state + vnode.el = cachedVNode.el; + vnode.component = cachedVNode.component; + if (vnode.transition) { + // recursively update transition hooks on subTree + setTransitionHooks(vnode, vnode.transition); + } + // avoid vnode being mounted as fresh + vnode.shapeFlag |= 512 /* COMPONENT_KEPT_ALIVE */; + // make this key the freshest + keys.delete(key); + keys.add(key); + } + else { + keys.add(key); + // prune oldest entry + if (max && keys.size > parseInt(max, 10)) { + pruneCacheEntry(keys.values().next().value); + } + } + // avoid vnode being unmounted + vnode.shapeFlag |= 256 /* COMPONENT_SHOULD_KEEP_ALIVE */; + current = vnode; + return rawVNode; + }; + } +}; +// export the public type for h/tsx inference +// also to avoid inline import() in generated d.ts files +const KeepAlive = KeepAliveImpl; +function matches(pattern, name) { + if (isArray(pattern)) { + return pattern.some((p) => matches(p, name)); + } + else if (isString(pattern)) { + return pattern.split(',').indexOf(name) > -1; + } + else if (pattern.test) { + return pattern.test(name); + } + /* istanbul ignore next */ + return false; +} +function onActivated(hook, target) { + registerKeepAliveHook(hook, "a" /* ACTIVATED */, target); +} +function onDeactivated(hook, target) { + registerKeepAliveHook(hook, "da" /* DEACTIVATED */, target); +} +function registerKeepAliveHook(hook, type, target = currentInstance) { + // cache the deactivate branch check wrapper for injected hooks so the same + // hook can be properly deduped by the scheduler. "__wdc" stands for "with + // deactivation check". + const wrappedHook = hook.__wdc || + (hook.__wdc = () => { + // only fire the hook if the target instance is NOT in a deactivated branch. + let current = target; + while (current) { + if (current.isDeactivated) { + return; + } + current = current.parent; + } + hook(); + }); + injectHook(type, wrappedHook, target); + // In addition to registering it on the target instance, we walk up the parent + // chain and register it on all ancestor instances that are keep-alive roots. + // This avoids the need to walk the entire component tree when invoking these + // hooks, and more importantly, avoids the need to track child components in + // arrays. + 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) { + // injectHook wraps the original for error handling, so make sure to remove + // the wrapped version. + const injected = injectHook(type, hook, keepAliveRoot, true /* prepend */); + onUnmounted(() => { + remove(keepAliveRoot[type], injected); + }, target); +} +function resetShapeFlag(vnode) { + let shapeFlag = vnode.shapeFlag; + if (shapeFlag & 256 /* COMPONENT_SHOULD_KEEP_ALIVE */) { + shapeFlag -= 256 /* COMPONENT_SHOULD_KEEP_ALIVE */; + } + if (shapeFlag & 512 /* COMPONENT_KEPT_ALIVE */) { + shapeFlag -= 512 /* COMPONENT_KEPT_ALIVE */; + } + vnode.shapeFlag = shapeFlag; +} +function getInnerChild(vnode) { + return vnode.shapeFlag & 128 /* SUSPENSE */ ? vnode.ssContent : vnode; +} + +function injectHook(type, hook, target = currentInstance, prepend = false) { + if (target) { + const hooks = target[type] || (target[type] = []); + // cache the error handling wrapper for injected hooks so the same hook + // can be properly deduped by the scheduler. "__weh" stands for "with error + // handling". + const wrappedHook = hook.__weh || + (hook.__weh = (...args) => { + if (target.isUnmounted) { + return; + } + // disable tracking inside all lifecycle hooks + // since they can potentially be called inside effects. + pauseTracking(); + // Set currentInstance during hook invocation. + // This assumes the hook does not synchronously trigger other hooks, which + // can only be false when the user does something really funky. + setCurrentInstance(target); + const res = callWithAsyncErrorHandling(hook, target, type, args); + setCurrentInstance(null); + resetTracking(); + return res; + }); + if (prepend) { + hooks.unshift(wrappedHook); + } + else { + hooks.push(wrappedHook); + } + return wrappedHook; + } + else if ((process.env.NODE_ENV !== 'production')) { + const apiName = toHandlerKey(ErrorTypeStrings[type].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().` + + (` If you are using async setup(), make sure to register lifecycle ` + + `hooks before the first await statement.` + )); + } +} +const createHook = (lifecycle) => (hook, target = currentInstance) => +// post-create lifecycle registrations are noops during SSR (except for serverPrefetch) +(!isInSSRComponentSetup || lifecycle === "sp" /* SERVER_PREFETCH */) && + injectHook(lifecycle, hook, target); +const onBeforeMount = createHook("bm" /* BEFORE_MOUNT */); +const onMounted = createHook("m" /* MOUNTED */); +const onBeforeUpdate = createHook("bu" /* BEFORE_UPDATE */); +const onUpdated = createHook("u" /* UPDATED */); +const onBeforeUnmount = createHook("bum" /* BEFORE_UNMOUNT */); +const onUnmounted = createHook("um" /* UNMOUNTED */); +const onServerPrefetch = createHook("sp" /* SERVER_PREFETCH */); +const onRenderTriggered = createHook("rtg" /* RENDER_TRIGGERED */); +const onRenderTracked = createHook("rtc" /* RENDER_TRACKED */); +function onErrorCaptured(hook, target = currentInstance) { + injectHook("ec" /* ERROR_CAPTURED */, hook, target); +} + +function createDuplicateChecker() { + const cache = Object.create(null); + return (type, key) => { + if (cache[key]) { + warn(`${type} property "${key}" is already defined in ${cache[key]}.`); + } + else { + cache[key] = type; + } + }; +} +let shouldCacheAccess = true; +function applyOptions(instance) { + const options = resolveMergedOptions(instance); + const publicThis = instance.proxy; + const ctx = instance.ctx; + // do not cache property access on public proxy during state initialization + shouldCacheAccess = false; + // call beforeCreate first before accessing other options since + // the hook may mutate resolved options (#2791) + if (options.beforeCreate) { + callHook(options.beforeCreate, instance, "bc" /* BEFORE_CREATE */); + } + const { + // state + data: dataOptions, computed: computedOptions, methods, watch: watchOptions, provide: provideOptions, inject: injectOptions, + // lifecycle + created, beforeMount, mounted, beforeUpdate, updated, activated, deactivated, beforeDestroy, beforeUnmount, destroyed, unmounted, render, renderTracked, renderTriggered, errorCaptured, serverPrefetch, + // public API + expose, inheritAttrs, + // assets + components, directives, filters } = options; + const checkDuplicateProperties = (process.env.NODE_ENV !== 'production') ? createDuplicateChecker() : null; + if ((process.env.NODE_ENV !== 'production')) { + const [propsOptions] = instance.propsOptions; + if (propsOptions) { + for (const key in propsOptions) { + checkDuplicateProperties("Props" /* PROPS */, key); + } + } + } + // options initialization order (to be consistent with Vue 2): + // - props (already done outside of this function) + // - inject + // - methods + // - data (deferred since it relies on `this` access) + // - computed + // - watch (deferred since it relies on `this` access) + if (injectOptions) { + resolveInjections(injectOptions, ctx, checkDuplicateProperties); + } + if (methods) { + for (const key in methods) { + const methodHandler = methods[key]; + if (isFunction(methodHandler)) { + // In dev mode, we use the `createRenderContext` function to define methods to the proxy target, + // and those are read-only but reconfigurable, so it needs to be redefined here + if ((process.env.NODE_ENV !== 'production')) { + Object.defineProperty(ctx, key, { + value: methodHandler.bind(publicThis), + configurable: true, + enumerable: true, + writable: true + }); + } + else { + ctx[key] = methodHandler.bind(publicThis); + } + if ((process.env.NODE_ENV !== 'production')) { + checkDuplicateProperties("Methods" /* METHODS */, key); + } + } + else if ((process.env.NODE_ENV !== 'production')) { + warn(`Method "${key}" has type "${typeof methodHandler}" in the component definition. ` + + `Did you reference the function correctly?`); + } + } + } + if (dataOptions) { + if ((process.env.NODE_ENV !== 'production') && !isFunction(dataOptions)) { + warn(`The data option must be a function. ` + + `Plain object usage is no longer supported.`); + } + const data = dataOptions.call(publicThis, publicThis); + if ((process.env.NODE_ENV !== 'production') && isPromise(data)) { + warn(`data() returned a Promise - note data() cannot be async; If you ` + + `intend to perform data fetching before component renders, use ` + + `async setup() + .`); + } + if (!isObject(data)) { + (process.env.NODE_ENV !== 'production') && warn(`data() should return an object.`); + } + else { + instance.data = reactive(data); + if ((process.env.NODE_ENV !== 'production')) { + for (const key in data) { + checkDuplicateProperties("Data" /* DATA */, key); + // expose data on ctx during dev + if (key[0] !== '$' && key[0] !== '_') { + Object.defineProperty(ctx, key, { + configurable: true, + enumerable: true, + get: () => data[key], + set: NOOP + }); + } + } + } + } + } + // state initialization complete at this point - start caching access + shouldCacheAccess = true; + if (computedOptions) { + for (const key in computedOptions) { + const opt = computedOptions[key]; + const get = isFunction(opt) + ? opt.bind(publicThis, publicThis) + : isFunction(opt.get) + ? opt.get.bind(publicThis, publicThis) + : NOOP; + if ((process.env.NODE_ENV !== 'production') && get === NOOP) { + warn(`Computed property "${key}" has no getter.`); + } + const set = !isFunction(opt) && isFunction(opt.set) + ? opt.set.bind(publicThis) + : (process.env.NODE_ENV !== 'production') + ? () => { + warn(`Write operation failed: computed property "${key}" is readonly.`); + } + : NOOP; + const c = computed$1({ + get, + set + }); + Object.defineProperty(ctx, key, { + enumerable: true, + configurable: true, + get: () => c.value, + set: v => (c.value = v) + }); + if ((process.env.NODE_ENV !== 'production')) { + checkDuplicateProperties("Computed" /* COMPUTED */, key); + } + } + } + if (watchOptions) { + for (const key in watchOptions) { + createWatcher(watchOptions[key], ctx, publicThis, key); + } + } + if (provideOptions) { + const provides = isFunction(provideOptions) + ? provideOptions.call(publicThis) + : provideOptions; + Reflect.ownKeys(provides).forEach(key => { + provide(key, provides[key]); + }); + } + if (created) { + callHook(created, instance, "c" /* CREATED */); + } + function registerLifecycleHook(register, hook) { + if (isArray(hook)) { + hook.forEach(_hook => register(_hook.bind(publicThis))); + } + else if (hook) { + register(hook.bind(publicThis)); + } + } + registerLifecycleHook(onBeforeMount, beforeMount); + registerLifecycleHook(onMounted, mounted); + registerLifecycleHook(onBeforeUpdate, beforeUpdate); + registerLifecycleHook(onUpdated, updated); + registerLifecycleHook(onActivated, activated); + registerLifecycleHook(onDeactivated, deactivated); + registerLifecycleHook(onErrorCaptured, errorCaptured); + registerLifecycleHook(onRenderTracked, renderTracked); + registerLifecycleHook(onRenderTriggered, renderTriggered); + registerLifecycleHook(onBeforeUnmount, beforeUnmount); + registerLifecycleHook(onUnmounted, unmounted); + registerLifecycleHook(onServerPrefetch, serverPrefetch); + if (isArray(expose)) { + if (expose.length) { + const exposed = instance.exposed || (instance.exposed = proxyRefs({})); + expose.forEach(key => { + exposed[key] = toRef(publicThis, key); + }); + } + else if (!instance.exposed) { + instance.exposed = EMPTY_OBJ; + } + } + // options that are handled when creating the instance but also need to be + // applied from mixins + if (render && instance.render === NOOP) { + instance.render = render; + } + if (inheritAttrs != null) { + instance.inheritAttrs = inheritAttrs; + } + // asset options. + if (components) + instance.components = components; + if (directives) + instance.directives = directives; +} +function resolveInjections(injectOptions, ctx, checkDuplicateProperties = NOOP) { + if (isArray(injectOptions)) { + injectOptions = normalizeInject(injectOptions); + } + for (const key in injectOptions) { + const opt = injectOptions[key]; + if (isObject(opt)) { + if ('default' in opt) { + ctx[key] = inject(opt.from || key, opt.default, true /* treat default function as factory */); + } + else { + ctx[key] = inject(opt.from || key); + } + } + else { + ctx[key] = inject(opt); + } + if ((process.env.NODE_ENV !== 'production')) { + checkDuplicateProperties("Inject" /* INJECT */, key); + } + } +} +function callHook(hook, instance, type) { + callWithAsyncErrorHandling(isArray(hook) + ? hook.map(h => h.bind(instance.proxy)) + : hook.bind(instance.proxy), instance, type); +} +function createWatcher(raw, ctx, publicThis, key) { + const getter = key.includes('.') + ? createPathGetter(publicThis, key) + : () => publicThis[key]; + if (isString(raw)) { + const handler = ctx[raw]; + if (isFunction(handler)) { + watch(getter, handler); + } + else if ((process.env.NODE_ENV !== 'production')) { + warn(`Invalid watch handler specified by key "${raw}"`, handler); + } + } + else if (isFunction(raw)) { + watch(getter, raw.bind(publicThis)); + } + else if (isObject(raw)) { + if (isArray(raw)) { + raw.forEach(r => createWatcher(r, ctx, publicThis, key)); + } + else { + const handler = isFunction(raw.handler) + ? raw.handler.bind(publicThis) + : ctx[raw.handler]; + if (isFunction(handler)) { + watch(getter, handler, raw); + } + else if ((process.env.NODE_ENV !== 'production')) { + warn(`Invalid watch handler specified by key "${raw.handler}"`, handler); + } + } + } + else if ((process.env.NODE_ENV !== 'production')) { + warn(`Invalid watch option: "${key}"`, raw); + } +} +/** + * Resolve merged options and cache it on the component. + * This is done only once per-component since the merging does not involve + * instances. + */ +function resolveMergedOptions(instance) { + const base = instance.type; + const { mixins, extends: extendsOptions } = base; + const { mixins: globalMixins, optionsCache: cache, config: { optionMergeStrategies } } = instance.appContext; + const cached = cache.get(base); + let resolved; + if (cached) { + resolved = cached; + } + else if (!globalMixins.length && !mixins && !extendsOptions) { + { + resolved = base; + } + } + else { + resolved = {}; + if (globalMixins.length) { + globalMixins.forEach(m => mergeOptions(resolved, m, optionMergeStrategies, true)); + } + mergeOptions(resolved, base, optionMergeStrategies); + } + cache.set(base, resolved); + return resolved; +} +function mergeOptions(to, from, strats, asMixin = false) { + const { mixins, extends: extendsOptions } = from; + if (extendsOptions) { + mergeOptions(to, extendsOptions, strats, true); + } + if (mixins) { + mixins.forEach((m) => mergeOptions(to, m, strats, true)); + } + for (const key in from) { + if (asMixin && key === 'expose') { + (process.env.NODE_ENV !== 'production') && + warn(`"expose" option is ignored when declared in mixins or extends. ` + + `It should only be declared in the base component itself.`); + } + else { + const strat = internalOptionMergeStrats[key] || (strats && strats[key]); + to[key] = strat ? strat(to[key], from[key]) : from[key]; + } + } + return to; +} +const internalOptionMergeStrats = { + data: mergeDataFn, + props: mergeObjectOptions, + emits: mergeObjectOptions, + // objects + methods: mergeObjectOptions, + computed: mergeObjectOptions, + // lifecycle + beforeCreate: mergeHook, + created: mergeHook, + beforeMount: mergeHook, + mounted: mergeHook, + beforeUpdate: mergeHook, + updated: mergeHook, + beforeDestroy: mergeHook, + destroyed: mergeHook, + activated: mergeHook, + deactivated: mergeHook, + errorCaptured: mergeHook, + serverPrefetch: mergeHook, + // assets + components: mergeObjectOptions, + directives: mergeObjectOptions, + // watch has special merge behavior in v2, but isn't actually needed in v3. + // since we are only exposing these for compat and nobody should be relying + // on the watch-specific behavior, just expose the object merge strat. + watch: mergeObjectOptions, + // provide / inject + provide: mergeDataFn, + inject: mergeInject +}; +function mergeDataFn(to, from) { + if (!from) { + return to; + } + if (!to) { + return from; + } + return function mergedDataFn() { + return (extend)(isFunction(to) ? to.call(this, this) : to, isFunction(from) ? from.call(this, this) : from); + }; +} +function mergeInject(to, from) { + return mergeObjectOptions(normalizeInject(to), normalizeInject(from)); +} +function normalizeInject(raw) { + if (isArray(raw)) { + const res = {}; + for (let i = 0; i < raw.length; i++) { + res[raw[i]] = raw[i]; + } + return res; + } + return raw; +} +function mergeHook(to, from) { + return to ? [...new Set([].concat(to, from))] : from; +} +function mergeObjectOptions(to, from) { + return to ? extend(extend(Object.create(null), to), from) : from; +} + +function initProps(instance, rawProps, isStateful, // result of bitwise flag comparison +isSSR = false) { + const props = {}; + const attrs = {}; + def(attrs, InternalObjectKey, 1); + instance.propsDefaults = Object.create(null); + setFullProps(instance, rawProps, props, attrs); + // ensure all declared prop keys are present + for (const key in instance.propsOptions[0]) { + if (!(key in props)) { + props[key] = undefined; + } + } + // validation + if ((process.env.NODE_ENV !== 'production')) { + validateProps(rawProps || {}, props, instance); + } + if (isStateful) { + // stateful + instance.props = isSSR ? props : shallowReactive(props); + } + else { + if (!instance.type.props) { + // functional w/ optional props, props === attrs + instance.props = attrs; + } + else { + // functional w/ declared props + instance.props = props; + } + } + instance.attrs = attrs; +} +function updateProps(instance, rawProps, rawPrevProps, optimized) { + const { props, attrs, vnode: { patchFlag } } = instance; + const rawCurrentProps = toRaw(props); + const [options] = instance.propsOptions; + let hasAttrsChanged = false; + if ( + // always force full diff in dev + // - #1942 if hmr is enabled with sfc component + // - vite#872 non-sfc component used by sfc component + !((process.env.NODE_ENV !== 'production') && + (instance.type.__hmrId || + (instance.parent && instance.parent.type.__hmrId))) && + (optimized || patchFlag > 0) && + !(patchFlag & 16 /* FULL_PROPS */)) { + if (patchFlag & 8 /* PROPS */) { + // Compiler-generated props & no keys change, just set the updated + // the props. + const propsToUpdate = instance.vnode.dynamicProps; + for (let i = 0; i < propsToUpdate.length; i++) { + let key = propsToUpdate[i]; + // PROPS flag guarantees rawProps to be non-null + const value = rawProps[key]; + if (options) { + // attr / props separation was done on init and will be consistent + // in this code path, so just check if attrs have it. + if (hasOwn(attrs, key)) { + if (value !== attrs[key]) { + attrs[key] = value; + hasAttrsChanged = true; + } + } + else { + const camelizedKey = camelize(key); + props[camelizedKey] = resolvePropValue(options, rawCurrentProps, camelizedKey, value, instance, false /* isAbsent */); + } + } + else { + if (value !== attrs[key]) { + attrs[key] = value; + hasAttrsChanged = true; + } + } + } + } + } + else { + // full props update. + if (setFullProps(instance, rawProps, props, attrs)) { + hasAttrsChanged = true; + } + // in case of dynamic props, check if we need to delete keys from + // the props object + let kebabKey; + for (const key in rawCurrentProps) { + if (!rawProps || + // for camelCase + (!hasOwn(rawProps, key) && + // it's possible the original props was passed in as kebab-case + // and converted to camelCase (#955) + ((kebabKey = hyphenate(key)) === key || !hasOwn(rawProps, kebabKey)))) { + if (options) { + if (rawPrevProps && + // for camelCase + (rawPrevProps[key] !== undefined || + // for kebab-case + rawPrevProps[kebabKey] !== undefined)) { + props[key] = resolvePropValue(options, rawCurrentProps, key, undefined, instance, true /* isAbsent */); + } + } + else { + delete props[key]; + } + } + } + // in the case of functional component w/o props declaration, props and + // attrs point to the same object so it should already have been updated. + if (attrs !== rawCurrentProps) { + for (const key in attrs) { + if (!rawProps || !hasOwn(rawProps, key)) { + delete attrs[key]; + hasAttrsChanged = true; + } + } + } + } + // trigger updates for $attrs in case it's used in component slots + if (hasAttrsChanged) { + trigger(instance, "set" /* SET */, '$attrs'); + } + if ((process.env.NODE_ENV !== 'production')) { + validateProps(rawProps || {}, props, instance); + } +} +function setFullProps(instance, rawProps, props, attrs) { + const [options, needCastKeys] = instance.propsOptions; + let hasAttrsChanged = false; + let rawCastValues; + if (rawProps) { + for (let key in rawProps) { + // key, ref are reserved and never passed down + if (isReservedProp(key)) { + continue; + } + const value = rawProps[key]; + // prop option names are camelized during normalization, so to support + // kebab -> camel conversion here we need to camelize the key. + let camelKey; + if (options && hasOwn(options, (camelKey = camelize(key)))) { + if (!needCastKeys || !needCastKeys.includes(camelKey)) { + props[camelKey] = value; + } + else { + (rawCastValues || (rawCastValues = {}))[camelKey] = value; + } + } + else if (!isEmitListener(instance.emitsOptions, key)) { + if (value !== attrs[key]) { + attrs[key] = value; + hasAttrsChanged = true; + } + } + } + } + if (needCastKeys) { + const rawCurrentProps = toRaw(props); + const castValues = rawCastValues || EMPTY_OBJ; + for (let i = 0; i < needCastKeys.length; i++) { + const key = needCastKeys[i]; + props[key] = resolvePropValue(options, rawCurrentProps, key, castValues[key], instance, !hasOwn(castValues, key)); + } + } + return hasAttrsChanged; +} +function resolvePropValue(options, props, key, value, instance, isAbsent) { + const opt = options[key]; + if (opt != null) { + const hasDefault = hasOwn(opt, 'default'); + // default values + if (hasDefault && value === undefined) { + const defaultValue = opt.default; + if (opt.type !== Function && isFunction(defaultValue)) { + const { propsDefaults } = instance; + if (key in propsDefaults) { + value = propsDefaults[key]; + } + else { + setCurrentInstance(instance); + value = propsDefaults[key] = defaultValue.call(null, props); + setCurrentInstance(null); + } + } + else { + value = defaultValue; + } + } + // boolean casting + if (opt[0 /* shouldCast */]) { + if (isAbsent && !hasDefault) { + value = false; + } + else if (opt[1 /* shouldCastTrue */] && + (value === '' || value === hyphenate(key))) { + value = true; + } + } + } + return value; +} +function normalizePropsOptions(comp, appContext, asMixin = false) { + const cache = appContext.propsCache; + const cached = cache.get(comp); + if (cached) { + return cached; + } + const raw = comp.props; + const normalized = {}; + const needCastKeys = []; + // apply mixin/extends props + let hasExtends = false; + if (__VUE_OPTIONS_API__ && !isFunction(comp)) { + const extendProps = (raw) => { + hasExtends = true; + const [props, keys] = normalizePropsOptions(raw, appContext, true); + extend(normalized, props); + if (keys) + needCastKeys.push(...keys); + }; + if (!asMixin && appContext.mixins.length) { + appContext.mixins.forEach(extendProps); + } + if (comp.extends) { + extendProps(comp.extends); + } + if (comp.mixins) { + comp.mixins.forEach(extendProps); + } + } + if (!raw && !hasExtends) { + cache.set(comp, EMPTY_ARR); + return EMPTY_ARR; + } + if (isArray(raw)) { + for (let i = 0; i < raw.length; i++) { + if ((process.env.NODE_ENV !== 'production') && !isString(raw[i])) { + warn(`props must be strings when using array syntax.`, raw[i]); + } + const normalizedKey = camelize(raw[i]); + if (validatePropName(normalizedKey)) { + normalized[normalizedKey] = EMPTY_OBJ; + } + } + } + else if (raw) { + if ((process.env.NODE_ENV !== 'production') && !isObject(raw)) { + warn(`invalid props options`, raw); + } + for (const key in raw) { + const normalizedKey = camelize(key); + if (validatePropName(normalizedKey)) { + const opt = raw[key]; + const prop = (normalized[normalizedKey] = + isArray(opt) || isFunction(opt) ? { type: opt } : opt); + if (prop) { + const booleanIndex = getTypeIndex(Boolean, prop.type); + const stringIndex = getTypeIndex(String, prop.type); + prop[0 /* shouldCast */] = booleanIndex > -1; + prop[1 /* shouldCastTrue */] = + stringIndex < 0 || booleanIndex < stringIndex; + // if the prop needs boolean casting or default value + if (booleanIndex > -1 || hasOwn(prop, 'default')) { + needCastKeys.push(normalizedKey); + } + } + } + } + } + const res = [normalized, needCastKeys]; + cache.set(comp, res); + return res; +} +function validatePropName(key) { + if (key[0] !== '$') { + return true; + } + else if ((process.env.NODE_ENV !== 'production')) { + warn(`Invalid prop name: "${key}" is a reserved property.`); + } + return false; +} +// use function string name to check type constructors +// so that it works across vms / iframes. +function getType(ctor) { + const match = ctor && ctor.toString().match(/^\s*function (\w+)/); + return match ? match[1] : ''; +} +function isSameType(a, b) { + return getType(a) === getType(b); +} +function getTypeIndex(type, expectedTypes) { + if (isArray(expectedTypes)) { + return expectedTypes.findIndex(t => isSameType(t, type)); + } + else if (isFunction(expectedTypes)) { + return isSameType(expectedTypes, type) ? 0 : -1; + } + return -1; +} +/** + * dev only + */ +function validateProps(rawProps, props, instance) { + const resolvedValues = toRaw(props); + const options = instance.propsOptions[0]; + for (const key in options) { + let opt = options[key]; + if (opt == null) + continue; + validateProp(key, resolvedValues[key], opt, !hasOwn(rawProps, key) && !hasOwn(rawProps, hyphenate(key))); + } +} +/** + * dev only + */ +function validateProp(name, value, prop, isAbsent) { + const { type, required, validator } = prop; + // required! + if (required && isAbsent) { + warn('Missing required prop: "' + name + '"'); + return; + } + // missing but optional + if (value == null && !prop.required) { + return; + } + // type check + if (type != null && type !== true) { + let isValid = false; + const types = isArray(type) ? type : [type]; + const expectedTypes = []; + // value is valid as long as one of the specified types match + for (let i = 0; i < types.length && !isValid; i++) { + const { valid, expectedType } = assertType(value, types[i]); + expectedTypes.push(expectedType || ''); + isValid = valid; + } + if (!isValid) { + warn(getInvalidTypeMessage(name, value, expectedTypes)); + return; + } + } + // custom validator + if (validator && !validator(value)) { + warn('Invalid prop: custom validator check failed for prop "' + name + '".'); + } +} +const isSimpleType = /*#__PURE__*/ makeMap('String,Number,Boolean,Function,Symbol,BigInt'); +/** + * dev only + */ +function assertType(value, type) { + let valid; + const expectedType = getType(type); + if (isSimpleType(expectedType)) { + const t = typeof value; + valid = t === expectedType.toLowerCase(); + // for primitive wrapper objects + 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 + }; +} +/** + * dev only + */ +function getInvalidTypeMessage(name, value, expectedTypes) { + let message = `Invalid prop: type check failed for prop "${name}".` + + ` Expected ${expectedTypes.map(capitalize).join(', ')}`; + const expectedType = expectedTypes[0]; + const receivedType = toRawType(value); + const expectedValue = styleValue(value, expectedType); + const receivedValue = styleValue(value, receivedType); + // check if we need to specify expected value + if (expectedTypes.length === 1 && + isExplicable(expectedType) && + !isBoolean(expectedType, receivedType)) { + message += ` with value ${expectedValue}`; + } + message += `, got ${receivedType} `; + // check if we need to specify received value + if (isExplicable(receivedType)) { + message += `with value ${receivedValue}.`; + } + return message; +} +/** + * dev only + */ +function styleValue(value, type) { + if (type === 'String') { + return `"${value}"`; + } + else if (type === 'Number') { + return `${Number(value)}`; + } + else { + return `${value}`; + } +} +/** + * dev only + */ +function isExplicable(type) { + const explicitTypes = ['string', 'number', 'boolean']; + return explicitTypes.some(elem => type.toLowerCase() === elem); +} +/** + * dev only + */ +function isBoolean(...args) { + return args.some(elem => elem.toLowerCase() === 'boolean'); +} + +const isInternalKey = (key) => key[0] === '_' || key === '$stable'; +const normalizeSlotValue = (value) => isArray(value) + ? value.map(normalizeVNode) + : [normalizeVNode(value)]; +const normalizeSlot = (key, rawSlot, ctx) => { + const normalized = withCtx((props) => { + if ((process.env.NODE_ENV !== 'production') && currentInstance) { + warn(`Slot "${key}" invoked outside of the render function: ` + + `this will not track dependencies used in the slot. ` + + `Invoke the slot function inside the render function instead.`); + } + return normalizeSlotValue(rawSlot(props)); + }, ctx); + normalized._c = false; + return normalized; +}; +const normalizeObjectSlots = (rawSlots, slots, instance) => { + const ctx = rawSlots._ctx; + for (const key in rawSlots) { + if (isInternalKey(key)) + continue; + const value = rawSlots[key]; + if (isFunction(value)) { + slots[key] = normalizeSlot(key, value, ctx); + } + else if (value != null) { + if ((process.env.NODE_ENV !== 'production') && + !(false )) { + warn(`Non-function value encountered for slot "${key}". ` + + `Prefer function slots for better performance.`); + } + const normalized = normalizeSlotValue(value); + slots[key] = () => normalized; + } + } +}; +const normalizeVNodeSlots = (instance, children) => { + if ((process.env.NODE_ENV !== 'production') && + !isKeepAlive(instance.vnode) && + !(false )) { + warn(`Non-function value encountered for default slot. ` + + `Prefer function slots for better performance.`); + } + const normalized = normalizeSlotValue(children); + instance.slots.default = () => normalized; +}; +const initSlots = (instance, children) => { + if (instance.vnode.shapeFlag & 32 /* SLOTS_CHILDREN */) { + const type = children._; + if (type) { + // users can get the shallow readonly version of the slots object through `this.$slots`, + // we should avoid the proxy object polluting the slots of the internal instance + instance.slots = toRaw(children); + // make compiler marker non-enumerable + def(children, '_', type); + } + else { + normalizeObjectSlots(children, (instance.slots = {})); + } + } + else { + instance.slots = {}; + if (children) { + normalizeVNodeSlots(instance, children); + } + } + def(instance.slots, InternalObjectKey, 1); +}; +const updateSlots = (instance, children, optimized) => { + const { vnode, slots } = instance; + let needDeletionCheck = true; + let deletionComparisonTarget = EMPTY_OBJ; + if (vnode.shapeFlag & 32 /* SLOTS_CHILDREN */) { + const type = children._; + if (type) { + // compiled slots. + if ((process.env.NODE_ENV !== 'production') && isHmrUpdating) { + // Parent was HMR updated so slot content may have changed. + // force update slots and mark instance for hmr as well + extend(slots, children); + } + else if (optimized && type === 1 /* STABLE */) { + // compiled AND stable. + // no need to update, and skip stale slots removal. + needDeletionCheck = false; + } + else { + // compiled but dynamic (v-if/v-for on slots) - update slots, but skip + // normalization. + extend(slots, children); + // #2893 + // when rendering the optimized slots by manually written render function, + // we need to delete the `slots._` flag if necessary to make subsequent updates reliable, + // i.e. let the `renderSlot` create the bailed Fragment + if (!optimized && type === 1 /* STABLE */) { + delete slots._; + } + } + } + else { + needDeletionCheck = !children.$stable; + normalizeObjectSlots(children, slots); + } + deletionComparisonTarget = children; + } + else if (children) { + // non slot object children (direct value) passed to a component + normalizeVNodeSlots(instance, children); + deletionComparisonTarget = { default: 1 }; + } + // delete stale slots + if (needDeletionCheck) { + for (const key in slots) { + if (!isInternalKey(key) && !(key in deletionComparisonTarget)) { + delete slots[key]; + } + } + } +}; + +/** +Runtime helper for applying directives to a vnode. Example usage: + +const comp = resolveComponent('comp') +const foo = resolveDirective('foo') +const bar = resolveDirective('bar') + +return withDirectives(h(comp), [ + [foo, this.x], + [bar, this.y] +]) +*/ +const isBuiltInDirective = /*#__PURE__*/ makeMap('bind,cloak,else-if,else,for,html,if,model,on,once,pre,show,slot,text'); +function validateDirectiveName(name) { + if (isBuiltInDirective(name)) { + warn('Do not use built-in directive ids as custom directive id: ' + name); + } +} +/** + * Adds directives to a VNode. + */ +function withDirectives(vnode, directives) { + const internalInstance = currentRenderingInstance; + if (internalInstance === null) { + (process.env.NODE_ENV !== 'production') && warn(`withDirectives can only be used inside render functions.`); + return vnode; + } + const instance = internalInstance.proxy; + const bindings = vnode.dirs || (vnode.dirs = []); + for (let i = 0; i < directives.length; i++) { + let [dir, value, arg, modifiers = EMPTY_OBJ] = directives[i]; + if (isFunction(dir)) { + dir = { + mounted: dir, + updated: dir + }; + } + bindings.push({ + dir, + instance, + value, + oldValue: void 0, + arg, + modifiers + }); + } + return vnode; +} +function invokeDirectiveHook(vnode, prevVNode, instance, name) { + const bindings = vnode.dirs; + const oldBindings = prevVNode && prevVNode.dirs; + for (let i = 0; i < bindings.length; i++) { + const binding = bindings[i]; + if (oldBindings) { + binding.oldValue = oldBindings[i].value; + } + let hook = binding.dir[name]; + if (hook) { + // disable tracking inside all lifecycle hooks + // since they can potentially be called inside effects. + pauseTracking(); + callWithAsyncErrorHandling(hook, instance, 8 /* DIRECTIVE_HOOK */, [ + vnode.el, + binding, + vnode, + prevVNode + ]); + resetTracking(); + } + } +} + +function createAppContext() { + return { + app: null, + config: { + isNativeTag: NO, + performance: false, + globalProperties: {}, + optionMergeStrategies: {}, + errorHandler: undefined, + warnHandler: undefined, + compilerOptions: {} + }, + mixins: [], + components: {}, + directives: {}, + provides: Object.create(null), + optionsCache: new WeakMap(), + propsCache: new WeakMap(), + emitsCache: new WeakMap() + }; +} +let uid$1 = 0; +function createAppAPI(render, hydrate) { + return function createApp(rootComponent, rootProps = null) { + if (rootProps != null && !isObject(rootProps)) { + (process.env.NODE_ENV !== 'production') && warn(`root props passed to app.mount() must be an object.`); + rootProps = null; + } + const context = createAppContext(); + const installedPlugins = new Set(); + let isMounted = false; + const app = (context.app = { + _uid: uid$1++, + _component: rootComponent, + _props: rootProps, + _container: null, + _context: context, + _instance: null, + version, + get config() { + return context.config; + }, + set config(v) { + if ((process.env.NODE_ENV !== 'production')) { + warn(`app.config cannot be replaced. Modify individual options instead.`); + } + }, + use(plugin, ...options) { + if (installedPlugins.has(plugin)) { + (process.env.NODE_ENV !== 'production') && warn(`Plugin has already been applied to target app.`); + } + else if (plugin && isFunction(plugin.install)) { + installedPlugins.add(plugin); + plugin.install(app, ...options); + } + else if (isFunction(plugin)) { + installedPlugins.add(plugin); + plugin(app, ...options); + } + else if ((process.env.NODE_ENV !== 'production')) { + warn(`A plugin must either be a function or an object with an "install" ` + + `function.`); + } + return app; + }, + mixin(mixin) { + if (__VUE_OPTIONS_API__) { + if (!context.mixins.includes(mixin)) { + context.mixins.push(mixin); + } + else if ((process.env.NODE_ENV !== 'production')) { + warn('Mixin has already been applied to target app' + + (mixin.name ? `: ${mixin.name}` : '')); + } + } + else if ((process.env.NODE_ENV !== 'production')) { + warn('Mixins are only available in builds supporting Options API'); + } + return app; + }, + component(name, component) { + if ((process.env.NODE_ENV !== 'production')) { + validateComponentName(name, context.config); + } + if (!component) { + return context.components[name]; + } + if ((process.env.NODE_ENV !== 'production') && context.components[name]) { + warn(`Component "${name}" has already been registered in target app.`); + } + context.components[name] = component; + return app; + }, + directive(name, directive) { + if ((process.env.NODE_ENV !== 'production')) { + validateDirectiveName(name); + } + if (!directive) { + return context.directives[name]; + } + if ((process.env.NODE_ENV !== 'production') && context.directives[name]) { + warn(`Directive "${name}" has already been registered in target app.`); + } + context.directives[name] = directive; + return app; + }, + mount(rootContainer, isHydrate, isSVG) { + if (!isMounted) { + const vnode = createVNode(rootComponent, rootProps); + // store app context on the root VNode. + // this will be set on the root instance on initial mount. + vnode.appContext = context; + // HMR root reload + if ((process.env.NODE_ENV !== 'production')) { + context.reload = () => { + render(cloneVNode(vnode), rootContainer, isSVG); + }; + } + if (isHydrate && hydrate) { + hydrate(vnode, rootContainer); + } + else { + render(vnode, rootContainer, isSVG); + } + isMounted = true; + app._container = rootContainer; + rootContainer.__vue_app__ = app; + if ((process.env.NODE_ENV !== 'production') || __VUE_PROD_DEVTOOLS__) { + app._instance = vnode.component; + devtoolsInitApp(app, version); + } + return vnode.component.proxy; + } + else if ((process.env.NODE_ENV !== 'production')) { + warn(`App has already been mounted.\n` + + `If you want to remount the same app, move your app creation logic ` + + `into a factory function and create fresh app instances for each ` + + `mount - e.g. \`const createMyApp = () => createApp(App)\``); + } + }, + unmount() { + if (isMounted) { + render(null, app._container); + if ((process.env.NODE_ENV !== 'production') || __VUE_PROD_DEVTOOLS__) { + app._instance = null; + devtoolsUnmountApp(app); + } + delete app._container.__vue_app__; + } + else if ((process.env.NODE_ENV !== 'production')) { + warn(`Cannot unmount an app that is not mounted.`); + } + }, + provide(key, value) { + if ((process.env.NODE_ENV !== 'production') && key in context.provides) { + warn(`App already provides property with key "${String(key)}". ` + + `It will be overwritten with the new value.`); + } + // TypeScript doesn't allow symbols as index type + // https://github.com/Microsoft/TypeScript/issues/24587 + context.provides[key] = value; + return app; + } + }); + return app; + }; +} + +let hasMismatch = false; +const isSVGContainer = (container) => /svg/.test(container.namespaceURI) && container.tagName !== 'foreignObject'; +const isComment = (node) => node.nodeType === 8 /* COMMENT */; +// Note: hydration is DOM-specific +// But we have to place it in core due to tight coupling with core - splitting +// it out creates a ton of unnecessary complexity. +// Hydration also depends on some renderer internal logic which needs to be +// passed in via arguments. +function createHydrationFunctions(rendererInternals) { + const { mt: mountComponent, p: patch, o: { patchProp, nextSibling, parentNode, remove, insert, createComment } } = rendererInternals; + const hydrate = (vnode, container) => { + if ((process.env.NODE_ENV !== 'production') && !container.hasChildNodes()) { + warn(`Attempting to hydrate existing markup but container is empty. ` + + `Performing full mount instead.`); + patch(null, vnode, container); + return; + } + hasMismatch = false; + hydrateNode(container.firstChild, vnode, null, null, null); + flushPostFlushCbs(); + if (hasMismatch && !false) { + // this error should show up in production + console.error(`Hydration completed but contains mismatches.`); + } + }; + const hydrateNode = (node, vnode, parentComponent, parentSuspense, slotScopeIds, optimized = false) => { + const isFragmentStart = isComment(node) && node.data === '['; + const onMismatch = () => handleMismatch(node, vnode, parentComponent, parentSuspense, slotScopeIds, isFragmentStart); + const { type, ref, shapeFlag } = vnode; + const domType = node.nodeType; + vnode.el = node; + let nextNode = null; + switch (type) { + case Text: + if (domType !== 3 /* TEXT */) { + nextNode = onMismatch(); + } + else { + if (node.data !== vnode.children) { + hasMismatch = true; + (process.env.NODE_ENV !== 'production') && + warn(`Hydration text mismatch:` + + `\n- Client: ${JSON.stringify(node.data)}` + + `\n- Server: ${JSON.stringify(vnode.children)}`); + node.data = vnode.children; + } + nextNode = nextSibling(node); + } + break; + case Comment$1: + if (domType !== 8 /* COMMENT */ || isFragmentStart) { + nextNode = onMismatch(); + } + else { + nextNode = nextSibling(node); + } + break; + case Static: + if (domType !== 1 /* ELEMENT */) { + nextNode = onMismatch(); + } + else { + // determine anchor, adopt content + nextNode = node; + // if the static vnode has its content stripped during build, + // adopt it from the server-rendered HTML. + const needToAdoptContent = !vnode.children.length; + for (let i = 0; i < vnode.staticCount; i++) { + if (needToAdoptContent) + vnode.children += nextNode.outerHTML; + if (i === vnode.staticCount - 1) { + vnode.anchor = nextNode; + } + nextNode = nextSibling(nextNode); + } + return nextNode; + } + break; + case Fragment: + if (!isFragmentStart) { + nextNode = onMismatch(); + } + else { + nextNode = hydrateFragment(node, vnode, parentComponent, parentSuspense, slotScopeIds, optimized); + } + break; + default: + if (shapeFlag & 1 /* ELEMENT */) { + if (domType !== 1 /* ELEMENT */ || + vnode.type.toLowerCase() !== + node.tagName.toLowerCase()) { + nextNode = onMismatch(); + } + else { + nextNode = hydrateElement(node, vnode, parentComponent, parentSuspense, slotScopeIds, optimized); + } + } + else if (shapeFlag & 6 /* COMPONENT */) { + // when setting up the render effect, if the initial vnode already + // has .el set, the component will perform hydration instead of mount + // on its sub-tree. + vnode.slotScopeIds = slotScopeIds; + const container = parentNode(node); + mountComponent(vnode, container, null, parentComponent, parentSuspense, isSVGContainer(container), optimized); + // component may be async, so in the case of fragments we cannot rely + // on component's rendered output to determine the end of the fragment + // instead, we do a lookahead to find the end anchor node. + nextNode = isFragmentStart + ? locateClosingAsyncAnchor(node) + : nextSibling(node); + // #3787 + // if component is async, it may get moved / unmounted before its + // inner component is loaded, so we need to give it a placeholder + // vnode that matches its adopted DOM. + if (isAsyncWrapper(vnode)) { + let subTree; + if (isFragmentStart) { + subTree = createVNode(Fragment); + subTree.anchor = nextNode + ? nextNode.previousSibling + : container.lastChild; + } + else { + subTree = + node.nodeType === 3 ? createTextVNode('') : createVNode('div'); + } + subTree.el = node; + vnode.component.subTree = subTree; + } + } + else if (shapeFlag & 64 /* TELEPORT */) { + if (domType !== 8 /* COMMENT */) { + nextNode = onMismatch(); + } + else { + nextNode = vnode.type.hydrate(node, vnode, parentComponent, parentSuspense, slotScopeIds, optimized, rendererInternals, hydrateChildren); + } + } + else if (shapeFlag & 128 /* SUSPENSE */) { + nextNode = vnode.type.hydrate(node, vnode, parentComponent, parentSuspense, isSVGContainer(parentNode(node)), slotScopeIds, optimized, rendererInternals, hydrateNode); + } + else if ((process.env.NODE_ENV !== 'production')) { + warn('Invalid HostVNode type:', type, `(${typeof type})`); + } + } + if (ref != null) { + setRef(ref, null, parentSuspense, vnode); + } + return nextNode; + }; + const hydrateElement = (el, vnode, parentComponent, parentSuspense, slotScopeIds, optimized) => { + optimized = optimized || !!vnode.dynamicChildren; + const { props, patchFlag, shapeFlag, dirs } = vnode; + // skip props & children if this is hoisted static nodes + if (patchFlag !== -1 /* HOISTED */) { + if (dirs) { + invokeDirectiveHook(vnode, null, parentComponent, 'created'); + } + // props + if (props) { + if (!optimized || + (patchFlag & 16 /* FULL_PROPS */ || + patchFlag & 32 /* HYDRATE_EVENTS */)) { + for (const key in props) { + if (!isReservedProp(key) && isOn(key)) { + patchProp(el, key, null, props[key]); + } + } + } + else if (props.onClick) { + // Fast path for click listeners (which is most often) to avoid + // iterating through props. + patchProp(el, 'onClick', null, props.onClick); + } + } + // vnode / directive hooks + let vnodeHooks; + if ((vnodeHooks = props && props.onVnodeBeforeMount)) { + invokeVNodeHook(vnodeHooks, parentComponent, vnode); + } + if (dirs) { + invokeDirectiveHook(vnode, null, parentComponent, 'beforeMount'); + } + if ((vnodeHooks = props && props.onVnodeMounted) || dirs) { + queueEffectWithSuspense(() => { + vnodeHooks && invokeVNodeHook(vnodeHooks, parentComponent, vnode); + dirs && invokeDirectiveHook(vnode, null, parentComponent, 'mounted'); + }, parentSuspense); + } + // children + if (shapeFlag & 16 /* ARRAY_CHILDREN */ && + // skip if element has innerHTML / textContent + !(props && (props.innerHTML || props.textContent))) { + let next = hydrateChildren(el.firstChild, vnode, el, parentComponent, parentSuspense, slotScopeIds, optimized); + let hasWarned = false; + while (next) { + hasMismatch = true; + if ((process.env.NODE_ENV !== 'production') && !hasWarned) { + warn(`Hydration children mismatch in <${vnode.type}>: ` + + `server rendered element contains more child nodes than client vdom.`); + hasWarned = true; + } + // The SSRed DOM contains more nodes than it should. Remove them. + const cur = next; + next = next.nextSibling; + remove(cur); + } + } + else if (shapeFlag & 8 /* TEXT_CHILDREN */) { + if (el.textContent !== vnode.children) { + hasMismatch = true; + (process.env.NODE_ENV !== 'production') && + warn(`Hydration text content mismatch in <${vnode.type}>:\n` + + `- Client: ${el.textContent}\n` + + `- Server: ${vnode.children}`); + el.textContent = vnode.children; + } + } + } + return el.nextSibling; + }; + const hydrateChildren = (node, parentVNode, container, parentComponent, parentSuspense, slotScopeIds, optimized) => { + optimized = optimized || !!parentVNode.dynamicChildren; + const children = parentVNode.children; + const l = children.length; + let hasWarned = false; + for (let i = 0; i < l; i++) { + const vnode = optimized + ? children[i] + : (children[i] = normalizeVNode(children[i])); + if (node) { + node = hydrateNode(node, vnode, parentComponent, parentSuspense, slotScopeIds, optimized); + } + else if (vnode.type === Text && !vnode.children) { + continue; + } + else { + hasMismatch = true; + if ((process.env.NODE_ENV !== 'production') && !hasWarned) { + warn(`Hydration children mismatch in <${container.tagName.toLowerCase()}>: ` + + `server rendered element contains fewer child nodes than client vdom.`); + hasWarned = true; + } + // the SSRed DOM didn't contain enough nodes. Mount the missing ones. + patch(null, vnode, container, null, parentComponent, parentSuspense, isSVGContainer(container), slotScopeIds); + } + } + return node; + }; + const hydrateFragment = (node, vnode, parentComponent, parentSuspense, slotScopeIds, optimized) => { + const { slotScopeIds: fragmentSlotScopeIds } = vnode; + if (fragmentSlotScopeIds) { + slotScopeIds = slotScopeIds + ? slotScopeIds.concat(fragmentSlotScopeIds) + : fragmentSlotScopeIds; + } + const container = parentNode(node); + const next = hydrateChildren(nextSibling(node), vnode, container, parentComponent, parentSuspense, slotScopeIds, optimized); + if (next && isComment(next) && next.data === ']') { + return nextSibling((vnode.anchor = next)); + } + else { + // fragment didn't hydrate successfully, since we didn't get a end anchor + // back. This should have led to node/children mismatch warnings. + hasMismatch = true; + // since the anchor is missing, we need to create one and insert it + insert((vnode.anchor = createComment(`]`, container)), container, next); // fixed by xxxxxx + return next; + } + }; + const handleMismatch = (node, vnode, parentComponent, parentSuspense, slotScopeIds, isFragment) => { + hasMismatch = true; + (process.env.NODE_ENV !== 'production') && + warn(`Hydration node mismatch:\n- Client vnode:`, vnode.type, `\n- Server rendered DOM:`, node, node.nodeType === 3 /* TEXT */ + ? `(text)` + : isComment(node) && node.data === '[' + ? `(start of fragment)` + : ``); + vnode.el = null; + if (isFragment) { + // remove excessive fragment nodes + const end = locateClosingAsyncAnchor(node); + while (true) { + const next = nextSibling(node); + if (next && next !== end) { + remove(next); + } + else { + break; + } + } + } + const next = nextSibling(node); + const container = parentNode(node); + remove(node); + patch(null, vnode, container, next, parentComponent, parentSuspense, isSVGContainer(container), slotScopeIds); + return next; + }; + const locateClosingAsyncAnchor = (node) => { + let match = 0; + while (node) { + node = nextSibling(node); + if (node && isComment(node)) { + if (node.data === '[') + match++; + if (node.data === ']') { + if (match === 0) { + return nextSibling(node); + } + else { + match--; + } + } + } + } + return node; + }; + return [hydrate, hydrateNode]; +} + +let supported; +let perf; +function startMeasure(instance, type) { + if (instance.appContext.config.performance && isSupported()) { + perf.mark(`vue-${type}-${instance.uid}`); + } + if ((process.env.NODE_ENV !== 'production') || __VUE_PROD_DEVTOOLS__) { + devtoolsPerfStart(instance, type, supported ? perf.now() : Date.now()); + } +} +function endMeasure(instance, type) { + if (instance.appContext.config.performance && isSupported()) { + const startTag = `vue-${type}-${instance.uid}`; + const endTag = startTag + `:end`; + perf.mark(endTag); + perf.measure(`<${formatComponentName(instance, instance.type)}> ${type}`, startTag, endTag); + perf.clearMarks(startTag); + perf.clearMarks(endTag); + } + if ((process.env.NODE_ENV !== 'production') || __VUE_PROD_DEVTOOLS__) { + devtoolsPerfEnd(instance, type, supported ? perf.now() : Date.now()); + } +} +function isSupported() { + if (supported !== undefined) { + return supported; + } + /* eslint-disable no-restricted-globals */ + if (typeof window !== 'undefined' && window.performance) { + supported = true; + perf = window.performance; + } + else { + supported = false; + } + /* eslint-enable no-restricted-globals */ + return supported; +} + +/** + * This is only called in esm-bundler builds. + * It is called when a renderer is created, in `baseCreateRenderer` so that + * importing runtime-core is side-effects free. + * + * istanbul-ignore-next + */ +function initFeatureFlags() { + let needWarn = false; + if (typeof __VUE_OPTIONS_API__ !== 'boolean') { + needWarn = true; + getGlobalThis().__VUE_OPTIONS_API__ = true; + } + if (typeof __VUE_PROD_DEVTOOLS__ !== 'boolean') { + needWarn = true; + getGlobalThis().__VUE_PROD_DEVTOOLS__ = false; + } + if ((process.env.NODE_ENV !== 'production') && needWarn) { + console.warn(`You are running the esm-bundler build of Vue. It is recommended to ` + + `configure your bundler to explicitly replace feature flag globals ` + + `with boolean literals to get proper tree-shaking in the final bundle. ` + + `See http://link.vuejs.org/feature-flags for more details.`); + } +} + +const prodEffectOptions = { + scheduler: queueJob, + // #1801, #2043 component render effects should allow recursive updates + allowRecurse: true +}; +function createDevEffectOptions(instance) { + return { + scheduler: queueJob, + allowRecurse: true, + onTrack: instance.rtc ? e => invokeArrayFns(instance.rtc, e) : void 0, + onTrigger: instance.rtg ? e => invokeArrayFns(instance.rtg, e) : void 0 + }; +} +const queuePostRenderEffect = queueEffectWithSuspense + ; +const setRef = (rawRef, oldRawRef, parentSuspense, vnode, isUnmount = false) => { + if (isArray(rawRef)) { + rawRef.forEach((r, i) => setRef(r, oldRawRef && (isArray(oldRawRef) ? oldRawRef[i] : oldRawRef), parentSuspense, vnode, isUnmount)); + return; + } + if (isAsyncWrapper(vnode) && !isUnmount) { + // when mounting async components, nothing needs to be done, + // because the template ref is forwarded to inner component + return; + } + const refValue = vnode.shapeFlag & 4 /* STATEFUL_COMPONENT */ + ? vnode.component.exposed || vnode.component.proxy + : vnode.el; + const value = isUnmount ? null : refValue; + const { i: owner, r: ref } = rawRef; + if ((process.env.NODE_ENV !== 'production') && !owner) { + warn(`Missing ref owner context. ref cannot be used on hoisted vnodes. ` + + `A vnode with ref must be created inside the render function.`); + return; + } + const oldRef = oldRawRef && oldRawRef.r; + const refs = owner.refs === EMPTY_OBJ ? (owner.refs = {}) : owner.refs; + const setupState = owner.setupState; + // dynamic ref changed. unset old ref + if (oldRef != null && oldRef !== ref) { + if (isString(oldRef)) { + refs[oldRef] = null; + if (hasOwn(setupState, oldRef)) { + setupState[oldRef] = null; + } + } + else if (isRef(oldRef)) { + oldRef.value = null; + } + } + if (isString(ref)) { + const doSet = () => { + { + refs[ref] = value; + } + if (hasOwn(setupState, ref)) { + setupState[ref] = value; + } + }; + // #1789: for non-null values, set them after render + // null values means this is unmount and it should not overwrite another + // ref with the same key + if (value) { + doSet.id = -1; + queuePostRenderEffect(doSet, parentSuspense); + } + else { + doSet(); + } + } + else if (isRef(ref)) { + const doSet = () => { + ref.value = value; + }; + if (value) { + doSet.id = -1; + queuePostRenderEffect(doSet, parentSuspense); + } + else { + doSet(); + } + } + else if (isFunction(ref)) { + callWithErrorHandling(ref, owner, 12 /* FUNCTION_REF */, [value, refs]); + } + else if ((process.env.NODE_ENV !== 'production')) { + warn('Invalid template ref type:', value, `(${typeof value})`); + } +}; +/** + * The createRenderer function accepts two generic arguments: + * HostNode and HostElement, corresponding to Node and Element types in the + * host environment. For example, for runtime-dom, HostNode would be the DOM + * `Node` interface and HostElement would be the DOM `Element` interface. + * + * Custom renderers can pass in the platform specific types like this: + * + * ``` js + * const { render, createApp } = createRenderer({ + * patchProp, + * ...nodeOps + * }) + * ``` + */ +function createRenderer(options) { + return baseCreateRenderer(options); +} +// Separate API for creating hydration-enabled renderer. +// Hydration logic is only used when calling this function, making it +// tree-shakable. +function createHydrationRenderer(options) { + return baseCreateRenderer(options, createHydrationFunctions); +} +// implementation +function baseCreateRenderer(options, createHydrationFns) { + // compile-time feature flags check + { + initFeatureFlags(); + } + if ((process.env.NODE_ENV !== 'production') || __VUE_PROD_DEVTOOLS__) { + const target = getGlobalThis(); + target.__VUE__ = true; + setDevtoolsHook(target.__VUE_DEVTOOLS_GLOBAL_HOOK__); + } + const { insert: hostInsert, remove: hostRemove, patchProp: hostPatchProp, forcePatchProp: hostForcePatchProp, createElement: hostCreateElement, createText: hostCreateText, createComment: hostCreateComment, setText: hostSetText, setElementText: hostSetElementText, parentNode: hostParentNode, nextSibling: hostNextSibling, setScopeId: hostSetScopeId = NOOP, cloneNode: hostCloneNode, insertStaticContent: hostInsertStaticContent } = options; + // Note: functions inside this closure should use `const xxx = () => {}` + // style in order to prevent being inlined by minifiers. + const patch = (n1, n2, container, anchor = null, parentComponent = null, parentSuspense = null, isSVG = false, slotScopeIds = null, optimized = false) => { + // patching & not same type, unmount old tree + if (n1 && !isSameVNodeType(n1, n2)) { + anchor = getNextHostNode(n1); + unmount(n1, parentComponent, parentSuspense, true); + n1 = null; + } + if (n2.patchFlag === -2 /* BAIL */) { + optimized = false; + n2.dynamicChildren = null; + } + const { type, ref, shapeFlag } = n2; + switch (type) { + case Text: + processText(n1, n2, container, anchor); + break; + case Comment$1: + processCommentNode(n1, n2, container, anchor); + break; + case Static: + if (n1 == null) { + mountStaticNode(n2, container, anchor, isSVG); + } + else if ((process.env.NODE_ENV !== 'production')) { + patchStaticNode(n1, n2, container, isSVG); + } + break; + case Fragment: + processFragment(n1, n2, container, anchor, parentComponent, parentSuspense, isSVG, slotScopeIds, optimized); + break; + default: + if (shapeFlag & 1 /* ELEMENT */) { + processElement(n1, n2, container, anchor, parentComponent, parentSuspense, isSVG, slotScopeIds, optimized); + } + else if (shapeFlag & 6 /* COMPONENT */) { + processComponent(n1, n2, container, anchor, parentComponent, parentSuspense, isSVG, slotScopeIds, optimized); + } + else if (shapeFlag & 64 /* TELEPORT */) { + type.process(n1, n2, container, anchor, parentComponent, parentSuspense, isSVG, slotScopeIds, optimized, internals); + } + else if (shapeFlag & 128 /* SUSPENSE */) { + type.process(n1, n2, container, anchor, parentComponent, parentSuspense, isSVG, slotScopeIds, optimized, internals); + } + else if ((process.env.NODE_ENV !== 'production')) { + warn('Invalid VNode type:', type, `(${typeof type})`); + } + } + // set ref + if (ref != null && parentComponent) { + setRef(ref, n1 && n1.ref, parentSuspense, n2 || n1, !n2); + } + }; + const processText = (n1, n2, container, anchor) => { + if (n1 == null) { + hostInsert((n2.el = hostCreateText(n2.children, container)), // fixed by xxxxxx + container, anchor); + } + else { + const el = (n2.el = n1.el); + if (n2.children !== n1.children) { + hostSetText(el, n2.children); + } + } + }; + const processCommentNode = (n1, n2, container, anchor) => { + if (n1 == null) { + hostInsert((n2.el = hostCreateComment(n2.children || '', container)), // fixed by xxxxxx + container, anchor); + } + else { + // there's no support for dynamic comments + n2.el = n1.el; + } + }; + const mountStaticNode = (n2, container, anchor, isSVG) => { + [n2.el, n2.anchor] = hostInsertStaticContent(n2.children, container, anchor, isSVG); + }; + /** + * Dev / HMR only + */ + const patchStaticNode = (n1, n2, container, isSVG) => { + // static nodes are only patched during dev for HMR + if (n2.children !== n1.children) { + const anchor = hostNextSibling(n1.anchor); + // remove existing + removeStaticNode(n1); + [n2.el, n2.anchor] = hostInsertStaticContent(n2.children, container, anchor, isSVG); + } + else { + n2.el = n1.el; + n2.anchor = n1.anchor; + } + }; + const moveStaticNode = ({ el, anchor }, container, nextSibling) => { + let next; + while (el && el !== anchor) { + next = hostNextSibling(el); + hostInsert(el, container, nextSibling); + el = next; + } + hostInsert(anchor, container, nextSibling); + }; + const removeStaticNode = ({ el, anchor }) => { + let next; + while (el && el !== anchor) { + next = hostNextSibling(el); + hostRemove(el); + el = next; + } + hostRemove(anchor); + }; + const processElement = (n1, n2, container, anchor, parentComponent, parentSuspense, isSVG, slotScopeIds, optimized) => { + isSVG = isSVG || n2.type === 'svg'; + if (n1 == null) { + mountElement(n2, container, anchor, parentComponent, parentSuspense, isSVG, slotScopeIds, optimized); + } + else { + patchElement(n1, n2, parentComponent, parentSuspense, isSVG, slotScopeIds, optimized); + } + }; + const mountElement = (vnode, container, anchor, parentComponent, parentSuspense, isSVG, slotScopeIds, optimized) => { + let el; + let vnodeHook; + const { type, props, shapeFlag, transition, patchFlag, dirs } = vnode; + if (!(process.env.NODE_ENV !== 'production') && + vnode.el && + hostCloneNode !== undefined && + patchFlag === -1 /* HOISTED */) { + // If a vnode has non-null el, it means it's being reused. + // Only static vnodes can be reused, so its mounted DOM nodes should be + // exactly the same, and we can simply do a clone here. + // only do this in production since cloned trees cannot be HMR updated. + el = vnode.el = hostCloneNode(vnode.el); + } + else { + el = vnode.el = hostCreateElement( + // fixed by xxxxxx + vnode.type, container); + // mount children first, since some props may rely on child content + // being already rendered, e.g. `