diff --git a/package.json b/package.json index 96687dba447b503de64bd14d51109383c5418175..e20de23264ba88133189b0411e7f18548e7eaadd 100644 --- a/package.json +++ b/package.json @@ -50,6 +50,7 @@ "@types/puppeteer": "^5.4.2", "@typescript-eslint/parser": "^4.12.0", "@vitejs/plugin-vue": "^1.0.4", + "@vitejs/plugin-vue-jsx": "^1.1.2", "@vue/compiler-sfc": "^3.0.5", "eslint": "^7.17.0", "fs-extra": "^9.0.1", @@ -68,7 +69,7 @@ "size-limit": "^4.10.1", "ts-jest": "^26.4.4", "typescript": "~4.1.3", - "vite": "^2.1.1", + "vite": "^2.1.2", "vue": "3.0.7", "yorkie": "^2.0.0" } diff --git a/packages/global.d.ts b/packages/global.d.ts index a683e58f53c02b757968a8631a22a58709c0676d..c1cbf8e6a6e2af19fb43fa224c8741d0a939350c 100644 --- a/packages/global.d.ts +++ b/packages/global.d.ts @@ -23,12 +23,17 @@ declare var __VUE_OPTIONS_API__: boolean declare var __UNI_FEATURE_WX__: boolean declare var __UNI_FEATURE_WXS__: boolean declare var __UNI_FEATURE_PROMISE__: boolean +declare var __UNI_FEATURE_LONGPRESS__: boolean declare var __UNI_FEATURE_ROUTER_MODE__: 'hash' | 'history' declare var __UNI_FEATURE_PAGES__: boolean declare var __UNI_FEATURE_TABBAR__: boolean +declare var __UNI_FEATURE_TOPWINDOW__: boolean +declare var __UNI_FEATURE_LEFTWINDOW__: boolean +declare var __UNI_FEATURE_RIGHTWINDOW__: boolean +declare var __UNI_FEATURE_RESPONSIVE__: boolean // TODO declare var __uniRoutes: any -declare var __uniConfig: any +declare var __uniConfig: UniApp.UniConfig declare var UniViewJSBridge: any declare var UniServiceJSBridge: any diff --git a/packages/shims-uni-app.d.ts b/packages/shims-uni-app.d.ts new file mode 100644 index 0000000000000000000000000000000000000000..2bbfd7622c2a048a608204f99da4e187b2d43e0c --- /dev/null +++ b/packages/shims-uni-app.d.ts @@ -0,0 +1,35 @@ +declare namespace UniApp { + interface LayoutWindowOptions { + matchMedia?: { + minWidth?: number + } + style?: Record + } + + interface UniConfig { + router: { + strict: boolean + } + topWindow?: LayoutWindowOptions + leftWindow?: LayoutWindowOptions + rightWindow?: LayoutWindowOptions + } + interface PagesJsonPageOptions { + path: string + style?: Record + } + interface PagesJsonSubpackagesOptions { + root: string + pages: PagesJsonPageOptions[] + } + + interface PagesJson { + pages: PagesJsonPageOptions[] + subpackages?: PagesJsonSubpackagesOptions[] + subPackages?: PagesJsonSubpackagesOptions[] + globalStyle?: {} + tabBar?: { + list: [] + } + } +} diff --git a/packages/uni-core/src/helpers/getRealRoute.ts b/packages/uni-core/src/helpers/getRealRoute.ts new file mode 100644 index 0000000000000000000000000000000000000000..1caf63444e5a99b2ec50f69be5031f7d9701331b --- /dev/null +++ b/packages/uni-core/src/helpers/getRealRoute.ts @@ -0,0 +1,32 @@ +export function getRealRoute(fromRoute: string, toRoute: string): string { + if (!toRoute) { + toRoute = fromRoute + if (toRoute.indexOf('/') === 0) { + return toRoute + } + const pages = getCurrentPages() + if (pages.length) { + fromRoute = (pages[pages.length - 1] as any).$page.route + } else { + fromRoute = '' + } + } else { + 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('/') +} diff --git a/packages/uni-core/src/helpers/index.ts b/packages/uni-core/src/helpers/index.ts new file mode 100644 index 0000000000000000000000000000000000000000..1d56a83f171c2981e3c84eee07c17ed53ff46414 --- /dev/null +++ b/packages/uni-core/src/helpers/index.ts @@ -0,0 +1,2 @@ +export * from './util' +export * from './getRealRoute' diff --git a/packages/uni-core/src/helpers/util.ts b/packages/uni-core/src/helpers/util.ts new file mode 100644 index 0000000000000000000000000000000000000000..2d1296fcb25e074a1ab24b2311279395860a515f --- /dev/null +++ b/packages/uni-core/src/helpers/util.ts @@ -0,0 +1,3 @@ +export function PolySymbol(name: string) { + return Symbol(__DEV__ ? '[uni-app]: ' + name : name) +} diff --git a/packages/uni-core/src/index.ts b/packages/uni-core/src/index.ts index 133cd53c341668a0223956c7cf9677297a2ba858..bf4b07117b7e8c4b48962096d66d8d55a851b8df 100644 --- a/packages/uni-core/src/index.ts +++ b/packages/uni-core/src/index.ts @@ -1,2 +1,3 @@ export * from './view' export * from './service' +export * from './helpers' diff --git a/packages/uni-core/src/view/plugin/index.ts b/packages/uni-core/src/view/plugin/index.ts index f71bd3d71d0e427c0cb9ab01c4ce4cd5b9c60539..28648d5cce29a5ce41606e0b5577f57c13ea5937 100644 --- a/packages/uni-core/src/view/plugin/index.ts +++ b/packages/uni-core/src/view/plugin/index.ts @@ -4,7 +4,9 @@ import { initLongPress } from './longPress' import { initAppConfig } from './appConfig' export function initView(app: App) { - initLongPress() + if (__UNI_FEATURE_LONGPRESS__) { + initLongPress() + } initAppConfig(app._context.config) // TODO wxs,behaviors } diff --git a/packages/uni-h5/dist/assets/index-71933e8d.css b/packages/uni-h5/dist/assets/index-71933e8d.css new file mode 100644 index 0000000000000000000000000000000000000000..d318ea466cdee171ca4d7e4174b8ee23217821cc --- /dev/null +++ b/packages/uni-h5/dist/assets/index-71933e8d.css @@ -0,0 +1,1369 @@ + +uni-page-head { + display: block; + box-sizing: border-box; +} +uni-page-head .uni-page-head { + position: fixed; + left: var(--window-left); + right: var(--window-right); + height: 44px; + height: calc(44px + constant(safe-area-inset-top)); + height: calc(44px + env(safe-area-inset-top)); + padding: 7px 3px; + padding-top: calc(7px + constant(safe-area-inset-top)); + padding-top: calc(7px + env(safe-area-inset-top)); + display: flex; + overflow: hidden; + justify-content: space-between; + box-sizing: border-box; + z-index: 998; + color: #fff; + background-color: #000; + transition-property: all; +} +uni-page-head .uni-page-head-titlePenetrate, +uni-page-head .uni-page-head-titlePenetrate .uni-page-head-bd, +uni-page-head .uni-page-head-titlePenetrate .uni-page-head-bd * { + pointer-events: none; +} +uni-page-head .uni-page-head-titlePenetrate * { + pointer-events: auto; +} +uni-page-head .uni-page-head.uni-page-head-transparent .uni-page-head-ft > div { + justify-content: center; +} +uni-page-head .uni-page-head ~ .uni-placeholder { + width: 100%; + height: 44px; + height: calc(44px + constant(safe-area-inset-top)); + height: calc(44px + env(safe-area-inset-top)); +} +uni-page-head .uni-placeholder-titlePenetrate { + pointer-events: none; +} +uni-page-head .uni-page-head * { + box-sizing: border-box; +} +uni-page-head .uni-page-head-hd { + display: flex; + align-items: center; + font-size: 16px; +} +uni-page-head .uni-page-head-bd { + position: absolute; + left: 70px; + right: 70px; + min-width: 0; + user-select: auto; +} +.uni-page-head-btn { + position: relative; + width: auto; + margin: 0 2px; + word-break: keep-all; + white-space: pre; + cursor: pointer; +} +.uni-page-head-transparent .uni-page-head-btn { + display: flex; + align-items: center; + width: 32px; + height: 32px; + border-radius: 50%; + background-color: rgba(0, 0, 0, 0.5); +} +uni-page-head .uni-btn-icon { + overflow: hidden; + min-width: 1em; +} +.uni-page-head-btn-red-dot::after { + content: attr(badge-text); + position: absolute; + right: 0; + top: 0; + background-color: red; + color: white; + width: 18px; + height: 18px; + line-height: 18px; + border-radius: 18px; + overflow: hidden; + transform: scale(0.5) translate(40%, -40%); + transform-origin: 100% 0; +} +.uni-page-head-btn-red-dot[badge-text]::after { + font-size: 12px; + width: auto; + min-width: 18px; + max-width: 42px; + text-align: center; + padding: 0 3px; + transform: scale(0.7) translate(40%, -40%); +} +.uni-page-head-btn-select > .uni-btn-icon::after { + display: inline-block; + font-family: 'unibtn'; + content: '\e601'; + margin-left: 2px; + transform: rotate(-90deg) scale(0.8); +} +.uni-page-head-search { + position: relative; + display: flex; + flex: 1; + margin: 0 2px; + line-height: 30px; + font-size: 15px; +} +.uni-page-head-search-input { + width: 100%; + height: 100%; + padding-left: 34px; + text-align: left; +} +.uni-page-head-search-placeholder { + position: absolute; + max-width: 100%; + height: 100%; + padding-left: 34px; + overflow: hidden; + word-break: keep-all; + white-space: pre; +} +.uni-page-head-search-placeholder-right { + right: 0; +} +.uni-page-head-search-placeholder-center { + left: 50%; + transform: translateX(-50%); +} +.uni-page-head-search-placeholder::before { + position: absolute; + top: 0; + left: 2px; + width: 30px; + content: '\ea0e'; + display: block; + font-size: 20px; + font-family: 'uni'; + text-align: center; +} +uni-page-head .uni-page-head-ft { + display: flex; + align-items: center; + flex-direction: row-reverse; + font-size: 13px; +} +uni-page-head .uni-page-head__title { + font-weight: bold; + font-size: 16px; + line-height: 30px; + text-align: center; + overflow: hidden; + white-space: nowrap; + text-overflow: ellipsis; +} +uni-page-head .uni-page-head__title .uni-loading { + width: 16px; + height: 16px; + margin-top: -3px; +} +uni-page-head .uni-page-head__title .uni-page-head__title_image { + width: auto; + height: 26px; + vertical-align: middle; +} +uni-page-head .uni-page-head-shadow { + overflow: visible; +} +uni-page-head .uni-page-head-shadow::after { + content: ''; + position: absolute; + left: 0; + right: 0; + top: 100%; + height: 5px; + background-size: 100% 100%; +} +uni-page-head .uni-page-head-shadow-grey::after { + background-image: url('https://cdn.dcloud.net.cn/img/shadow-grey.png'); +} +uni-page-head .uni-page-head-shadow-blue::after { + background-image: url('https://cdn.dcloud.net.cn/img/shadow-blue.png'); +} +uni-page-head .uni-page-head-shadow-green::after { + background-image: url('https://cdn.dcloud.net.cn/img/shadow-green.png'); +} +uni-page-head .uni-page-head-shadow-orange::after { + background-image: url('https://cdn.dcloud.net.cn/img/shadow-orange.png'); +} +uni-page-head .uni-page-head-shadow-red::after { + background-image: url('https://cdn.dcloud.net.cn/img/shadow-red.png'); +} +uni-page-head .uni-page-head-shadow-yellow::after { + background-image: url('https://cdn.dcloud.net.cn/img/shadow-yellow.png'); +} + +uni-page-wrapper { + display: block; + height: 100%; + position: relative; +} +uni-page-head[uni-page-head-type='default'] ~ uni-page-wrapper { + height: calc(100% - 44px); + height: calc(100% - 44px - constant(safe-area-inset-top)); + height: calc(100% - 44px - env(safe-area-inset-top)); +} +uni-page-body { + display: block; + box-sizing: border-box; + width: 100%; +} + +uni-page-refresh { + position: absolute; + top: 0; + width: 100%; + height: 40px; + display: block; + box-sizing: border-box; +} +uni-page-refresh .uni-page-refresh { + position: absolute; + top: -45px; + left: 50%; + transform: translate3d(-50%, 0, 0); + width: 40px; + height: 40px; + justify-content: center; + align-items: center; + background: #fff; + border-radius: 50%; + box-shadow: 0 1px 6px rgba(0, 0, 0, .117647), 0 1px 4px rgba(0, 0, 0, .117647); + display: none; + z-index: 997; +} +uni-page-refresh .uni-page-refresh-inner { + display: flex; + align-items: center; + justify-content: center; + line-height: 0; + width: 40px; + height: 40px; + border-radius: 50%; +} +uni-page-refresh.uni-page-refresh--pulling .uni-page-refresh, + uni-page-refresh.uni-page-refresh--aborting .uni-page-refresh, + uni-page-refresh.uni-page-refresh--reached .uni-page-refresh, + uni-page-refresh.uni-page-refresh--refreshing .uni-page-refresh, + uni-page-refresh.uni-page-refresh--restoring .uni-page-refresh { + display: flex; +} +uni-page-refresh.uni-page-refresh--pulling .uni-page-refresh__spinner, + uni-page-refresh.uni-page-refresh--aborting .uni-page-refresh__spinner, + uni-page-refresh.uni-page-refresh--reached .uni-page-refresh__spinner, + uni-page-refresh.uni-page-refresh--refreshing .uni-page-refresh__icon, + uni-page-refresh.uni-page-refresh--restoring .uni-page-refresh__icon { + display: none; +} +uni-page-refresh.uni-page-refresh--refreshing .uni-page-refresh__spinner { + transform-origin: center center; + animation: uni-page-refresh-rotate 2s linear infinite; +} +uni-page-refresh.uni-page-refresh--refreshing .uni-page-refresh__path { + stroke-dasharray: 1, 200; + stroke-dashoffset: 0; + stroke-linecap: round; + animation: uni-page-refresh-dash 1.5s ease-in-out infinite, uni-page-refresh-colorful 6s ease-in-out infinite; +} +@keyframes uni-page-refresh-rotate { +100% { + -webkit-transform: rotate(360deg); + transform: rotate(360deg); +} +} +@keyframes uni-page-refresh-dash { +0% { + stroke-dasharray: 1, 200; + stroke-dashoffset: 0; +} +50% { + stroke-dasharray: 89, 200; + stroke-dashoffset: -35px; +} +100% { + stroke-dasharray: 89, 200; + stroke-dashoffset: -124px; +} +} + +uni-page { + display: block; + width: 100%; + height: 100%; +} + +.uni-async-error { + position: absolute; + left: 0; + right: 0; + top: 0; + bottom: 0; + color: #999; + padding: 100px 10px; + text-align: center; +} + +.uni-async-loading { + box-sizing: border-box; + width: 100%; + padding: 50px; + text-align: center; +} +.uni-async-loading .uni-loading { + width: 30px; + height: 30px; +} + +uni-canvas { + width: 300px; + height: 150px; + display: block; + position: relative; +} +uni-canvas > canvas { + position: absolute; + top: 0; + left: 0; + width: 100%; + height: 100%; +} + +uni-checkbox-group[hidden] { + display: none; +} +.ql-container { + display: block; + position: relative; + box-sizing: border-box; + -webkit-user-select: text; + user-select: text; + outline: none; + overflow: hidden; + width: 100%; + height: 200px; + min-height: 200px; +} +.ql-container[hidden] { + display: none; +} +.ql-container .ql-editor { + position: relative; + font-size: inherit; + line-height: inherit; + font-family: inherit; + min-height: inherit; + width: 100%; + height: 100%; + padding: 0; + overflow-x: hidden; + overflow-y: auto; + -webkit-tap-highlight-color: transparent; + -webkit-touch-callout: none; + -webkit-overflow-scrolling: touch; +} +.ql-container .ql-editor::-webkit-scrollbar { + width: 0 !important; +} +.ql-container .ql-editor.scroll-disabled { + overflow: hidden; +} +.ql-container .ql-image-overlay { + display: flex; + position: absolute; + box-sizing: border-box; + border: 1px dashed #ccc; + justify-content: center; + align-items: center; + -webkit-user-select: none; + user-select: none; +} +.ql-container .ql-image-overlay .ql-image-size { + position: absolute; + padding: 4px 8px; + text-align: center; + background-color: #fff; + color: #888; + border: 1px solid #ccc; + box-sizing: border-box; + opacity: 0.8; + right: 4px; + top: 4px; + font-size: 12px; + display: inline-block; + width: auto; +} +.ql-container .ql-image-overlay .ql-image-toolbar { + position: relative; + text-align: center; + box-sizing: border-box; + background: #000; + border-radius: 5px; + color: #fff; + font-size: 0; + min-height: 24px; + z-index: 100; +} +.ql-container .ql-image-overlay .ql-image-toolbar span { + display: inline-block; + cursor: pointer; + padding: 5px; + font-size: 12px; + border-right: 1px solid #fff; +} +.ql-container .ql-image-overlay .ql-image-toolbar span:last-child { + border-right: 0; +} +.ql-container .ql-image-overlay .ql-image-toolbar span.triangle-up { + padding: 0; + position: absolute; + top: -12px; + left: 50%; + transform: translatex(-50%); + width: 0; + height: 0; + border-width: 6px; + border-style: solid; + border-color: transparent transparent black transparent; +} +.ql-container .ql-image-overlay .ql-image-handle { + position: absolute; + height: 12px; + width: 12px; + border-radius: 50%; + border: 1px solid #ccc; + box-sizing: border-box; + background: #fff; +} +.ql-container img { + display: inline-block; + max-width: 100%; +} +.ql-clipboard p { + margin: 0; + padding: 0; +} +.ql-editor { + box-sizing: border-box; + height: 100%; + outline: none; + overflow-y: auto; + tab-size: 4; + -moz-tab-size: 4; + text-align: left; + white-space: pre-wrap; + word-wrap: break-word; +} +.ql-editor > * { + cursor: text; +} +.ql-editor p, +.ql-editor ol, +.ql-editor ul, +.ql-editor pre, +.ql-editor blockquote, +.ql-editor h1, +.ql-editor h2, +.ql-editor h3, +.ql-editor h4, +.ql-editor h5, +.ql-editor h6 { + margin: 0; + padding: 0; + counter-reset: list-1 list-2 list-3 list-4 list-5 list-6 list-7 list-8 list-9; +} +.ql-editor ol > li, +.ql-editor ul > li { + list-style-type: none; +} +.ql-editor ul > li::before { + content: '\2022'; +} +.ql-editor ul[data-checked=true], +.ql-editor ul[data-checked=false] { + pointer-events: none; +} +.ql-editor ul[data-checked=true] > li *, +.ql-editor ul[data-checked=false] > li * { + pointer-events: all; +} +.ql-editor ul[data-checked=true] > li::before, +.ql-editor ul[data-checked=false] > li::before { + color: #777; + cursor: pointer; + pointer-events: all; +} +.ql-editor ul[data-checked=true] > li::before { + content: '\2611'; +} +.ql-editor ul[data-checked=false] > li::before { + content: '\2610'; +} +.ql-editor li::before { + display: inline-block; + white-space: nowrap; + width: 2em; +} +.ql-editor ol li { + counter-reset: list-1 list-2 list-3 list-4 list-5 list-6 list-7 list-8 list-9; + counter-increment: list-0; +} +.ql-editor ol li:before { + content: counter(list-0, decimal) '. '; +} +.ql-editor ol li.ql-indent-1 { + counter-increment: list-1; +} +.ql-editor ol li.ql-indent-1:before { + content: counter(list-1, lower-alpha) '. '; +} +.ql-editor ol li.ql-indent-1 { + counter-reset: list-2 list-3 list-4 list-5 list-6 list-7 list-8 list-9; +} +.ql-editor ol li.ql-indent-2 { + counter-increment: list-2; +} +.ql-editor ol li.ql-indent-2:before { + content: counter(list-2, lower-roman) '. '; +} +.ql-editor ol li.ql-indent-2 { + counter-reset: list-3 list-4 list-5 list-6 list-7 list-8 list-9; +} +.ql-editor ol li.ql-indent-3 { + counter-increment: list-3; +} +.ql-editor ol li.ql-indent-3:before { + content: counter(list-3, decimal) '. '; +} +.ql-editor ol li.ql-indent-3 { + counter-reset: list-4 list-5 list-6 list-7 list-8 list-9; +} +.ql-editor ol li.ql-indent-4 { + counter-increment: list-4; +} +.ql-editor ol li.ql-indent-4:before { + content: counter(list-4, lower-alpha) '. '; +} +.ql-editor ol li.ql-indent-4 { + counter-reset: list-5 list-6 list-7 list-8 list-9; +} +.ql-editor ol li.ql-indent-5 { + counter-increment: list-5; +} +.ql-editor ol li.ql-indent-5:before { + content: counter(list-5, lower-roman) '. '; +} +.ql-editor ol li.ql-indent-5 { + counter-reset: list-6 list-7 list-8 list-9; +} +.ql-editor ol li.ql-indent-6 { + counter-increment: list-6; +} +.ql-editor ol li.ql-indent-6:before { + content: counter(list-6, decimal) '. '; +} +.ql-editor ol li.ql-indent-6 { + counter-reset: list-7 list-8 list-9; +} +.ql-editor ol li.ql-indent-7 { + counter-increment: list-7; +} +.ql-editor ol li.ql-indent-7:before { + content: counter(list-7, lower-alpha) '. '; +} +.ql-editor ol li.ql-indent-7 { + counter-reset: list-8 list-9; +} +.ql-editor ol li.ql-indent-8 { + counter-increment: list-8; +} +.ql-editor ol li.ql-indent-8:before { + content: counter(list-8, lower-roman) '. '; +} +.ql-editor ol li.ql-indent-8 { + counter-reset: list-9; +} +.ql-editor ol li.ql-indent-9 { + counter-increment: list-9; +} +.ql-editor ol li.ql-indent-9:before { + content: counter(list-9, decimal) '. '; +} +.ql-editor .ql-indent-1:not(.ql-direction-rtl) { + padding-left: 2em; +} +.ql-editor li.ql-indent-1:not(.ql-direction-rtl) { + padding-left: 2em; +} +.ql-editor .ql-indent-1.ql-direction-rtl.ql-align-right { + padding-right: 2em; +} +.ql-editor li.ql-indent-1.ql-direction-rtl.ql-align-right { + padding-right: 2em; +} +.ql-editor .ql-indent-2:not(.ql-direction-rtl) { + padding-left: 4em; +} +.ql-editor li.ql-indent-2:not(.ql-direction-rtl) { + padding-left: 4em; +} +.ql-editor .ql-indent-2.ql-direction-rtl.ql-align-right { + padding-right: 4em; +} +.ql-editor li.ql-indent-2.ql-direction-rtl.ql-align-right { + padding-right: 4em; +} +.ql-editor .ql-indent-3:not(.ql-direction-rtl) { + padding-left: 6em; +} +.ql-editor li.ql-indent-3:not(.ql-direction-rtl) { + padding-left: 6em; +} +.ql-editor .ql-indent-3.ql-direction-rtl.ql-align-right { + padding-right: 6em; +} +.ql-editor li.ql-indent-3.ql-direction-rtl.ql-align-right { + padding-right: 6em; +} +.ql-editor .ql-indent-4:not(.ql-direction-rtl) { + padding-left: 8em; +} +.ql-editor li.ql-indent-4:not(.ql-direction-rtl) { + padding-left: 8em; +} +.ql-editor .ql-indent-4.ql-direction-rtl.ql-align-right { + padding-right: 8em; +} +.ql-editor li.ql-indent-4.ql-direction-rtl.ql-align-right { + padding-right: 8em; +} +.ql-editor .ql-indent-5:not(.ql-direction-rtl) { + padding-left: 10em; +} +.ql-editor li.ql-indent-5:not(.ql-direction-rtl) { + padding-left: 10em; +} +.ql-editor .ql-indent-5.ql-direction-rtl.ql-align-right { + padding-right: 10em; +} +.ql-editor li.ql-indent-5.ql-direction-rtl.ql-align-right { + padding-right: 10em; +} +.ql-editor .ql-indent-6:not(.ql-direction-rtl) { + padding-left: 12em; +} +.ql-editor li.ql-indent-6:not(.ql-direction-rtl) { + padding-left: 12em; +} +.ql-editor .ql-indent-6.ql-direction-rtl.ql-align-right { + padding-right: 12em; +} +.ql-editor li.ql-indent-6.ql-direction-rtl.ql-align-right { + padding-right: 12em; +} +.ql-editor .ql-indent-7:not(.ql-direction-rtl) { + padding-left: 14em; +} +.ql-editor li.ql-indent-7:not(.ql-direction-rtl) { + padding-left: 14em; +} +.ql-editor .ql-indent-7.ql-direction-rtl.ql-align-right { + padding-right: 14em; +} +.ql-editor li.ql-indent-7.ql-direction-rtl.ql-align-right { + padding-right: 14em; +} +.ql-editor .ql-indent-8:not(.ql-direction-rtl) { + padding-left: 16em; +} +.ql-editor li.ql-indent-8:not(.ql-direction-rtl) { + padding-left: 16em; +} +.ql-editor .ql-indent-8.ql-direction-rtl.ql-align-right { + padding-right: 16em; +} +.ql-editor li.ql-indent-8.ql-direction-rtl.ql-align-right { + padding-right: 16em; +} +.ql-editor .ql-indent-9:not(.ql-direction-rtl) { + padding-left: 18em; +} +.ql-editor li.ql-indent-9:not(.ql-direction-rtl) { + padding-left: 18em; +} +.ql-editor .ql-indent-9.ql-direction-rtl.ql-align-right { + padding-right: 18em; +} +.ql-editor li.ql-indent-9.ql-direction-rtl.ql-align-right { + padding-right: 18em; +} +.ql-editor .ql-direction-rtl { + direction: rtl; + text-align: inherit; +} +.ql-editor .ql-align-center { + text-align: center; +} +.ql-editor .ql-align-justify { + text-align: justify; +} +.ql-editor .ql-align-right { + text-align: right; +} +.ql-editor.ql-blank::before { + color: rgba(0, 0, 0, 0.6); + content: attr(data-placeholder); + font-style: italic; + pointer-events: none; + position: absolute; +} +.ql-container.ql-disabled .ql-editor ul[data-checked] > li::before { + pointer-events: none; +} +.ql-clipboard { + left: -100000px; + height: 1px; + overflow-y: hidden; + position: absolute; + top: 50%; +} + + + +uni-icon { + display: inline-block; + font-size: 0; + box-sizing: border-box; +} +uni-icon[hidden] { + display: none; +} +uni-icon > i { + font: normal normal normal 14px/1 'weui'; +} +uni-icon > i:before { + margin: 0; + box-sizing: border-box; +} +@font-face { + font-weight: normal; + font-style: normal; + font-family: 'weui'; + src: url('data:application/octet-stream;base64,AAEAAAALAIAAAwAwR1NVQrD+s+0AAAE4AAAAQk9TLzJAKEx8AAABfAAAAFZjbWFw65cFHQAAAhwAAAJQZ2x5Zp+UEEcAAASUAAAIvGhlYWQUqc7xAAAA4AAAADZoaGVhB/YD+wAAALwAAAAkaG10eEJoAAAAAAHUAAAASGxvY2EUxhJeAAAEbAAAACZtYXhwASEAQwAAARgAAAAgbmFtZeNcHtgAAA1QAAAB5nBvc3T6OoZLAAAPOAAAAOYAAQAAA+gAAABaA+gAAAAAA7MAAQAAAAAAAAAAAAAAAAAAABIAAQAAAAEAAMCU2KdfDzz1AAsD6AAAAADY7EUUAAAAANjsRRQAAAAAA7MD5AAAAAgAAgAAAAAAAAABAAAAEgA3AAUAAAAAAAIAAAAKAAoAAAD/AAAAAAAAAAEAAAAKAB4ALAABREZMVAAIAAQAAAAAAAAAAQAAAAFsaWdhAAgAAAABAAAAAQAEAAQAAAABAAgAAQAGAAAAAQAAAAAAAQOwAZAABQAIAnoCvAAAAIwCegK8AAAB4AAxAQIAAAIABQMAAAAAAAAAAAAAAAAAAAAAAAAAAAAAUGZFZABA6gHqEQPoAAAAWgPoAAAAAAABAAAAAAAAAAAAAAPoAAAD6AAAA+gAAAPoAAAD6AAAA+gAAAPoAAAD6AAAA+gAAAPoAAAD6AAAA+gAAAPoAAAD6AAAA+gAAAPoAAAD6AAAAAAABQAAAAMAAAAsAAAABAAAAXQAAQAAAAAAbgADAAEAAAAsAAMACgAAAXQABABCAAAABAAEAAEAAOoR//8AAOoB//8AAAABAAQAAAABAAIAAwAEAAUABgAHAAgACQAKAAsADAANAA4ADwAQABEAAAEGAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAwAAAAAANwAAAAAAAAAEQAA6gEAAOoBAAAAAQAA6gIAAOoCAAAAAgAA6gMAAOoDAAAAAwAA6gQAAOoEAAAABAAA6gUAAOoFAAAABQAA6gYAAOoGAAAABgAA6gcAAOoHAAAABwAA6ggAAOoIAAAACAAA6gkAAOoJAAAACQAA6goAAOoKAAAACgAA6gsAAOoLAAAACwAA6gwAAOoMAAAADAAA6g0AAOoNAAAADQAA6g4AAOoOAAAADgAA6g8AAOoPAAAADwAA6hAAAOoQAAAAEAAA6hEAAOoRAAAAEQAAAAAARACKAMQBEgFgAZIB4gH6AioCeAK0AwwDZAOiA9wEEAReAAAAAgAAAAADlQOVABQAKQAAJSInJicmNDc2NzYyFxYXFhQHBgcGJzI3Njc2NCcmJyYiBwYHBhQXFhcWAfRxYV83OTk3X2HiYV83OTk3X2FxZFVTMTIyMVNVyFVTMTIyMVNVUzk3X2HiYV83OTk3X2HiYV83OTIyMVNVyFVTMTIyMVNVyFVTMTIAAAIAAAAAA7MDswAXAC0AAAEiBwYHBhUUFxYXFjMyNzY3NjU0JyYnJhMHBiIvASY2OwERNDY7ATIWFREzMhYB7nZnZDs9PTtkZ3Z8amY7Pj47Zmkhdg4oDnYODRddCwcmBwtdFw0Dsz47Zmp8dmdkOz09O2Rndn1pZjs+/fCaEhKaEhoBFwgLCwj+6RoAAwAAAAADlQOVABQAGAAhAAAlIicmJyY0NzY3NjIXFhcWFAcGBwYDETMRJzI2NCYiBhQWAfRxYV83OTk3X2HiYV83OTk3X2GQPh8RGRkiGRlTOTdfYeJhXzc5OTdfYeJhXzc5AfT+3QEjKhgjGBgjGAAAAAACAAAAAAOxA+QAFwAsAAABBgcGDwERFBcWFxYXNjc2NzY1EScmJyYTAQYvASY/ATYyHwEWNjclNjIfARYB9WlsP3A3Rz5sXmxsXW09SDdwQGuP/tUEBIoDAxIBBQFxAQUCARICBQERBAPjFyASJBL+rI51ZUg/HBw/SGV1jgFUEiQSIP66/tkDA48EBBkCAVYCAQHlAQIQBAAAAAADAAAAAAOxA+QAFwAmAC8AAAEGBwYPAREUFxYXFhc2NzY3NjURJyYnJgczMhYVAxQGKwEiJwM0NhMiJjQ2MhYUBgH1aWtAcDdHPmxebGxdbT1IN3BAa4M0BAYMAwImBQELBh4PFhYeFRUD5BggEiQS/q2PdWRJPh0dPklkdY8BUxIkEiD4BgT+xgIDBQE6BAb+QBUfFRUfFQAAAAACAAAAAAOVA5UAFAAaAAAlIicmJyY0NzY3NjIXFhcWFAcGBwYDJwcXAScB9HFhXzc5OTdfYeJhXzc5OTdfYaJzLJ8BFi1TOTdfYeJhXzc5OTdfYeJhXzc5AUhzLJ8BFSwAAAAAAwAAAAADlQOVABQAKQAvAAAlIicmJyY0NzY3NjIXFhcWFAcGBwYnMjc2NzY0JyYnJiIHBgcGFBcWFxYTNxcBJzcB9HFhXzc5OTdfYeJhXzc5OTdfYXFkVVMxMjIxU1XIVVMxMjIxU1Uz8iT+6p8jUzk3X2HiYV83OTk3X2HiYV83OTIyMVNVyFVTMTIyMVNVyFVTMTIBBPIj/uufJAAAAAEAAAAAA5kDGAAHAAAlATcXARcBBgGF/vg7zgHYOv3vAcsBCTvPAdg7/e4BAAAAAAIAAAAAA5UDlQAFABoAAAE1IxUXNwMiJyYnJjQ3Njc2MhcWFxYUBwYHBgITPrEsvnFhXzc5OTdfYeJhXzc5OTdfYQIO4PqxLP7kOTdfYeJhXzc5OTdfYeJhXzc5AAAAAAMAAAAAA5UDlQAFABoALwAAARcHJzUzAyInJicmNDc2NzYyFxYXFhQHBgcGJzI3Njc2NCcmJyYiBwYHBhQXFhcWAg2iI7EyGXFhXzc5OTdfYeJhXzc5OTdfYXFkVVMxMjIxU1XIVVMxMjIxU1UCCaIksfr9ZTk3X2HiYV83OTk3X2HiYV83OTIyMVNVyFVTMTIyMVNVyFVTMTIAAAMAAAAAA5UDlQAUABgAIQAAJSInJicmNDc2NzYyFxYXFhQHBgcGAxMzEwMyNjQmIg4BFgH0cWFfNzk5N19h4mFfNzk5N19hkQU2BSAQFRUgFQEWUzk3X2HiYV83OTk3X2HiYV83OQKV/sQBPP43Fh8VFR8WAAAAAAQAAAAAA5UDlQAUACkALQA2AAAlIicmJyY0NzY3NjIXFhcWFAcGBwYnMjc2NzY0JyYnJiIHBgcGFBcWFxYTMxEjEyImNDYyFhQGAfRxYV83OTk3X2HiYV83OTk3X2FxZFVTMTIyMVNVyFVTMTIyMVNVSzIyGREZGSIZGVM5N19h4mFfNzk5N19h4mFfNzkyMjFTVchVUzEyMjFTVchVUzEyAcL+3QFNGCMYGCMYAAAAAwAAAAADlQOVABQAKQA1AAAlIicmJyY0NzY3NjIXFhcWFAcGBwYnMjc2NzY0JyYnJiIHBgcGFBcWFxYTFwcnByc3JzcXNxcB9HFhXzc5OTdfYeJhXzc5OTdfYXFkVVMxMjIxU1XIVVMxMjIxU1WHgiOCgiOCgiOCgiNTOTdfYeJhXzc5OTdfYeJhXzc5MjIxU1XIVVMxMjIxU1XIVVMxMgFvgiOCgiOCgiOCgiMAAAACAAAAAANUA0IAGAAlAAABFwcnDgEjIicmJyY0NzY3NjIXFhcWFRQGJzQuASIOARQeATI+AQKoqyOsJ180T0RCJycnJ0JEn0RCJiglDUFvg29BQW+Db0EBYKwjrCAjKCZCRJ9EQicnJydCRE82YZdBb0FBb4NvQUFvAAAAAgAAAAADlQOVAAsAIAAAATcnBycHFwcXNxc3AyInJicmNDc2NzYyFxYXFhQHBgcGAiB9LH19LH19LH19LKlxYV83OTk3X2HiYV83OTk3X2EB9H0sfX0sfX0sfX0s/tw5N19h4mFfNzk5N19h4mFfNzkAAAACAAAAAAOVA5UAFAAcAAAlIicmJyY0NzY3NjIXFhcWFAcGBwYDJzcnBwYfAQH0cWFfNzk5N19h4mFfNzk5N19hHoqKK7UBAbVTOTdfYeJhXzc5OTdfYeJhXzc5ARKPjy27AQG6AAAAAAUAAAAAA1cDbAAJAB0AJwArAC8AAAETHgEzITI2NxMzAw4BIyEiJicDIzU0NjMhMhYdASUyFh0BIzU0NjMHMxMjEzMDIwEaIgETDQEuDRMBIjIiAjAh/tIhMAIiVgwJApoJDP7xCQzQDAkVMhUyiTIVMgLd/cgOEhIOAjj9xSEuLiECOx4IDAwIHo4MCR0dCQz6/okBd/6JAAAAAAAAEADGAAEAAAAAAAEABAAAAAEAAAAAAAIABwAEAAEAAAAAAAMABAALAAEAAAAAAAQABAAPAAEAAAAAAAUACwATAAEAAAAAAAYABAAeAAEAAAAAAAoAKwAiAAEAAAAAAAsAEwBNAAMAAQQJAAEACABgAAMAAQQJAAIADgBoAAMAAQQJAAMACAB2AAMAAQQJAAQACAB+AAMAAQQJAAUAFgCGAAMAAQQJAAYACACcAAMAAQQJAAoAVgCkAAMAAQQJAAsAJgD6d2V1aVJlZ3VsYXJ3ZXVpd2V1aVZlcnNpb24gMS4wd2V1aUdlbmVyYXRlZCBieSBzdmcydHRmIGZyb20gRm9udGVsbG8gcHJvamVjdC5odHRwOi8vZm9udGVsbG8uY29tAHcAZQB1AGkAUgBlAGcAdQBsAGEAcgB3AGUAdQBpAHcAZQB1AGkAVgBlAHIAcwBpAG8AbgAgADEALgAwAHcAZQB1AGkARwBlAG4AZQByAGEAdABlAGQAIABiAHkAIABzAHYAZwAyAHQAdABmACAAZgByAG8AbQAgAEYAbwBuAHQAZQBsAGwAbwAgAHAAcgBvAGoAZQBjAHQALgBoAHQAdABwADoALwAvAGYAbwBuAHQAZQBsAGwAbwAuAGMAbwBtAAAAAgAAAAAAAAAKAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAASAQIBAwEEAQUBBgEHAQgBCQEKAQsBDAENAQ4BDwEQAREBEgETAAZjaXJjbGUIZG93bmxvYWQEaW5mbwxzYWZlLXN1Y2Nlc3MJc2FmZS13YXJuB3N1Y2Nlc3MOc3VjY2Vzcy1jaXJjbGURc3VjY2Vzcy1uby1jaXJjbGUHd2FpdGluZw53YWl0aW5nLWNpcmNsZQR3YXJuC2luZm8tY2lyY2xlBmNhbmNlbAZzZWFyY2gFY2xlYXIEYmFjawZkZWxldGUAAAAA') + format('truetype'); +} +.uni-icon-success:before { + content: '\EA06'; +} +.uni-icon-success_circle:before { + content: '\EA07'; +} +.uni-icon-success_no_circle:before { + content: '\EA08'; +} +.uni-icon-safe_success:before { + content: '\EA04'; +} +.uni-icon-safe_warn:before { + content: '\EA05'; +} +.uni-icon-info:before { + content: '\EA03'; +} +.uni-icon-info_circle:before { + content: '\EA0C'; +} +.uni-icon-warn:before { + content: '\EA0B'; +} +.uni-icon-waiting:before { + content: '\EA09'; +} +.uni-icon-waiting_circle:before { + content: '\EA0A'; +} +.uni-icon-circle:before { + content: '\EA01'; +} +.uni-icon-cancel:before { + content: '\EA0D'; +} +.uni-icon-download:before { + content: '\EA02'; +} +.uni-icon-search:before { + content: '\EA0E'; +} +.uni-icon-clear:before { + content: '\EA0F'; +} +.uni-icon-success { + color: #007aff; +} +.uni-icon-success_circle { + color: #007aff; +} +.uni-icon-success_no_circle { + color: #007aff; +} +.uni-icon-safe_success { + color: #007aff; +} +.uni-icon-safe_warn { + color: #ffbe00; +} +.uni-icon-info { + color: #10aeff; +} +.uni-icon-info_circle { + color: #007aff; +} +.uni-icon-warn { + color: #f76260; +} +.uni-icon-waiting { + color: #10aeff; +} +.uni-icon-waiting_circle { + color: #10aeff; +} +.uni-icon-circle { + color: #c9c9c9; +} +.uni-icon-cancel { + color: #f43530; +} +.uni-icon-download { + color: #007aff; +} +.uni-icon-search { + color: #b2b2b2; +} +.uni-icon-clear { + color: #b2b2b2; +} + +uni-image { + width: 320px; + height: 240px; + display: inline-block; + overflow: hidden; + position: relative; +} +uni-image[hidden] { + display: none; +} +uni-image>div { + width: 100%; + height: 100%; +} +uni-image>img { + -webkit-touch-callout: none; + -webkit-user-select: none; + -moz-user-select: none; + display: block; + position: absolute; + top: 0; + left: 0; + width: 100%; + height: 100%; + opacity: 0; +} +uni-image>.uni-image-will-change { + will-change: transform; +} + +uni-input { + display: block; + font-size: 16px; + line-height: 1.4em; + height: 1.4em; + min-height: 1.4em; + overflow: hidden; +} +uni-input[hidden] { + display: none; +} +.uni-input-wrapper, +.uni-input-placeholder, +.uni-input-form, +.uni-input-input { + outline: none; + border: none; + padding: 0; + margin: 0; + text-decoration: inherit; +} +.uni-input-wrapper, +.uni-input-form { + display: flex; + position: relative; + width: 100%; + height: 100%; + flex-direction: column; + justify-content: center; +} +.uni-input-placeholder, +.uni-input-input { + width: 100%; +} +.uni-input-placeholder { + position: absolute; + top: auto !important; + left: 0; + color: gray; + overflow: hidden; + text-overflow: clip; + white-space: pre; + word-break: keep-all; + pointer-events: none; + line-height: inherit; +} +.uni-input-input { + display: block; + height: 100%; + background: none; + color: inherit; + opacity: 1; + -webkit-text-fill-color: currentcolor; + font: inherit; + line-height: inherit; + letter-spacing: inherit; + text-align: inherit; + text-indent: inherit; + text-transform: inherit; + text-shadow: inherit; +} +.uni-input-input[type="search"]::-webkit-search-cancel-button { + display: none; +} +.uni-input-input::-webkit-outer-spin-button, +.uni-input-input::-webkit-inner-spin-button { + -webkit-appearance: none; + margin: 0; +} +.uni-input-input[type="number"] { + -moz-appearance: textfield; +} + +.uni-label-pointer { + cursor: pointer; +} + +uni-movable-view { + display: inline-block; + width: 10px; + height: 10px; + top: 0px; + left: 0px; + position: absolute; + cursor: grab; +} +uni-movable-view[hidden] { + display: none; +} + +uni-navigator { + height: auto; + width: auto; + display: block; + cursor: pointer; +} +uni-navigator[hidden] { + display: none; +} +.navigator-hover { + background-color: rgba(0, 0, 0, 0.1); + opacity: 0.7; +} + +uni-radio { + -webkit-tap-highlight-color: transparent; + display: inline-block; + cursor: pointer; +} +uni-radio[hidden] { + display: none; +} +uni-radio[disabled] { + cursor: not-allowed; +} +uni-radio .uni-radio-wrapper { + display: -webkit-inline-flex; + display: inline-flex; + -webkit-align-items: center; + align-items: center; + vertical-align: middle; +} +uni-radio .uni-radio-input { + -webkit-appearance: none; + appearance: none; + margin-right: 5px; + outline: 0; + border: 1px solid #D1D1D1; + background-color: #ffffff; + border-radius: 50%; + width: 22px; + height: 22px; + position: relative; +} +uni-radio:not([disabled]) .uni-radio-input:hover { + border-color: #007aff; +} +uni-radio .uni-radio-input.uni-radio-input-checked:before { + font: normal normal normal 14px/1 "uni"; + content: "\EA08"; + color: #ffffff; + font-size: 18px; + position: absolute; + top: 50%; + left: 50%; + transform: translate(-50%, -48%) scale(0.73); + -webkit-transform: translate(-50%, -48%) scale(0.73); +} +uni-radio .uni-radio-input.uni-radio-input-disabled { + background-color: #E1E1E1; + border-color: #D1D1D1; +} +uni-radio .uni-radio-input.uni-radio-input-disabled:before { + color: #ADADAD; +} +uni-radio-group { + display: block; +} + +uni-radio-group[hidden] { + display: none; +} + +@keyframes once-show { +from { + top: 0; +} +} +uni-resize-sensor, +uni-resize-sensor > div { + position: absolute; + left: 0; + top: 0; + right: 0; + bottom: 0; + overflow: hidden; +} +uni-resize-sensor { + display: block; + z-index: -1; + visibility: hidden; + animation: once-show 1ms; +} +uni-resize-sensor > div > div { + position: absolute; + left: 0; + top: 0; +} +uni-resize-sensor > div:first-child > div { + width: 100000px; + height: 100000px; +} +uni-resize-sensor > div:last-child > div { + width: 200%; + height: 200%; +} + +uni-scroll-view { + display: block; + width: 100%; +} +uni-scroll-view[hidden] { + display: none; +} +.uni-scroll-view { + position: relative; + -webkit-overflow-scrolling: touch; + width: 100%; + /* display: flex; 时在安卓下会导致scrollWidth和offsetWidth一样 */ + height: 100%; + max-height: inherit; +} +.uni-scroll-view-content { + width: 100%; + height: 100%; +} +.uni-scroll-view-refresher { + position: relative; + overflow: hidden; +} +.uni-scroll-view-refresh { + position: absolute; + top: 0; + left: 0; + right: 0; + bottom: 0; + display: flex; + flex-direction: row; + justify-content: center; + align-items: center; +} +.uni-scroll-view-refresh-inner { + display: flex; + align-items: center; + justify-content: center; + line-height: 0; + width: 40px; + height: 40px; + border-radius: 50%; + background-color: #fff; + box-shadow: 0 1px 6px rgba(0, 0, 0, 0.117647), + 0 1px 4px rgba(0, 0, 0, 0.117647); +} +.uni-scroll-view-refresh__spinner { + transform-origin: center center; + animation: uni-scroll-view-refresh-rotate 2s linear infinite; +} +.uni-scroll-view-refresh__spinner > circle { + stroke: currentColor; + stroke-linecap: round; + animation: uni-scroll-view-refresh-dash 2s linear infinite; +} +@keyframes uni-scroll-view-refresh-rotate { +0% { + transform: rotate(0deg); +} +100% { + transform: rotate(360deg); +} +} +@keyframes uni-scroll-view-refresh-dash { +0% { + stroke-dasharray: 1, 200; + stroke-dashoffset: 0; +} +50% { + stroke-dasharray: 89, 200; + stroke-dashoffset: -35px; +} +100% { + stroke-dasharray: 89, 200; + stroke-dashoffset: -124px; +} +} + +uni-swiper-item { + display: block; + overflow: hidden; + will-change: transform; + position: absolute; + width: 100%; + height: 100%; + cursor: grab; +} +uni-swiper-item[hidden] { + display: none; +} + +uni-switch { + -webkit-tap-highlight-color: transparent; + display: inline-block; + cursor: pointer; +} +uni-switch[hidden] { + display: none; +} +uni-switch[disabled] { + cursor: not-allowed; +} +uni-switch .uni-switch-wrapper { + display: -webkit-inline-flex; + display: inline-flex; + -webkit-align-items: center; + align-items: center; + vertical-align: middle; +} +uni-switch .uni-switch-input { + -webkit-appearance: none; + appearance: none; + position: relative; + width: 52px; + height: 32px; + margin-right: 5px; + border: 1px solid #DFDFDF; + outline: 0; + border-radius: 16px; + box-sizing: border-box; + background-color: #DFDFDF; + transition: background-color 0.1s, border 0.1s; +} +uni-switch[disabled] .uni-switch-input { + opacity: .7; +} +uni-switch .uni-switch-input:before { + content: " "; + position: absolute; + top: 0; + left: 0; + width: 50px; + height: 30px; + border-radius: 15px; + background-color: #FDFDFD; + transition: -webkit-transform 0.3s; + transition: transform 0.3s; + transition: transform 0.3s, -webkit-transform 0.3s; +} +uni-switch .uni-switch-input:after { + content: " "; + position: absolute; + top: 0; + left: 0; + width: 30px; + height: 30px; + border-radius: 15px; + background-color: #FFFFFF; + box-shadow: 0 1px 3px rgba(0, 0, 0, 0.4); + transition: -webkit-transform 0.3s; + transition: transform 0.3s; + transition: transform 0.3s, -webkit-transform 0.3s; +} +uni-switch .uni-switch-input.uni-switch-input-checked { + border-color: #007aff; + background-color: #007aff; +} +uni-switch .uni-switch-input.uni-switch-input-checked:before { + -webkit-transform: scale(0); + transform: scale(0); +} +uni-switch .uni-switch-input.uni-switch-input-checked:after { + -webkit-transform: translateX(20px); + transform: translateX(20px); +} +uni-switch .uni-checkbox-input { + margin-right: 5px; + -webkit-appearance: none; + appearance: none; + outline: 0; + border: 1px solid #D1D1D1; + background-color: #FFFFFF; + border-radius: 3px; + width: 22px; + height: 22px; + position: relative; + color: #007aff; +} +uni-switch:not([disabled]) .uni-checkbox-input:hover { + border-color: #007aff; +} +uni-switch .uni-checkbox-input.uni-checkbox-input-checked:before { + font: normal normal normal 14px/1 "uni"; + content: "\EA08"; + color: inherit; + font-size: 22px; + position: absolute; + top: 50%; + left: 50%; + transform: translate(-50%, -48%) scale(0.73); + -webkit-transform: translate(-50%, -48%) scale(0.73); +} +uni-switch .uni-checkbox-input.uni-checkbox-input-disabled { + background-color: #E1E1E1; +} +uni-switch .uni-checkbox-input.uni-checkbox-input-disabled:before { + color: #ADADAD; +} + +uni-text[selectable] { + cursor: auto; + user-select: text; + -webkit-user-select: text; +} + +uni-textarea { + width: 300px; + height: 150px; + display: block; + position: relative; + font-size: 16px; + line-height: normal; + white-space: pre-wrap; + word-break: break-all; +} +uni-textarea[hidden] { + display: none; +} +.uni-textarea-wrapper, +.uni-textarea-placeholder, +.uni-textarea-line, +.uni-textarea-compute, +.uni-textarea-textarea { + outline: none; + border: none; + padding: 0; + margin: 0; + text-decoration: inherit; +} +.uni-textarea-wrapper { + display: block; + position: relative; + width: 100%; + height: 100%; +} +.uni-textarea-placeholder, +.uni-textarea-line, +.uni-textarea-compute, +.uni-textarea-textarea { + position: absolute; + width: 100%; + height: 100%; + left: 0; + top: 0; + white-space: inherit; + word-break: inherit; +} +.uni-textarea-placeholder { + color: grey; + overflow: hidden; +} +.uni-textarea-line, +.uni-textarea-compute { + visibility: hidden; + height: auto; +} +.uni-textarea-line { + width: 1em; +} +.uni-textarea-textarea { + resize: none; + background: none; + color: inherit; + opacity: 1; + -webkit-text-fill-color: currentcolor; + font: inherit; + line-height: inherit; + letter-spacing: inherit; + text-align: inherit; + text-indent: inherit; + text-transform: inherit; + text-shadow: inherit; +} +/* 用于解决 iOS textarea 内部默认边距 */ +.uni-textarea-textarea-fix-margin { + width: auto; + right: 0; + margin: 0 -3px; +} + +uni-view { + display: block; +} +uni-view[hidden] { + display: none; +} diff --git a/packages/uni-h5/dist/assets/index-a549e8ca.css b/packages/uni-h5/dist/assets/index-a549e8ca.css new file mode 100644 index 0000000000000000000000000000000000000000..64edb5adbab4717dcf3c46f692d957019ef093fc --- /dev/null +++ b/packages/uni-h5/dist/assets/index-a549e8ca.css @@ -0,0 +1,1369 @@ + +uni-canvas { + width: 300px; + height: 150px; + display: block; + position: relative; +} +uni-canvas > canvas { + position: absolute; + top: 0; + left: 0; + width: 100%; + height: 100%; +} + +uni-checkbox-group[hidden] { + display: none; +} +.ql-container { + display: block; + position: relative; + box-sizing: border-box; + -webkit-user-select: text; + user-select: text; + outline: none; + overflow: hidden; + width: 100%; + height: 200px; + min-height: 200px; +} +.ql-container[hidden] { + display: none; +} +.ql-container .ql-editor { + position: relative; + font-size: inherit; + line-height: inherit; + font-family: inherit; + min-height: inherit; + width: 100%; + height: 100%; + padding: 0; + overflow-x: hidden; + overflow-y: auto; + -webkit-tap-highlight-color: transparent; + -webkit-touch-callout: none; + -webkit-overflow-scrolling: touch; +} +.ql-container .ql-editor::-webkit-scrollbar { + width: 0 !important; +} +.ql-container .ql-editor.scroll-disabled { + overflow: hidden; +} +.ql-container .ql-image-overlay { + display: flex; + position: absolute; + box-sizing: border-box; + border: 1px dashed #ccc; + justify-content: center; + align-items: center; + -webkit-user-select: none; + user-select: none; +} +.ql-container .ql-image-overlay .ql-image-size { + position: absolute; + padding: 4px 8px; + text-align: center; + background-color: #fff; + color: #888; + border: 1px solid #ccc; + box-sizing: border-box; + opacity: 0.8; + right: 4px; + top: 4px; + font-size: 12px; + display: inline-block; + width: auto; +} +.ql-container .ql-image-overlay .ql-image-toolbar { + position: relative; + text-align: center; + box-sizing: border-box; + background: #000; + border-radius: 5px; + color: #fff; + font-size: 0; + min-height: 24px; + z-index: 100; +} +.ql-container .ql-image-overlay .ql-image-toolbar span { + display: inline-block; + cursor: pointer; + padding: 5px; + font-size: 12px; + border-right: 1px solid #fff; +} +.ql-container .ql-image-overlay .ql-image-toolbar span:last-child { + border-right: 0; +} +.ql-container .ql-image-overlay .ql-image-toolbar span.triangle-up { + padding: 0; + position: absolute; + top: -12px; + left: 50%; + transform: translatex(-50%); + width: 0; + height: 0; + border-width: 6px; + border-style: solid; + border-color: transparent transparent black transparent; +} +.ql-container .ql-image-overlay .ql-image-handle { + position: absolute; + height: 12px; + width: 12px; + border-radius: 50%; + border: 1px solid #ccc; + box-sizing: border-box; + background: #fff; +} +.ql-container img { + display: inline-block; + max-width: 100%; +} +.ql-clipboard p { + margin: 0; + padding: 0; +} +.ql-editor { + box-sizing: border-box; + height: 100%; + outline: none; + overflow-y: auto; + tab-size: 4; + -moz-tab-size: 4; + text-align: left; + white-space: pre-wrap; + word-wrap: break-word; +} +.ql-editor > * { + cursor: text; +} +.ql-editor p, +.ql-editor ol, +.ql-editor ul, +.ql-editor pre, +.ql-editor blockquote, +.ql-editor h1, +.ql-editor h2, +.ql-editor h3, +.ql-editor h4, +.ql-editor h5, +.ql-editor h6 { + margin: 0; + padding: 0; + counter-reset: list-1 list-2 list-3 list-4 list-5 list-6 list-7 list-8 list-9; +} +.ql-editor ol > li, +.ql-editor ul > li { + list-style-type: none; +} +.ql-editor ul > li::before { + content: '\2022'; +} +.ql-editor ul[data-checked=true], +.ql-editor ul[data-checked=false] { + pointer-events: none; +} +.ql-editor ul[data-checked=true] > li *, +.ql-editor ul[data-checked=false] > li * { + pointer-events: all; +} +.ql-editor ul[data-checked=true] > li::before, +.ql-editor ul[data-checked=false] > li::before { + color: #777; + cursor: pointer; + pointer-events: all; +} +.ql-editor ul[data-checked=true] > li::before { + content: '\2611'; +} +.ql-editor ul[data-checked=false] > li::before { + content: '\2610'; +} +.ql-editor li::before { + display: inline-block; + white-space: nowrap; + width: 2em; +} +.ql-editor ol li { + counter-reset: list-1 list-2 list-3 list-4 list-5 list-6 list-7 list-8 list-9; + counter-increment: list-0; +} +.ql-editor ol li:before { + content: counter(list-0, decimal) '. '; +} +.ql-editor ol li.ql-indent-1 { + counter-increment: list-1; +} +.ql-editor ol li.ql-indent-1:before { + content: counter(list-1, lower-alpha) '. '; +} +.ql-editor ol li.ql-indent-1 { + counter-reset: list-2 list-3 list-4 list-5 list-6 list-7 list-8 list-9; +} +.ql-editor ol li.ql-indent-2 { + counter-increment: list-2; +} +.ql-editor ol li.ql-indent-2:before { + content: counter(list-2, lower-roman) '. '; +} +.ql-editor ol li.ql-indent-2 { + counter-reset: list-3 list-4 list-5 list-6 list-7 list-8 list-9; +} +.ql-editor ol li.ql-indent-3 { + counter-increment: list-3; +} +.ql-editor ol li.ql-indent-3:before { + content: counter(list-3, decimal) '. '; +} +.ql-editor ol li.ql-indent-3 { + counter-reset: list-4 list-5 list-6 list-7 list-8 list-9; +} +.ql-editor ol li.ql-indent-4 { + counter-increment: list-4; +} +.ql-editor ol li.ql-indent-4:before { + content: counter(list-4, lower-alpha) '. '; +} +.ql-editor ol li.ql-indent-4 { + counter-reset: list-5 list-6 list-7 list-8 list-9; +} +.ql-editor ol li.ql-indent-5 { + counter-increment: list-5; +} +.ql-editor ol li.ql-indent-5:before { + content: counter(list-5, lower-roman) '. '; +} +.ql-editor ol li.ql-indent-5 { + counter-reset: list-6 list-7 list-8 list-9; +} +.ql-editor ol li.ql-indent-6 { + counter-increment: list-6; +} +.ql-editor ol li.ql-indent-6:before { + content: counter(list-6, decimal) '. '; +} +.ql-editor ol li.ql-indent-6 { + counter-reset: list-7 list-8 list-9; +} +.ql-editor ol li.ql-indent-7 { + counter-increment: list-7; +} +.ql-editor ol li.ql-indent-7:before { + content: counter(list-7, lower-alpha) '. '; +} +.ql-editor ol li.ql-indent-7 { + counter-reset: list-8 list-9; +} +.ql-editor ol li.ql-indent-8 { + counter-increment: list-8; +} +.ql-editor ol li.ql-indent-8:before { + content: counter(list-8, lower-roman) '. '; +} +.ql-editor ol li.ql-indent-8 { + counter-reset: list-9; +} +.ql-editor ol li.ql-indent-9 { + counter-increment: list-9; +} +.ql-editor ol li.ql-indent-9:before { + content: counter(list-9, decimal) '. '; +} +.ql-editor .ql-indent-1:not(.ql-direction-rtl) { + padding-left: 2em; +} +.ql-editor li.ql-indent-1:not(.ql-direction-rtl) { + padding-left: 2em; +} +.ql-editor .ql-indent-1.ql-direction-rtl.ql-align-right { + padding-right: 2em; +} +.ql-editor li.ql-indent-1.ql-direction-rtl.ql-align-right { + padding-right: 2em; +} +.ql-editor .ql-indent-2:not(.ql-direction-rtl) { + padding-left: 4em; +} +.ql-editor li.ql-indent-2:not(.ql-direction-rtl) { + padding-left: 4em; +} +.ql-editor .ql-indent-2.ql-direction-rtl.ql-align-right { + padding-right: 4em; +} +.ql-editor li.ql-indent-2.ql-direction-rtl.ql-align-right { + padding-right: 4em; +} +.ql-editor .ql-indent-3:not(.ql-direction-rtl) { + padding-left: 6em; +} +.ql-editor li.ql-indent-3:not(.ql-direction-rtl) { + padding-left: 6em; +} +.ql-editor .ql-indent-3.ql-direction-rtl.ql-align-right { + padding-right: 6em; +} +.ql-editor li.ql-indent-3.ql-direction-rtl.ql-align-right { + padding-right: 6em; +} +.ql-editor .ql-indent-4:not(.ql-direction-rtl) { + padding-left: 8em; +} +.ql-editor li.ql-indent-4:not(.ql-direction-rtl) { + padding-left: 8em; +} +.ql-editor .ql-indent-4.ql-direction-rtl.ql-align-right { + padding-right: 8em; +} +.ql-editor li.ql-indent-4.ql-direction-rtl.ql-align-right { + padding-right: 8em; +} +.ql-editor .ql-indent-5:not(.ql-direction-rtl) { + padding-left: 10em; +} +.ql-editor li.ql-indent-5:not(.ql-direction-rtl) { + padding-left: 10em; +} +.ql-editor .ql-indent-5.ql-direction-rtl.ql-align-right { + padding-right: 10em; +} +.ql-editor li.ql-indent-5.ql-direction-rtl.ql-align-right { + padding-right: 10em; +} +.ql-editor .ql-indent-6:not(.ql-direction-rtl) { + padding-left: 12em; +} +.ql-editor li.ql-indent-6:not(.ql-direction-rtl) { + padding-left: 12em; +} +.ql-editor .ql-indent-6.ql-direction-rtl.ql-align-right { + padding-right: 12em; +} +.ql-editor li.ql-indent-6.ql-direction-rtl.ql-align-right { + padding-right: 12em; +} +.ql-editor .ql-indent-7:not(.ql-direction-rtl) { + padding-left: 14em; +} +.ql-editor li.ql-indent-7:not(.ql-direction-rtl) { + padding-left: 14em; +} +.ql-editor .ql-indent-7.ql-direction-rtl.ql-align-right { + padding-right: 14em; +} +.ql-editor li.ql-indent-7.ql-direction-rtl.ql-align-right { + padding-right: 14em; +} +.ql-editor .ql-indent-8:not(.ql-direction-rtl) { + padding-left: 16em; +} +.ql-editor li.ql-indent-8:not(.ql-direction-rtl) { + padding-left: 16em; +} +.ql-editor .ql-indent-8.ql-direction-rtl.ql-align-right { + padding-right: 16em; +} +.ql-editor li.ql-indent-8.ql-direction-rtl.ql-align-right { + padding-right: 16em; +} +.ql-editor .ql-indent-9:not(.ql-direction-rtl) { + padding-left: 18em; +} +.ql-editor li.ql-indent-9:not(.ql-direction-rtl) { + padding-left: 18em; +} +.ql-editor .ql-indent-9.ql-direction-rtl.ql-align-right { + padding-right: 18em; +} +.ql-editor li.ql-indent-9.ql-direction-rtl.ql-align-right { + padding-right: 18em; +} +.ql-editor .ql-direction-rtl { + direction: rtl; + text-align: inherit; +} +.ql-editor .ql-align-center { + text-align: center; +} +.ql-editor .ql-align-justify { + text-align: justify; +} +.ql-editor .ql-align-right { + text-align: right; +} +.ql-editor.ql-blank::before { + color: rgba(0, 0, 0, 0.6); + content: attr(data-placeholder); + font-style: italic; + pointer-events: none; + position: absolute; +} +.ql-container.ql-disabled .ql-editor ul[data-checked] > li::before { + pointer-events: none; +} +.ql-clipboard { + left: -100000px; + height: 1px; + overflow-y: hidden; + position: absolute; + top: 50%; +} + + + +uni-icon { + display: inline-block; + font-size: 0; + box-sizing: border-box; +} +uni-icon[hidden] { + display: none; +} +uni-icon > i { + font: normal normal normal 14px/1 'weui'; +} +uni-icon > i:before { + margin: 0; + box-sizing: border-box; +} +@font-face { + font-weight: normal; + font-style: normal; + font-family: 'weui'; + src: url('data:application/octet-stream;base64,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') + format('truetype'); +} +.uni-icon-success:before { + content: '\EA06'; +} +.uni-icon-success_circle:before { + content: '\EA07'; +} +.uni-icon-success_no_circle:before { + content: '\EA08'; +} +.uni-icon-safe_success:before { + content: '\EA04'; +} +.uni-icon-safe_warn:before { + content: '\EA05'; +} +.uni-icon-info:before { + content: '\EA03'; +} +.uni-icon-info_circle:before { + content: '\EA0C'; +} +.uni-icon-warn:before { + content: '\EA0B'; +} +.uni-icon-waiting:before { + content: '\EA09'; +} +.uni-icon-waiting_circle:before { + content: '\EA0A'; +} +.uni-icon-circle:before { + content: '\EA01'; +} +.uni-icon-cancel:before { + content: '\EA0D'; +} +.uni-icon-download:before { + content: '\EA02'; +} +.uni-icon-search:before { + content: '\EA0E'; +} +.uni-icon-clear:before { + content: '\EA0F'; +} +.uni-icon-success { + color: #007aff; +} +.uni-icon-success_circle { + color: #007aff; +} +.uni-icon-success_no_circle { + color: #007aff; +} +.uni-icon-safe_success { + color: #007aff; +} +.uni-icon-safe_warn { + color: #ffbe00; +} +.uni-icon-info { + color: #10aeff; +} +.uni-icon-info_circle { + color: #007aff; +} +.uni-icon-warn { + color: #f76260; +} +.uni-icon-waiting { + color: #10aeff; +} +.uni-icon-waiting_circle { + color: #10aeff; +} +.uni-icon-circle { + color: #c9c9c9; +} +.uni-icon-cancel { + color: #f43530; +} +.uni-icon-download { + color: #007aff; +} +.uni-icon-search { + color: #b2b2b2; +} +.uni-icon-clear { + color: #b2b2b2; +} + +uni-image { + width: 320px; + height: 240px; + display: inline-block; + overflow: hidden; + position: relative; +} +uni-image[hidden] { + display: none; +} +uni-image>div { + width: 100%; + height: 100%; +} +uni-image>img { + -webkit-touch-callout: none; + -webkit-user-select: none; + -moz-user-select: none; + display: block; + position: absolute; + top: 0; + left: 0; + width: 100%; + height: 100%; + opacity: 0; +} +uni-image>.uni-image-will-change { + will-change: transform; +} + +uni-input { + display: block; + font-size: 16px; + line-height: 1.4em; + height: 1.4em; + min-height: 1.4em; + overflow: hidden; +} +uni-input[hidden] { + display: none; +} +.uni-input-wrapper, +.uni-input-placeholder, +.uni-input-form, +.uni-input-input { + outline: none; + border: none; + padding: 0; + margin: 0; + text-decoration: inherit; +} +.uni-input-wrapper, +.uni-input-form { + display: flex; + position: relative; + width: 100%; + height: 100%; + flex-direction: column; + justify-content: center; +} +.uni-input-placeholder, +.uni-input-input { + width: 100%; +} +.uni-input-placeholder { + position: absolute; + top: auto !important; + left: 0; + color: gray; + overflow: hidden; + text-overflow: clip; + white-space: pre; + word-break: keep-all; + pointer-events: none; + line-height: inherit; +} +.uni-input-input { + display: block; + height: 100%; + background: none; + color: inherit; + opacity: 1; + -webkit-text-fill-color: currentcolor; + font: inherit; + line-height: inherit; + letter-spacing: inherit; + text-align: inherit; + text-indent: inherit; + text-transform: inherit; + text-shadow: inherit; +} +.uni-input-input[type="search"]::-webkit-search-cancel-button { + display: none; +} +.uni-input-input::-webkit-outer-spin-button, +.uni-input-input::-webkit-inner-spin-button { + -webkit-appearance: none; + margin: 0; +} +.uni-input-input[type="number"] { + -moz-appearance: textfield; +} + +.uni-label-pointer { + cursor: pointer; +} + +uni-movable-view { + display: inline-block; + width: 10px; + height: 10px; + top: 0px; + left: 0px; + position: absolute; + cursor: grab; +} +uni-movable-view[hidden] { + display: none; +} + +uni-navigator { + height: auto; + width: auto; + display: block; + cursor: pointer; +} +uni-navigator[hidden] { + display: none; +} +.navigator-hover { + background-color: rgba(0, 0, 0, 0.1); + opacity: 0.7; +} + +uni-radio { + -webkit-tap-highlight-color: transparent; + display: inline-block; + cursor: pointer; +} +uni-radio[hidden] { + display: none; +} +uni-radio[disabled] { + cursor: not-allowed; +} +uni-radio .uni-radio-wrapper { + display: -webkit-inline-flex; + display: inline-flex; + -webkit-align-items: center; + align-items: center; + vertical-align: middle; +} +uni-radio .uni-radio-input { + -webkit-appearance: none; + appearance: none; + margin-right: 5px; + outline: 0; + border: 1px solid #D1D1D1; + background-color: #ffffff; + border-radius: 50%; + width: 22px; + height: 22px; + position: relative; +} +uni-radio:not([disabled]) .uni-radio-input:hover { + border-color: #007aff; +} +uni-radio .uni-radio-input.uni-radio-input-checked:before { + font: normal normal normal 14px/1 "uni"; + content: "\EA08"; + color: #ffffff; + font-size: 18px; + position: absolute; + top: 50%; + left: 50%; + transform: translate(-50%, -48%) scale(0.73); + -webkit-transform: translate(-50%, -48%) scale(0.73); +} +uni-radio .uni-radio-input.uni-radio-input-disabled { + background-color: #E1E1E1; + border-color: #D1D1D1; +} +uni-radio .uni-radio-input.uni-radio-input-disabled:before { + color: #ADADAD; +} +uni-radio-group { + display: block; +} + +uni-radio-group[hidden] { + display: none; +} + +@keyframes once-show { +from { + top: 0; +} +} +uni-resize-sensor, +uni-resize-sensor > div { + position: absolute; + left: 0; + top: 0; + right: 0; + bottom: 0; + overflow: hidden; +} +uni-resize-sensor { + display: block; + z-index: -1; + visibility: hidden; + animation: once-show 1ms; +} +uni-resize-sensor > div > div { + position: absolute; + left: 0; + top: 0; +} +uni-resize-sensor > div:first-child > div { + width: 100000px; + height: 100000px; +} +uni-resize-sensor > div:last-child > div { + width: 200%; + height: 200%; +} + +uni-scroll-view { + display: block; + width: 100%; +} +uni-scroll-view[hidden] { + display: none; +} +.uni-scroll-view { + position: relative; + -webkit-overflow-scrolling: touch; + width: 100%; + /* display: flex; 时在安卓下会导致scrollWidth和offsetWidth一样 */ + height: 100%; + max-height: inherit; +} +.uni-scroll-view-content { + width: 100%; + height: 100%; +} +.uni-scroll-view-refresher { + position: relative; + overflow: hidden; +} +.uni-scroll-view-refresh { + position: absolute; + top: 0; + left: 0; + right: 0; + bottom: 0; + display: flex; + flex-direction: row; + justify-content: center; + align-items: center; +} +.uni-scroll-view-refresh-inner { + display: flex; + align-items: center; + justify-content: center; + line-height: 0; + width: 40px; + height: 40px; + border-radius: 50%; + background-color: #fff; + box-shadow: 0 1px 6px rgba(0, 0, 0, 0.117647), + 0 1px 4px rgba(0, 0, 0, 0.117647); +} +.uni-scroll-view-refresh__spinner { + transform-origin: center center; + animation: uni-scroll-view-refresh-rotate 2s linear infinite; +} +.uni-scroll-view-refresh__spinner > circle { + stroke: currentColor; + stroke-linecap: round; + animation: uni-scroll-view-refresh-dash 2s linear infinite; +} +@keyframes uni-scroll-view-refresh-rotate { +0% { + transform: rotate(0deg); +} +100% { + transform: rotate(360deg); +} +} +@keyframes uni-scroll-view-refresh-dash { +0% { + stroke-dasharray: 1, 200; + stroke-dashoffset: 0; +} +50% { + stroke-dasharray: 89, 200; + stroke-dashoffset: -35px; +} +100% { + stroke-dasharray: 89, 200; + stroke-dashoffset: -124px; +} +} + +uni-swiper-item { + display: block; + overflow: hidden; + will-change: transform; + position: absolute; + width: 100%; + height: 100%; + cursor: grab; +} +uni-swiper-item[hidden] { + display: none; +} + +uni-switch { + -webkit-tap-highlight-color: transparent; + display: inline-block; + cursor: pointer; +} +uni-switch[hidden] { + display: none; +} +uni-switch[disabled] { + cursor: not-allowed; +} +uni-switch .uni-switch-wrapper { + display: -webkit-inline-flex; + display: inline-flex; + -webkit-align-items: center; + align-items: center; + vertical-align: middle; +} +uni-switch .uni-switch-input { + -webkit-appearance: none; + appearance: none; + position: relative; + width: 52px; + height: 32px; + margin-right: 5px; + border: 1px solid #DFDFDF; + outline: 0; + border-radius: 16px; + box-sizing: border-box; + background-color: #DFDFDF; + transition: background-color 0.1s, border 0.1s; +} +uni-switch[disabled] .uni-switch-input { + opacity: .7; +} +uni-switch .uni-switch-input:before { + content: " "; + position: absolute; + top: 0; + left: 0; + width: 50px; + height: 30px; + border-radius: 15px; + background-color: #FDFDFD; + transition: -webkit-transform 0.3s; + transition: transform 0.3s; + transition: transform 0.3s, -webkit-transform 0.3s; +} +uni-switch .uni-switch-input:after { + content: " "; + position: absolute; + top: 0; + left: 0; + width: 30px; + height: 30px; + border-radius: 15px; + background-color: #FFFFFF; + box-shadow: 0 1px 3px rgba(0, 0, 0, 0.4); + transition: -webkit-transform 0.3s; + transition: transform 0.3s; + transition: transform 0.3s, -webkit-transform 0.3s; +} +uni-switch .uni-switch-input.uni-switch-input-checked { + border-color: #007aff; + background-color: #007aff; +} +uni-switch .uni-switch-input.uni-switch-input-checked:before { + -webkit-transform: scale(0); + transform: scale(0); +} +uni-switch .uni-switch-input.uni-switch-input-checked:after { + -webkit-transform: translateX(20px); + transform: translateX(20px); +} +uni-switch .uni-checkbox-input { + margin-right: 5px; + -webkit-appearance: none; + appearance: none; + outline: 0; + border: 1px solid #D1D1D1; + background-color: #FFFFFF; + border-radius: 3px; + width: 22px; + height: 22px; + position: relative; + color: #007aff; +} +uni-switch:not([disabled]) .uni-checkbox-input:hover { + border-color: #007aff; +} +uni-switch .uni-checkbox-input.uni-checkbox-input-checked:before { + font: normal normal normal 14px/1 "uni"; + content: "\EA08"; + color: inherit; + font-size: 22px; + position: absolute; + top: 50%; + left: 50%; + transform: translate(-50%, -48%) scale(0.73); + -webkit-transform: translate(-50%, -48%) scale(0.73); +} +uni-switch .uni-checkbox-input.uni-checkbox-input-disabled { + background-color: #E1E1E1; +} +uni-switch .uni-checkbox-input.uni-checkbox-input-disabled:before { + color: #ADADAD; +} + +uni-text[selectable] { + cursor: auto; + user-select: text; + -webkit-user-select: text; +} + +uni-textarea { + width: 300px; + height: 150px; + display: block; + position: relative; + font-size: 16px; + line-height: normal; + white-space: pre-wrap; + word-break: break-all; +} +uni-textarea[hidden] { + display: none; +} +.uni-textarea-wrapper, +.uni-textarea-placeholder, +.uni-textarea-line, +.uni-textarea-compute, +.uni-textarea-textarea { + outline: none; + border: none; + padding: 0; + margin: 0; + text-decoration: inherit; +} +.uni-textarea-wrapper { + display: block; + position: relative; + width: 100%; + height: 100%; +} +.uni-textarea-placeholder, +.uni-textarea-line, +.uni-textarea-compute, +.uni-textarea-textarea { + position: absolute; + width: 100%; + height: 100%; + left: 0; + top: 0; + white-space: inherit; + word-break: inherit; +} +.uni-textarea-placeholder { + color: grey; + overflow: hidden; +} +.uni-textarea-line, +.uni-textarea-compute { + visibility: hidden; + height: auto; +} +.uni-textarea-line { + width: 1em; +} +.uni-textarea-textarea { + resize: none; + background: none; + color: inherit; + opacity: 1; + -webkit-text-fill-color: currentcolor; + font: inherit; + line-height: inherit; + letter-spacing: inherit; + text-align: inherit; + text-indent: inherit; + text-transform: inherit; + text-shadow: inherit; +} +/* 用于解决 iOS textarea 内部默认边距 */ +.uni-textarea-textarea-fix-margin { + width: auto; + right: 0; + margin: 0 -3px; +} + +uni-view { + display: block; +} +uni-view[hidden] { + display: none; +} + +uni-page-head { + display: block; + box-sizing: border-box; +} +uni-page-head .uni-page-head { + position: fixed; + left: var(--window-left); + right: var(--window-right); + height: 44px; + height: calc(44px + constant(safe-area-inset-top)); + height: calc(44px + env(safe-area-inset-top)); + padding: 7px 3px; + padding-top: calc(7px + constant(safe-area-inset-top)); + padding-top: calc(7px + env(safe-area-inset-top)); + display: flex; + overflow: hidden; + justify-content: space-between; + box-sizing: border-box; + z-index: 998; + color: #fff; + background-color: #000; + transition-property: all; +} +uni-page-head .uni-page-head-titlePenetrate, +uni-page-head .uni-page-head-titlePenetrate .uni-page-head-bd, +uni-page-head .uni-page-head-titlePenetrate .uni-page-head-bd * { + pointer-events: none; +} +uni-page-head .uni-page-head-titlePenetrate * { + pointer-events: auto; +} +uni-page-head .uni-page-head.uni-page-head-transparent .uni-page-head-ft > div { + justify-content: center; +} +uni-page-head .uni-page-head ~ .uni-placeholder { + width: 100%; + height: 44px; + height: calc(44px + constant(safe-area-inset-top)); + height: calc(44px + env(safe-area-inset-top)); +} +uni-page-head .uni-placeholder-titlePenetrate { + pointer-events: none; +} +uni-page-head .uni-page-head * { + box-sizing: border-box; +} +uni-page-head .uni-page-head-hd { + display: flex; + align-items: center; + font-size: 16px; +} +uni-page-head .uni-page-head-bd { + position: absolute; + left: 70px; + right: 70px; + min-width: 0; + user-select: auto; +} +.uni-page-head-btn { + position: relative; + width: auto; + margin: 0 2px; + word-break: keep-all; + white-space: pre; + cursor: pointer; +} +.uni-page-head-transparent .uni-page-head-btn { + display: flex; + align-items: center; + width: 32px; + height: 32px; + border-radius: 50%; + background-color: rgba(0, 0, 0, 0.5); +} +uni-page-head .uni-btn-icon { + overflow: hidden; + min-width: 1em; +} +.uni-page-head-btn-red-dot::after { + content: attr(badge-text); + position: absolute; + right: 0; + top: 0; + background-color: red; + color: white; + width: 18px; + height: 18px; + line-height: 18px; + border-radius: 18px; + overflow: hidden; + transform: scale(0.5) translate(40%, -40%); + transform-origin: 100% 0; +} +.uni-page-head-btn-red-dot[badge-text]::after { + font-size: 12px; + width: auto; + min-width: 18px; + max-width: 42px; + text-align: center; + padding: 0 3px; + transform: scale(0.7) translate(40%, -40%); +} +.uni-page-head-btn-select > .uni-btn-icon::after { + display: inline-block; + font-family: 'unibtn'; + content: '\e601'; + margin-left: 2px; + transform: rotate(-90deg) scale(0.8); +} +.uni-page-head-search { + position: relative; + display: flex; + flex: 1; + margin: 0 2px; + line-height: 30px; + font-size: 15px; +} +.uni-page-head-search-input { + width: 100%; + height: 100%; + padding-left: 34px; + text-align: left; +} +.uni-page-head-search-placeholder { + position: absolute; + max-width: 100%; + height: 100%; + padding-left: 34px; + overflow: hidden; + word-break: keep-all; + white-space: pre; +} +.uni-page-head-search-placeholder-right { + right: 0; +} +.uni-page-head-search-placeholder-center { + left: 50%; + transform: translateX(-50%); +} +.uni-page-head-search-placeholder::before { + position: absolute; + top: 0; + left: 2px; + width: 30px; + content: '\ea0e'; + display: block; + font-size: 20px; + font-family: 'uni'; + text-align: center; +} +uni-page-head .uni-page-head-ft { + display: flex; + align-items: center; + flex-direction: row-reverse; + font-size: 13px; +} +uni-page-head .uni-page-head__title { + font-weight: bold; + font-size: 16px; + line-height: 30px; + text-align: center; + overflow: hidden; + white-space: nowrap; + text-overflow: ellipsis; +} +uni-page-head .uni-page-head__title .uni-loading { + width: 16px; + height: 16px; + margin-top: -3px; +} +uni-page-head .uni-page-head__title .uni-page-head__title_image { + width: auto; + height: 26px; + vertical-align: middle; +} +uni-page-head .uni-page-head-shadow { + overflow: visible; +} +uni-page-head .uni-page-head-shadow::after { + content: ''; + position: absolute; + left: 0; + right: 0; + top: 100%; + height: 5px; + background-size: 100% 100%; +} +uni-page-head .uni-page-head-shadow-grey::after { + background-image: url('https://cdn.dcloud.net.cn/img/shadow-grey.png'); +} +uni-page-head .uni-page-head-shadow-blue::after { + background-image: url('https://cdn.dcloud.net.cn/img/shadow-blue.png'); +} +uni-page-head .uni-page-head-shadow-green::after { + background-image: url('https://cdn.dcloud.net.cn/img/shadow-green.png'); +} +uni-page-head .uni-page-head-shadow-orange::after { + background-image: url('https://cdn.dcloud.net.cn/img/shadow-orange.png'); +} +uni-page-head .uni-page-head-shadow-red::after { + background-image: url('https://cdn.dcloud.net.cn/img/shadow-red.png'); +} +uni-page-head .uni-page-head-shadow-yellow::after { + background-image: url('https://cdn.dcloud.net.cn/img/shadow-yellow.png'); +} + +uni-page-wrapper { + display: block; + height: 100%; + position: relative; +} +uni-page-head[uni-page-head-type='default'] ~ uni-page-wrapper { + height: calc(100% - 44px); + height: calc(100% - 44px - constant(safe-area-inset-top)); + height: calc(100% - 44px - env(safe-area-inset-top)); +} +uni-page-body { + display: block; + box-sizing: border-box; + width: 100%; +} + +uni-page-refresh { + position: absolute; + top: 0; + width: 100%; + height: 40px; + display: block; + box-sizing: border-box; +} +uni-page-refresh .uni-page-refresh { + position: absolute; + top: -45px; + left: 50%; + transform: translate3d(-50%, 0, 0); + width: 40px; + height: 40px; + justify-content: center; + align-items: center; + background: #fff; + border-radius: 50%; + box-shadow: 0 1px 6px rgba(0, 0, 0, .117647), 0 1px 4px rgba(0, 0, 0, .117647); + display: none; + z-index: 997; +} +uni-page-refresh .uni-page-refresh-inner { + display: flex; + align-items: center; + justify-content: center; + line-height: 0; + width: 40px; + height: 40px; + border-radius: 50%; +} +uni-page-refresh.uni-page-refresh--pulling .uni-page-refresh, + uni-page-refresh.uni-page-refresh--aborting .uni-page-refresh, + uni-page-refresh.uni-page-refresh--reached .uni-page-refresh, + uni-page-refresh.uni-page-refresh--refreshing .uni-page-refresh, + uni-page-refresh.uni-page-refresh--restoring .uni-page-refresh { + display: flex; +} +uni-page-refresh.uni-page-refresh--pulling .uni-page-refresh__spinner, + uni-page-refresh.uni-page-refresh--aborting .uni-page-refresh__spinner, + uni-page-refresh.uni-page-refresh--reached .uni-page-refresh__spinner, + uni-page-refresh.uni-page-refresh--refreshing .uni-page-refresh__icon, + uni-page-refresh.uni-page-refresh--restoring .uni-page-refresh__icon { + display: none; +} +uni-page-refresh.uni-page-refresh--refreshing .uni-page-refresh__spinner { + transform-origin: center center; + animation: uni-page-refresh-rotate 2s linear infinite; +} +uni-page-refresh.uni-page-refresh--refreshing .uni-page-refresh__path { + stroke-dasharray: 1, 200; + stroke-dashoffset: 0; + stroke-linecap: round; + animation: uni-page-refresh-dash 1.5s ease-in-out infinite, uni-page-refresh-colorful 6s ease-in-out infinite; +} +@keyframes uni-page-refresh-rotate { +100% { + -webkit-transform: rotate(360deg); + transform: rotate(360deg); +} +} +@keyframes uni-page-refresh-dash { +0% { + stroke-dasharray: 1, 200; + stroke-dashoffset: 0; +} +50% { + stroke-dasharray: 89, 200; + stroke-dashoffset: -35px; +} +100% { + stroke-dasharray: 89, 200; + stroke-dashoffset: -124px; +} +} + +uni-page { + display: block; + width: 100%; + height: 100%; +} + +.uni-async-error { + position: absolute; + left: 0; + right: 0; + top: 0; + bottom: 0; + color: #999; + padding: 100px 10px; + text-align: center; +} + +.uni-async-loading { + box-sizing: border-box; + width: 100%; + padding: 50px; + text-align: center; +} +.uni-async-loading .uni-loading { + width: 30px; + height: 30px; +} diff --git a/packages/uni-h5/dist/uni-h5.esm.js b/packages/uni-h5/dist/uni-h5.esm.js index b3a23cd6593c4763f2d64f25b768bf887a69b4cc..c354c8c5781220439daf4e0ffb490886dd4fb795 100644 --- a/packages/uni-h5/dist/uni-h5.esm.js +++ b/packages/uni-h5/dist/uni-h5.esm.js @@ -1,8 +1,7 @@ -var __assign = Object.assign; -import {isFunction, extend, isPlainObject, isArray, hasOwn, isObject, capitalize, toRawType, makeMap as makeMap$1, isPromise, hyphenate} from "@vue/shared"; -import {injectHook, openBlock, createBlock, createVNode, Fragment, renderList, toDisplayString, createCommentVNode, createTextVNode, Transition, withCtx, withModifiers, withDirectives, vShow, nextTick, computed, resolveComponent, KeepAlive, resolveDynamicComponent, mergeProps, toHandlers, renderSlot, vModelDynamic, vModelText} from "vue"; -import {TABBAR_HEIGHT, plusReady, debounce, NAVBAR_HEIGHT, COMPONENT_NAME_PREFIX, isCustomElement} from "@dcloudio/uni-shared"; -import {createRouter, createWebHistory, createWebHashHistory, useRoute} from "vue-router"; +import {isFunction, extend, isPlainObject, hasOwn as hasOwn$1, hyphenate, isArray, isObject as isObject$1, capitalize, toRawType, makeMap as makeMap$1, isPromise} from "@vue/shared"; +import {injectHook, defineComponent, nextTick, computed, openBlock, createBlock, Fragment, withDirectives, createVNode, vShow, createCommentVNode, withCtx, KeepAlive, resolveDynamicComponent, resolveComponent, mergeProps, onMounted, ref, toDisplayString, toHandlers, renderSlot, withModifiers, vModelDynamic, renderList, vModelText, createTextVNode} from "vue"; +import {COMPONENT_NAME_PREFIX, RESPONSIVE_MIN_WIDTH, isCustomElement, plusReady, debounce, NAVBAR_HEIGHT} from "@dcloudio/uni-shared"; +import {createRouter, createWebHistory, createWebHashHistory, useRoute, RouterView} from "vue-router"; function applyOptions(options, instance2, publicThis) { Object.keys(options).forEach((name) => { if (name.indexOf("on") === 0) { @@ -27,8 +26,8 @@ function callHook(name, args) { const hooks = this.$[name]; let ret; if (hooks) { - for (let i2 = 0; i2 < hooks.length; i2++) { - ret = hooks[i2](args); + for (let i = 0; i < hooks.length; i++) { + ret = hooks[i](args); } } return ret; @@ -420,8 +419,8 @@ function normalizeTouchList(touches) { if (touches && touches instanceof TouchList) { const res = []; const {top} = getWindowOffset(); - for (let i2 = 0; i2 < touches.length; i2++) { - const touch = touches[i2]; + for (let i = 0; i < touches.length; i++) { + const touch = touches[i]; res.push({ identifier: touch.identifier, pageX: touch.pageX, @@ -508,8 +507,8 @@ class ComponentDescriptor { } const descriptors = []; const els = this.$el.querySelectorAll(selector); - for (let i2 = 0; i2 < els.length; i2++) { - const el = els[i2]; + for (let i = 0; i < els.length; i++) { + const el = els[i]; el.__vue__ && descriptors.push(createComponentDescriptor(el.__vue__, false)); } return descriptors; @@ -639,7 +638,9 @@ function initAppConfig$1(appConfig) { } } function initView(app) { - initLongPress(); + if (__UNI_FEATURE_LONGPRESS__) { + initLongPress(); + } initAppConfig$1(app._context.config); } const ServiceJSBridge = initBridge("service"); @@ -683,6 +684,40 @@ function initAppConfig(appConfig) { function initService(app) { initAppConfig(app._context.config); } +function PolySymbol(name) { + return Symbol(process.env.NODE_ENV !== "production" ? "[uni-app]: " + name : name); +} +function getRealRoute(fromRoute, toRoute) { + if (!toRoute) { + toRoute = fromRoute; + if (toRoute.indexOf("/") === 0) { + return toRoute; + } + const pages = getCurrentPages(); + if (pages.length) { + fromRoute = pages[pages.length - 1].$page.route; + } else { + fromRoute = ""; + } + } else { + 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++) { + } + 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("/"); +} let appVm; function getApp$1() { return appVm; @@ -696,7 +731,9 @@ function initApp(vm) { appVm.globalData = appVm.$options.globalData || {}; } function initRouter(app) { - app.use(createAppRouter(createRouter(createRouterOptions()))); + const router = createAppRouter(createRouter(createRouterOptions())); + app.use(router); + return router; } const scrollBehavior = (to, from, savedPosition) => { if (savedPosition) { @@ -739,2791 +776,2820 @@ const afterEach = (to, from, failure) => { console.log("afterEach.id", history.state.__id__); console.log("afterEach", to, from, failure, JSON.stringify(history.state)); }; -var tabBar_vue_vue_type_style_index_0_lang = "\nuni-tabbar {\r\n display: block;\r\n box-sizing: border-box;\r\n position: fixed;\r\n left: 0;\r\n bottom: 0;\r\n width: 100%;\r\n z-index: 998;\n}\nuni-tabbar .uni-tabbar {\r\n display: flex;\r\n position: fixed;\r\n left: 0;\r\n bottom: 0;\r\n width: 100%;\r\n z-index: 998;\r\n box-sizing: border-box;\r\n padding-bottom: 0;\r\n padding-bottom: constant(safe-area-inset-bottom);\r\n padding-bottom: env(safe-area-inset-bottom);\n}\nuni-tabbar .uni-tabbar ~ .uni-placeholder {\r\n width: 100%;\r\n height: 50px;\r\n margin-bottom: 0;\r\n margin-bottom: constant(safe-area-inset-bottom);\r\n margin-bottom: env(safe-area-inset-bottom);\n}\nuni-tabbar .uni-tabbar * {\r\n box-sizing: border-box;\n}\nuni-tabbar .uni-tabbar__item {\r\n display: flex;\r\n justify-content: center;\r\n align-items: center;\r\n flex-direction: column;\r\n flex: 1;\r\n font-size: 0;\r\n text-align: center;\r\n -webkit-tap-highlight-color: rgba(0, 0, 0, 0);\n}\nuni-tabbar .uni-tabbar__bd {\r\n position: relative;\r\n height: 50px;\r\n display: flex;\r\n flex-direction: column;\r\n align-items: center;\r\n justify-content: center;\r\n cursor: pointer;\n}\nuni-tabbar .uni-tabbar__icon {\r\n position: relative;\r\n display: inline-block;\r\n margin-top: 5px;\r\n width: 24px;\r\n height: 24px;\n}\nuni-tabbar .uni-tabbar__icon.uni-tabbar__icon__diff {\r\n margin-top: 0px;\r\n width: 34px;\r\n height: 34px;\n}\nuni-tabbar .uni-tabbar__icon img {\r\n width: 100%;\r\n height: 100%;\n}\nuni-tabbar .uni-tabbar__label {\r\n position: relative;\r\n text-align: center;\r\n font-size: 10px;\r\n line-height: 1.8;\n}\nuni-tabbar .uni-tabbar-border {\r\n position: absolute;\r\n left: 0;\r\n top: 0;\r\n width: 100%;\r\n height: 1px;\r\n transform: scaleY(0.5);\n}\nuni-tabbar .uni-tabbar__reddot {\r\n position: absolute;\r\n top: 0;\r\n right: 0;\r\n width: 12px;\r\n height: 12px;\r\n border-radius: 50%;\r\n background-color: #f43530;\r\n color: #ffffff;\r\n transform: translate(40%, -20%);\n}\nuni-tabbar .uni-tabbar__badge {\r\n width: auto;\r\n height: 16px;\r\n line-height: 16px;\r\n border-radius: 16px;\r\n min-width: 16px;\r\n padding: 0 2px;\r\n font-size: 12px;\r\n text-align: center;\r\n white-space: nowrap;\n}\r\n"; -const _sfc_main$y = { - name: "TabBar", - props: { - position: { - default: "bottom", - validator(value) { - return ["bottom", "top"].indexOf(value) !== -1; +var TabBar = defineComponent({ + name: "TabBar" +}); +const SEP = "$$"; +function getCurrentPages$1() { + return []; +} +let id = history.state && history.state.__id__ || 1; +function createPageState(type) { + return { + __id__: ++id, + __type__: type + }; +} +function isPage(vm) { + return vm.$options.mpType === "page"; +} +function initPublicPage(route) { + if (!route) { + const {path} = __uniRoutes[0]; + return {id, path, route: path.substr(1), fullPath: path}; + } + return { + id, + path: route.path, + route: route.meta.pagePath, + fullPath: route.meta.isEntry ? route.meta.pagePath : route.fullPath, + options: {} + }; +} +function initPage(vm) { + const route = vm.$route; + vm.__page__ = initPublicPage(route); +} +function routeCache(key, cache, pruneCacheEntry) { + const pageId = parseInt(key.split(SEP)[1]); + if (!pageId) { + return; + } + nextTick(() => { + const keys = cache.keys(); + for (const key2 of keys) { + const cPageId = parseInt(key2.split(SEP)[1]); + if (cPageId && cPageId > pageId) { + pruneCacheEntry(key2); } - }, - color: { - type: String, - default: "#999" - }, - selectedColor: { - type: String, - default: "#007aff" - }, - backgroundColor: { - type: String, - default: "#f7f7fa" - }, - borderStyle: { - default: "black", - validator(value) { - return ["black", "white"].indexOf(value) !== -1; + } + console.log("customKeepAlive", JSON.stringify([...cache.keys()])); + }); +} +function useKeepAliveRoute() { + const route = useRoute(); + const routeKey = computed(() => route.fullPath + "$$" + (history.state.__id__ || 1)); + return { + routeKey, + routeCache + }; +} +var Layout = defineComponent({ + name: "Layout", + emits: ["change"], + setup() { + const route = __UNI_FEATURE_TABBAR__ ? useRoute() : null; + const keepAliveRoute = __UNI_FEATURE_PAGES__ ? useKeepAliveRoute() : null; + __UNI_FEATURE_TOPWINDOW__ ? useTopWindow() : null; + __UNI_FEATURE_LEFTWINDOW__ ? useLeftWindow() : null; + __UNI_FEATURE_RIGHTWINDOW__ ? useRightWindow() : null; + return () => { + return openBlock(), createBlock(Fragment, null, [ + createLayoutVNode(keepAliveRoute), + createTabBarVNode(route) + ], 64); + }; + } +}); +function createLayoutVNode(keepAliveRoute, topWindow, leftWindow, rightWindow) { + const routerVNode = __UNI_FEATURE_PAGES__ ? createRouterViewVNode(keepAliveRoute) : createPageVNode(); + if (!__UNI_FEATURE_RESPONSIVE__) { + return routerVNode; + } + const topWindowVNode = __UNI_FEATURE_TOPWINDOW__ ? createTopWindowVNode() : createCommentVNode("", true); + const leftWindowVNode = __UNI_FEATURE_LEFTWINDOW__ ? createLeftWindowVNode() : createCommentVNode("", true); + const rightWindowVNode = __UNI_FEATURE_RIGHTWINDOW__ ? createRightWindowVNode() : createCommentVNode("", true); + return createVNode("uni-layout", null, [ + topWindowVNode, + createVNode("uni-content", null, [ + createVNode("uni-main", null, [routerVNode]), + leftWindowVNode, + rightWindowVNode + ]) + ]); +} +function createTabBarVNode(route) { + return __UNI_FEATURE_TABBAR__ ? withDirectives(createVNode(TabBar, null, null, 512), [ + [vShow, route.meta.isTabBar] + ]) : createCommentVNode("", true); +} +function createPageVNode() { + return createVNode(__uniRoutes[1].component); +} +function createRouterViewVNode(keepAliveRoute) { + return createVNode(RouterView, null, { + default: withCtx(({Component}) => [ + (openBlock(), createBlock(KeepAlive, {cache: keepAliveRoute.routeCache}, [ + (openBlock(), createBlock(resolveDynamicComponent(Component), { + key: keepAliveRoute.routeKey.value + })) + ], 1032, ["cache"])) + ]), + _: 1 + }); +} +function useTopWindow() { + const component = resolveComponent("VUniTopWindow"); + return { + component, + style: component.style, + height: 0, + show: false + }; +} +function useLeftWindow() { + const component = resolveComponent("VUniLeftWindow"); + return { + component, + style: component.style, + height: 0 + }; +} +function useRightWindow() { + const component = resolveComponent("VUniRightWindow"); + return { + component, + style: component.style, + height: 0 + }; +} +function createTopWindowVNode(topWindow) { + if (!__UNI_FEATURE_TOPWINDOW__) { + return createCommentVNode("", true); + } + const {component, style, height, show} = useTopWindow(); + return withDirectives(createVNode("uni-top-window", null, [ + createVNode("div", { + ref: "topWindow", + class: "uni-top-window", + style + }, [ + createVNode(component, mergeProps({ + onVnodeMounted(vnode) { + }, + "navigation-bar-title-text": "" + }), null, 16, ["navigation-bar-title-text"]) + ], 4), + createVNode("div", { + class: "uni-top-window--placeholder", + style: {height} + }, null, 4) + ], 512), [[vShow, show]]); +} +function createLeftWindowVNode(leftWindow) { +} +function createRightWindowVNode(leftWindow) { +} +function appendCss(css, cssId, replace = false) { + let style = document.getElementById(cssId); + if (style && replace) { + style.parentNode.removeChild(style); + style = null; + } + if (!style) { + style = document.createElement("style"); + style.type = "text/css"; + cssId && (style.id = cssId); + document.getElementsByTagName("head")[0].appendChild(style); + } + style.appendChild(document.createTextNode(css)); +} +const screen = window.screen; +const documentElement = document.documentElement; +let styleObj; +function updateCssVar(name, value) { + if (!styleObj) { + styleObj = documentElement.style; + } + styleObj.setProperty(name, value); +} +function checkMinWidth(minWidth) { + const sizes = [ + window.outerWidth, + window.outerHeight, + screen.width, + screen.height, + documentElement.clientWidth, + documentElement.clientHeight + ]; + return Math.max.apply(null, sizes) > minWidth; +} +const CSS_VARS = [ + "--status-bar-height", + "--top-window-height", + "--window-left", + "--window-right", + "--window-margin" +]; +var AppComponent = defineComponent({ + name: "App", + setup() { + useCssVar(); + useAppLifecycle(); + const {appClass, onLayoutChange} = useAppClass(); + return () => (openBlock(), createBlock("uni-app", { + class: appClass.value + }, [ + createVNode(Layout, { + onChange: onLayoutChange + }, null, 8, ["onChange"]) + ], 2)); + } +}); +function useCssVar() { + CSS_VARS.forEach((name) => updateCssVar(name, "0px")); +} +function useAppLifecycle() { + onMounted(() => { + document.addEventListener("visibilitychange", function() { + if (document.visibilityState === "visible") { + UniServiceJSBridge.emit("onAppEnterForeground"); + } else { + UniServiceJSBridge.emit("onAppEnterBackground"); + } + }); + }); +} +function useAppClass() { + const showTabBar = ref(false); + const showMaxWidth = ref(false); + function onLayoutChange(type, value) { + if (type === "showTabBar") { + showTabBar.value = value; + } else if (type === "showMaxWidth") { + showMaxWidth.value = value; + } + } + const appClass = computed(() => { + return { + "uni-app--showtabbar": showTabBar.value, + "uni-app--maxwidth": showMaxWidth.value + }; + }); + return { + appClass, + onLayoutChange + }; +} +const _sfc_main$u = {}; +const _hoisted_1$e = /* @__PURE__ */ createVNode("uni-top-window", null, null, -1); +function _sfc_render$s(_ctx, _cache) { + const _component_router_view = resolveComponent("router-view"); + return openBlock(), createBlock("uni-layout", null, [ + _hoisted_1$e, + createVNode("uni-content", null, [ + createVNode("uni-main", null, [ + (openBlock(), createBlock(KeepAlive, null, [ + createVNode(_component_router_view) + ], 1024)) + ]) + ]) + ]); +} +_sfc_main$u.render = _sfc_render$s; +function initSystemComponents(app) { + AppComponent.name = COMPONENT_NAME_PREFIX + AppComponent.name; + app.component(AppComponent.name, AppComponent); + app.component(_sfc_main$u.name, _sfc_main$u); +} +function initMixin(app) { + app.mixin({ + created() { + if (isApp(this)) { + initApp(this); + } else if (isPage(this)) { + initPage(this); + this.$callHook("onLoad", {}); + this.$callHook("onShow"); } }, - list: { - type: Array, - default: function() { - return []; + mounted() { + if (isPage(this)) { + this.$callHook("onReady"); } } - }, - computed: { - borderColor() { - return this.borderStyle === "white" ? "rgba(255, 255, 255, 0.33)" : "rgba(0, 0, 0, 0.33)"; + }); +} +function initLayout(router) { + if (!__UNI_FEATURE_RESPONSIVE__) { + return {}; + } + initTopWindow(router); + initLeftWindow(); + initRightWindow(); + return {}; +} +function initMediaQuery(minWidth, callback) { + const mediaQueryList = window.matchMedia("(min-width: " + minWidth + "px)"); + if (mediaQueryList.addEventListener) { + mediaQueryList.addEventListener("change", callback); + } else { + mediaQueryList.addListener(callback); + } +} +function initTopWindow(router) { + const res = { + matchTopWindow: ref(false), + topWindowStyle: ref({}), + showTopWindow: ref(false) + }; + if (__UNI_FEATURE_TOPWINDOW__) { + return _initTopWindow(res, router); + } + return res; +} +function _initTopWindow(res, router) { + let topWindowMinWidth = RESPONSIVE_MIN_WIDTH; + const {matchMedia, style} = __uniConfig.topWindow; + if (matchMedia && hasOwn$1(matchMedia, "minWidth")) { + topWindowMinWidth = matchMedia.minWidth; + } + if (checkMinWidth(topWindowMinWidth)) { + initMediaQuery(topWindowMinWidth, (ev) => { + res.matchTopWindow.value = ev.matches; + nextTick(() => { + }); + }); + } + res.topWindowStyle = ref(style); + res.showTopWindow = computed(() => { + if (!res.matchTopWindow.value) { + return false; } - }, - watch: { - $route(to, from) { - if (to.meta.isTabBar) { - this.__path__ = to.path; - } + if (router && !router.currentRoute.value.meta.topWindow) { + return false; } - }, - beforeCreate() { - this.__path__ = this.$route.path; - }, - methods: { - _getRealPath(filePath) { - if (filePath.indexOf("/") !== 0) { - filePath = "/" + filePath; - } - return this.$getRealPath(filePath); - }, - _switchTab({ - text: text2, - pagePath - }, index2) { - let url = "/" + pagePath; - if (url === __uniRoutes[0].alias) { - url = "/"; - } - const detail = { - index: index2, - text: text2, - pagePath - }; - if (this.$route.path !== url) { - this.__path__ = this.$route.path; - uni.switchTab({ - from: "tabBar", - url, - detail - }); - } else { - UniServiceJSBridge.emit("onTabItemTap", detail); - } + return true; + }); + return res; +} +function initLeftWindow() { + let leftWindowMinWidth = RESPONSIVE_MIN_WIDTH; + if (__UNI_FEATURE_LEFTWINDOW__) { + const {matchMedia} = __uniConfig.leftWindow; + if (matchMedia && hasOwn$1(matchMedia, "minWidth")) { + leftWindowMinWidth = matchMedia.minWidth; + } + } + return {leftWindowMinWidth}; +} +function initRightWindow() { + let rightWindowMinWidth = RESPONSIVE_MIN_WIDTH; + if (__UNI_FEATURE_RIGHTWINDOW__) { + const {matchMedia} = __uniConfig.rightWindow; + if (matchMedia && hasOwn$1(matchMedia, "minWidth")) { + rightWindowMinWidth = matchMedia.minWidth; } } + return {rightWindowMinWidth}; +} +const layoutKey = PolySymbol(process.env.NODE_ENV !== "production" ? "layout" : "l"); +function initProvide(app, router) { + app.provide(layoutKey, initLayout(router)); +} +var index = { + install(app) { + app._context.config.isCustomElement = isCustomElement; + initApp$1(app); + initView(app); + initService(app); + initSystemComponents(app); + initMixin(app); + initProvide(app, __UNI_FEATURE_PAGES__ && initRouter(app) || void 0); + } }; -const _hoisted_1$h = {class: "uni-tabbar__bd"}; -const _hoisted_2$b = /* @__PURE__ */ createVNode("div", {class: "uni-placeholder"}, null, -1); -function _sfc_render$w(_ctx, _cache, $props, $setup, $data, $options) { - return openBlock(), createBlock("uni-tabbar", null, [ - createVNode("div", { - style: {backgroundColor: $props.backgroundColor}, - class: "uni-tabbar" - }, [ - createVNode("div", { - style: {backgroundColor: $options.borderColor}, - class: "uni-tabbar-border" - }, null, 4), - (openBlock(true), createBlock(Fragment, null, renderList($props.list, (item, index2) => { - return openBlock(), createBlock("div", { - key: item.pagePath, - class: "uni-tabbar__item", - onClick: ($event) => $options._switchTab(item, index2) - }, [ - createVNode("div", _hoisted_1$h, [ - item.iconPath ? (openBlock(), createBlock("div", { - key: 0, - class: [{"uni-tabbar__icon__diff": !item.text}, "uni-tabbar__icon"] - }, [ - createVNode("img", { - src: $options._getRealPath(_ctx.$route.meta.pagePath === item.pagePath ? item.selectedIconPath : item.iconPath) - }, null, 8, ["src"]), - item.redDot ? (openBlock(), createBlock("div", { - key: 0, - class: [{"uni-tabbar__badge": !!item.badge}, "uni-tabbar__reddot"] - }, toDisplayString(item.badge), 3)) : createCommentVNode("", true) - ], 2)) : createCommentVNode("", true), - item.text ? (openBlock(), createBlock("div", { - key: 1, - style: {color: _ctx.$route.meta.pagePath === item.pagePath ? $props.selectedColor : $props.color, fontSize: item.iconPath ? "10px" : "14px"}, - class: "uni-tabbar__label" - }, [ - createTextVNode(toDisplayString(item.text) + " ", 1), - item.redDot && !item.iconPath ? (openBlock(), createBlock("div", { - key: 0, - class: [{"uni-tabbar__badge": !!item.badge}, "uni-tabbar__reddot"] - }, toDisplayString(item.badge), 3)) : createCommentVNode("", true) - ], 4)) : createCommentVNode("", true) - ]) - ], 8, ["onClick"]); - }), 128)) - ], 4), - _hoisted_2$b - ]); +function broadcast(componentName, eventName, ...params) { + const children = this.$children; + const len = children.length; + for (let i = 0; i < len; i++) { + const child = children[i]; + const name = child.$options.name && child.$options.name.substr(4); + if (~componentName.indexOf(name)) { + child.$emit.apply(child, [eventName].concat(params)); + return false; + } else { + if (broadcast.apply(child, [componentName, eventName].concat([params])) === false) { + return false; + } + } + } } -_sfc_main$y.render = _sfc_render$w; -var Transtion = { +var emitter = { methods: { - beforeTransition() { + $dispatch(componentName, eventName, ...params) { + console.log("$dispatch", componentName, eventName, params); }, - afterTransition() { + $broadcast(componentName, eventName, ...params) { + if (typeof componentName === "string") { + componentName = [componentName]; + } + broadcast.apply(this, [componentName, eventName].concat(params)); } } }; -var toast_vue_vue_type_style_index_0_lang = "\nuni-toast {\r\n position: fixed;\r\n top: 0;\r\n right: 0;\r\n bottom: 0;\r\n left: 0;\r\n z-index: 999;\r\n display: block;\r\n box-sizing: border-box;\r\n pointer-events: none;\n}\nuni-toast .uni-sample-toast {\r\n position: fixed;\r\n z-index: 999;\r\n top: 50%;\r\n left: 50%;\r\n transform: translate(-50%, -50%);\r\n text-align: center;\r\n max-width: 80%;\n}\nuni-toast .uni-simple-toast__text {\r\n display: inline-block;\r\n vertical-align: middle;\r\n color: #ffffff;\r\n background-color: rgba(17, 17, 17, 0.7);\r\n padding: 10px 20px;\r\n border-radius: 5px;\r\n font-size: 13px;\r\n text-align: center;\r\n max-width: 100%;\r\n word-break: break-all;\r\n white-space: normal;\n}\nuni-toast .uni-mask {\r\n pointer-events: auto;\n}\nuni-toast .uni-toast {\r\n position: fixed;\r\n z-index: 999;\r\n width: 8em;\r\n top: 50%;\r\n left: 50%;\r\n transform: translate(-50%, -50%);\r\n background: rgba(17, 17, 17, 0.7);\r\n text-align: center;\r\n border-radius: 5px;\r\n color: #ffffff;\n}\nuni-toast .uni-toast * {\r\n box-sizing: border-box;\n}\nuni-toast .uni-toast__icon {\r\n margin: 20px 0 0;\r\n width: 38px;\r\n height: 38px;\r\n vertical-align: baseline;\n}\nuni-toast .uni-icon_toast {\r\n margin: 15px 0 0;\n}\nuni-toast .uni-icon_toast.uni-icon-success-no-circle:before {\r\n color: #ffffff;\r\n font-size: 55px;\n}\nuni-toast .uni-icon_toast.uni-loading {\r\n margin: 20px 0 0;\r\n width: 38px;\r\n height: 38px;\r\n vertical-align: baseline;\n}\nuni-toast .uni-toast__content {\r\n margin: 0 0 15px;\n}\r\n"; -const _sfc_main$x = { - name: "Toast", - mixins: [Transtion], +var listeners = { props: { - title: { + id: { type: String, default: "" - }, - icon: { - default: "success", - validator(value) { - return ["success", "loading", "none"].indexOf(value) !== -1; - } - }, - image: { - type: String, - default: "" - }, - duration: { - type: Number, - default: 1500 - }, - mask: { - type: Boolean, - default: false - }, - visible: { - type: Boolean, - default: false } }, - computed: { - iconClass() { - if (this.icon === "success") { - return "uni-icon-success-no-circle"; + created() { + this._addListeners(this.id); + this.$watch("id", (newId, oldId) => { + this._removeListeners(oldId, true); + this._addListeners(newId, true); + }); + }, + beforeDestroy() { + this._removeListeners(this.id); + }, + methods: { + _addListeners(id2, watch) { + if (watch && !id2) { + return; } - if (this.icon === "loading") { - return "uni-loading"; + const {listeners: listeners2} = this.$options; + if (!isPlainObject(listeners2)) { + return; } - return ""; - } - }, - beforeUpdate() { - if (this.visible) { - this.timeoutId && clearTimeout(this.timeoutId); - this.timeoutId = setTimeout(() => { - UniServiceJSBridge.emit("onHideToast"); - }, this.duration); + Object.keys(listeners2).forEach((name) => { + if (watch) { + if (name.indexOf("@") !== 0 && name.indexOf("uni-") !== 0) { + UniViewJSBridge.on(`uni-${name}-${this.$page.id}-${id2}`, this[listeners2[name]]); + } + } else { + if (name.indexOf("@") === 0) { + this.$on(`uni-${name.substr(1)}`, this[listeners2[name]]); + } else if (name.indexOf("uni-") === 0) { + UniViewJSBridge.on(name, this[listeners2[name]]); + } else if (id2) { + UniViewJSBridge.on(`uni-${name}-${this.$page.id}-${id2}`, this[listeners2[name]]); + } + } + }); + }, + _removeListeners(id2, watch) { + if (watch && !id2) { + return; + } + const {listeners: listeners2} = this.$options; + if (!isPlainObject(listeners2)) { + return; + } + Object.keys(listeners2).forEach((name) => { + if (watch) { + if (name.indexOf("@") !== 0 && name.indexOf("uni-") !== 0) { + UniViewJSBridge.off(`uni-${name}-${this.$page.id}-${id2}`, this[listeners2[name]]); + } + } else { + if (name.indexOf("@") === 0) { + this.$off(`uni-${name.substr(1)}`, this[listeners2[name]]); + } else if (name.indexOf("uni-") === 0) { + UniViewJSBridge.off(name, this[listeners2[name]]); + } else if (id2) { + UniViewJSBridge.off(`uni-${name}-${this.$page.id}-${id2}`, this[listeners2[name]]); + } + } + }); } } }; -const _hoisted_1$g = { - key: 1, - class: "uni-sample-toast" -}; -const _hoisted_2$a = {class: "uni-simple-toast__text"}; -const _hoisted_3$6 = { - key: 2, - class: "uni-toast" -}; -const _hoisted_4$5 = {class: "uni-toast__content"}; -function _sfc_render$v(_ctx, _cache, $props, $setup, $data, $options) { - return openBlock(), createBlock(Transition, {name: "uni-fade"}, { - default: withCtx(() => [ - $props.visible ? (openBlock(), createBlock("uni-toast", { - key: 0, - "data-duration": $props.duration - }, [ - $props.mask ? (openBlock(), createBlock("div", { - key: 0, - class: "uni-mask", - style: {background: "transparent"}, - onTouchmovePassive: _cache[1] || (_cache[1] = withModifiers(() => { - }, ["prevent"])) - }, null, 32)) : createCommentVNode("", true), - !$props.image && !$options.iconClass ? (openBlock(), createBlock("div", _hoisted_1$g, [ - createVNode("p", _hoisted_2$a, toDisplayString($props.title), 1) - ])) : (openBlock(), createBlock("div", _hoisted_3$6, [ - $props.image ? (openBlock(), createBlock("img", { - key: 0, - src: $props.image, - class: "uni-toast__icon" - }, null, 8, ["src"])) : (openBlock(), createBlock("i", { - key: 1, - class: [$options.iconClass, "uni-icon_toast"] - }, null, 2)), - createVNode("p", _hoisted_4$5, toDisplayString($props.title), 1) - ])) - ], 8, ["data-duration"])) : createCommentVNode("", true) - ]), - _: 1 - }); -} -_sfc_main$x.render = _sfc_render$v; -var modal_vue_vue_type_style_index_0_lang = '\nuni-modal {\r\n position: fixed;\r\n top: 0;\r\n right: 0;\r\n bottom: 0;\r\n left: 0;\r\n z-index: 999;\r\n display: block;\r\n box-sizing: border-box;\n}\nuni-modal .uni-modal {\r\n position: fixed;\r\n z-index: 999;\r\n width: 80%;\r\n max-width: 300px;\r\n top: 50%;\r\n left: 50%;\r\n transform: translate(-50%, -50%);\r\n background-color: #ffffff;\r\n text-align: center;\r\n border-radius: 3px;\r\n overflow: hidden;\n}\nuni-modal .uni-modal * {\r\n box-sizing: border-box;\n}\nuni-modal .uni-modal__hd {\r\n padding: 1em 1.6em 0.3em;\n}\nuni-modal .uni-modal__title {\r\n font-weight: 400;\r\n font-size: 18px;\r\n word-wrap:break-word;\r\n word-break:break-all;\r\n white-space: pre-wrap;\r\n overflow : hidden;\r\n text-overflow: ellipsis;\r\n display: -webkit-box;\r\n -webkit-line-clamp: 2;\r\n -webkit-box-orient: vertical;\n}\nuni-modal .uni-modal__bd {\r\n padding: 1.3em 1.6em 1.3em;\r\n min-height: 40px;\r\n font-size: 15px;\r\n line-height: 1.4;\r\n word-wrap: break-word;\r\n word-break: break-all;\r\n white-space: pre-wrap;\r\n color: #999999;\r\n max-height: 400px;\r\n overflow-y: auto;\n}\nuni-modal .uni-modal__ft {\r\n position: relative;\r\n line-height: 48px;\r\n font-size: 18px;\r\n display: flex;\n}\nuni-modal .uni-modal__ft:after {\r\n content: " ";\r\n position: absolute;\r\n left: 0;\r\n top: 0;\r\n right: 0;\r\n height: 1px;\r\n border-top: 1px solid #d5d5d6;\r\n color: #d5d5d6;\r\n transform-origin: 0 0;\r\n transform: scaleY(0.5);\n}\nuni-modal .uni-modal__btn {\r\n display: block;\r\n flex: 1;\r\n color: #3cc51f;\r\n text-decoration: none;\r\n -webkit-tap-highlight-color: rgba(0, 0, 0, 0);\r\n position: relative;\n}\nuni-modal .uni-modal__btn:active {\r\n background-color: #eeeeee;\n}\nuni-modal .uni-modal__btn:after {\r\n content: " ";\r\n position: absolute;\r\n left: 0;\r\n top: 0;\r\n width: 1px;\r\n bottom: 0;\r\n border-left: 1px solid #d5d5d6;\r\n color: #d5d5d6;\r\n transform-origin: 0 0;\r\n transform: scaleX(0.5);\n}\nuni-modal .uni-modal__btn:first-child:after {\r\n display: none;\n}\nuni-modal .uni-modal__btn_default {\r\n color: #353535;\n}\nuni-modal .uni-modal__btn_primary {\r\n color: #007aff;\n}\r\n'; -const _sfc_main$w = { - name: "Modal", - mixins: [Transtion], +var hover = { + data() { + return { + hovering: false + }; + }, props: { - title: { - type: String, - default: "" - }, - content: { + hoverClass: { type: String, - default: "" + default: "none" }, - showCancel: { + hoverStopPropagation: { type: Boolean, - default: true + default: false }, - cancelText: { - type: String, - default: "\u53D6\u6D88" + hoverStartTime: { + type: [Number, String], + default: 50 }, - cancelColor: { - type: String, - default: "#000000" + hoverStayTime: { + type: [Number, String], + default: 400 + } + }, + methods: { + _hoverTouchStart(evt) { + if (evt._hoverPropagationStopped) { + return; + } + if (!this.hoverClass || this.hoverClass === "none" || this.disabled) { + return; + } + if (evt.touches.length > 1) { + return; + } + if (this.hoverStopPropagation) { + evt._hoverPropagationStopped = true; + } + this._hoverTouch = true; + this._hoverStartTimer = setTimeout(() => { + this.hovering = true; + if (!this._hoverTouch) { + this._hoverReset(); + } + }, this.hoverStartTime); }, - confirmText: { - type: String, - default: "\u786E\u5B9A" + _hoverTouchEnd(evt) { + this._hoverTouch = false; + if (this.hovering) { + this._hoverReset(); + } }, - confirmColor: { - type: String, - default: "#007aff" + _hoverReset() { + requestAnimationFrame(() => { + clearTimeout(this._hoverStayTimer); + this._hoverStayTimer = setTimeout(() => { + this.hovering = false; + }, this.hoverStayTime); + }); }, - visible: { - type: Boolean, - default: false + _hoverTouchCancel(evt) { + this._hoverTouch = false; + this.hovering = false; + clearTimeout(this._hoverStartTimer); + } + } +}; +var subscriber = { + mounted() { + this._toggleListeners("subscribe", this.id); + this.$watch("id", (newId, oldId) => { + this._toggleListeners("unsubscribe", oldId, true); + this._toggleListeners("subscribe", newId, true); + }); + }, + beforeDestroy() { + this._toggleListeners("unsubscribe", this.id); + if (this._contextId) { + this._toggleListeners("unsubscribe", this._contextId); } }, methods: { - _close(type) { - this.$emit("close", type); + _toggleListeners(type, id2, watch) { + if (watch && !id2) { + return; + } + if (!isFunction(this._handleSubscribe)) { + return; + } + UniViewJSBridge[type](this.$page.id + "-" + this.$options.name.replace(/VUni([A-Z])/, "$1").toLowerCase() + "-" + id2, this._handleSubscribe); + }, + _getContextInfo() { + const id2 = `context-${this._uid}`; + if (!this._contextId) { + this._toggleListeners("subscribe", id2); + this._contextId = id2; + } + return { + name: this.$options.name.replace(/VUni([A-Z])/, "$1").toLowerCase(), + id: id2, + page: this.$page.id + }; } } }; -const _hoisted_1$f = /* @__PURE__ */ createVNode("div", {class: "uni-mask"}, null, -1); -const _hoisted_2$9 = {class: "uni-modal"}; -const _hoisted_3$5 = { - key: 0, - class: "uni-modal__hd" -}; -const _hoisted_4$4 = {class: "uni-modal__ft"}; -function _sfc_render$u(_ctx, _cache, $props, $setup, $data, $options) { - return openBlock(), createBlock(Transition, {name: "uni-fade"}, { - default: withCtx(() => [ - withDirectives(createVNode("uni-modal", { - onTouchmovePassive: _cache[4] || (_cache[4] = withModifiers(() => { - }, ["prevent"])) - }, [ - _hoisted_1$f, - createVNode("div", _hoisted_2$9, [ - $props.title ? (openBlock(), createBlock("div", _hoisted_3$5, [ - createVNode("strong", { - class: "uni-modal__title", - textContent: toDisplayString($props.title) - }, null, 8, ["textContent"]) - ])) : createCommentVNode("", true), - createVNode("div", { - class: "uni-modal__bd", - onTouchmovePassive: _cache[1] || (_cache[1] = withModifiers(() => { - }, ["stop"])), - textContent: toDisplayString($props.content) - }, null, 40, ["textContent"]), - createVNode("div", _hoisted_4$4, [ - $props.showCancel ? (openBlock(), createBlock("div", { - key: 0, - style: {color: $props.cancelColor}, - class: "uni-modal__btn uni-modal__btn_default", - onClick: _cache[2] || (_cache[2] = ($event) => $options._close("cancel")) - }, toDisplayString($props.cancelText), 5)) : createCommentVNode("", true), - createVNode("div", { - style: {color: $props.confirmColor}, - class: "uni-modal__btn uni-modal__btn_primary", - onClick: _cache[3] || (_cache[3] = ($event) => $options._close("confirm")) - }, toDisplayString($props.confirmText), 5) - ]) - ]) - ], 544), [ - [vShow, $props.visible] - ]) - ]), - _: 1 - }); +function hideKeyboard() { + document.activeElement.blur(); +} +function iosHideKeyboard() { } -_sfc_main$w.render = _sfc_render$u; -var actionSheet_vue_vue_type_style_index_0_lang = '\nuni-actionsheet {\r\n display: block;\r\n box-sizing: border-box;\n}\nuni-actionsheet .uni-actionsheet {\r\n position: fixed;\r\n left: 0;\r\n bottom: 0;\r\n transform: translate(0, 100%);\r\n backface-visibility: hidden;\r\n z-index: 999;\r\n width: 100%;\r\n background-color: #efeff4;\r\n visibility: hidden;\r\n transition: transform 0.3s, visibility 0.3s;\n}\nuni-actionsheet .uni-actionsheet.uni-actionsheet_toggle {\r\n visibility: visible;\r\n transform: translate(0, 0);\n}\nuni-actionsheet .uni-actionsheet * {\r\n box-sizing: border-box;\n}\nuni-actionsheet .uni-actionsheet__menu {\r\n background-color: #fcfcfd;\n}\nuni-actionsheet .uni-actionsheet__action {\r\n margin-top: 6px;\r\n background-color: #fcfcfd;\n}\nuni-actionsheet .uni-actionsheet__cell ,\r\n uni-actionsheet .uni-actionsheet__title {\r\n position: relative;\r\n padding: 10px 0;\r\n text-align: center;\r\n font-size: 18px;\n}\nuni-actionsheet .uni-actionsheet__cell:before {\r\n content: " ";\r\n position: absolute;\r\n left: 0;\r\n top: 0;\r\n right: 0;\r\n height: 1px;\r\n border-top: 1px solid #e5e5e5;\r\n color: #e5e5e5;\r\n transform-origin: 0 0;\r\n transform: scaleY(0.5);\n}\nuni-actionsheet .uni-actionsheet__cell:active {\r\n background-color: #ececec;\n}\nuni-actionsheet .uni-actionsheet__cell:first-child:before {\r\n display: none;\n}\r\n'; -const _sfc_main$v = { - name: "ActionSheet", +var keyboard = { + name: "Keyboard", props: { - title: { - type: String, - default: "" - }, - itemList: { - type: Array, - default() { - return []; - } + cursorSpacing: { + type: [Number, String], + default: 0 }, - itemColor: { - type: String, - default: "#000000" + showConfirmBar: { + type: [Boolean, String], + default: "auto" }, - visible: { + adjustPosition: { type: Boolean, - default: false + default: true } }, - methods: { - _close(tapIndex) { - this.$emit("close", tapIndex); - } - } -}; -const _hoisted_1$e = {class: "uni-actionsheet__menu"}; -const _hoisted_2$8 = { - key: 0, - class: "uni-actionsheet__title" -}; -const _hoisted_3$4 = {class: "uni-actionsheet__action"}; -function _sfc_render$t(_ctx, _cache, $props, $setup, $data, $options) { - return openBlock(), createBlock("uni-actionsheet", { - onTouchmovePassive: _cache[3] || (_cache[3] = withModifiers(() => { - }, ["prevent"])) - }, [ - createVNode(Transition, {name: "uni-fade"}, { - default: withCtx(() => [ - withDirectives(createVNode("div", { - class: "uni-mask", - onClick: _cache[1] || (_cache[1] = ($event) => $options._close(-1)) - }, null, 512), [ - [vShow, $props.visible] - ]) - ]), - _: 1 - }), - createVNode("div", { - class: [{"uni-actionsheet_toggle": $props.visible}, "uni-actionsheet"] - }, [ - createVNode("div", _hoisted_1$e, [ - $props.title ? (openBlock(), createBlock("div", _hoisted_2$8, toDisplayString($props.title), 1)) : createCommentVNode("", true), - (openBlock(true), createBlock(Fragment, null, renderList($props.itemList, (itemTitle, index2) => { - return openBlock(), createBlock("div", { - key: index2, - style: {color: $props.itemColor}, - class: "uni-actionsheet__cell", - onClick: ($event) => $options._close(index2) - }, toDisplayString(itemTitle), 13, ["onClick"]); - }), 128)) - ]), - createVNode("div", _hoisted_3$4, [ - createVNode("div", { - style: {color: $props.itemColor}, - class: "uni-actionsheet__cell", - onClick: _cache[2] || (_cache[2] = ($event) => $options._close(-1)) - }, " \u53D6\u6D88 ", 4) - ]) - ], 2) - ], 32); -} -_sfc_main$v.render = _sfc_render$t; -var Components = { - Toast: _sfc_main$x, - Modal: _sfc_main$w, - ActionSheet: _sfc_main$v -}; -var components = __assign({ - TabBar: _sfc_main$y -}, Components); -var ActionSheet = { - data() { - return { - showActionSheet: { - visible: false + watch: { + focus(val) { + if (val && false) { + this.showSoftKeybord(); } - }; - }, - created() { - UniServiceJSBridge.on("onShowActionSheet", (args, callback) => { - this.showActionSheet = args; - this.onActionSheetCloseCallback = callback; - }); - UniServiceJSBridge.on("onHidePopup", (args) => { - this.showActionSheet.visible = false; - }); + } }, - methods: { - _onActionSheetClose(type) { - this.showActionSheet.visible = false; - isFunction(this.onActionSheetCloseCallback) && this.onActionSheetCloseCallback(type); + mounted() { + if (this.autoFocus || this.focus) { + this.showSoftKeybord(); } - } -}; -var Modal = { - data() { - return { - showModal: { - visible: false - } - }; }, - created() { - UniServiceJSBridge.on("onShowModal", (args, callback) => { - this.showModal = args; - this.onModalCloseCallback = callback; - }); - UniServiceJSBridge.on("onHidePopup", (args) => { - this.showModal.visible = false; - }); + beforeDestroy() { + this.onKeyboardHide(); }, methods: { - _onModalClose(type) { - this.showModal.visible = false; - isFunction(this.onModalCloseCallback) && this.onModalCloseCallback(type); - } - } + initKeyboard(el) { + el.addEventListener("focus", () => { + this.hideKeyboardTemp = function() { + hideKeyboard(); + }; + UniViewJSBridge.subscribe("hideKeyboard", this.hideKeyboardTemp); + document.addEventListener("click", iosHideKeyboard, false); + }); + el.addEventListener("blur", this.onKeyboardHide.bind(this)); + }, + showSoftKeybord() { + plusReady(() => { + plus.key.showSoftKeybord(); + }); + }, + setSoftinputTemporary() { + plusReady(() => { + const currentWebview = plus.webview.currentWebview(); + const style = currentWebview.getStyle() || {}; + const rect = this.$el.getBoundingClientRect(); + currentWebview.setSoftinputTemporary && currentWebview.setSoftinputTemporary({ + mode: style.softinputMode === "adjustResize" ? "adjustResize" : this.adjustPosition ? "adjustPan" : "nothing", + position: { + top: rect.top, + height: rect.height + (Number(this.cursorSpacing) || 0) + } + }); + }); + }, + setSoftinputNavBar() { + if (this.showConfirmBar === "auto") { + delete this.__softinputNavBar; + return; + } + plusReady(() => { + const currentWebview = plus.webview.currentWebview(); + const {softinputNavBar} = currentWebview.getStyle() || {}; + const showConfirmBar = softinputNavBar !== "none"; + if (showConfirmBar !== this.showConfirmBar) { + this.__softinputNavBar = softinputNavBar || "auto"; + currentWebview.setStyle({ + softinputNavBar: this.showConfirmBar ? "auto" : "none" + }); + } else { + delete this.__softinputNavBar; + } + }); + }, + resetSoftinputNavBar() { + const softinputNavBar = this.__softinputNavBar; + if (softinputNavBar) { + plusReady(() => { + const currentWebview = plus.webview.currentWebview(); + currentWebview.setStyle({ + softinputNavBar + }); + }); + } + }, + onKeyboardHide() { + UniViewJSBridge.unsubscribe("hideKeyboard", this.hideKeyboardTemp); + document.removeEventListener("click", iosHideKeyboard, false); + if (String(navigator.vendor).indexOf("Apple") === 0) { + document.documentElement.scrollTo(document.documentElement.scrollLeft, document.documentElement.scrollTop); + } + } + } }; -var Toast = { +function throttle(fn, wait) { + let last = 0; + let timeout; + const newFn = function(...arg) { + const now = Date.now(); + clearTimeout(timeout); + const waitCallback = () => { + last = now; + fn.apply(this, arg); + }; + if (now - last < wait) { + timeout = setTimeout(waitCallback, wait - (now - last)); + return; + } + waitCallback(); + }; + newFn.cancel = function() { + clearTimeout(timeout); + }; + return newFn; +} +var baseInput = { + name: "BaseInput", + mixins: [emitter, keyboard], + model: { + prop: "value", + event: "update:value" + }, + props: { + value: { + type: [String, Number], + default: "" + } + }, data() { return { - showToast: { - visible: false - } + valueSync: this._getValueString(this.value) }; }, created() { - let showType = ""; - const createOnShow = (type) => { - return (args) => { - showType = type; - setTimeout(() => { - this.showToast = args; - }, 10); - }; - }; - UniServiceJSBridge.on("onShowToast", createOnShow("onShowToast")); - UniServiceJSBridge.on("onShowLoading", createOnShow("onShowLoading")); - const createOnHide = (type) => { - return () => { - if (!showType) { - return; - } - let warnMsg = ""; - if (type === "onHideToast" && showType !== "onShowToast") { - warnMsg = "\u8BF7\u6CE8\u610F showToast \u4E0E hideToast \u5FC5\u987B\u914D\u5BF9\u4F7F\u7528"; - } else if (type === "onHideLoading" && showType !== "onShowLoading") { - warnMsg = "\u8BF7\u6CE8\u610F showLoading \u4E0E hideLoading \u5FC5\u987B\u914D\u5BF9\u4F7F\u7528"; - } - if (warnMsg) { - return console.warn(warnMsg); - } - showType = ""; - setTimeout(() => { - this.showToast.visible = false; - }, 10); - }; + const valueChange = this.__valueChange = debounce((val) => { + this.valueSync = this._getValueString(val); + }, 100); + this.$watch("value", valueChange); + this.__triggerInput = throttle(($event, detail) => { + this.$emit("update:value", detail.value); + this.$trigger("input", $event, detail); + }, 100); + this.$triggerInput = ($event, detail) => { + this.__valueChange.cancel(); + this.__triggerInput($event, detail); }; - UniServiceJSBridge.on("onHidePopup", createOnHide("onHidePopup")); - UniServiceJSBridge.on("onHideToast", createOnHide("onHideToast")); - UniServiceJSBridge.on("onHideLoading", createOnHide("onHideLoading")); + }, + beforeDestroy() { + this.__valueChange.cancel(); + this.__triggerInput.cancel(); + }, + methods: { + _getValueString(value) { + return value === null ? "" : String(value); + } } }; -var mixins = [ActionSheet, Modal, Toast, Transtion]; -var chars = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/"; -var lookup = new Uint8Array(256); -for (var i$1 = 0; i$1 < chars.length; i$1++) { - lookup[chars.charCodeAt(i$1)] = i$1; -} -function encode(arraybuffer) { - var bytes = new Uint8Array(arraybuffer), i2, len = bytes.length, base64 = ""; - for (i2 = 0; i2 < len; i2 += 3) { - base64 += chars[bytes[i2] >> 2]; - base64 += chars[(bytes[i2] & 3) << 4 | bytes[i2 + 1] >> 4]; - base64 += chars[(bytes[i2 + 1] & 15) << 2 | bytes[i2 + 2] >> 6]; - base64 += chars[bytes[i2 + 2] & 63]; - } - if (len % 3 === 2) { - base64 = base64.substring(0, base64.length - 1) + "="; - } else if (len % 3 === 1) { - base64 = base64.substring(0, base64.length - 2) + "=="; - } - return base64; -} -function decode(base64) { - var bufferLength = base64.length * 0.75, len = base64.length, i2, p2 = 0, encoded1, encoded2, encoded3, encoded4; - if (base64[base64.length - 1] === "=") { - bufferLength--; - if (base64[base64.length - 2] === "=") { - bufferLength--; +let supportsPassive$1 = false; +try { + const opts = {}; + Object.defineProperty(opts, "passive", { + get() { + supportsPassive$1 = true; } - } - var arraybuffer = new ArrayBuffer(bufferLength), bytes = new Uint8Array(arraybuffer); - for (i2 = 0; i2 < len; i2 += 4) { - encoded1 = lookup[base64.charCodeAt(i2)]; - encoded2 = lookup[base64.charCodeAt(i2 + 1)]; - encoded3 = lookup[base64.charCodeAt(i2 + 2)]; - encoded4 = lookup[base64.charCodeAt(i2 + 3)]; - bytes[p2++] = encoded1 << 2 | encoded2 >> 4; - bytes[p2++] = (encoded2 & 15) << 4 | encoded3 >> 2; - bytes[p2++] = (encoded3 & 3) << 6 | encoded4 & 63; - } - return arraybuffer; -} -function validateProtocolFail(name, msg) { - const errMsg = `${name}:fail ${msg}`; - { - console.error(errMsg); - } - return { - errMsg - }; + }); + window.addEventListener("test-passive", null, opts); +} catch (e2) { } -function validateProtocol(name, data, protocol) { - for (const key in protocol) { - const errMsg = validateProp(key, data[key], protocol[key], !hasOwn(data, key)); - if (errMsg) { - return validateProtocolFail(name, errMsg); +const passiveOptions = supportsPassive$1 ? {passive: true} : false; +const _sfc_main$t = { + name: "Audio", + mixins: [subscriber], + props: { + id: { + type: String, + default: "" + }, + src: { + type: String, + default: "" + }, + loop: { + type: [Boolean, String], + default: false + }, + controls: { + type: [Boolean, String], + default: false + }, + poster: { + type: String, + default: "" + }, + name: { + type: String, + default: "" + }, + author: { + type: String, + default: "" } - } -} -function validateProtocols(name, args, protocol) { - if (!protocol) { - return; - } - if (isArray(protocol)) { - const len = protocol.length; - const argsLen = args.length; - for (let i2 = 0; i2 < len; i2++) { - const opts = protocol[i2]; - const data = Object.create(null); - if (argsLen > i2) { - data[opts.name] = args[i2]; - } - const errMsg = validateProtocol(name, data, {[opts.name]: opts}); - if (errMsg) { - return errMsg; + }, + data() { + return { + playing: false, + currentTime: this.getTime(0) + }; + }, + watch: { + src(val) { + if (this.$refs.audio) { + this.$refs.audio.src = this.$getRealPath(val); } } - return; - } - return validateProtocol(name, args[0] || Object.create(null), protocol); -} -function validateProp(name, value, prop, isAbsent) { - const {type, required, validator} = prop; - if (required && isAbsent) { - return 'Missing required args: "' + name + '"'; - } - if (value == null && !prop.required) { - return; - } - if (type != null && type !== true) { - let isValid = false; - const types = isArray(type) ? type : [type]; - const expectedTypes = []; - for (let i2 = 0; i2 < types.length && !isValid; i2++) { - const {valid, expectedType} = assertType(value, types[i2]); - expectedTypes.push(expectedType || ""); - isValid = valid; - } - if (!isValid) { - return getInvalidTypeMessage(name, value, expectedTypes); - } - } - if (validator && !validator(value)) { - return 'Invalid args: custom validator check failed for args "' + name + '".'; - } -} -const isSimpleType = /* @__PURE__ */ makeMap$1("String,Number,Boolean,Function,Symbol"); -function assertType(value, type) { - let valid; - const expectedType = getType(type); - if (isSimpleType(expectedType)) { - const t2 = typeof value; - valid = t2 === expectedType.toLowerCase(); - if (!valid && t2 === "object") { - valid = value instanceof type; - } - } else if (expectedType === "Object") { - valid = isObject(value); - } else if (expectedType === "Array") { - valid = isArray(value); - } else { - { - valid = value instanceof type; - } - } - return { - valid, - expectedType - }; -} -function getInvalidTypeMessage(name, value, expectedTypes) { - let message = `Invalid args: type check failed for args "${name}". Expected ${expectedTypes.map(capitalize).join(", ")}`; - const expectedType = expectedTypes[0]; - const receivedType = toRawType(value); - const expectedValue = styleValue(value, expectedType); - const receivedValue = styleValue(value, receivedType); - if (expectedTypes.length === 1 && isExplicable(expectedType) && !isBoolean(expectedType, receivedType)) { - message += ` with value ${expectedValue}`; - } - message += `, got ${receivedType} `; - if (isExplicable(receivedType)) { - message += `with value ${receivedValue}.`; - } - return message; -} -function getType(ctor) { - const match = ctor && ctor.toString().match(/^\s*function (\w+)/); - return match ? match[1] : ""; -} -function styleValue(value, type) { - if (type === "String") { - return `"${value}"`; - } else if (type === "Number") { - return `${Number(value)}`; - } else { - return `${value}`; - } -} -function isExplicable(type) { - const explicitTypes = ["string", "number", "boolean"]; - return explicitTypes.some((elem) => type.toLowerCase() === elem); -} -function isBoolean(...args) { - return args.some((elem) => elem.toLowerCase() === "boolean"); -} -function tryCatch(fn) { - return function() { - try { - return fn.apply(fn, arguments); - } catch (e2) { - console.error(e2); - } - }; -} -let invokeCallbackId = 1; -const invokeCallbacks = {}; -function createInvokeCallbackName(name, callbackId) { - return "api." + name + "." + callbackId; -} -function addInvokeCallback(id2, name, callback, keepAlive = false) { - invokeCallbacks[id2] = { - name, - keepAlive, - callback - }; - return id2; -} -function invokeCallback(id2, res, extras) { - if (typeof id2 === "number") { - const opts = invokeCallbacks[id2]; - if (opts) { - if (!opts.keepAlive) { - delete invokeCallbacks[id2]; + }, + mounted() { + const audio = this.$refs.audio; + audio.addEventListener("error", ($event) => { + this.playing = false; + this.$trigger("error", $event, {}); + }); + audio.addEventListener("play", ($event) => { + this.playing = true; + this.$trigger("play", $event, {}); + }); + audio.addEventListener("pause", ($event) => { + this.playing = false; + this.$trigger("pause", $event, {}); + }); + audio.addEventListener("ended", ($event) => { + this.playing = false; + this.$trigger("ended", $event, {}); + }); + audio.addEventListener("timeupdate", ($event) => { + var currentTime = audio.currentTime; + this.currentTime = this.getTime(currentTime); + var duration = audio.duration; + this.$trigger("timeupdate", $event, { + currentTime, + duration + }); + }); + audio.src = this.$getRealPath(this.src); + }, + methods: { + _handleSubscribe({ + type, + data = {} + }) { + var audio = this.$refs.audio; + switch (type) { + case "setSrc": + audio.src = this.$getRealPath(data.src); + this.$emit("update:src", data.src); + break; + case "play": + audio.play(); + break; + case "pause": + audio.pause(); + break; + case "seek": + audio.currentTime = data.position; + break; } - return opts.callback(res, extras); - } - } - return res; -} -function getKeepAliveApiCallback(name, callback) { - const onName = "api." + name.replace("off", "on"); - for (const key in invokeCallbacks) { - const item = invokeCallbacks[key]; - if (item.callback === callback && item.name.indexOf(onName) === 0) { - delete invokeCallbacks[key]; - return Number(key); + }, + trigger() { + if (this.playing) { + this.$refs.audio.pause(); + } else { + this.$refs.audio.play(); + } + }, + getTime(time) { + var h = Math.floor(time / 3600); + var m = Math.floor(time % 3600 / 60); + var s = Math.floor(time % 3600 % 60); + h = (h < 10 ? "0" : "") + h; + m = (m < 10 ? "0" : "") + m; + s = (s < 10 ? "0" : "") + s; + var str = m + ":" + s; + if (h !== "00") { + str = h + ":" + str; + } + return str; } } - return -1; -} -function createKeepAliveApiCallback(name, callback) { - if (name.indexOf("off") === 0) { - return getKeepAliveApiCallback(name, callback); - } - const id2 = invokeCallbackId++; - return addInvokeCallback(id2, createInvokeCallbackName(name, id2), callback, true); +}; +const _hoisted_1$d = {class: "uni-audio-default"}; +const _hoisted_2$7 = {class: "uni-audio-right"}; +const _hoisted_3$3 = {class: "uni-audio-time"}; +const _hoisted_4$3 = {class: "uni-audio-info"}; +const _hoisted_5$1 = {class: "uni-audio-name"}; +const _hoisted_6$1 = {class: "uni-audio-author"}; +function _sfc_render$r(_ctx, _cache, $props, $setup, $data, $options) { + return openBlock(), createBlock("uni-audio", mergeProps({ + id: $props.id, + controls: !!$props.controls + }, _ctx.$attrs), [ + createVNode("audio", { + ref: "audio", + loop: $props.loop, + style: {display: "none"} + }, null, 8, ["loop"]), + createVNode("div", _hoisted_1$d, [ + createVNode("div", { + style: "background-image: url(" + _ctx.$getRealPath($props.poster) + ");", + class: "uni-audio-left" + }, [ + createVNode("div", { + class: [{play: !$data.playing, pause: $data.playing}, "uni-audio-button"], + onClick: _cache[1] || (_cache[1] = (...args) => $options.trigger && $options.trigger(...args)) + }, null, 2) + ], 4), + createVNode("div", _hoisted_2$7, [ + createVNode("div", _hoisted_3$3, toDisplayString($data.currentTime), 1), + createVNode("div", _hoisted_4$3, [ + createVNode("div", _hoisted_5$1, toDisplayString($props.name), 1), + createVNode("div", _hoisted_6$1, toDisplayString($props.author), 1) + ]) + ]) + ]) + ], 16, ["id", "controls"]); } -const API_SUCCESS = "success"; -const API_FAIL = "fail"; -const API_COMPLETE = "complete"; -function getApiCallbacks(args) { - const apiCallbacks = {}; - for (const name in args) { - const fn = args[name]; - if (isFunction(fn)) { - apiCallbacks[name] = tryCatch(fn); - delete args[name]; +_sfc_main$t.render = _sfc_render$r; +const pixelRatio = function() { + const canvas = document.createElement("canvas"); + canvas.height = canvas.width = 0; + const context = canvas.getContext("2d"); + const backingStore = context.backingStorePixelRatio || context.webkitBackingStorePixelRatio || context.mozBackingStorePixelRatio || context.msBackingStorePixelRatio || context.oBackingStorePixelRatio || context.backingStorePixelRatio || 1; + return (window.devicePixelRatio || 1) / backingStore; +}(); +const forEach = function(obj, func) { + for (const key in obj) { + if (hasOwn$1(obj, key)) { + func(obj[key], key); } } - return apiCallbacks; -} -function normalizeErrMsg(errMsg, name) { - if (!errMsg || errMsg.indexOf(":fail") === -1) { - return name + ":ok"; - } - return name + errMsg.substring(errMsg.indexOf(":fail")); -} -function createAsyncApiCallback(name, args = {}, {beforeAll, beforeSuccess} = {}) { - if (!isPlainObject(args)) { - args = {}; - } - const {success, fail, complete} = getApiCallbacks(args); - const hasSuccess = isFunction(success); - const hasFail = isFunction(fail); - const hasComplete = isFunction(complete); - const callbackId = invokeCallbackId++; - addInvokeCallback(callbackId, createInvokeCallbackName(name, callbackId), (res) => { - res = res || {}; - res.errMsg = normalizeErrMsg(res.errMsg, name); - isFunction(beforeAll) && beforeAll(res); - if (res.errMsg === name + ":ok") { - isFunction(beforeSuccess) && beforeSuccess(res); - hasSuccess && success(res); - } else { - hasFail && fail(res); - } - hasComplete && complete(res); - }); - return callbackId; -} -const callbacks = [API_SUCCESS, API_FAIL, API_COMPLETE]; -function hasCallback(args) { - if (isPlainObject(args) && callbacks.find((cb) => isFunction(args[cb]))) { - return true; - } - return false; -} -function handlePromise(promise) { - if (__UNI_FEATURE_PROMISE__) { - return promise.then((data) => { - return [null, data]; - }).catch((err) => [err]); - } - return promise; -} -function promisify(fn) { - return (args = {}) => { - if (hasCallback(args)) { - return fn(args); - } - return handlePromise(new Promise((resolve, reject) => { - fn(Object.assign(args, {success: resolve, fail: reject})); - })); - }; -} -const API_TYPE_ON = 0; -const API_TYPE_TASK = 1; -const API_TYPE_SYNC = 2; -const API_TYPE_ASYNC = 3; -function formatApiArgs(args, options) { - return args; -} -function wrapperOnApi(name, fn) { - return (callback) => fn.apply(null, createKeepAliveApiCallback(name, callback)); -} -function wrapperTaskApi(name, fn, options) { - return (args) => fn.apply(null, [args, createAsyncApiCallback(name, args, options)]); -} -function wrapperSyncApi(fn) { - return (...args) => fn.apply(null, args); -} -function wrapperAsyncApi(name, fn, options) { - return (args) => { - const callbackId = createAsyncApiCallback(name, args, options); - const res = fn.apply(null, [args, callbackId]); - if (res) { - invokeCallback(callbackId, res); +}; +const ratioArgs = { + fillRect: "all", + clearRect: "all", + strokeRect: "all", + moveTo: "all", + lineTo: "all", + arc: [0, 1, 2], + arcTo: "all", + bezierCurveTo: "all", + isPointinPath: "all", + isPointinStroke: "all", + quadraticCurveTo: "all", + rect: "all", + translate: "all", + createRadialGradient: "all", + createLinearGradient: "all", + setTransform: [4, 5] +}; +const proto = CanvasRenderingContext2D.prototype; +proto.drawImageByCanvas = function(_super) { + return function(canvas, srcx, srcy, srcw, srch, desx, desy, desw, desh, isScale) { + if (!this.__hidpi__) { + return _super.apply(this, arguments); } + srcx *= pixelRatio; + srcy *= pixelRatio; + srcw *= pixelRatio; + srch *= pixelRatio; + desx *= pixelRatio; + desy *= pixelRatio; + desw = isScale ? desw * pixelRatio : desw; + desh = isScale ? desh * pixelRatio : desh; + _super.call(this, canvas, srcx, srcy, srcw, srch, desx, desy, desw, desh); }; -} -function wrapperApi(fn, name, protocol, options) { - return function(...args) { - if (process.env.NODE_ENV !== "production") { - const errMsg = validateProtocols(name, args, protocol); - if (errMsg) { - return errMsg; +}(proto.drawImage); +if (pixelRatio !== 1) { + forEach(ratioArgs, function(value, key) { + proto[key] = function(_super) { + return function() { + if (!this.__hidpi__) { + return _super.apply(this, arguments); + } + let args = Array.prototype.slice.call(arguments); + if (value === "all") { + args = args.map(function(a2) { + return a2 * pixelRatio; + }); + } else if (Array.isArray(value)) { + for (let i = 0; i < value.length; i++) { + args[value[i]] *= pixelRatio; + } + } + return _super.apply(this, args); + }; + }(proto[key]); + }); + proto.stroke = function(_super) { + return function() { + if (!this.__hidpi__) { + return _super.apply(this, arguments); } - } - return fn.apply(null, formatApiArgs(args)); - }; + this.lineWidth *= pixelRatio; + _super.apply(this, arguments); + this.lineWidth /= pixelRatio; + }; + }(proto.stroke); + proto.fillText = function(_super) { + return function() { + if (!this.__hidpi__) { + return _super.apply(this, arguments); + } + const args = Array.prototype.slice.call(arguments); + args[1] *= pixelRatio; + args[2] *= pixelRatio; + var font2 = this.font; + this.font = font2.replace(/(\d+\.?\d*)(px|em|rem|pt)/g, function(w, m, u) { + return m * pixelRatio + u; + }); + _super.apply(this, args); + this.font = font2; + }; + }(proto.fillText); + proto.strokeText = function(_super) { + return function() { + if (!this.__hidpi__) { + return _super.apply(this, arguments); + } + var args = Array.prototype.slice.call(arguments); + args[1] *= pixelRatio; + args[2] *= pixelRatio; + var font2 = this.font; + this.font = font2.replace(/(\d+\.?\d*)(px|em|rem|pt)/g, function(w, m, u) { + return m * pixelRatio + u; + }); + _super.apply(this, args); + this.font = font2; + }; + }(proto.strokeText); + proto.drawImage = function(_super) { + return function() { + if (!this.__hidpi__) { + return _super.apply(this, arguments); + } + this.scale(pixelRatio, pixelRatio); + _super.apply(this, arguments); + this.scale(1 / pixelRatio, 1 / pixelRatio); + }; + }(proto.drawImage); } -function createSyncApi(name, fn, protocol, options) { - return createApi(API_TYPE_SYNC, name, fn, process.env.NODE_ENV !== "production" ? protocol : void 0, options); +function wrapper(canvas) { + canvas.width = canvas.offsetWidth * pixelRatio; + canvas.height = canvas.offsetHeight * pixelRatio; + canvas.getContext("2d").__hidpi__ = true; } -function createAsyncApi(name, fn, protocol, options) { - return promisify(createApi(API_TYPE_ASYNC, name, fn, process.env.NODE_ENV !== "production" ? protocol : void 0, options)); +var index_vue_vue_type_style_index_0_lang$k = "\nuni-canvas {\r\n width: 300px;\r\n height: 150px;\r\n display: block;\r\n position: relative;\n}\nuni-canvas > canvas {\r\n position: absolute;\r\n top: 0;\r\n left: 0;\r\n width: 100%;\r\n height: 100%;\n}\r\n"; +function resolveColor(color) { + color = color.slice(0); + color[3] = color[3] / 255; + return "rgba(" + color.join(",") + ")"; } -function createApi(type, name, fn, protocol, options) { - switch (type) { - case API_TYPE_ON: - return wrapperApi(wrapperOnApi(name, fn), name, protocol); - case API_TYPE_TASK: - return wrapperApi(wrapperTaskApi(name, fn), name, protocol); - case API_TYPE_SYNC: - return wrapperApi(wrapperSyncApi(fn), name, protocol); - case API_TYPE_ASYNC: - return wrapperApi(wrapperAsyncApi(name, fn, options), name, protocol); - } +function processTouches(target, touches) { + return [].map.call(touches, (touch) => { + var boundingClientRect = target.getBoundingClientRect(); + return { + identifier: touch.identifier, + x: touch.clientX - boundingClientRect.left, + y: touch.clientY - boundingClientRect.top + }; + }); } -const Base64ToArrayBufferProtocol = [ - { - name: "base64", - type: String, - required: true - } -]; -const ArrayBufferToBase64Protocol = [ - { - name: "arrayBuffer", - type: [ArrayBuffer, Uint8Array], - required: true - } -]; -const base64ToArrayBuffer = /* @__PURE__ */ createSyncApi("base64ToArrayBuffer", (base64) => { - return decode(base64); -}, Base64ToArrayBufferProtocol); -const arrayBufferToBase64 = /* @__PURE__ */ createSyncApi("arrayBufferToBase64", (arrayBuffer) => { - return encode(arrayBuffer); -}, ArrayBufferToBase64Protocol); -const Upx2pxProtocol = [ - { - name: "upx", - type: [Number, String], - required: true +var tempCanvas; +function getTempCanvas(width = 0, height = 0) { + if (!tempCanvas) { + tempCanvas = document.createElement("canvas"); } -]; -const EPS = 1e-4; -const BASE_DEVICE_WIDTH = 750; -let isIOS$1 = false; -let deviceWidth = 0; -let deviceDPR = 0; -function checkDeviceWidth() { - const {platform, pixelRatio: pixelRatio2, windowWidth} = __GLOBAL__.getSystemInfoSync(); - deviceWidth = windowWidth; - deviceDPR = pixelRatio2; - isIOS$1 = platform === "ios"; + tempCanvas.width = width; + tempCanvas.height = height; + return tempCanvas; } -const upx2px = /* @__PURE__ */ createSyncApi("upx2px", (number, newDeviceWidth) => { - if (deviceWidth === 0) { - checkDeviceWidth(); - } - number = Number(number); - if (number === 0) { - return 0; - } - let result = number / BASE_DEVICE_WIDTH * (newDeviceWidth || deviceWidth); - if (result < 0) { - result = -result; - } - result = Math.floor(result + EPS); - if (result === 0) { - if (deviceDPR === 1 || !isIOS$1) { - result = 1; - } else { - result = 0.5; - } - } - return number < 0 ? -result : result; -}, Upx2pxProtocol); -var HOOKS; -(function(HOOKS2) { - HOOKS2["INVOKE"] = "invoke"; - HOOKS2["SUCCESS"] = "success"; - HOOKS2["FAIL"] = "fail"; - HOOKS2["COMPLETE"] = "complete"; - HOOKS2["RETURN_VALUE"] = "returnValue"; -})(HOOKS || (HOOKS = {})); -const globalInterceptors = {}; -const scopedInterceptors = {}; -const AddInterceptorProtocol = [ - { - name: "method", - type: [String, Object], - required: true - } -]; -const RemoveInterceptorProtocol = AddInterceptorProtocol; -function mergeInterceptorHook(interceptors, interceptor) { - Object.keys(interceptor).forEach((hook) => { - if (isFunction(interceptor[hook])) { - interceptors[hook] = mergeHook(interceptors[hook], interceptor[hook]); - } - }); -} -function removeInterceptorHook(interceptors, interceptor) { - if (!interceptors || !interceptor) { - return; - } - Object.keys(interceptor).forEach((hook) => { - if (isFunction(interceptor[hook])) { - removeHook(interceptors[hook], interceptor[hook]); - } - }); -} -function mergeHook(parentVal, childVal) { - const res = childVal ? parentVal ? parentVal.concat(childVal) : isArray(childVal) ? childVal : [childVal] : parentVal; - return res ? dedupeHooks(res) : res; -} -function dedupeHooks(hooks) { - const res = []; - for (let i2 = 0; i2 < hooks.length; i2++) { - if (res.indexOf(hooks[i2]) === -1) { - res.push(hooks[i2]); - } - } - return res; -} -function removeHook(hooks, hook) { - if (!hooks) { - return; - } - const index2 = hooks.indexOf(hook); - if (index2 !== -1) { - hooks.splice(index2, 1); - } -} -const addInterceptor = /* @__PURE__ */ createSyncApi("addInterceptor", (method, interceptor) => { - if (typeof method === "string" && isPlainObject(interceptor)) { - mergeInterceptorHook(scopedInterceptors[method] || (scopedInterceptors[method] = {}), interceptor); - } else if (isPlainObject(method)) { - mergeInterceptorHook(globalInterceptors, method); - } -}, AddInterceptorProtocol); -const removeInterceptor = /* @__PURE__ */ createSyncApi("removeInterceptor", (method, interceptor) => { - if (typeof method === "string") { - if (isPlainObject(interceptor)) { - removeInterceptorHook(scopedInterceptors[method], interceptor); - } else { - delete scopedInterceptors[method]; - } - } else if (isPlainObject(method)) { - removeInterceptorHook(globalInterceptors, method); - } -}, RemoveInterceptorProtocol); -const promiseInterceptor = { - returnValue(res) { - if (!isPromise(res)) { - return res; - } - return res.then((res2) => { - return res2[1]; - }).catch((res2) => { - return res2[0]; - }); - } -}; -function getCurrentPageVm() { - const pages = getCurrentPages(); - const len = pages.length; - const page = pages[len - 1]; - return page && page.$vm; -} -const defaultOptions = { - thresholds: [0], - initialRatio: 0, - observeAll: false -}; -let reqComponentObserverId = 1; -const reqComponentObserverCallbacks = {}; -ServiceJSBridge.subscribe("requestComponentObserver", ({reqId, reqEnd, res}) => { - const callback = reqComponentObserverCallbacks[reqId]; - if (callback) { - if (reqEnd) { - return delete reqComponentObserverCallbacks[reqId]; - } - callback(res); - } -}); -class ServiceIntersectionObserver { - constructor(component, options) { - this._pageId = component.$page.id; - this._component = component._$id || component; - this._options = extend({}, defaultOptions, options || {}); - this._relativeInfo = []; - } - relativeTo(selector, margins) { - if (this._reqId) { - throw new Error('Relative nodes cannot be added after "observe" call in IntersectionObserver'); - } - this._relativeInfo.push({ - selector, - margins - }); - return this; - } - relativeToViewport(margins) { - return this.relativeTo(null, margins); - } - observe(selector, callback) { - if (typeof callback !== "function") { - return; - } - if (this._reqId) { - throw new Error('"observe" call can be only called once in IntersectionObserver'); - } - this._reqId = reqComponentObserverId++; - reqComponentObserverCallbacks[this._reqId] = callback; - UniServiceJSBridge.publishHandler("addIntersectionObserver", { - selector, - reqId: this._reqId, - component: this._component, - options: this._options, - relativeInfo: this._relativeInfo - }, this._pageId); - } - disconnect() { - UniServiceJSBridge.publishHandler("removeIntersectionObserver", { - reqId: this._reqId - }, this._pageId); - } -} -const createIntersectionObserver = /* @__PURE__ */ createSyncApi("createIntersectionObserver", (context, options) => { - if (!context) { - context = getCurrentPageVm(); - } - return new ServiceIntersectionObserver(context, options); -}); -const createSelectorQuery = () => { -}; -const CanIUseProtocol = [ - { - name: "schema", - type: String, - required: true - } -]; -const MakePhoneCallProtocol = { - phoneNumber: { - type: String, - required: true, - validator(phoneNumber) { - if (!phoneNumber) { - return "makePhoneCall:fail parameter error: parameter.phoneNumber should not be empty String;"; - } - } - } -}; -const OpenDocumentProtocol = { - filePath: { - type: String, - required: true - }, - fileType: { - type: String - } -}; -const GetImageInfoOptions = { - formatArgs: { - src(src, params) { - params.src = uni.getRealPath(src); - } - } -}; -const GetImageInfoProtocol = { - src: { - type: String, - required: true - } -}; -function cssSupports(css) { - return window.CSS && window.CSS.supports && window.CSS.supports(css); -} -const SCHEMA_CSS = { - "css.var": cssSupports("--a:0"), - "css.env": cssSupports("top:env(a)"), - "css.constant": cssSupports("top:constant(a)") -}; -const canIUse = /* @__PURE__ */ createSyncApi("canIUse", (schema) => { - if (hasOwn(SCHEMA_CSS, schema)) { - return SCHEMA_CSS[schema]; - } - return true; -}, CanIUseProtocol); -const makePhoneCall = /* @__PURE__ */ createAsyncApi("makePhoneCall", (option) => { - window.location.href = `tel:${option.phoneNumber}`; -}, MakePhoneCallProtocol); -const ua = navigator.userAgent; -const isAndroid = /android/i.test(ua); -const isIOS = /iphone|ipad|ipod/i.test(ua); -const getSystemInfoSync = /* @__PURE__ */ createSyncApi("getSystemInfoSync", () => { - var screen = window.screen; - var pixelRatio2 = window.devicePixelRatio; - const screenFix = /^Apple/.test(navigator.vendor) && typeof window.orientation === "number"; - const landscape = screenFix && Math.abs(window.orientation) === 90; - var screenWidth = screenFix ? Math[landscape ? "max" : "min"](screen.width, screen.height) : screen.width; - var screenHeight = screenFix ? Math[landscape ? "min" : "max"](screen.height, screen.width) : screen.height; - var windowWidth = Math.min(window.innerWidth, document.documentElement.clientWidth, screenWidth) || screenWidth; - var windowHeight = window.innerHeight; - var language = navigator.language; - var statusBarHeight = out.top; - var osname; - var osversion; - var model; - if (isIOS) { - osname = "iOS"; - const osversionFind = ua.match(/OS\s([\w_]+)\slike/); - if (osversionFind) { - osversion = osversionFind[1].replace(/_/g, "."); - } - const modelFind = ua.match(/\(([a-zA-Z]+);/); - if (modelFind) { - model = modelFind[1]; - } - } else if (isAndroid) { - osname = "Android"; - const osversionFind = ua.match(/Android[\s/]([\w\.]+)[;\s]/); - if (osversionFind) { - osversion = osversionFind[1]; - } - const infoFind = ua.match(/\((.+?)\)/); - const infos = infoFind ? infoFind[1].split(";") : ua.split(" "); - const otherInfo = [ - /\bAndroid\b/i, - /\bLinux\b/i, - /\bU\b/i, - /^\s?[a-z][a-z]$/i, - /^\s?[a-z][a-z]-[a-z][a-z]$/i, - /\bwv\b/i, - /\/[\d\.,]+$/, - /^\s?[\d\.,]+$/, - /\bBrowser\b/i, - /\bMobile\b/i - ]; - for (let i2 = 0; i2 < infos.length; i2++) { - const info = infos[i2]; - if (info.indexOf("Build") > 0) { - model = info.split("Build")[0].trim(); - break; - } - let other; - for (let o2 = 0; o2 < otherInfo.length; o2++) { - if (otherInfo[o2].test(info)) { - other = true; - break; - } - } - if (!other) { - model = info.trim(); - break; - } - } - } else { - osname = "Other"; - osversion = "0"; - } - var system = `${osname} ${osversion}`; - var platform = osname.toLocaleLowerCase(); - var safeArea = { - left: out.left, - right: windowWidth - out.right, - top: out.top, - bottom: windowHeight - out.bottom, - width: windowWidth - out.left - out.right, - height: windowHeight - out.top - out.bottom - }; - const {top: windowTop, bottom: windowBottom} = getWindowOffset(); - windowHeight -= windowTop; - windowHeight -= windowBottom; - return { - windowTop, - windowBottom, - windowWidth, - windowHeight, - pixelRatio: pixelRatio2, - screenWidth, - screenHeight, - language, - statusBarHeight, - system, - platform, - model, - safeArea, - safeAreaInsets: { - top: out.top, - right: out.right, - bottom: out.bottom, - left: out.left - } - }; -}); -const getSystemInfo = /* @__PURE__ */ createAsyncApi("getSystemInfo", () => { - return getSystemInfoSync(); -}); -const openDocument = /* @__PURE__ */ createAsyncApi("openDocument", (option) => { - window.open(option.filePath); -}, OpenDocumentProtocol); -function _getServiceAddress() { - return window.location.protocol + "//" + window.location.host; -} -const getImageInfo = /* @__PURE__ */ createAsyncApi("getImageInfo", ({src}, callback) => { - const img = new Image(); - img.onload = function() { - callback({ - errMsg: "getImageInfo:ok", - width: img.naturalWidth, - height: img.naturalHeight, - path: src.indexOf("/") === 0 ? _getServiceAddress() + src : src - }); - }; - img.onerror = function() { - callback({ - errMsg: "getImageInfo:fail" - }); - }; - img.src = src; -}, GetImageInfoProtocol, GetImageInfoOptions); -const navigateBack = /* @__PURE__ */ createAsyncApi("navigateBack", () => { -}); -const SEP = "$$"; -function getCurrentPages$1() { - return []; -} -let id = history.state && history.state.__id__ || 1; -function createPageState(type) { - return { - __id__: ++id, - __type__: type - }; -} -function isPage(vm) { - return vm.$options.mpType === "page"; -} -function initPublicPage(route) { - return { - id, - path: route.path, - route: route.meta.pagePath, - fullPath: route.meta.isEntry ? route.meta.pagePath : route.fullPath, - options: {} - }; -} -function initPage(vm) { - const route = vm.$route; - vm.__page__ = initPublicPage(route); -} -function routeCache(key, cache, pruneCacheEntry) { - const pageId = parseInt(key.split(SEP)[1]); - if (!pageId) { - return; - } - nextTick(() => { - const keys = cache.keys(); - for (const key2 of keys) { - const cPageId = parseInt(key2.split(SEP)[1]); - if (cPageId && cPageId > pageId) { - pruneCacheEntry(key2); - } +const _sfc_main$s = { + name: "Canvas", + mixins: [subscriber], + props: { + canvasId: { + type: String, + default: "" + }, + disableScroll: { + type: [Boolean, String], + default: false } - console.log("customKeepAlive", JSON.stringify([...cache.keys()])); - }); -} -function useKeepAliveRoute() { - const route = useRoute(); - const routeKey = computed(() => route.fullPath + "$$" + (history.state.__id__ || 1)); - return { - routeKey, - routeCache - }; -} -const navigateTo = /* @__PURE__ */ createAsyncApi("navigateTo", (options) => { - const router = getApp().$router; - router.push({ - path: options.url, - force: true, - state: createPageState("navigateTo") - }); -}); -const redirectTo = /* @__PURE__ */ createAsyncApi("redirectTo", () => { -}); -const reLaunch = /* @__PURE__ */ createAsyncApi("reLaunch", () => { -}); -const switchTab = /* @__PURE__ */ createAsyncApi("switchTab", () => { -}); -const getRealPath = /* @__PURE__ */ createSyncApi("getRealPath", (path) => { - return path; -}); -var api = /* @__PURE__ */ Object.freeze({ - __proto__: null, - [Symbol.toStringTag]: "Module", - upx2px, - addInterceptor, - removeInterceptor, - promiseInterceptor, - arrayBufferToBase64, - base64ToArrayBuffer, - createIntersectionObserver, - createSelectorQuery, - canIUse, - makePhoneCall, - getSystemInfo, - getSystemInfoSync, - openDocument, - getImageInfo, - navigateBack, - navigateTo, - redirectTo, - reLaunch, - switchTab, - getRealPath -}); -const _sfc_main$u = { - name: "App", - components, - mixins, + }, data() { return { - transitionName: "fade", - hideTabBar: false, - tabBar: __uniConfig.tabBar || {}, - sysComponents: this.$sysComponents + actionsWaiting: false }; }, computed: { - key() { - return this.$route.path + "-" + (history.state.__id__ || 0); - }, - hasTabBar() { - return __uniConfig.tabBar && __uniConfig.tabBar.list && __uniConfig.tabBar.list.length; - }, - showTabBar() { - return this.$route.meta.isTabBar && !this.hideTabBar; - } - }, - watch: { - $route(newRoute, oldRoute) { - UniServiceJSBridge.emit("onHidePopup"); + id() { + return this.canvasId; }, - hideTabBar(newVal, oldVal) { - if (canIUse("css.var")) { - const windowBottomValue = !newVal ? TABBAR_HEIGHT : 0; - const envMethod = canIUse("css.env") ? "env" : canIUse("css.constant") ? "constant" : ""; - const windowBottom = windowBottomValue && envMethod ? `calc(${windowBottomValue}px + ${envMethod}(safe-area-inset-bottom))` : `${windowBottomValue}px`; - document.documentElement.style.setProperty("--window-bottom", windowBottom); - console.debug(`uni.${windowBottom ? "showTabBar" : "hideTabBar"}\uFF1A--window-bottom=${windowBottom}`); - } - window.dispatchEvent(new CustomEvent("resize")); + _listeners() { + var $listeners = Object.assign({}, this.$listeners); + var events = ["touchstart", "touchmove", "touchend"]; + events.forEach((event2) => { + var existing = $listeners[event2]; + var eventHandler = []; + if (existing) { + eventHandler.push(($event) => { + this.$trigger(event2, Object.assign({}, $event, { + touches: processTouches($event.currentTarget, $event.touches), + changedTouches: processTouches($event.currentTarget, $event.changedTouches) + })); + }); + } + if (this.disableScroll && event2 === "touchmove") { + eventHandler.push(this._touchmove); + } + $listeners[event2] = eventHandler; + }); + return $listeners; } }, - setup() { - const {routeKey, routeCache: routeCache2} = useKeepAliveRoute(); - return { - routeKey, - routeCache: routeCache2 - }; - }, created() { - if (canIUse("css.var")) { - document.documentElement.style.setProperty("--status-bar-height", "0px"); - } + this._actionsDefer = []; + this._images = {}; }, mounted() { - window.addEventListener("message", function(evt) { - if (isPlainObject(evt.data) && evt.data.type === "WEB_INVOKE_APPSERVICE") { - UniServiceJSBridge.emit("onWebInvokeAppService", evt.data.data, evt.data.pageId); - } - }); - document.addEventListener("visibilitychange", function() { - if (document.visibilityState === "visible") { - UniServiceJSBridge.emit("onAppEnterForeground"); - } else { - UniServiceJSBridge.emit("onAppEnterBackground"); - } - }); - } -}; -function _sfc_render$s(_ctx, _cache, $props, $setup, $data, $options) { - const _component_router_view = resolveComponent("router-view"); - const _component_tab_bar = resolveComponent("tab-bar"); - return openBlock(), createBlock("uni-app", { - class: {"uni-app--showtabbar": $options.showTabBar} - }, [ - createVNode(_component_router_view, null, { - default: withCtx(({Component}) => [ - (openBlock(), createBlock(KeepAlive, {cache: $setup.routeCache}, [ - (openBlock(), createBlock(resolveDynamicComponent(Component), {key: $setup.routeKey})) - ], 1032, ["cache"])) - ]), - _: 1 - }), - $options.hasTabBar ? withDirectives((openBlock(), createBlock(_component_tab_bar, mergeProps({key: 0}, $data.tabBar), null, 16)), [ - [vShow, $options.showTabBar] - ]) : createCommentVNode("", true) - ], 2); -} -_sfc_main$u.render = _sfc_render$s; -function mergeTitleNView(navigationBar, titleNView) { - if (isPlainObject(titleNView)) { - if (hasOwn(titleNView, "backgroundColor")) { - navigationBar.backgroundColor = titleNView.backgroundColor; - } - if (hasOwn(titleNView, "buttons")) { - navigationBar.buttons = titleNView.buttons; - } - if (hasOwn(titleNView, "titleColor")) { - navigationBar.textColor = titleNView.titleColor; - } - if (hasOwn(titleNView, "titleText")) { - navigationBar.titleText = titleNView.titleText; - } - if (hasOwn(titleNView, "titleSize")) { - navigationBar.titleSize = titleNView.titleSize; - } - if (hasOwn(titleNView, "type")) { - navigationBar.type = titleNView.type; - } - if (hasOwn(titleNView, "searchInput") && typeof titleNView.searchInput === "object") { - navigationBar.searchInput = Object.assign({ - autoFocus: false, - align: "center", - color: "#000000", - backgroundColor: "rgba(255,255,255,0.5)", - borderRadius: "0px", - placeholder: "", - placeholderColor: "#CCCCCC", - disabled: false - }, titleNView.searchInput); - } - } - return navigationBar; -} -function broadcast(componentName, eventName, ...params) { - const children = this.$children; - const len = children.length; - for (let i2 = 0; i2 < len; i2++) { - const child = children[i2]; - const name = child.$options.name && child.$options.name.substr(4); - if (~componentName.indexOf(name)) { - child.$emit.apply(child, [eventName].concat(params)); - return false; - } else { - if (broadcast.apply(child, [componentName, eventName].concat([params])) === false) { - return false; - } - } - } -} -var emitter = { - methods: { - $dispatch(componentName, eventName, ...params) { - console.log("$dispatch", componentName, eventName, params); - }, - $broadcast(componentName, eventName, ...params) { - if (typeof componentName === "string") { - componentName = [componentName]; - } - broadcast.apply(this, [componentName, eventName].concat(params)); - } - } -}; -var listeners = { - props: { - id: { - type: String, - default: "" - } - }, - created() { - this._addListeners(this.id); - this.$watch("id", (newId, oldId) => { - this._removeListeners(oldId, true); - this._addListeners(newId, true); + this._resize({ + width: this.$refs.sensor.$el.offsetWidth, + height: this.$refs.sensor.$el.offsetHeight }); }, beforeDestroy() { - this._removeListeners(this.id); + const canvas = this.$refs.canvas; + canvas.height = canvas.width = 0; }, methods: { - _addListeners(id2, watch) { - if (watch && !id2) { + _handleSubscribe({ + type, + data = {} + }) { + var method = this[type]; + if (type.indexOf("_") !== 0 && typeof method === "function") { + method(data); + } + }, + _resize() { + var canvas = this.$refs.canvas; + if (canvas.width > 0 && canvas.height > 0) { + var context = canvas.getContext("2d"); + var imageData = context.getImageData(0, 0, canvas.width, canvas.height); + wrapper(this.$refs.canvas); + context.putImageData(imageData, 0, 0); + } else { + wrapper(this.$refs.canvas); + } + }, + _touchmove(event2) { + event2.preventDefault(); + }, + actionsChanged({ + actions, + reserve, + callbackId + }) { + var self = this; + if (!actions) { return; } - const {listeners: listeners2} = this.$options; - if (!isPlainObject(listeners2)) { + if (this.actionsWaiting) { + this._actionsDefer.push([actions, reserve, callbackId]); return; } - Object.keys(listeners2).forEach((name) => { - if (watch) { - if (name.indexOf("@") !== 0 && name.indexOf("uni-") !== 0) { - UniViewJSBridge.on(`uni-${name}-${this.$page.id}-${id2}`, this[listeners2[name]]); + var canvas = this.$refs.canvas; + var c2d = canvas.getContext("2d"); + if (!reserve) { + c2d.fillStyle = "#000000"; + c2d.strokeStyle = "#000000"; + c2d.shadowColor = "#000000"; + c2d.shadowBlur = 0; + c2d.shadowOffsetX = 0; + c2d.shadowOffsetY = 0; + c2d.setTransform(1, 0, 0, 1, 0, 0); + c2d.clearRect(0, 0, canvas.width, canvas.height); + } + this.preloadImage(actions); + for (let index2 = 0; index2 < actions.length; index2++) { + const action = actions[index2]; + let method = action.method; + const data = action.data; + if (/^set/.test(method) && method !== "setTransform") { + const method1 = method[3].toLowerCase() + method.slice(4); + let color; + if (method1 === "fillStyle" || method1 === "strokeStyle") { + if (data[0] === "normal") { + color = resolveColor(data[1]); + } else if (data[0] === "linear") { + const LinearGradient = c2d.createLinearGradient(...data[1]); + data[2].forEach(function(data2) { + const offset = data2[0]; + const color2 = resolveColor(data2[1]); + LinearGradient.addColorStop(offset, color2); + }); + color = LinearGradient; + } else if (data[0] === "radial") { + const x = data[1][0]; + const y = data[1][1]; + const r = data[1][2]; + const LinearGradient = c2d.createRadialGradient(x, y, 0, x, y, r); + data[2].forEach(function(data2) { + const offset = data2[0]; + const color2 = resolveColor(data2[1]); + LinearGradient.addColorStop(offset, color2); + }); + color = LinearGradient; + } else if (data[0] === "pattern") { + const loaded = this.checkImageLoaded(data[1], actions.slice(index2 + 1), callbackId, function(image2) { + if (image2) { + c2d[method1] = c2d.createPattern(image2, data[2]); + } + }); + if (!loaded) { + break; + } + continue; + } + c2d[method1] = color; + } else if (method1 === "globalAlpha") { + c2d[method1] = data[0] / 255; + } else if (method1 === "shadow") { + var _ = ["shadowOffsetX", "shadowOffsetY", "shadowBlur", "shadowColor"]; + data.forEach(function(color_, method_) { + c2d[_[method_]] = _[method_] === "shadowColor" ? resolveColor(color_) : color_; + }); + } else { + if (method1 === "fontSize") { + c2d.font = c2d.font.replace(/\d+\.?\d*px/, data[0] + "px"); + } else { + if (method1 === "lineDash") { + c2d.setLineDash(data[0]); + c2d.lineDashOffset = data[1] || 0; + } else { + if (method1 === "textBaseline") { + if (data[0] === "normal") { + data[0] = "alphabetic"; + } + c2d[method1] = data[0]; + } else { + c2d[method1] = data[0]; + } + } + } + } + } else if (method === "fillPath" || method === "strokePath") { + method = method.replace(/Path/, ""); + c2d.beginPath(); + data.forEach(function(data_) { + c2d[data_.method].apply(c2d, data_.data); + }); + c2d[method](); + } else if (method === "fillText") { + c2d.fillText.apply(c2d, data); + } else if (method === "drawImage") { + var A = function() { + var dataArray = [...data]; + var url = dataArray[0]; + var otherData = dataArray.slice(1); + self._images = self._images || {}; + if (!self.checkImageLoaded(url, actions.slice(index2 + 1), callbackId, function(image2) { + if (image2) { + c2d.drawImage.apply(c2d, [image2].concat([...otherData.slice(4, 8)], [...otherData.slice(0, 4)])); + } + })) + return "break"; + }(); + if (A === "break") { + break; } } else { - if (name.indexOf("@") === 0) { - this.$on(`uni-${name.substr(1)}`, this[listeners2[name]]); - } else if (name.indexOf("uni-") === 0) { - UniViewJSBridge.on(name, this[listeners2[name]]); - } else if (id2) { - UniViewJSBridge.on(`uni-${name}-${this.$page.id}-${id2}`, this[listeners2[name]]); + if (method === "clip") { + data.forEach(function(data_) { + c2d[data_.method].apply(c2d, data_.data); + }); + c2d.clip(); + } else { + c2d[method].apply(c2d, data); + } + } + } + if (!this.actionsWaiting && callbackId) { + UniViewJSBridge.publishHandler("onDrawCanvas", { + callbackId, + data: { + errMsg: "drawCanvas:ok" + } + }, this.$page.id); + } + }, + preloadImage: function(actions) { + var self = this; + actions.forEach(function(action) { + var method = action.method; + var data = action.data; + var src = ""; + if (method === "drawImage") { + src = data[0]; + src = self.$getRealPath(src); + data[0] = src; + } else if (method === "setFillStyle" && data[0] === "pattern") { + src = data[1]; + src = self.$getRealPath(src); + data[1] = src; + } + if (src && !self._images[src]) { + loadImage(); + } + function loadImage() { + self._images[src] = new Image(); + self._images[src].onload = function() { + self._images[src].ready = true; + }; + function loadBlob(blob) { + self._images[src].src = (window.URL || window.webkitURL).createObjectURL(blob); + } + function loadFile(path) { + var bitmap = new plus.nativeObj.Bitmap("bitmap" + Date.now()); + bitmap.load(path, function() { + self._images[src].src = bitmap.toBase64Data(); + bitmap.clear(); + }, function() { + bitmap.clear(); + console.error("preloadImage error"); + }); + } + function loadUrl(url) { + function plusDownload() { + plus.downloader.createDownload(url, { + filename: "_doc/uniapp_temp/download/" + }, function(d, status) { + if (status === 200) { + loadFile(d.filename); + } else { + self._images[src].src = src; + } + }).start(); + } + var xhr = new XMLHttpRequest(); + xhr.open("GET", url, true); + xhr.responseType = "blob"; + xhr.onload = function() { + if (this.status === 200) { + loadBlob(this.response); + } + }; + xhr.onerror = window.plus ? plusDownload : function() { + self._images[src].src = src; + }; + xhr.send(); + } + if (window.plus && (!window.webkit || !window.webkit.messageHandlers)) { + self._images[src].src = src; + } else { + if (window.plus && src.indexOf("http://") !== 0 && src.indexOf("https://") !== 0 && !/^data:.*,.*/.test(src)) { + loadFile(src); + } else if (/^data:.*,.*/.test(src)) { + self._images[src].src = src; + } else { + loadUrl(src); + } } } }); }, - _removeListeners(id2, watch) { - if (watch && !id2) { - return; + checkImageLoaded: function(src, actions, callbackId, fn) { + var self = this; + var image2 = this._images[src]; + if (image2.ready) { + fn(image2); + return true; + } else { + this._actionsDefer.unshift([actions, true]); + this.actionsWaiting = true; + image2.onload = function() { + image2.ready = true; + fn(image2); + self.actionsWaiting = false; + var actions2 = self._actionsDefer.slice(0); + self._actionsDefer = []; + for (var action = actions2.shift(); action; ) { + self.actionsChanged({ + actions: action[0], + reserve: action[1], + callbackId + }); + action = actions2.shift(); + } + }; + return false; + } + }, + getImageData({ + x = 0, + y = 0, + width, + height, + destWidth, + destHeight, + hidpi = true, + callbackId + }) { + var imgData; + var canvas = this.$refs.canvas; + if (!width) { + width = canvas.offsetWidth - x; } - const {listeners: listeners2} = this.$options; - if (!isPlainObject(listeners2)) { - return; + if (!height) { + height = canvas.offsetHeight - y; } - Object.keys(listeners2).forEach((name) => { - if (watch) { - if (name.indexOf("@") !== 0 && name.indexOf("uni-") !== 0) { - UniViewJSBridge.off(`uni-${name}-${this.$page.id}-${id2}`, this[listeners2[name]]); + try { + if (!hidpi) { + if (!destWidth && !destHeight) { + destWidth = Math.round(width * pixelRatio); + destHeight = Math.round(height * pixelRatio); + } else if (!destWidth) { + destWidth = Math.round(width / height * destHeight); + } else if (!destHeight) { + destHeight = Math.round(height / width * destWidth); } } else { - if (name.indexOf("@") === 0) { - this.$off(`uni-${name.substr(1)}`, this[listeners2[name]]); - } else if (name.indexOf("uni-") === 0) { - UniViewJSBridge.off(name, this[listeners2[name]]); - } else if (id2) { - UniViewJSBridge.off(`uni-${name}-${this.$page.id}-${id2}`, this[listeners2[name]]); - } + destWidth = width; + destHeight = height; } - }); - } - } -}; -var hover = { - data() { - return { - hovering: false - }; - }, - props: { - hoverClass: { - type: String, - default: "none" - }, - hoverStopPropagation: { - type: Boolean, - default: false - }, - hoverStartTime: { - type: [Number, String], - default: 50 - }, - hoverStayTime: { - type: [Number, String], - default: 400 - } - }, - methods: { - _hoverTouchStart(evt) { - if (evt._hoverPropagationStopped) { - return; - } - if (!this.hoverClass || this.hoverClass === "none" || this.disabled) { - return; - } - if (evt.touches.length > 1) { - return; - } - if (this.hoverStopPropagation) { - evt._hoverPropagationStopped = true; - } - this._hoverTouch = true; - this._hoverStartTimer = setTimeout(() => { - this.hovering = true; - if (!this._hoverTouch) { - this._hoverReset(); + const newCanvas = getTempCanvas(destWidth, destHeight); + const context = newCanvas.getContext("2d"); + context.__hidpi__ = true; + context.drawImageByCanvas(canvas, x, y, width, height, 0, 0, destWidth, destHeight, false); + imgData = context.getImageData(0, 0, destWidth, destHeight); + newCanvas.height = newCanvas.width = 0; + context.__hidpi__ = false; + } catch (error) { + if (!callbackId) { + return; } - }, this.hoverStartTime); - }, - _hoverTouchEnd(evt) { - this._hoverTouch = false; - if (this.hovering) { - this._hoverReset(); - } - }, - _hoverReset() { - requestAnimationFrame(() => { - clearTimeout(this._hoverStayTimer); - this._hoverStayTimer = setTimeout(() => { - this.hovering = false; - }, this.hoverStayTime); - }); - }, - _hoverTouchCancel(evt) { - this._hoverTouch = false; - this.hovering = false; - clearTimeout(this._hoverStartTimer); - } - } -}; -var subscriber = { - mounted() { - this._toggleListeners("subscribe", this.id); - this.$watch("id", (newId, oldId) => { - this._toggleListeners("unsubscribe", oldId, true); - this._toggleListeners("subscribe", newId, true); - }); - }, - beforeDestroy() { - this._toggleListeners("unsubscribe", this.id); - if (this._contextId) { - this._toggleListeners("unsubscribe", this._contextId); - } - }, - methods: { - _toggleListeners(type, id2, watch) { - if (watch && !id2) { - return; - } - if (!isFunction(this._handleSubscribe)) { + UniViewJSBridge.publishHandler("onCanvasMethodCallback", { + callbackId, + data: { + errMsg: "canvasGetImageData:fail" + } + }, this.$page.id); return; } - UniViewJSBridge[type](this.$page.id + "-" + this.$options.name.replace(/VUni([A-Z])/, "$1").toLowerCase() + "-" + id2, this._handleSubscribe); - }, - _getContextInfo() { - const id2 = `context-${this._uid}`; - if (!this._contextId) { - this._toggleListeners("subscribe", id2); - this._contextId = id2; - } - return { - name: this.$options.name.replace(/VUni([A-Z])/, "$1").toLowerCase(), - id: id2, - page: this.$page.id - }; - } - } -}; -function hideKeyboard() { - document.activeElement.blur(); -} -function iosHideKeyboard() { -} -var keyboard = { - name: "Keyboard", - props: { - cursorSpacing: { - type: [Number, String], - default: 0 - }, - showConfirmBar: { - type: [Boolean, String], - default: "auto" - }, - adjustPosition: { - type: Boolean, - default: true - } - }, - watch: { - focus(val) { - if (val && false) { - this.showSoftKeybord(); - } - } - }, - mounted() { - if (this.autoFocus || this.focus) { - this.showSoftKeybord(); - } - }, - beforeDestroy() { - this.onKeyboardHide(); - }, - methods: { - initKeyboard(el) { - el.addEventListener("focus", () => { - this.hideKeyboardTemp = function() { - hideKeyboard(); + if (!callbackId) { + return { + data: Array.prototype.slice.call(imgData.data), + width: destWidth, + height: destHeight }; - UniViewJSBridge.subscribe("hideKeyboard", this.hideKeyboardTemp); - document.addEventListener("click", iosHideKeyboard, false); - }); - el.addEventListener("blur", this.onKeyboardHide.bind(this)); - }, - showSoftKeybord() { - plusReady(() => { - plus.key.showSoftKeybord(); - }); - }, - setSoftinputTemporary() { - plusReady(() => { - const currentWebview = plus.webview.currentWebview(); - const style = currentWebview.getStyle() || {}; - const rect = this.$el.getBoundingClientRect(); - currentWebview.setSoftinputTemporary && currentWebview.setSoftinputTemporary({ - mode: style.softinputMode === "adjustResize" ? "adjustResize" : this.adjustPosition ? "adjustPan" : "nothing", - position: { - top: rect.top, - height: rect.height + (Number(this.cursorSpacing) || 0) + } else { + UniViewJSBridge.publishHandler("onCanvasMethodCallback", { + callbackId, + data: { + errMsg: "canvasGetImageData:ok", + data: [...imgData.data], + width: destWidth, + height: destHeight } - }); - }); + }, this.$page.id); + } }, - setSoftinputNavBar() { - if (this.showConfirmBar === "auto") { - delete this.__softinputNavBar; + putImageData({ + data, + x, + y, + width, + height, + callbackId + }) { + try { + if (!height) { + height = Math.round(data.length / 4 / width); + } + const canvas = getTempCanvas(width, height); + const context = canvas.getContext("2d"); + context.putImageData(new ImageData(new Uint8ClampedArray(data), width, height), 0, 0); + this.$refs.canvas.getContext("2d").drawImage(canvas, x, y, width, height); + canvas.height = canvas.width = 0; + } catch (error) { + UniViewJSBridge.publishHandler("onCanvasMethodCallback", { + callbackId, + data: { + errMsg: "canvasPutImageData:fail" + } + }, this.$page.id); return; } - plusReady(() => { - const currentWebview = plus.webview.currentWebview(); - const {softinputNavBar} = currentWebview.getStyle() || {}; - const showConfirmBar = softinputNavBar !== "none"; - if (showConfirmBar !== this.showConfirmBar) { - this.__softinputNavBar = softinputNavBar || "auto"; - currentWebview.setStyle({ - softinputNavBar: this.showConfirmBar ? "auto" : "none" - }); - } else { - delete this.__softinputNavBar; + UniViewJSBridge.publishHandler("onCanvasMethodCallback", { + callbackId, + data: { + errMsg: "canvasPutImageData:ok" } - }); + }, this.$page.id); }, - resetSoftinputNavBar() { - const softinputNavBar = this.__softinputNavBar; - if (softinputNavBar) { - plusReady(() => { - const currentWebview = plus.webview.currentWebview(); - currentWebview.setStyle({ - softinputNavBar - }); - }); + getDataUrl({ + x = 0, + y = 0, + width, + height, + destWidth, + destHeight, + hidpi = true, + fileType, + qualit, + callbackId + }) { + const res = this.getImageData({ + x, + y, + width, + height, + destWidth, + destHeight, + hidpi + }); + if (!res.data || !res.data.length) { + UniViewJSBridge.publishHandler("onCanvasMethodCallback", { + callbackId, + data: { + errMsg: "canvasGetDataUrl:fail" + } + }, this.$page.id); + return; } - }, - onKeyboardHide() { - UniViewJSBridge.unsubscribe("hideKeyboard", this.hideKeyboardTemp); - document.removeEventListener("click", iosHideKeyboard, false); - if (String(navigator.vendor).indexOf("Apple") === 0) { - document.documentElement.scrollTo(document.documentElement.scrollLeft, document.documentElement.scrollTop); + let imgData; + try { + imgData = new ImageData(new Uint8ClampedArray(res.data), res.width, res.height); + } catch (error) { + UniViewJSBridge.publishHandler("onCanvasMethodCallback", { + callbackId, + data: { + errMsg: "canvasGetDataUrl:fail" + } + }, this.$page.id); + return; } + destWidth = res.width; + destHeight = res.height; + const canvas = getTempCanvas(destWidth, destHeight); + const c2d = canvas.getContext("2d"); + c2d.putImageData(imgData, 0, 0); + let base64 = canvas.toDataURL("image/png"); + canvas.height = canvas.width = 0; + const img = new Image(); + img.onload = () => { + const canvas2 = getTempCanvas(destWidth, destHeight); + if (fileType === "jpeg" || fileType === "jpg") { + fileType = "jpeg"; + c2d.fillStyle = "#fff"; + c2d.fillRect(0, 0, destWidth, destHeight); + } + c2d.drawImage(img, 0, 0); + base64 = canvas2.toDataURL(`image/${fileType}`, qualit); + canvas2.height = canvas2.width = 0; + UniViewJSBridge.publishHandler("onCanvasMethodCallback", { + callbackId, + data: { + errMsg: "canvasGetDataUrl:ok", + base64 + } + }, this.$page.id); + }; + img.src = base64; } } }; -function throttle(fn, wait) { - let last = 0; - let timeout; - const newFn = function(...arg) { - const now = Date.now(); - clearTimeout(timeout); - const waitCallback = () => { - last = now; - fn.apply(this, arg); - }; - if (now - last < wait) { - timeout = setTimeout(waitCallback, wait - (now - last)); - return; - } - waitCallback(); - }; - newFn.cancel = function() { - clearTimeout(timeout); - }; - return newFn; +const _hoisted_1$c = { + ref: "canvas", + width: "300", + height: "150" +}; +const _hoisted_2$6 = {style: {position: "absolute", top: "0", left: "0", width: "100%", height: "100%", overflow: "hidden"}}; +function _sfc_render$q(_ctx, _cache, $props, $setup, $data, $options) { + const _component_v_uni_resize_sensor = resolveComponent("v-uni-resize-sensor"); + return openBlock(), createBlock("uni-canvas", mergeProps({ + "canvas-id": $props.canvasId, + "disable-scroll": $props.disableScroll + }, toHandlers($options._listeners)), [ + createVNode("canvas", _hoisted_1$c, null, 512), + createVNode("div", _hoisted_2$6, [ + renderSlot(_ctx.$slots, "default") + ]), + createVNode(_component_v_uni_resize_sensor, { + ref: "sensor", + onResize: $options._resize + }, null, 8, ["onResize"]) + ], 16, ["canvas-id", "disable-scroll"]); } -var baseInput = { - name: "BaseInput", - mixins: [emitter, keyboard], - model: { - prop: "value", - event: "update:value" - }, +_sfc_main$s.render = _sfc_render$q; +const _sfc_main$r = { + name: "Checkbox", + mixins: [emitter, listeners], props: { + checked: { + type: [Boolean, String], + default: false + }, + id: { + type: String, + default: "" + }, + disabled: { + type: [Boolean, String], + default: false + }, + color: { + type: String, + default: "#007aff" + }, value: { - type: [String, Number], + type: String, default: "" } }, data() { return { - valueSync: this._getValueString(this.value) + checkboxChecked: this.checked, + checkboxValue: this.value }; }, + watch: { + checked(val) { + this.checkboxChecked = val; + }, + value(val) { + this.checkboxValue = val; + } + }, + listeners: { + "label-click": "_onClick", + "@label-click": "_onClick" + }, created() { - const valueChange = this.__valueChange = debounce((val) => { - this.valueSync = this._getValueString(val); - }, 100); - this.$watch("value", valueChange); - this.__triggerInput = throttle(($event, detail) => { - this.$emit("update:value", detail.value); - this.$trigger("input", $event, detail); - }, 100); - this.$triggerInput = ($event, detail) => { - this.__valueChange.cancel(); - this.__triggerInput($event, detail); - }; + this.$dispatch("CheckboxGroup", "uni-checkbox-group-update", { + type: "add", + vm: this + }); + this.$dispatch("Form", "uni-form-group-update", { + type: "add", + vm: this + }); }, beforeDestroy() { - this.__valueChange.cancel(); - this.__triggerInput.cancel(); + this.$dispatch("CheckboxGroup", "uni-checkbox-group-update", { + type: "remove", + vm: this + }); + this.$dispatch("Form", "uni-form-group-update", { + type: "remove", + vm: this + }); }, methods: { - _getValueString(value) { - return value === null ? "" : String(value); + _onClick($event) { + if (this.disabled) { + return; + } + this.checkboxChecked = !this.checkboxChecked; + this.$dispatch("CheckboxGroup", "uni-checkbox-change", $event); + }, + _resetFormData() { + this.checkboxChecked = false; } } }; -let supportsPassive$1 = false; -try { - const opts = {}; - Object.defineProperty(opts, "passive", { - get() { - supportsPassive$1 = true; - } - }); - window.addEventListener("test-passive", null, opts); -} catch (e2) { +const _hoisted_1$b = {class: "uni-checkbox-wrapper"}; +function _sfc_render$p(_ctx, _cache, $props, $setup, $data, $options) { + return openBlock(), createBlock("uni-checkbox", mergeProps({disabled: $props.disabled}, _ctx.$attrs, { + onClick: _cache[1] || (_cache[1] = (...args) => $options._onClick && $options._onClick(...args)) + }), [ + createVNode("div", _hoisted_1$b, [ + createVNode("div", { + class: [[$data.checkboxChecked ? "uni-checkbox-input-checked" : ""], "uni-checkbox-input"], + style: {color: $props.color} + }, null, 6), + renderSlot(_ctx.$slots, "default") + ]) + ], 16, ["disabled"]); } -const passiveOptions = supportsPassive$1 ? {passive: true} : false; -const _sfc_main$t = { - name: "Audio", - mixins: [subscriber], +_sfc_main$r.render = _sfc_render$p; +var index_vue_vue_type_style_index_0_lang$j = "\nuni-checkbox-group[hidden] {\r\n display: none;\n}\r\n"; +const _sfc_main$q = { + name: "CheckboxGroup", + mixins: [emitter, listeners], props: { - id: { - type: String, - default: "" - }, - src: { - type: String, - default: "" - }, - loop: { - type: [Boolean, String], - default: false - }, - controls: { - type: [Boolean, String], - default: false - }, - poster: { - type: String, - default: "" - }, name: { type: String, default: "" - }, - author: { - type: String, - default: "" } }, data() { return { - playing: false, - currentTime: this.getTime(0) + checkboxList: [] }; }, - watch: { - src(val) { - if (this.$refs.audio) { - this.$refs.audio.src = this.$getRealPath(val); - } - } + listeners: { + "@checkbox-change": "_changeHandler", + "@checkbox-group-update": "_checkboxGroupUpdateHandler" }, - mounted() { - const audio = this.$refs.audio; - audio.addEventListener("error", ($event) => { - this.playing = false; - this.$trigger("error", $event, {}); - }); - audio.addEventListener("play", ($event) => { - this.playing = true; - this.$trigger("play", $event, {}); - }); - audio.addEventListener("pause", ($event) => { - this.playing = false; - this.$trigger("pause", $event, {}); - }); - audio.addEventListener("ended", ($event) => { - this.playing = false; - this.$trigger("ended", $event, {}); + created() { + this.$dispatch("Form", "uni-form-group-update", { + type: "add", + vm: this }); - audio.addEventListener("timeupdate", ($event) => { - var currentTime = audio.currentTime; - this.currentTime = this.getTime(currentTime); - var duration = audio.duration; - this.$trigger("timeupdate", $event, { - currentTime, - duration - }); + }, + beforeDestroy() { + this.$dispatch("Form", "uni-form-group-update", { + type: "remove", + vm: this }); - audio.src = this.$getRealPath(this.src); }, methods: { - _handleSubscribe({ - type, - data = {} - }) { - var audio = this.$refs.audio; - switch (type) { - case "setSrc": - audio.src = this.$getRealPath(data.src); - this.$emit("update:src", data.src); - break; - case "play": - audio.play(); - break; - case "pause": - audio.pause(); - break; - case "seek": - audio.currentTime = data.position; - break; - } + _changeHandler($event) { + const value = []; + this.checkboxList.forEach((vm) => { + if (vm.checkboxChecked) { + value.push(vm.value); + } + }); + this.$trigger("change", $event, { + value + }); }, - trigger() { - if (this.playing) { - this.$refs.audio.pause(); + _checkboxGroupUpdateHandler($event) { + if ($event.type === "add") { + this.checkboxList.push($event.vm); } else { - this.$refs.audio.play(); + const index2 = this.checkboxList.indexOf($event.vm); + this.checkboxList.splice(index2, 1); } }, - getTime(time) { - var h = Math.floor(time / 3600); - var m = Math.floor(time % 3600 / 60); - var s = Math.floor(time % 3600 % 60); - h = (h < 10 ? "0" : "") + h; - m = (m < 10 ? "0" : "") + m; - s = (s < 10 ? "0" : "") + s; - var str = m + ":" + s; - if (h !== "00") { - str = h + ":" + str; + _getFormData() { + const data = {}; + if (this.name !== "") { + const value = []; + this.checkboxList.forEach((vm) => { + if (vm.checkboxChecked) { + value.push(vm.value); + } + }); + data.value = value; + data.key = this.name; + } + return data; + } + } +}; +function _sfc_render$o(_ctx, _cache, $props, $setup, $data, $options) { + return openBlock(), createBlock("uni-checkbox-group", _ctx.$attrs, [ + renderSlot(_ctx.$slots, "default") + ], 16); +} +_sfc_main$q.render = _sfc_render$o; +var startTag = /^<([-A-Za-z0-9_]+)((?:\s+[a-zA-Z_:][-a-zA-Z0-9_:.]*(?:\s*=\s*(?:(?:"[^"]*")|(?:'[^']*')|[^>\s]+))?)*)\s*(\/?)>/; +var endTag = /^<\/([-A-Za-z0-9_]+)[^>]*>/; +var attr = /([a-zA-Z_:][-a-zA-Z0-9_:.]*)(?:\s*=\s*(?:(?:"((?:\\.|[^"])*)")|(?:'((?:\\.|[^'])*)')|([^>\s]+)))?/g; +var empty = makeMap("area,base,basefont,br,col,frame,hr,img,input,link,meta,param,embed,command,keygen,source,track,wbr"); +var block = makeMap("a,address,article,applet,aside,audio,blockquote,button,canvas,center,dd,del,dir,div,dl,dt,fieldset,figcaption,figure,footer,form,frameset,h1,h2,h3,h4,h5,h6,header,hgroup,hr,iframe,isindex,li,map,menu,noframes,noscript,object,ol,output,p,pre,section,script,table,tbody,td,tfoot,th,thead,tr,ul,video"); +var inline = makeMap("abbr,acronym,applet,b,basefont,bdo,big,br,button,cite,code,del,dfn,em,font,i,iframe,img,input,ins,kbd,label,map,object,q,s,samp,script,select,small,span,strike,strong,sub,sup,textarea,tt,u,var"); +var closeSelf = makeMap("colgroup,dd,dt,li,options,p,td,tfoot,th,thead,tr"); +var fillAttrs = makeMap("checked,compact,declare,defer,disabled,ismap,multiple,nohref,noresize,noshade,nowrap,readonly,selected"); +var special = makeMap("script,style"); +function HTMLParser(html, handler) { + var index2; + var chars2; + var match; + var stack = []; + var last = html; + stack.last = function() { + return this[this.length - 1]; + }; + while (html) { + chars2 = true; + if (!stack.last() || !special[stack.last()]) { + if (html.indexOf(""); + if (index2 >= 0) { + if (handler.comment) { + handler.comment(html.substring(4, index2)); + } + html = html.substring(index2 + 3); + chars2 = false; + } + } else if (html.indexOf("]*>"), function(all, text3) { + text3 = text3.replace(/|/g, "$1$2"); + if (handler.chars) { + handler.chars(text3); + } + return ""; + }); + parseEndTag("", stack.last()); + } + if (html == last) { + throw "Parse Error: " + html; + } + last = html; + } + parseEndTag(); + function parseStartTag(tag, tagName, rest, unary) { + tagName = tagName.toLowerCase(); + if (block[tagName]) { + while (stack.last() && inline[stack.last()]) { + parseEndTag("", stack.last()); + } + } + if (closeSelf[tagName] && stack.last() == tagName) { + parseEndTag("", tagName); + } + unary = empty[tagName] || !!unary; + if (!unary) { + stack.push(tagName); + } + if (handler.start) { + var attrs2 = []; + rest.replace(attr, function(match2, name) { + var value = arguments[2] ? arguments[2] : arguments[3] ? arguments[3] : arguments[4] ? arguments[4] : fillAttrs[name] ? name : ""; + attrs2.push({ + name, + value, + escaped: value.replace(/(^|[^\\])"/g, '$1\\"') + }); + }); + if (handler.start) { + handler.start(tagName, attrs2, unary); + } + } + } + function parseEndTag(tag, tagName) { + if (!tagName) { + var pos = 0; + } else { + for (var pos = stack.length - 1; pos >= 0; pos--) { + if (stack[pos] == tagName) { + break; + } + } + } + if (pos >= 0) { + for (var i = stack.length - 1; i >= pos; i--) { + if (handler.end) { + handler.end(stack[i]); + } } - return str; + stack.length = pos; } } -}; -const _hoisted_1$d = {class: "uni-audio-default"}; -const _hoisted_2$7 = {class: "uni-audio-right"}; -const _hoisted_3$3 = {class: "uni-audio-time"}; -const _hoisted_4$3 = {class: "uni-audio-info"}; -const _hoisted_5$1 = {class: "uni-audio-name"}; -const _hoisted_6$1 = {class: "uni-audio-author"}; -function _sfc_render$r(_ctx, _cache, $props, $setup, $data, $options) { - return openBlock(), createBlock("uni-audio", mergeProps({ - id: $props.id, - controls: !!$props.controls - }, _ctx.$attrs), [ - createVNode("audio", { - ref: "audio", - loop: $props.loop, - style: {display: "none"} - }, null, 8, ["loop"]), - createVNode("div", _hoisted_1$d, [ - createVNode("div", { - style: "background-image: url(" + _ctx.$getRealPath($props.poster) + ");", - class: "uni-audio-left" - }, [ - createVNode("div", { - class: [{play: !$data.playing, pause: $data.playing}, "uni-audio-button"], - onClick: _cache[1] || (_cache[1] = (...args) => $options.trigger && $options.trigger(...args)) - }, null, 2) - ], 4), - createVNode("div", _hoisted_2$7, [ - createVNode("div", _hoisted_3$3, toDisplayString($data.currentTime), 1), - createVNode("div", _hoisted_4$3, [ - createVNode("div", _hoisted_5$1, toDisplayString($props.name), 1), - createVNode("div", _hoisted_6$1, toDisplayString($props.author), 1) - ]) - ]) - ]) - ], 16, ["id", "controls"]); } -_sfc_main$t.render = _sfc_render$r; -const pixelRatio = function() { - const canvas = document.createElement("canvas"); - canvas.height = canvas.width = 0; - const context = canvas.getContext("2d"); - const backingStore = context.backingStorePixelRatio || context.webkitBackingStorePixelRatio || context.mozBackingStorePixelRatio || context.msBackingStorePixelRatio || context.oBackingStorePixelRatio || context.backingStorePixelRatio || 1; - return (window.devicePixelRatio || 1) / backingStore; -}(); -const forEach = function(obj, func) { - for (const key in obj) { - if (hasOwn(obj, key)) { - func(obj[key], key); - } +function makeMap(str) { + var obj = {}; + var items = str.split(","); + for (var i = 0; i < items.length; i++) { + obj[items[i]] = true; } -}; -const ratioArgs = { - fillRect: "all", - clearRect: "all", - strokeRect: "all", - moveTo: "all", - lineTo: "all", - arc: [0, 1, 2], - arcTo: "all", - bezierCurveTo: "all", - isPointinPath: "all", - isPointinStroke: "all", - quadraticCurveTo: "all", - rect: "all", - translate: "all", - createRadialGradient: "all", - createLinearGradient: "all", - setTransform: [4, 5] -}; -const proto = CanvasRenderingContext2D.prototype; -proto.drawImageByCanvas = function(_super) { - return function(canvas, srcx, srcy, srcw, srch, desx, desy, desw, desh, isScale) { - if (!this.__hidpi__) { - return _super.apply(this, arguments); - } - srcx *= pixelRatio; - srcy *= pixelRatio; - srcw *= pixelRatio; - srch *= pixelRatio; - desx *= pixelRatio; - desy *= pixelRatio; - desw = isScale ? desw * pixelRatio : desw; - desh = isScale ? desh * pixelRatio : desh; - _super.call(this, canvas, srcx, srcy, srcw, srch, desx, desy, desw, desh); + return obj; +} +function divider(Quill) { + const BlockEmbed = Quill.import("blots/block/embed"); + class Divider extends BlockEmbed { + } + Divider.blotName = "divider"; + Divider.tagName = "HR"; + return { + "formats/divider": Divider }; -}(proto.drawImage); -if (pixelRatio !== 1) { - forEach(ratioArgs, function(value, key) { - proto[key] = function(_super) { - return function() { - if (!this.__hidpi__) { - return _super.apply(this, arguments); +} +function ins(Quill) { + const Inline = Quill.import("blots/inline"); + class Ins extends Inline { + } + Ins.blotName = "ins"; + Ins.tagName = "INS"; + return { + "formats/ins": Ins + }; +} +function align(Quill) { + const {Scope, Attributor} = Quill.import("parchment"); + const config = { + scope: Scope.BLOCK, + whitelist: ["left", "right", "center", "justify"] + }; + const AlignStyle = new Attributor.Style("align", "text-align", config); + return { + "formats/align": AlignStyle + }; +} +function direction(Quill) { + const {Scope, Attributor} = Quill.import("parchment"); + const config = { + scope: Scope.BLOCK, + whitelist: ["rtl"] + }; + const DirectionStyle = new Attributor.Style("direction", "direction", config); + return { + "formats/direction": DirectionStyle + }; +} +function list(Quill) { + const Parchment = Quill.import("parchment"); + const Container = Quill.import("blots/container"); + const ListItem = Quill.import("formats/list/item"); + class List extends Container { + static create(value) { + const tagName = value === "ordered" ? "OL" : "UL"; + const node = super.create(tagName); + if (value === "checked" || value === "unchecked") { + node.setAttribute("data-checked", value === "checked"); + } + return node; + } + static formats(domNode) { + if (domNode.tagName === "OL") + return "ordered"; + if (domNode.tagName === "UL") { + if (domNode.hasAttribute("data-checked")) { + return domNode.getAttribute("data-checked") === "true" ? "checked" : "unchecked"; + } else { + return "bullet"; } - let args = Array.prototype.slice.call(arguments); - if (value === "all") { - args = args.map(function(a2) { - return a2 * pixelRatio; - }); - } else if (Array.isArray(value)) { - for (let i2 = 0; i2 < value.length; i2++) { - args[value[i2]] *= pixelRatio; - } + } + return void 0; + } + constructor(domNode) { + super(domNode); + const listEventHandler = (e2) => { + if (e2.target.parentNode !== domNode) + return; + const format = this.statics.formats(domNode); + const blot = Parchment.find(e2.target); + if (format === "checked") { + blot.format("list", "unchecked"); + } else if (format === "unchecked") { + blot.format("list", "checked"); } - return _super.apply(this, args); }; - }(proto[key]); - }); - proto.stroke = function(_super) { - return function() { - if (!this.__hidpi__) { - return _super.apply(this, arguments); - } - this.lineWidth *= pixelRatio; - _super.apply(this, arguments); - this.lineWidth /= pixelRatio; - }; - }(proto.stroke); - proto.fillText = function(_super) { - return function() { - if (!this.__hidpi__) { - return _super.apply(this, arguments); + domNode.addEventListener("click", listEventHandler); + } + format(name, value) { + if (this.children.length > 0) { + this.children.tail.format(name, value); } - const args = Array.prototype.slice.call(arguments); - args[1] *= pixelRatio; - args[2] *= pixelRatio; - var font2 = this.font; - this.font = font2.replace(/(\d+\.?\d*)(px|em|rem|pt)/g, function(w, m, u) { - return m * pixelRatio + u; - }); - _super.apply(this, args); - this.font = font2; - }; - }(proto.fillText); - proto.strokeText = function(_super) { - return function() { - if (!this.__hidpi__) { - return _super.apply(this, arguments); + } + formats() { + return {[this.statics.blotName]: this.statics.formats(this.domNode)}; + } + insertBefore(blot, ref2) { + if (blot instanceof ListItem) { + super.insertBefore(blot, ref2); + } else { + const index2 = ref2 == null ? this.length() : ref2.offset(this); + const after = this.split(index2); + after.parent.insertBefore(blot, after); } - var args = Array.prototype.slice.call(arguments); - args[1] *= pixelRatio; - args[2] *= pixelRatio; - var font2 = this.font; - this.font = font2.replace(/(\d+\.?\d*)(px|em|rem|pt)/g, function(w, m, u) { - return m * pixelRatio + u; - }); - _super.apply(this, args); - this.font = font2; - }; - }(proto.strokeText); - proto.drawImage = function(_super) { - return function() { - if (!this.__hidpi__) { - return _super.apply(this, arguments); + } + optimize(context) { + super.optimize(context); + const next = this.next; + if (next != null && next.prev === this && next.statics.blotName === this.statics.blotName && next.domNode.tagName === this.domNode.tagName && next.domNode.getAttribute("data-checked") === this.domNode.getAttribute("data-checked")) { + next.moveChildren(this); + next.remove(); } - this.scale(pixelRatio, pixelRatio); - _super.apply(this, arguments); - this.scale(1 / pixelRatio, 1 / pixelRatio); - }; - }(proto.drawImage); + } + replace(target) { + if (target.statics.blotName !== this.statics.blotName) { + const item = Parchment.create(this.statics.defaultChild); + target.moveChildren(item); + this.appendChild(item); + } + super.replace(target); + } + } + List.blotName = "list"; + List.scope = Parchment.Scope.BLOCK_BLOT; + List.tagName = ["OL", "UL"]; + List.defaultChild = "list-item"; + List.allowedChildren = [ListItem]; + return { + "formats/list": List + }; } -function wrapper(canvas) { - canvas.width = canvas.offsetWidth * pixelRatio; - canvas.height = canvas.offsetHeight * pixelRatio; - canvas.getContext("2d").__hidpi__ = true; +function background(Quill) { + const {Scope} = Quill.import("parchment"); + const BackgroundStyle = Quill.import("formats/background"); + const BackgroundColorStyle = new BackgroundStyle.constructor("backgroundColor", "background-color", { + scope: Scope.INLINE + }); + return { + "formats/backgroundColor": BackgroundColorStyle + }; } -var index_vue_vue_type_style_index_0_lang$k = "\nuni-canvas {\r\n width: 300px;\r\n height: 150px;\r\n display: block;\r\n position: relative;\n}\nuni-canvas > canvas {\r\n position: absolute;\r\n top: 0;\r\n left: 0;\r\n width: 100%;\r\n height: 100%;\n}\r\n"; -function resolveColor(color) { - color = color.slice(0); - color[3] = color[3] / 255; - return "rgba(" + color.join(",") + ")"; +function box(Quill) { + const {Scope, Attributor} = Quill.import("parchment"); + const config = { + scope: Scope.BLOCK + }; + const margin = [ + "margin", + "marginTop", + "marginBottom", + "marginLeft", + "marginRight" + ]; + const padding = [ + "padding", + "paddingTop", + "paddingBottom", + "paddingLeft", + "paddingRight" + ]; + const result = {}; + margin.concat(padding).forEach((name) => { + result[`formats/${name}`] = new Attributor.Style(name, hyphenate(name), config); + }); + return result; } -function processTouches(target, touches) { - return [].map.call(touches, (touch) => { - var boundingClientRect = target.getBoundingClientRect(); - return { - identifier: touch.identifier, - x: touch.clientX - boundingClientRect.left, - y: touch.clientY - boundingClientRect.top - }; +function font(Quill) { + const {Scope, Attributor} = Quill.import("parchment"); + const config = { + scope: Scope.INLINE + }; + const font2 = [ + "font", + "fontSize", + "fontStyle", + "fontVariant", + "fontWeight", + "fontFamily" + ]; + const result = {}; + font2.forEach((name) => { + result[`formats/${name}`] = new Attributor.Style(name, hyphenate(name), config); }); + return result; } -var tempCanvas; -function getTempCanvas(width = 0, height = 0) { - if (!tempCanvas) { - tempCanvas = document.createElement("canvas"); - } - tempCanvas.width = width; - tempCanvas.height = height; - return tempCanvas; +function text(Quill) { + const {Scope, Attributor} = Quill.import("parchment"); + const text2 = [ + { + name: "lineHeight", + scope: Scope.BLOCK + }, + { + name: "letterSpacing", + scope: Scope.INLINE + }, + { + name: "textDecoration", + scope: Scope.INLINE + }, + { + name: "textIndent", + scope: Scope.BLOCK + } + ]; + const result = {}; + text2.forEach(({name, scope}) => { + result[`formats/${name}`] = new Attributor.Style(name, hyphenate(name), { + scope + }); + }); + return result; } -const _sfc_main$s = { - name: "Canvas", - mixins: [subscriber], +function image(Quill) { + const Image2 = Quill.import("formats/image"); + const ATTRIBUTES = [ + "alt", + "height", + "width", + "data-custom", + "class", + "data-local" + ]; + Image2.sanitize = (url) => url; + Image2.formats = function formats(domNode) { + return ATTRIBUTES.reduce(function(formats2, attribute) { + if (domNode.hasAttribute(attribute)) { + formats2[attribute] = domNode.getAttribute(attribute); + } + return formats2; + }, {}); + }; + const format = Image2.prototype.format; + Image2.prototype.format = function(name, value) { + if (ATTRIBUTES.indexOf(name) > -1) { + if (value) { + this.domNode.setAttribute(name, value); + } else { + this.domNode.removeAttribute(name); + } + } else { + format.call(this, name, value); + } + }; +} +function register(Quill) { + const formats = { + divider, + ins, + align, + direction, + list, + background, + box, + font, + text, + image + }; + const options = {}; + Object.values(formats).forEach((value) => Object.assign(options, value(Quill))); + Quill.register(options, true); +} +var editor_css_vue_type_style_index_0_src_lang = ".ql-container {\n display: block;\n position: relative;\n box-sizing: border-box;\n -webkit-user-select: text;\n user-select: text;\n outline: none;\n overflow: hidden;\n width: 100%;\n height: 200px;\n min-height: 200px;\n}\n.ql-container[hidden] {\n display: none;\n}\n.ql-container .ql-editor {\n position: relative;\n font-size: inherit;\n line-height: inherit;\n font-family: inherit;\n min-height: inherit;\n width: 100%;\n height: 100%;\n padding: 0;\n overflow-x: hidden;\n overflow-y: auto;\n -webkit-tap-highlight-color: transparent;\n -webkit-touch-callout: none;\n -webkit-overflow-scrolling: touch;\n}\n.ql-container .ql-editor::-webkit-scrollbar {\n width: 0 !important;\n}\n.ql-container .ql-editor.scroll-disabled {\n overflow: hidden;\n}\n.ql-container .ql-image-overlay {\n display: flex;\n position: absolute;\n box-sizing: border-box;\n border: 1px dashed #ccc;\n justify-content: center;\n align-items: center;\n -webkit-user-select: none;\n user-select: none;\n}\n.ql-container .ql-image-overlay .ql-image-size {\n position: absolute;\n padding: 4px 8px;\n text-align: center;\n background-color: #fff;\n color: #888;\n border: 1px solid #ccc;\n box-sizing: border-box;\n opacity: 0.8;\n right: 4px;\n top: 4px;\n font-size: 12px;\n display: inline-block;\n width: auto;\n}\n.ql-container .ql-image-overlay .ql-image-toolbar {\n position: relative;\n text-align: center;\n box-sizing: border-box;\n background: #000;\n border-radius: 5px;\n color: #fff;\n font-size: 0;\n min-height: 24px;\n z-index: 100;\n}\n.ql-container .ql-image-overlay .ql-image-toolbar span {\n display: inline-block;\n cursor: pointer;\n padding: 5px;\n font-size: 12px;\n border-right: 1px solid #fff;\n}\n.ql-container .ql-image-overlay .ql-image-toolbar span:last-child {\n border-right: 0;\n}\n.ql-container .ql-image-overlay .ql-image-toolbar span.triangle-up {\n padding: 0;\n position: absolute;\n top: -12px;\n left: 50%;\n transform: translatex(-50%);\n width: 0;\n height: 0;\n border-width: 6px;\n border-style: solid;\n border-color: transparent transparent black transparent;\n}\n.ql-container .ql-image-overlay .ql-image-handle {\n position: absolute;\n height: 12px;\n width: 12px;\n border-radius: 50%;\n border: 1px solid #ccc;\n box-sizing: border-box;\n background: #fff;\n}\n.ql-container img {\n display: inline-block;\n max-width: 100%;\n}\n.ql-clipboard p {\n margin: 0;\n padding: 0;\n}\n.ql-editor {\n box-sizing: border-box;\n height: 100%;\n outline: none;\n overflow-y: auto;\n tab-size: 4;\n -moz-tab-size: 4;\n text-align: left;\n white-space: pre-wrap;\n word-wrap: break-word;\n}\n.ql-editor > * {\n cursor: text;\n}\n.ql-editor p,\n.ql-editor ol,\n.ql-editor ul,\n.ql-editor pre,\n.ql-editor blockquote,\n.ql-editor h1,\n.ql-editor h2,\n.ql-editor h3,\n.ql-editor h4,\n.ql-editor h5,\n.ql-editor h6 {\n margin: 0;\n padding: 0;\n counter-reset: list-1 list-2 list-3 list-4 list-5 list-6 list-7 list-8 list-9;\n}\n.ql-editor ol > li,\n.ql-editor ul > li {\n list-style-type: none;\n}\n.ql-editor ul > li::before {\n content: '\\2022';\n}\n.ql-editor ul[data-checked=true],\n.ql-editor ul[data-checked=false] {\n pointer-events: none;\n}\n.ql-editor ul[data-checked=true] > li *,\n.ql-editor ul[data-checked=false] > li * {\n pointer-events: all;\n}\n.ql-editor ul[data-checked=true] > li::before,\n.ql-editor ul[data-checked=false] > li::before {\n color: #777;\n cursor: pointer;\n pointer-events: all;\n}\n.ql-editor ul[data-checked=true] > li::before {\n content: '\\2611';\n}\n.ql-editor ul[data-checked=false] > li::before {\n content: '\\2610';\n}\n.ql-editor li::before {\n display: inline-block;\n white-space: nowrap;\n width: 2em;\n}\n.ql-editor ol li {\n counter-reset: list-1 list-2 list-3 list-4 list-5 list-6 list-7 list-8 list-9;\n counter-increment: list-0;\n}\n.ql-editor ol li:before {\n content: counter(list-0, decimal) '. ';\n}\n.ql-editor ol li.ql-indent-1 {\n counter-increment: list-1;\n}\n.ql-editor ol li.ql-indent-1:before {\n content: counter(list-1, lower-alpha) '. ';\n}\n.ql-editor ol li.ql-indent-1 {\n counter-reset: list-2 list-3 list-4 list-5 list-6 list-7 list-8 list-9;\n}\n.ql-editor ol li.ql-indent-2 {\n counter-increment: list-2;\n}\n.ql-editor ol li.ql-indent-2:before {\n content: counter(list-2, lower-roman) '. ';\n}\n.ql-editor ol li.ql-indent-2 {\n counter-reset: list-3 list-4 list-5 list-6 list-7 list-8 list-9;\n}\n.ql-editor ol li.ql-indent-3 {\n counter-increment: list-3;\n}\n.ql-editor ol li.ql-indent-3:before {\n content: counter(list-3, decimal) '. ';\n}\n.ql-editor ol li.ql-indent-3 {\n counter-reset: list-4 list-5 list-6 list-7 list-8 list-9;\n}\n.ql-editor ol li.ql-indent-4 {\n counter-increment: list-4;\n}\n.ql-editor ol li.ql-indent-4:before {\n content: counter(list-4, lower-alpha) '. ';\n}\n.ql-editor ol li.ql-indent-4 {\n counter-reset: list-5 list-6 list-7 list-8 list-9;\n}\n.ql-editor ol li.ql-indent-5 {\n counter-increment: list-5;\n}\n.ql-editor ol li.ql-indent-5:before {\n content: counter(list-5, lower-roman) '. ';\n}\n.ql-editor ol li.ql-indent-5 {\n counter-reset: list-6 list-7 list-8 list-9;\n}\n.ql-editor ol li.ql-indent-6 {\n counter-increment: list-6;\n}\n.ql-editor ol li.ql-indent-6:before {\n content: counter(list-6, decimal) '. ';\n}\n.ql-editor ol li.ql-indent-6 {\n counter-reset: list-7 list-8 list-9;\n}\n.ql-editor ol li.ql-indent-7 {\n counter-increment: list-7;\n}\n.ql-editor ol li.ql-indent-7:before {\n content: counter(list-7, lower-alpha) '. ';\n}\n.ql-editor ol li.ql-indent-7 {\n counter-reset: list-8 list-9;\n}\n.ql-editor ol li.ql-indent-8 {\n counter-increment: list-8;\n}\n.ql-editor ol li.ql-indent-8:before {\n content: counter(list-8, lower-roman) '. ';\n}\n.ql-editor ol li.ql-indent-8 {\n counter-reset: list-9;\n}\n.ql-editor ol li.ql-indent-9 {\n counter-increment: list-9;\n}\n.ql-editor ol li.ql-indent-9:before {\n content: counter(list-9, decimal) '. ';\n}\n.ql-editor .ql-indent-1:not(.ql-direction-rtl) {\n padding-left: 2em;\n}\n.ql-editor li.ql-indent-1:not(.ql-direction-rtl) {\n padding-left: 2em;\n}\n.ql-editor .ql-indent-1.ql-direction-rtl.ql-align-right {\n padding-right: 2em;\n}\n.ql-editor li.ql-indent-1.ql-direction-rtl.ql-align-right {\n padding-right: 2em;\n}\n.ql-editor .ql-indent-2:not(.ql-direction-rtl) {\n padding-left: 4em;\n}\n.ql-editor li.ql-indent-2:not(.ql-direction-rtl) {\n padding-left: 4em;\n}\n.ql-editor .ql-indent-2.ql-direction-rtl.ql-align-right {\n padding-right: 4em;\n}\n.ql-editor li.ql-indent-2.ql-direction-rtl.ql-align-right {\n padding-right: 4em;\n}\n.ql-editor .ql-indent-3:not(.ql-direction-rtl) {\n padding-left: 6em;\n}\n.ql-editor li.ql-indent-3:not(.ql-direction-rtl) {\n padding-left: 6em;\n}\n.ql-editor .ql-indent-3.ql-direction-rtl.ql-align-right {\n padding-right: 6em;\n}\n.ql-editor li.ql-indent-3.ql-direction-rtl.ql-align-right {\n padding-right: 6em;\n}\n.ql-editor .ql-indent-4:not(.ql-direction-rtl) {\n padding-left: 8em;\n}\n.ql-editor li.ql-indent-4:not(.ql-direction-rtl) {\n padding-left: 8em;\n}\n.ql-editor .ql-indent-4.ql-direction-rtl.ql-align-right {\n padding-right: 8em;\n}\n.ql-editor li.ql-indent-4.ql-direction-rtl.ql-align-right {\n padding-right: 8em;\n}\n.ql-editor .ql-indent-5:not(.ql-direction-rtl) {\n padding-left: 10em;\n}\n.ql-editor li.ql-indent-5:not(.ql-direction-rtl) {\n padding-left: 10em;\n}\n.ql-editor .ql-indent-5.ql-direction-rtl.ql-align-right {\n padding-right: 10em;\n}\n.ql-editor li.ql-indent-5.ql-direction-rtl.ql-align-right {\n padding-right: 10em;\n}\n.ql-editor .ql-indent-6:not(.ql-direction-rtl) {\n padding-left: 12em;\n}\n.ql-editor li.ql-indent-6:not(.ql-direction-rtl) {\n padding-left: 12em;\n}\n.ql-editor .ql-indent-6.ql-direction-rtl.ql-align-right {\n padding-right: 12em;\n}\n.ql-editor li.ql-indent-6.ql-direction-rtl.ql-align-right {\n padding-right: 12em;\n}\n.ql-editor .ql-indent-7:not(.ql-direction-rtl) {\n padding-left: 14em;\n}\n.ql-editor li.ql-indent-7:not(.ql-direction-rtl) {\n padding-left: 14em;\n}\n.ql-editor .ql-indent-7.ql-direction-rtl.ql-align-right {\n padding-right: 14em;\n}\n.ql-editor li.ql-indent-7.ql-direction-rtl.ql-align-right {\n padding-right: 14em;\n}\n.ql-editor .ql-indent-8:not(.ql-direction-rtl) {\n padding-left: 16em;\n}\n.ql-editor li.ql-indent-8:not(.ql-direction-rtl) {\n padding-left: 16em;\n}\n.ql-editor .ql-indent-8.ql-direction-rtl.ql-align-right {\n padding-right: 16em;\n}\n.ql-editor li.ql-indent-8.ql-direction-rtl.ql-align-right {\n padding-right: 16em;\n}\n.ql-editor .ql-indent-9:not(.ql-direction-rtl) {\n padding-left: 18em;\n}\n.ql-editor li.ql-indent-9:not(.ql-direction-rtl) {\n padding-left: 18em;\n}\n.ql-editor .ql-indent-9.ql-direction-rtl.ql-align-right {\n padding-right: 18em;\n}\n.ql-editor li.ql-indent-9.ql-direction-rtl.ql-align-right {\n padding-right: 18em;\n}\n.ql-editor .ql-direction-rtl {\n direction: rtl;\n text-align: inherit;\n}\n.ql-editor .ql-align-center {\n text-align: center;\n}\n.ql-editor .ql-align-justify {\n text-align: justify;\n}\n.ql-editor .ql-align-right {\n text-align: right;\n}\n.ql-editor.ql-blank::before {\n color: rgba(0, 0, 0, 0.6);\n content: attr(data-placeholder);\n font-style: italic;\n pointer-events: none;\n position: absolute;\n}\n.ql-container.ql-disabled .ql-editor ul[data-checked] > li::before {\n pointer-events: none;\n}\n.ql-clipboard {\n left: -100000px;\n height: 1px;\n overflow-y: hidden;\n position: absolute;\n top: 50%;\n}\n"; +var index_vue_vue_type_style_index_1_lang = "\n"; +const _sfc_main$p = { + name: "Editor", + mixins: [subscriber, emitter, keyboard], props: { - canvasId: { + id: { type: String, default: "" }, - disableScroll: { + readOnly: { + type: [Boolean, String], + default: false + }, + placeholder: { + type: String, + default: "" + }, + showImgSize: { + type: [Boolean, String], + default: false + }, + showImgToolbar: { + type: [Boolean, String], + default: false + }, + showImgResize: { type: [Boolean, String], default: false } }, data() { return { - actionsWaiting: false + quillReady: false }; }, - computed: { - id() { - return this.canvasId; - }, - _listeners() { - var $listeners = Object.assign({}, this.$listeners); - var events = ["touchstart", "touchmove", "touchend"]; - events.forEach((event2) => { - var existing = $listeners[event2]; - var eventHandler = []; - if (existing) { - eventHandler.push(($event) => { - this.$trigger(event2, Object.assign({}, $event, { - touches: processTouches($event.currentTarget, $event.touches), - changedTouches: processTouches($event.currentTarget, $event.changedTouches) - })); - }); - } - if (this.disableScroll && event2 === "touchmove") { - eventHandler.push(this._touchmove); + computed: {}, + watch: { + readOnly(value) { + if (this.quillReady) { + const quill = this.quill; + quill.enable(!value); + if (!value) { + quill.blur(); } - $listeners[event2] = eventHandler; - }); - return $listeners; + } + }, + placeholder(value) { + if (this.quillReady) { + this.quill.root.setAttribute("data-placeholder", value); + } } }, - created() { - this._actionsDefer = []; - this._images = {}; - }, mounted() { - this._resize({ - width: this.$refs.sensor.$el.offsetWidth, - height: this.$refs.sensor.$el.offsetHeight + const imageResizeModules = []; + if (this.showImgSize) { + imageResizeModules.push("DisplaySize"); + } + if (this.showImgToolbar) { + imageResizeModules.push("Toolbar"); + } + if (this.showImgResize) { + imageResizeModules.push("Resize"); + } + this.loadQuill(() => { + if (imageResizeModules.length) { + this.loadImageResizeModule(() => { + this.initQuill(imageResizeModules); + }); + } else { + this.initQuill(imageResizeModules); + } }); }, - beforeDestroy() { - const canvas = this.$refs.canvas; - canvas.height = canvas.width = 0; - }, methods: { _handleSubscribe({ type, - data = {} - }) { - var method = this[type]; - if (type.indexOf("_") !== 0 && typeof method === "function") { - method(data); - } - }, - _resize() { - var canvas = this.$refs.canvas; - if (canvas.width > 0 && canvas.height > 0) { - var context = canvas.getContext("2d"); - var imageData = context.getImageData(0, 0, canvas.width, canvas.height); - wrapper(this.$refs.canvas); - context.putImageData(imageData, 0, 0); - } else { - wrapper(this.$refs.canvas); - } - }, - _touchmove(event2) { - event2.preventDefault(); - }, - actionsChanged({ - actions, - reserve, - callbackId + data }) { - var self = this; - if (!actions) { - return; - } - if (this.actionsWaiting) { - this._actionsDefer.push([actions, reserve, callbackId]); - return; - } - var canvas = this.$refs.canvas; - var c2d = canvas.getContext("2d"); - if (!reserve) { - c2d.fillStyle = "#000000"; - c2d.strokeStyle = "#000000"; - c2d.shadowColor = "#000000"; - c2d.shadowBlur = 0; - c2d.shadowOffsetX = 0; - c2d.shadowOffsetY = 0; - c2d.setTransform(1, 0, 0, 1, 0, 0); - c2d.clearRect(0, 0, canvas.width, canvas.height); - } - this.preloadImage(actions); - for (let index2 = 0; index2 < actions.length; index2++) { - const action = actions[index2]; - let method = action.method; - const data = action.data; - if (/^set/.test(method) && method !== "setTransform") { - const method1 = method[3].toLowerCase() + method.slice(4); - let color; - if (method1 === "fillStyle" || method1 === "strokeStyle") { - if (data[0] === "normal") { - color = resolveColor(data[1]); - } else if (data[0] === "linear") { - const LinearGradient = c2d.createLinearGradient(...data[1]); - data[2].forEach(function(data2) { - const offset = data2[0]; - const color2 = resolveColor(data2[1]); - LinearGradient.addColorStop(offset, color2); - }); - color = LinearGradient; - } else if (data[0] === "radial") { - const x = data[1][0]; - const y = data[1][1]; - const r = data[1][2]; - const LinearGradient = c2d.createRadialGradient(x, y, 0, x, y, r); - data[2].forEach(function(data2) { - const offset = data2[0]; - const color2 = resolveColor(data2[1]); - LinearGradient.addColorStop(offset, color2); - }); - color = LinearGradient; - } else if (data[0] === "pattern") { - const loaded = this.checkImageLoaded(data[1], actions.slice(index2 + 1), callbackId, function(image2) { - if (image2) { - c2d[method1] = c2d.createPattern(image2, data[2]); + const {options, callbackId} = data; + const quill = this.quill; + const Quill = window.Quill; + let res; + let range; + let errMsg; + if (this.quillReady) { + switch (type) { + case "format": + { + let {name = "", value = false} = options; + range = quill.getSelection(true); + let format = quill.getFormat(range)[name] || false; + if (["bold", "italic", "underline", "strike", "ins"].includes(name)) { + value = !format; + } else if (name === "direction") { + value = value === "rtl" && format ? false : value; + const align2 = quill.getFormat(range).align; + if (value === "rtl" && !align2) { + quill.format("align", "right", Quill.sources.USER); + } else if (!value && align2 === "right") { + quill.format("align", false, Quill.sources.USER); } - }); - if (!loaded) { - break; + } else if (name === "indent") { + const rtl = quill.getFormat(range).direction === "rtl"; + value = value === "+1"; + if (rtl) { + value = !value; + } + value = value ? "+1" : "-1"; + } else { + if (name === "list") { + value = value === "check" ? "unchecked" : value; + format = format === "checked" ? "unchecked" : format; + } + value = format && format !== (value || false) || !format && value ? value : !format; } - continue; + quill.format(name, value, Quill.sources.USER); } - c2d[method1] = color; - } else if (method1 === "globalAlpha") { - c2d[method1] = data[0] / 255; - } else if (method1 === "shadow") { - var _ = ["shadowOffsetX", "shadowOffsetY", "shadowBlur", "shadowColor"]; - data.forEach(function(color_, method_) { - c2d[_[method_]] = _[method_] === "shadowColor" ? resolveColor(color_) : color_; - }); - } else { - if (method1 === "fontSize") { - c2d.font = c2d.font.replace(/\d+\.?\d*px/, data[0] + "px"); - } else { - if (method1 === "lineDash") { - c2d.setLineDash(data[0]); - c2d.lineDashOffset = data[1] || 0; + break; + case "insertDivider": + range = quill.getSelection(true); + quill.insertText(range.index, "\n", Quill.sources.USER); + quill.insertEmbed(range.index + 1, "divider", true, Quill.sources.USER); + quill.setSelection(range.index + 2, Quill.sources.SILENT); + break; + case "insertImage": + { + range = quill.getSelection(true); + const {src = "", alt = "", width = "", height = "", extClass = "", data: data2 = {}} = options; + const path = this.$getRealPath(src); + quill.insertEmbed(range.index, "image", path, Quill.sources.USER); + const local = /^(file|blob):/.test(path) ? path : false; + quill.formatText(range.index, 1, "data-local", local); + quill.formatText(range.index, 1, "alt", alt); + quill.formatText(range.index, 1, "width", width); + quill.formatText(range.index, 1, "height", height); + quill.formatText(range.index, 1, "class", extClass); + quill.formatText(range.index, 1, "data-custom", Object.keys(data2).map((key) => `${key}=${data2[key]}`).join("&")); + quill.setSelection(range.index + 1, Quill.sources.SILENT); + } + break; + case "insertText": + { + range = quill.getSelection(true); + const {text: text2 = ""} = options; + quill.insertText(range.index, text2, Quill.sources.USER); + quill.setSelection(range.index + text2.length, 0, Quill.sources.SILENT); + } + break; + case "setContents": + { + const {delta, html} = options; + if (typeof delta === "object") { + quill.setContents(delta, Quill.sources.SILENT); + } else if (typeof html === "string") { + quill.setContents(this.html2delta(html), Quill.sources.SILENT); } else { - if (method1 === "textBaseline") { - if (data[0] === "normal") { - data[0] = "alphabetic"; - } - c2d[method1] = data[0]; - } else { - c2d[method1] = data[0]; - } + errMsg = "contents is missing"; } } - } - } else if (method === "fillPath" || method === "strokePath") { - method = method.replace(/Path/, ""); - c2d.beginPath(); - data.forEach(function(data_) { - c2d[data_.method].apply(c2d, data_.data); - }); - c2d[method](); - } else if (method === "fillText") { - c2d.fillText.apply(c2d, data); - } else if (method === "drawImage") { - var A = function() { - var dataArray = [...data]; - var url = dataArray[0]; - var otherData = dataArray.slice(1); - self._images = self._images || {}; - if (!self.checkImageLoaded(url, actions.slice(index2 + 1), callbackId, function(image2) { - if (image2) { - c2d.drawImage.apply(c2d, [image2].concat([...otherData.slice(4, 8)], [...otherData.slice(0, 4)])); + break; + case "getContents": + res = this.getContents(); + break; + case "clear": + quill.setContents([]); + break; + case "removeFormat": + { + range = quill.getSelection(true); + const parchment = Quill.import("parchment"); + if (range.length) { + quill.removeFormat(range, Quill.sources.USER); + } else { + Object.keys(quill.getFormat(range)).forEach((key) => { + if (parchment.query(key, parchment.Scope.INLINE)) { + quill.format(key, false); + } + }); } - })) - return "break"; - }(); - if (A === "break") { + } + break; + case "undo": + quill.history.undo(); + break; + case "redo": + quill.history.redo(); break; - } - } else { - if (method === "clip") { - data.forEach(function(data_) { - c2d[data_.method].apply(c2d, data_.data); - }); - c2d.clip(); - } else { - c2d[method].apply(c2d, data); - } } + this.updateStatus(range); + } else { + errMsg = "not ready"; } - if (!this.actionsWaiting && callbackId) { - UniViewJSBridge.publishHandler("onDrawCanvas", { - callbackId, - data: { - errMsg: "drawCanvas:ok" - } + if (callbackId) { + UniViewJSBridge.publishHandler("onEditorMethodCallback", { + callbackId, + data: Object.assign({}, res, { + errMsg: `${type}:${errMsg ? "fail " + errMsg : "ok"}` + }) }, this.$page.id); } }, - preloadImage: function(actions) { - var self = this; - actions.forEach(function(action) { - var method = action.method; - var data = action.data; - var src = ""; - if (method === "drawImage") { - src = data[0]; - src = self.$getRealPath(src); - data[0] = src; - } else if (method === "setFillStyle" && data[0] === "pattern") { - src = data[1]; - src = self.$getRealPath(src); - data[1] = src; + loadQuill(callback) { + if (typeof window.Quill === "function") { + if (typeof callback === "function") { + callback(); } - if (src && !self._images[src]) { - loadImage(); + return; + } + const script = document.createElement("script"); + script.src = window.plus ? "./__uniappquill.js" : "https://unpkg.com/quill@1.3.7/dist/quill.min.js"; + document.body.appendChild(script); + script.onload = callback; + }, + loadImageResizeModule(callback) { + if (typeof window.ImageResize === "function") { + if (typeof callback === "function") { + callback(); } - function loadImage() { - self._images[src] = new Image(); - self._images[src].onload = function() { - self._images[src].ready = true; - }; - function loadBlob(blob) { - self._images[src].src = (window.URL || window.webkitURL).createObjectURL(blob); - } - function loadFile(path) { - var bitmap = new plus.nativeObj.Bitmap("bitmap" + Date.now()); - bitmap.load(path, function() { - self._images[src].src = bitmap.toBase64Data(); - bitmap.clear(); - }, function() { - bitmap.clear(); - console.error("preloadImage error"); - }); - } - function loadUrl(url) { - function plusDownload() { - plus.downloader.createDownload(url, { - filename: "_doc/uniapp_temp/download/" - }, function(d, status) { - if (status === 200) { - loadFile(d.filename); - } else { - self._images[src].src = src; - } - }).start(); - } - var xhr = new XMLHttpRequest(); - xhr.open("GET", url, true); - xhr.responseType = "blob"; - xhr.onload = function() { - if (this.status === 200) { - loadBlob(this.response); - } - }; - xhr.onerror = window.plus ? plusDownload : function() { - self._images[src].src = src; - }; - xhr.send(); - } - if (window.plus && (!window.webkit || !window.webkit.messageHandlers)) { - self._images[src].src = src; + return; + } + const script = document.createElement("script"); + script.src = window.plus ? "./__uniappquillimageresize.js" : "https://unpkg.com/quill-image-resize-mp@3.0.1/image-resize.min.js"; + document.body.appendChild(script); + script.onload = callback; + }, + initQuill(imageResizeModules) { + const Quill = window.Quill; + register(Quill); + const options = { + toolbar: false, + readOnly: this.readOnly, + placeholder: this.placeholder, + modules: {} + }; + if (imageResizeModules.length) { + Quill.register("modules/ImageResize", window.ImageResize.default); + options.modules.ImageResize = { + modules: imageResizeModules + }; + } + const quill = this.quill = new Quill(this.$el, options); + const $el = quill.root; + const events = ["focus", "blur", "input"]; + events.forEach((name) => { + $el.addEventListener(name, ($event) => { + if (name === "input") { + $event.stopPropagation(); } else { - if (window.plus && src.indexOf("http://") !== 0 && src.indexOf("https://") !== 0 && !/^data:.*,.*/.test(src)) { - loadFile(src); - } else if (/^data:.*,.*/.test(src)) { - self._images[src].src = src; - } else { - loadUrl(src); - } + this.$trigger(name, $event, this.getContents()); } + }); + }); + quill.on(Quill.events.TEXT_CHANGE, () => { + this.$trigger("input", {}, this.getContents()); + }); + quill.on(Quill.events.SELECTION_CHANGE, this.updateStatus.bind(this)); + quill.on(Quill.events.SCROLL_OPTIMIZE, () => { + const range = quill.selection.getRange()[0]; + this.updateStatus(range); + }); + quill.clipboard.addMatcher(Node.ELEMENT_NODE, (node, delta) => { + if (this.skipMatcher) { + return delta; } + delta.ops = delta.ops.filter(({insert}) => typeof insert === "string").map(({insert}) => ({insert})); + return delta; }); + this.initKeyboard($el); + this.quillReady = true; + this.$trigger("ready", event, {}); }, - checkImageLoaded: function(src, actions, callbackId, fn) { - var self = this; - var image2 = this._images[src]; - if (image2.ready) { - fn(image2); - return true; - } else { - this._actionsDefer.unshift([actions, true]); - this.actionsWaiting = true; - image2.onload = function() { - image2.ready = true; - fn(image2); - self.actionsWaiting = false; - var actions2 = self._actionsDefer.slice(0); - self._actionsDefer = []; - for (var action = actions2.shift(); action; ) { - self.actionsChanged({ - actions: action[0], - reserve: action[1], - callbackId - }); - action = actions2.shift(); - } - }; - return false; - } + getContents() { + const quill = this.quill; + const html = quill.root.innerHTML; + const text2 = quill.getText(); + const delta = quill.getContents(); + return { + html, + text: text2, + delta + }; }, - getImageData({ - x = 0, - y = 0, - width, - height, - destWidth, - destHeight, - hidpi = true, - callbackId - }) { - var imgData; - var canvas = this.$refs.canvas; - if (!width) { - width = canvas.offsetWidth - x; - } - if (!height) { - height = canvas.offsetHeight - y; - } - try { - if (!hidpi) { - if (!destWidth && !destHeight) { - destWidth = Math.round(width * pixelRatio); - destHeight = Math.round(height * pixelRatio); - } else if (!destWidth) { - destWidth = Math.round(width / height * destHeight); - } else if (!destHeight) { - destHeight = Math.round(height / width * destWidth); + html2delta(html) { + const tags = ["span", "strong", "b", "ins", "em", "i", "u", "a", "del", "s", "sub", "sup", "img", "div", "p", "h1", "h2", "h3", "h4", "h5", "h6", "hr", "ol", "ul", "li", "br"]; + let content = ""; + let disable; + HTMLParser(html, { + start: function(tag, attrs2, unary) { + if (!tags.includes(tag)) { + disable = !unary; + return; } - } else { - destWidth = width; - destHeight = height; - } - const newCanvas = getTempCanvas(destWidth, destHeight); - const context = newCanvas.getContext("2d"); - context.__hidpi__ = true; - context.drawImageByCanvas(canvas, x, y, width, height, 0, 0, destWidth, destHeight, false); - imgData = context.getImageData(0, 0, destWidth, destHeight); - newCanvas.height = newCanvas.width = 0; - context.__hidpi__ = false; - } catch (error) { - if (!callbackId) { - return; - } - UniViewJSBridge.publishHandler("onCanvasMethodCallback", { - callbackId, - data: { - errMsg: "canvasGetImageData:fail" + disable = false; + const arrts = attrs2.map(({name, value}) => `${name}="${value}"`).join(" "); + const start = `<${tag} ${arrts} ${unary ? "/" : ""}>`; + content += start; + }, + end: function(tag) { + if (!disable) { + content += ``; } - }, this.$page.id); - return; - } - if (!callbackId) { - return { - data: Array.prototype.slice.call(imgData.data), - width: destWidth, - height: destHeight - }; - } else { - UniViewJSBridge.publishHandler("onCanvasMethodCallback", { - callbackId, - data: { - errMsg: "canvasGetImageData:ok", - data: [...imgData.data], - width: destWidth, - height: destHeight + }, + chars: function(text2) { + if (!disable) { + content += text2; } - }, this.$page.id); - } - }, - putImageData({ - data, - x, - y, - width, - height, - callbackId - }) { - try { - if (!height) { - height = Math.round(data.length / 4 / width); } - const canvas = getTempCanvas(width, height); - const context = canvas.getContext("2d"); - context.putImageData(new ImageData(new Uint8ClampedArray(data), width, height), 0, 0); - this.$refs.canvas.getContext("2d").drawImage(canvas, x, y, width, height); - canvas.height = canvas.width = 0; - } catch (error) { - UniViewJSBridge.publishHandler("onCanvasMethodCallback", { - callbackId, - data: { - errMsg: "canvasPutImageData:fail" - } - }, this.$page.id); - return; + }); + this.skipMatcher = true; + const delta = this.quill.clipboard.convert(content); + this.skipMatcher = false; + return delta; + }, + updateStatus(range) { + const status = range ? this.quill.getFormat(range) : {}; + const keys = Object.keys(status); + if (keys.length !== Object.keys(this.__status || {}).length || keys.find((key) => status[key] !== this.__status[key])) { + this.__status = status; + this.$trigger("statuschange", {}, status); } - UniViewJSBridge.publishHandler("onCanvasMethodCallback", { - callbackId, - data: { - errMsg: "canvasPutImageData:ok" + } + } +}; +function _sfc_render$n(_ctx, _cache, $props, $setup, $data, $options) { + return openBlock(), createBlock("uni-editor", mergeProps({ + id: $props.id, + class: "ql-container" + }, _ctx.$attrs), null, 16, ["id"]); +} +_sfc_main$p.render = _sfc_render$n; +var index_vue_vue_type_style_index_0_lang$i = "\r\n"; +const _sfc_main$o = { + name: "Form", + mixins: [listeners], + data() { + return { + childrenList: [] + }; + }, + listeners: { + "@form-submit": "_onSubmit", + "@form-reset": "_onReset", + "@form-group-update": "_formGroupUpdateHandler" + }, + methods: { + _onSubmit($event) { + const data = {}; + this.childrenList.forEach((vm) => { + if (vm._getFormData && vm._getFormData().key) { + data[vm._getFormData().key] = vm._getFormData().value; } - }, this.$page.id); + }); + this.$trigger("submit", $event, { + value: data + }); }, - getDataUrl({ - x = 0, - y = 0, - width, - height, - destWidth, - destHeight, - hidpi = true, - fileType, - qualit, - callbackId - }) { - const res = this.getImageData({ - x, - y, - width, - height, - destWidth, - destHeight, - hidpi + _onReset($event) { + this.$trigger("reset", $event, {}); + this.childrenList.forEach((vm) => { + vm._resetFormData && vm._resetFormData(); }); - if (!res.data || !res.data.length) { - UniViewJSBridge.publishHandler("onCanvasMethodCallback", { - callbackId, - data: { - errMsg: "canvasGetDataUrl:fail" - } - }, this.$page.id); - return; + }, + _formGroupUpdateHandler($event) { + if ($event.type === "add") { + this.childrenList.push($event.vm); + } else { + const index2 = this.childrenList.indexOf($event.vm); + this.childrenList.splice(index2, 1); + } + } + } +}; +function _sfc_render$m(_ctx, _cache, $props, $setup, $data, $options) { + return openBlock(), createBlock("uni-form", _ctx.$attrs, [ + createVNode("span", null, [ + renderSlot(_ctx.$slots, "default") + ]) + ], 16); +} +_sfc_main$o.render = _sfc_render$m; +var index_vue_vue_type_style_index_0_lang$h = "\nuni-icon {\r\n display: inline-block;\r\n font-size: 0;\r\n box-sizing: border-box;\n}\nuni-icon[hidden] {\r\n display: none;\n}\nuni-icon > i {\r\n font: normal normal normal 14px/1 'weui';\n}\nuni-icon > i:before {\r\n margin: 0;\r\n box-sizing: border-box;\n}\n@font-face {\r\n font-weight: normal;\r\n font-style: normal;\r\n font-family: 'weui';\r\n src: url('data:application/octet-stream;base64,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')\r\n format('truetype');\n}\n.uni-icon-success:before {\r\n content: '\\EA06';\n}\n.uni-icon-success_circle:before {\r\n content: '\\EA07';\n}\n.uni-icon-success_no_circle:before {\r\n content: '\\EA08';\n}\n.uni-icon-safe_success:before {\r\n content: '\\EA04';\n}\n.uni-icon-safe_warn:before {\r\n content: '\\EA05';\n}\n.uni-icon-info:before {\r\n content: '\\EA03';\n}\n.uni-icon-info_circle:before {\r\n content: '\\EA0C';\n}\n.uni-icon-warn:before {\r\n content: '\\EA0B';\n}\n.uni-icon-waiting:before {\r\n content: '\\EA09';\n}\n.uni-icon-waiting_circle:before {\r\n content: '\\EA0A';\n}\n.uni-icon-circle:before {\r\n content: '\\EA01';\n}\n.uni-icon-cancel:before {\r\n content: '\\EA0D';\n}\n.uni-icon-download:before {\r\n content: '\\EA02';\n}\n.uni-icon-search:before {\r\n content: '\\EA0E';\n}\n.uni-icon-clear:before {\r\n content: '\\EA0F';\n}\n.uni-icon-success {\r\n color: #007aff;\n}\n.uni-icon-success_circle {\r\n color: #007aff;\n}\n.uni-icon-success_no_circle {\r\n color: #007aff;\n}\n.uni-icon-safe_success {\r\n color: #007aff;\n}\n.uni-icon-safe_warn {\r\n color: #ffbe00;\n}\n.uni-icon-info {\r\n color: #10aeff;\n}\n.uni-icon-info_circle {\r\n color: #007aff;\n}\n.uni-icon-warn {\r\n color: #f76260;\n}\n.uni-icon-waiting {\r\n color: #10aeff;\n}\n.uni-icon-waiting_circle {\r\n color: #10aeff;\n}\n.uni-icon-circle {\r\n color: #c9c9c9;\n}\n.uni-icon-cancel {\r\n color: #f43530;\n}\n.uni-icon-download {\r\n color: #007aff;\n}\n.uni-icon-search {\r\n color: #b2b2b2;\n}\n.uni-icon-clear {\r\n color: #b2b2b2;\n}\r\n"; +const _sfc_main$n = { + name: "Icon", + props: { + type: { + type: String, + required: true, + default: "" + }, + size: { + type: [String, Number], + default: 23 + }, + color: { + type: String, + default: "" + } + }, + methods: { + _converPx(value) { + if (/^-?\d+[ur]px$/i.test(value)) { + return value.replace(/(^-?\d+)[ur]px$/i, (text2, num) => { + return `${uni.upx2px(parseFloat(num))}px`; + }); + } else if (/^-?[\d\.]+$/.test(value)) { + return `${value}px`; + } + return value || ""; + } + } +}; +function _sfc_render$l(_ctx, _cache, $props, $setup, $data, $options) { + return openBlock(), createBlock("uni-icon", _ctx.$attrs, [ + createVNode("i", { + class: `uni-icon-${$props.type}`, + style: {"font-size": $options._converPx($props.size), color: $props.color}, + role: "img" + }, null, 6) + ], 16); +} +_sfc_main$n.render = _sfc_render$l; +var index_vue_vue_type_style_index_0_lang$g = "\nuni-image {\r\n width: 320px;\r\n height: 240px;\r\n display: inline-block;\r\n overflow: hidden;\r\n position: relative;\n}\nuni-image[hidden] {\r\n display: none;\n}\nuni-image>div {\r\n width: 100%;\r\n height: 100%;\n}\nuni-image>img {\r\n -webkit-touch-callout: none;\r\n -webkit-user-select: none;\r\n -moz-user-select: none;\r\n display: block;\r\n position: absolute;\r\n top: 0;\r\n left: 0;\r\n width: 100%;\r\n height: 100%;\r\n opacity: 0;\n}\nuni-image>.uni-image-will-change {\r\n will-change: transform;\n}\r\n"; +const _sfc_main$m = { + name: "Image", + props: { + src: { + type: String, + default: "" + }, + mode: { + type: String, + default: "scaleToFill" + }, + lazyLoad: { + type: [Boolean, String], + default: false + } + }, + data() { + return { + originalWidth: 0, + originalHeight: 0, + availHeight: "" + }; + }, + computed: { + ratio() { + return this.originalWidth && this.originalHeight ? this.originalWidth / this.originalHeight : 0; + }, + realImagePath() { + return this.$getRealPath(this.src); + }, + modeStyle() { + let size = "auto"; + let position = ""; + const repeat = "no-repeat"; + switch (this.mode) { + case "aspectFit": + size = "contain"; + position = "center center"; + break; + case "aspectFill": + size = "cover"; + position = "center center"; + break; + case "widthFix": + size = "100% 100%"; + break; + case "top": + position = "center top"; + break; + case "bottom": + position = "center bottom"; + break; + case "center": + position = "center center"; + break; + case "left": + position = "left center"; + break; + case "right": + position = "right center"; + break; + case "top left": + position = "left top"; + break; + case "top right": + position = "right top"; + break; + case "bottom left": + position = "left bottom"; + break; + case "bottom right": + position = "right bottom"; + break; + default: + size = "100% 100%"; + position = "0% 0%"; + break; + } + return `background-position:${position};background-size:${size};background-repeat:${repeat};`; + } + }, + watch: { + src(newValue, oldValue) { + this._setContentImage(); + this._loadImage(); + }, + mode(newValue, oldValue) { + if (oldValue === "widthFix") { + this.$el.style.height = this.availHeight; } - let imgData; - try { - imgData = new ImageData(new Uint8ClampedArray(res.data), res.width, res.height); - } catch (error) { - UniViewJSBridge.publishHandler("onCanvasMethodCallback", { - callbackId, - data: { - errMsg: "canvasGetDataUrl:fail" - } - }, this.$page.id); - return; + if (newValue === "widthFix" && this.ratio) { + this._fixSize(); } - destWidth = res.width; - destHeight = res.height; - const canvas = getTempCanvas(destWidth, destHeight); - const c2d = canvas.getContext("2d"); - c2d.putImageData(imgData, 0, 0); - let base64 = canvas.toDataURL("image/png"); - canvas.height = canvas.width = 0; + } + }, + mounted() { + this.availHeight = this.$el.style.height || ""; + this._setContentImage(); + if (!this.realImagePath) { + return; + } + this._loadImage(); + }, + methods: { + _resize() { + if (this.mode === "widthFix") { + this._fixSize(); + } + }, + _fixSize() { + const elWidth = this._getWidth(); + if (elWidth) { + let height = elWidth / this.ratio; + if (typeof navigator && navigator.vendor === "Google Inc." && height > 10) { + height = Math.round(height / 2) * 2; + } + this.$el.style.height = height + "px"; + } + }, + _setContentImage() { + this.$refs.content.style.backgroundImage = this.src ? `url("${this.realImagePath}")` : "none"; + }, + _loadImage() { + const _self = this; const img = new Image(); - img.onload = () => { - const canvas2 = getTempCanvas(destWidth, destHeight); - if (fileType === "jpeg" || fileType === "jpg") { - fileType = "jpeg"; - c2d.fillStyle = "#fff"; - c2d.fillRect(0, 0, destWidth, destHeight); + img.onload = function($event) { + _self.originalWidth = this.width; + _self.originalHeight = this.height; + if (_self.mode === "widthFix") { + _self._fixSize(); } - c2d.drawImage(img, 0, 0); - base64 = canvas2.toDataURL(`image/${fileType}`, qualit); - canvas2.height = canvas2.width = 0; - UniViewJSBridge.publishHandler("onCanvasMethodCallback", { - callbackId, - data: { - errMsg: "canvasGetDataUrl:ok", - base64 - } - }, this.$page.id); + _self.$trigger("load", $event, { + width: this.width, + height: this.height + }); }; - img.src = base64; + img.onerror = function($event) { + _self.$trigger("error", $event, { + errMsg: `GET ${_self.src} 404 (Not Found)` + }); + }; + img.src = this.realImagePath; + }, + _getWidth() { + const computedStyle = window.getComputedStyle(this.$el); + const borderWidth = (parseFloat(computedStyle.borderLeftWidth, 10) || 0) + (parseFloat(computedStyle.borderRightWidth, 10) || 0); + const paddingWidth = (parseFloat(computedStyle.paddingLeft, 10) || 0) + (parseFloat(computedStyle.paddingRight, 10) || 0); + return this.$el.offsetWidth - borderWidth - paddingWidth; } } }; -const _hoisted_1$c = { - ref: "canvas", - width: "300", - height: "150" -}; -const _hoisted_2$6 = {style: {position: "absolute", top: "0", left: "0", width: "100%", height: "100%", overflow: "hidden"}}; -function _sfc_render$q(_ctx, _cache, $props, $setup, $data, $options) { +function _sfc_render$k(_ctx, _cache, $props, $setup, $data, $options) { const _component_v_uni_resize_sensor = resolveComponent("v-uni-resize-sensor"); - return openBlock(), createBlock("uni-canvas", mergeProps({ - "canvas-id": $props.canvasId, - "disable-scroll": $props.disableScroll - }, toHandlers($options._listeners)), [ - createVNode("canvas", _hoisted_1$c, null, 512), - createVNode("div", _hoisted_2$6, [ - renderSlot(_ctx.$slots, "default") - ]), - createVNode(_component_v_uni_resize_sensor, { + return openBlock(), createBlock("uni-image", _ctx.$attrs, [ + createVNode("div", { + ref: "content", + style: $options.modeStyle + }, null, 4), + createVNode("img", {src: $options.realImagePath}, null, 8, ["src"]), + $props.mode === "widthFix" ? (openBlock(), createBlock(_component_v_uni_resize_sensor, { + key: 0, ref: "sensor", onResize: $options._resize - }, null, 8, ["onResize"]) - ], 16, ["canvas-id", "disable-scroll"]); + }, null, 8, ["onResize"])) : createCommentVNode("", true) + ], 16); } -_sfc_main$s.render = _sfc_render$q; -const _sfc_main$r = { - name: "Checkbox", - mixins: [emitter, listeners], +_sfc_main$m.render = _sfc_render$k; +var index_vue_vue_type_style_index_0_lang$f = '\nuni-input {\r\n display: block;\r\n font-size: 16px;\r\n line-height: 1.4em;\r\n height: 1.4em;\r\n min-height: 1.4em;\r\n overflow: hidden;\n}\nuni-input[hidden] {\r\n display: none;\n}\n.uni-input-wrapper,\r\n.uni-input-placeholder,\r\n.uni-input-form,\r\n.uni-input-input {\r\n outline: none;\r\n border: none;\r\n padding: 0;\r\n margin: 0;\r\n text-decoration: inherit;\n}\n.uni-input-wrapper,\r\n.uni-input-form {\r\n display: flex;\r\n position: relative;\r\n width: 100%;\r\n height: 100%;\r\n flex-direction: column;\r\n justify-content: center;\n}\n.uni-input-placeholder,\r\n.uni-input-input {\r\n width: 100%;\n}\n.uni-input-placeholder {\r\n position: absolute;\r\n top: auto !important;\r\n left: 0;\r\n color: gray;\r\n overflow: hidden;\r\n text-overflow: clip;\r\n white-space: pre;\r\n word-break: keep-all;\r\n pointer-events: none;\r\n line-height: inherit;\n}\n.uni-input-input {\r\n display: block;\r\n height: 100%;\r\n background: none;\r\n color: inherit;\r\n opacity: 1;\r\n -webkit-text-fill-color: currentcolor;\r\n font: inherit;\r\n line-height: inherit;\r\n letter-spacing: inherit;\r\n text-align: inherit;\r\n text-indent: inherit;\r\n text-transform: inherit;\r\n text-shadow: inherit;\n}\n.uni-input-input[type="search"]::-webkit-search-cancel-button {\r\n display: none;\n}\n.uni-input-input::-webkit-outer-spin-button,\r\n.uni-input-input::-webkit-inner-spin-button {\r\n -webkit-appearance: none;\r\n margin: 0;\n}\n.uni-input-input[type="number"] {\r\n -moz-appearance: textfield;\n}\r\n'; +const INPUT_TYPES = ["text", "number", "idcard", "digit", "password"]; +const NUMBER_TYPES = ["number", "digit"]; +const _sfc_main$l = { + name: "Input", + mixins: [baseInput], props: { - checked: { + name: { + type: String, + default: "" + }, + type: { + type: String, + default: "text" + }, + password: { type: [Boolean, String], default: false }, - id: { + placeholder: { + type: String, + default: "" + }, + placeholderStyle: { type: String, default: "" }, + placeholderClass: { + type: String, + default: "input-placeholder" + }, disabled: { type: [Boolean, String], default: false }, - color: { - type: String, - default: "#007aff" + maxlength: { + type: [Number, String], + default: 140 }, - value: { + focus: { + type: [Boolean, String], + default: false + }, + confirmType: { type: String, - default: "" + default: "done" } }, data() { return { - checkboxChecked: this.checked, - checkboxValue: this.value + composing: false, + wrapperHeight: 0, + cachedValue: "" }; }, - watch: { - checked(val) { - this.checkboxChecked = val; - }, - value(val) { - this.checkboxValue = val; - } - }, - listeners: { - "label-click": "_onClick", - "@label-click": "_onClick" - }, - created() { - this.$dispatch("CheckboxGroup", "uni-checkbox-group-update", { - type: "add", - vm: this - }); - this.$dispatch("Form", "uni-form-group-update", { - type: "add", - vm: this - }); - }, - beforeDestroy() { - this.$dispatch("CheckboxGroup", "uni-checkbox-group-update", { - type: "remove", - vm: this - }); - this.$dispatch("Form", "uni-form-group-update", { - type: "remove", - vm: this - }); - }, - methods: { - _onClick($event) { - if (this.disabled) { - return; + computed: { + inputType: function() { + let type = ""; + switch (this.type) { + case "text": + this.confirmType === "search" && (type = "search"); + break; + case "idcard": + type = "text"; + break; + case "digit": + type = "number"; + break; + default: + type = ~INPUT_TYPES.indexOf(this.type) ? this.type : "text"; + break; } - this.checkboxChecked = !this.checkboxChecked; - this.$dispatch("CheckboxGroup", "uni-checkbox-change", $event); + return this.password ? "password" : type; }, - _resetFormData() { - this.checkboxChecked = false; - } - } -}; -const _hoisted_1$b = {class: "uni-checkbox-wrapper"}; -function _sfc_render$p(_ctx, _cache, $props, $setup, $data, $options) { - return openBlock(), createBlock("uni-checkbox", mergeProps({disabled: $props.disabled}, _ctx.$attrs, { - onClick: _cache[1] || (_cache[1] = (...args) => $options._onClick && $options._onClick(...args)) - }), [ - createVNode("div", _hoisted_1$b, [ - createVNode("div", { - class: [[$data.checkboxChecked ? "uni-checkbox-input-checked" : ""], "uni-checkbox-input"], - style: {color: $props.color} - }, null, 6), - renderSlot(_ctx.$slots, "default") - ]) - ], 16, ["disabled"]); -} -_sfc_main$r.render = _sfc_render$p; -var index_vue_vue_type_style_index_0_lang$j = "\nuni-checkbox-group[hidden] {\r\n display: none;\n}\r\n"; -const _sfc_main$q = { - name: "CheckboxGroup", - mixins: [emitter, listeners], - props: { - name: { - type: String, - default: "" + step() { + return ~NUMBER_TYPES.indexOf(this.type) ? "0.000000000000000001" : ""; } }, - data() { - return { - checkboxList: [] - }; - }, - listeners: { - "@checkbox-change": "_changeHandler", - "@checkbox-group-update": "_checkboxGroupUpdateHandler" + watch: { + focus(val) { + this.$refs.input && this.$refs.input[val ? "focus" : "blur"](); + }, + maxlength(value) { + const realValue = this.valueSync.slice(0, parseInt(value, 10)); + realValue !== this.valueSync && (this.valueSync = realValue); + } }, created() { this.$dispatch("Form", "uni-form-group-update", { @@ -3531,6 +3597,27 @@ const _sfc_main$q = { vm: this }); }, + mounted() { + if (this.confirmType === "search") { + const formElem = document.createElement("form"); + formElem.action = ""; + formElem.onsubmit = function() { + return false; + }; + formElem.className = "uni-input-form"; + formElem.appendChild(this.$refs.input); + this.$refs.wrapper.appendChild(formElem); + } + let $vm = this; + while ($vm) { + const scopeId = $vm.$options._scopeId; + if (scopeId) { + this.$refs.placeholder.setAttribute(scopeId, ""); + } + $vm = $vm.$parent; + } + this.initKeyboard(this.$refs.input); + }, beforeDestroy() { this.$dispatch("Form", "uni-form-group-update", { type: "remove", @@ -3538,4885 +3625,4604 @@ const _sfc_main$q = { }); }, methods: { - _changeHandler($event) { - const value = []; - this.checkboxList.forEach((vm) => { - if (vm.checkboxChecked) { - value.push(vm.value); - } - }); - this.$trigger("change", $event, { - value - }); - }, - _checkboxGroupUpdateHandler($event) { - if ($event.type === "add") { - this.checkboxList.push($event.vm); - } else { - const index2 = this.checkboxList.indexOf($event.vm); - this.checkboxList.splice(index2, 1); - } - }, - _getFormData() { - const data = {}; - if (this.name !== "") { - const value = []; - this.checkboxList.forEach((vm) => { - if (vm.checkboxChecked) { - value.push(vm.value); - } - }); - data.value = value; - data.key = this.name; - } - return data; - } - } -}; -function _sfc_render$o(_ctx, _cache, $props, $setup, $data, $options) { - return openBlock(), createBlock("uni-checkbox-group", _ctx.$attrs, [ - renderSlot(_ctx.$slots, "default") - ], 16); -} -_sfc_main$q.render = _sfc_render$o; -var startTag = /^<([-A-Za-z0-9_]+)((?:\s+[a-zA-Z_:][-a-zA-Z0-9_:.]*(?:\s*=\s*(?:(?:"[^"]*")|(?:'[^']*')|[^>\s]+))?)*)\s*(\/?)>/; -var endTag = /^<\/([-A-Za-z0-9_]+)[^>]*>/; -var attr = /([a-zA-Z_:][-a-zA-Z0-9_:.]*)(?:\s*=\s*(?:(?:"((?:\\.|[^"])*)")|(?:'((?:\\.|[^'])*)')|([^>\s]+)))?/g; -var empty = makeMap("area,base,basefont,br,col,frame,hr,img,input,link,meta,param,embed,command,keygen,source,track,wbr"); -var block = makeMap("a,address,article,applet,aside,audio,blockquote,button,canvas,center,dd,del,dir,div,dl,dt,fieldset,figcaption,figure,footer,form,frameset,h1,h2,h3,h4,h5,h6,header,hgroup,hr,iframe,isindex,li,map,menu,noframes,noscript,object,ol,output,p,pre,section,script,table,tbody,td,tfoot,th,thead,tr,ul,video"); -var inline = makeMap("abbr,acronym,applet,b,basefont,bdo,big,br,button,cite,code,del,dfn,em,font,i,iframe,img,input,ins,kbd,label,map,object,q,s,samp,script,select,small,span,strike,strong,sub,sup,textarea,tt,u,var"); -var closeSelf = makeMap("colgroup,dd,dt,li,options,p,td,tfoot,th,thead,tr"); -var fillAttrs = makeMap("checked,compact,declare,defer,disabled,ismap,multiple,nohref,noresize,noshade,nowrap,readonly,selected"); -var special = makeMap("script,style"); -function HTMLParser(html, handler) { - var index2; - var chars2; - var match; - var stack = []; - var last = html; - stack.last = function() { - return this[this.length - 1]; - }; - while (html) { - chars2 = true; - if (!stack.last() || !special[stack.last()]) { - if (html.indexOf(""); - if (index2 >= 0) { - if (handler.comment) { - handler.comment(html.substring(4, index2)); - } - html = html.substring(index2 + 3); - chars2 = false; - } - } else if (html.indexOf("]*>"), function(all, text3) { - text3 = text3.replace(/|/g, "$1$2"); - if (handler.chars) { - handler.chars(text3); - } - return ""; - }); - parseEndTag("", stack.last()); - } - if (html == last) { - throw "Parse Error: " + html; - } - last = html; - } - parseEndTag(); - function parseStartTag(tag, tagName, rest, unary) { - tagName = tagName.toLowerCase(); - if (block[tagName]) { - while (stack.last() && inline[stack.last()]) { - parseEndTag("", stack.last()); - } - } - if (closeSelf[tagName] && stack.last() == tagName) { - parseEndTag("", tagName); - } - unary = empty[tagName] || !!unary; - if (!unary) { - stack.push(tagName); - } - if (handler.start) { - var attrs2 = []; - rest.replace(attr, function(match2, name) { - var value = arguments[2] ? arguments[2] : arguments[3] ? arguments[3] : arguments[4] ? arguments[4] : fillAttrs[name] ? name : ""; - attrs2.push({ - name, - value, - escaped: value.replace(/(^|[^\\])"/g, '$1\\"') + _onKeyup($event) { + if ($event.keyCode === 13) { + this.$trigger("confirm", $event, { + value: $event.target.value }); - }); - if (handler.start) { - handler.start(tagName, attrs2, unary); - } - } - } - function parseEndTag(tag, tagName) { - if (!tagName) { - var pos = 0; - } else { - for (var pos = stack.length - 1; pos >= 0; pos--) { - if (stack[pos] == tagName) { - break; - } - } - } - if (pos >= 0) { - for (var i2 = stack.length - 1; i2 >= pos; i2--) { - if (handler.end) { - handler.end(stack[i2]); - } } - stack.length = pos; - } - } -} -function makeMap(str) { - var obj = {}; - var items = str.split(","); - for (var i2 = 0; i2 < items.length; i2++) { - obj[items[i2]] = true; - } - return obj; -} -function divider(Quill) { - const BlockEmbed = Quill.import("blots/block/embed"); - class Divider extends BlockEmbed { - } - Divider.blotName = "divider"; - Divider.tagName = "HR"; - return { - "formats/divider": Divider - }; -} -function ins(Quill) { - const Inline = Quill.import("blots/inline"); - class Ins extends Inline { - } - Ins.blotName = "ins"; - Ins.tagName = "INS"; - return { - "formats/ins": Ins - }; -} -function align(Quill) { - const {Scope, Attributor} = Quill.import("parchment"); - const config = { - scope: Scope.BLOCK, - whitelist: ["left", "right", "center", "justify"] - }; - const AlignStyle = new Attributor.Style("align", "text-align", config); - return { - "formats/align": AlignStyle - }; -} -function direction(Quill) { - const {Scope, Attributor} = Quill.import("parchment"); - const config = { - scope: Scope.BLOCK, - whitelist: ["rtl"] - }; - const DirectionStyle = new Attributor.Style("direction", "direction", config); - return { - "formats/direction": DirectionStyle - }; -} -function list(Quill) { - const Parchment = Quill.import("parchment"); - const Container = Quill.import("blots/container"); - const ListItem = Quill.import("formats/list/item"); - class List extends Container { - static create(value) { - const tagName = value === "ordered" ? "OL" : "UL"; - const node = super.create(tagName); - if (value === "checked" || value === "unchecked") { - node.setAttribute("data-checked", value === "checked"); + }, + _onInput($event) { + if (this.composing) { + return; } - return node; - } - static formats(domNode) { - if (domNode.tagName === "OL") - return "ordered"; - if (domNode.tagName === "UL") { - if (domNode.hasAttribute("data-checked")) { - return domNode.getAttribute("data-checked") === "true" ? "checked" : "unchecked"; + if (~NUMBER_TYPES.indexOf(this.type)) { + if (this.$refs.input.validity && !this.$refs.input.validity.valid) { + $event.target.value = this.cachedValue; + this.valueSync = $event.target.value; + return; } else { - return "bullet"; + this.cachedValue = this.valueSync; } } - return void 0; - } - constructor(domNode) { - super(domNode); - const listEventHandler = (e2) => { - if (e2.target.parentNode !== domNode) + if (this.inputType === "number") { + const maxlength = parseInt(this.maxlength, 10); + if (maxlength > 0 && $event.target.value.length > maxlength) { + $event.target.value = $event.target.value.slice(0, maxlength); + this.valueSync = $event.target.value; return; - const format = this.statics.formats(domNode); - const blot = Parchment.find(e2.target); - if (format === "checked") { - blot.format("list", "unchecked"); - } else if (format === "unchecked") { - blot.format("list", "checked"); } - }; - domNode.addEventListener("click", listEventHandler); - } - format(name, value) { - if (this.children.length > 0) { - this.children.tail.format(name, value); } + this.$triggerInput($event, { + value: this.valueSync + }); + }, + _onFocus($event) { + this.$trigger("focus", $event, { + value: $event.target.value + }); + }, + _onBlur($event) { + this.$trigger("blur", $event, { + value: $event.target.value + }); + }, + _onComposition($event) { + if ($event.type === "compositionstart") { + this.composing = true; + } else { + this.composing = false; + } + }, + _resetFormData() { + this.valueSync = ""; + }, + _getFormData() { + return this.name ? { + value: this.valueSync, + key: this.name + } : {}; } - formats() { - return {[this.statics.blotName]: this.statics.formats(this.domNode)}; + } +}; +const _hoisted_1$a = { + ref: "wrapper", + class: "uni-input-wrapper" +}; +function _sfc_render$j(_ctx, _cache, $props, $setup, $data, $options) { + return openBlock(), createBlock("uni-input", mergeProps({ + onChange: _cache[8] || (_cache[8] = withModifiers(() => { + }, ["stop"])) + }, _ctx.$attrs), [ + createVNode("div", _hoisted_1$a, [ + withDirectives(createVNode("div", { + ref: "placeholder", + style: $props.placeholderStyle, + class: [$props.placeholderClass, "uni-input-placeholder"], + textContent: toDisplayString($props.placeholder) + }, null, 14, ["textContent"]), [ + [vShow, !($data.composing || _ctx.valueSync.length)] + ]), + withDirectives(createVNode("input", { + ref: "input", + "onUpdate:modelValue": _cache[1] || (_cache[1] = ($event) => _ctx.valueSync = $event), + disabled: $props.disabled, + type: $options.inputType, + maxlength: $props.maxlength, + step: $options.step, + autofocus: $props.focus, + class: "uni-input-input", + autocomplete: "off", + onFocus: _cache[2] || (_cache[2] = (...args) => $options._onFocus && $options._onFocus(...args)), + onBlur: _cache[3] || (_cache[3] = (...args) => $options._onBlur && $options._onBlur(...args)), + onInput: _cache[4] || (_cache[4] = withModifiers((...args) => $options._onInput && $options._onInput(...args), ["stop"])), + onCompositionstart: _cache[5] || (_cache[5] = (...args) => $options._onComposition && $options._onComposition(...args)), + onCompositionend: _cache[6] || (_cache[6] = (...args) => $options._onComposition && $options._onComposition(...args)), + onKeyup: _cache[7] || (_cache[7] = withModifiers((...args) => $options._onKeyup && $options._onKeyup(...args), ["stop"])) + }, null, 40, ["disabled", "type", "maxlength", "step", "autofocus"]), [ + [vModelDynamic, _ctx.valueSync] + ]) + ], 512) + ], 16); +} +_sfc_main$l.render = _sfc_render$j; +var index_vue_vue_type_style_index_0_lang$e = "\n.uni-label-pointer {\r\n cursor: pointer;\n}\r\n"; +const _sfc_main$k = { + name: "Label", + mixins: [emitter], + props: { + for: { + type: String, + default: "" } - insertBefore(blot, ref) { - if (blot instanceof ListItem) { - super.insertBefore(blot, ref); + }, + computed: { + pointer() { + return this.for || this.$slots.default && this.$slots.default.length; + } + }, + methods: { + _onClick($event) { + let stopPropagation = /^uni-(checkbox|radio|switch)-/.test($event.target.className); + if (!stopPropagation) { + stopPropagation = /^uni-(checkbox|radio|switch|button)$/i.test($event.target.tagName); + } + if (stopPropagation) { + return; + } + if (this.for) { + UniViewJSBridge.emit("uni-label-click-" + this.$page.id + "-" + this.for, $event, true); } else { - const index2 = ref == null ? this.length() : ref.offset(this); - const after = this.split(index2); - after.parent.insertBefore(blot, after); + this.$broadcast(["Checkbox", "Radio", "Switch", "Button"], "uni-label-click", $event, true); } } - optimize(context) { - super.optimize(context); - const next = this.next; - if (next != null && next.prev === this && next.statics.blotName === this.statics.blotName && next.domNode.tagName === this.domNode.tagName && next.domNode.getAttribute("data-checked") === this.domNode.getAttribute("data-checked")) { - next.moveChildren(this); - next.remove(); + } +}; +function _sfc_render$i(_ctx, _cache, $props, $setup, $data, $options) { + return openBlock(), createBlock("uni-label", mergeProps({ + class: {"uni-label-pointer": $options.pointer} + }, _ctx.$attrs, { + onClick: _cache[1] || (_cache[1] = (...args) => $options._onClick && $options._onClick(...args)) + }), [ + renderSlot(_ctx.$slots, "default") + ], 16); +} +_sfc_main$k.render = _sfc_render$i; +const addListenerToElement = function(element, type, callback, capture) { + element.addEventListener(type, ($event) => { + if (typeof callback === "function") { + if (callback($event) === false) { + $event.preventDefault(); + $event.stopPropagation(); } } - replace(target) { - if (target.statics.blotName !== this.statics.blotName) { - const item = Parchment.create(this.statics.defaultChild); - target.moveChildren(item); - this.appendChild(item); - } - super.replace(target); + }, { + passive: false + }); +}; +var touchtrack = { + beforeDestroy() { + document.removeEventListener("mousemove", this.__mouseMoveEventListener); + document.removeEventListener("mouseup", this.__mouseUpEventListener); + }, + methods: { + touchtrack: function(element, method, useCancel) { + const self = this; + let x0 = 0; + let y0 = 0; + let x1 = 0; + let y1 = 0; + const fn = function($event, state, x, y) { + if (self[method]({ + target: $event.target, + currentTarget: $event.currentTarget, + preventDefault: $event.preventDefault.bind($event), + stopPropagation: $event.stopPropagation.bind($event), + touches: $event.touches, + changedTouches: $event.changedTouches, + detail: { + state, + x0: x, + y0: y, + dx: x - x0, + dy: y - y0, + ddx: x - x1, + ddy: y - y1, + timeStamp: $event.timeStamp + } + }) === false) { + return false; + } + }; + let $eventOld = null; + let hasTouchStart; + let hasMouseDown; + addListenerToElement(element, "touchstart", function($event) { + hasTouchStart = true; + if ($event.touches.length === 1 && !$eventOld) { + $eventOld = $event; + x0 = x1 = $event.touches[0].pageX; + y0 = y1 = $event.touches[0].pageY; + return fn($event, "start", x0, y0); + } + }); + addListenerToElement(element, "mousedown", function($event) { + hasMouseDown = true; + if (!hasTouchStart && !$eventOld) { + $eventOld = $event; + x0 = x1 = $event.pageX; + y0 = y1 = $event.pageY; + return fn($event, "start", x0, y0); + } + }); + addListenerToElement(element, "touchmove", function($event) { + if ($event.touches.length === 1 && $eventOld) { + const res = fn($event, "move", $event.touches[0].pageX, $event.touches[0].pageY); + x1 = $event.touches[0].pageX; + y1 = $event.touches[0].pageY; + return res; + } + }); + const mouseMoveEventListener = this.__mouseMoveEventListener = function($event) { + if (!hasTouchStart && hasMouseDown && $eventOld) { + const res = fn($event, "move", $event.pageX, $event.pageY); + x1 = $event.pageX; + y1 = $event.pageY; + return res; + } + }; + document.addEventListener("mousemove", mouseMoveEventListener); + addListenerToElement(element, "touchend", function($event) { + if ($event.touches.length === 0 && $eventOld) { + hasTouchStart = false; + $eventOld = null; + return fn($event, "end", $event.changedTouches[0].pageX, $event.changedTouches[0].pageY); + } + }); + const mouseUpEventListener = this.__mouseUpEventListener = function($event) { + hasMouseDown = false; + if (!hasTouchStart && $eventOld) { + $eventOld = null; + return fn($event, "end", $event.pageX, $event.pageY); + } + }; + document.addEventListener("mouseup", mouseUpEventListener); + addListenerToElement(element, "touchcancel", function($event) { + if ($eventOld) { + hasTouchStart = false; + const $eventTemp = $eventOld; + $eventOld = null; + return fn($event, useCancel ? "cancel" : "end", $eventTemp.touches[0].pageX, $eventTemp.touches[0].pageY); + } + }); } } - List.blotName = "list"; - List.scope = Parchment.Scope.BLOCK_BLOT; - List.tagName = ["OL", "UL"]; - List.defaultChild = "list-item"; - List.allowedChildren = [ListItem]; - return { - "formats/list": List - }; -} -function background(Quill) { - const {Scope} = Quill.import("parchment"); - const BackgroundStyle = Quill.import("formats/background"); - const BackgroundColorStyle = new BackgroundStyle.constructor("backgroundColor", "background-color", { - scope: Scope.INLINE - }); - return { - "formats/backgroundColor": BackgroundColorStyle - }; +}; +function e(e2, t2, n) { + return e2 > t2 - n && e2 < t2 + n; } -function box(Quill) { - const {Scope, Attributor} = Quill.import("parchment"); - const config = { - scope: Scope.BLOCK - }; - const margin = [ - "margin", - "marginTop", - "marginBottom", - "marginLeft", - "marginRight" - ]; - const padding = [ - "padding", - "paddingTop", - "paddingBottom", - "paddingLeft", - "paddingRight" - ]; - const result = {}; - margin.concat(padding).forEach((name) => { - result[`formats/${name}`] = new Attributor.Style(name, hyphenate(name), config); - }); - return result; +function t(t2, n) { + return e(t2, 0, n); } -function font(Quill) { - const {Scope, Attributor} = Quill.import("parchment"); - const config = { - scope: Scope.INLINE - }; - const font2 = [ - "font", - "fontSize", - "fontStyle", - "fontVariant", - "fontWeight", - "fontFamily" - ]; - const result = {}; - font2.forEach((name) => { - result[`formats/${name}`] = new Attributor.Style(name, hyphenate(name), config); - }); - return result; +function Decline() { } -function text(Quill) { - const {Scope, Attributor} = Quill.import("parchment"); - const text2 = [ - { - name: "lineHeight", - scope: Scope.BLOCK - }, - { - name: "letterSpacing", - scope: Scope.INLINE - }, - { - name: "textDecoration", - scope: Scope.INLINE - }, - { - name: "textIndent", - scope: Scope.BLOCK - } - ]; - const result = {}; - text2.forEach(({name, scope}) => { - result[`formats/${name}`] = new Attributor.Style(name, hyphenate(name), { - scope - }); - }); - return result; +Decline.prototype.x = function(e2) { + return Math.sqrt(e2); +}; +function Friction$1(e2, t2) { + this._m = e2; + this._f = 1e3 * t2; + this._startTime = 0; + this._v = 0; } -function image(Quill) { - const Image2 = Quill.import("formats/image"); - const ATTRIBUTES = [ - "alt", - "height", - "width", - "data-custom", - "class", - "data-local" - ]; - Image2.sanitize = (url) => url; - Image2.formats = function formats(domNode) { - return ATTRIBUTES.reduce(function(formats2, attribute) { - if (domNode.hasAttribute(attribute)) { - formats2[attribute] = domNode.getAttribute(attribute); - } - return formats2; - }, {}); +Friction$1.prototype.setV = function(x, y) { + var n = Math.pow(Math.pow(x, 2) + Math.pow(y, 2), 0.5); + this._x_v = x; + this._y_v = y; + this._x_a = -this._f * this._x_v / n; + this._y_a = -this._f * this._y_v / n; + this._t = Math.abs(x / this._x_a) || Math.abs(y / this._y_a); + this._lastDt = null; + this._startTime = new Date().getTime(); +}; +Friction$1.prototype.setS = function(x, y) { + this._x_s = x; + this._y_s = y; +}; +Friction$1.prototype.s = function(t2) { + if (t2 === void 0) { + t2 = (new Date().getTime() - this._startTime) / 1e3; + } + if (t2 > this._t) { + t2 = this._t; + this._lastDt = t2; + } + var x = this._x_v * t2 + 0.5 * this._x_a * Math.pow(t2, 2) + this._x_s; + var y = this._y_v * t2 + 0.5 * this._y_a * Math.pow(t2, 2) + this._y_s; + if (this._x_a > 0 && x < this._endPositionX || this._x_a < 0 && x > this._endPositionX) { + x = this._endPositionX; + } + if (this._y_a > 0 && y < this._endPositionY || this._y_a < 0 && y > this._endPositionY) { + y = this._endPositionY; + } + return { + x, + y }; - const format = Image2.prototype.format; - Image2.prototype.format = function(name, value) { - if (ATTRIBUTES.indexOf(name) > -1) { - if (value) { - this.domNode.setAttribute(name, value); - } else { - this.domNode.removeAttribute(name); - } - } else { - format.call(this, name, value); - } +}; +Friction$1.prototype.ds = function(t2) { + if (t2 === void 0) { + t2 = (new Date().getTime() - this._startTime) / 1e3; + } + if (t2 > this._t) { + t2 = this._t; + } + return { + dx: this._x_v + this._x_a * t2, + dy: this._y_v + this._y_a * t2 }; -} -function register(Quill) { - const formats = { - divider, - ins, - align, - direction, - list, - background, - box, - font, - text, - image +}; +Friction$1.prototype.delta = function() { + return { + x: -1.5 * Math.pow(this._x_v, 2) / this._x_a || 0, + y: -1.5 * Math.pow(this._y_v, 2) / this._y_a || 0 }; - const options = {}; - Object.values(formats).forEach((value) => Object.assign(options, value(Quill))); - Quill.register(options, true); -} -var editor_css_vue_type_style_index_0_src_lang = ".ql-container {\n display: block;\n position: relative;\n box-sizing: border-box;\n -webkit-user-select: text;\n user-select: text;\n outline: none;\n overflow: hidden;\n width: 100%;\n height: 200px;\n min-height: 200px;\n}\n.ql-container[hidden] {\n display: none;\n}\n.ql-container .ql-editor {\n position: relative;\n font-size: inherit;\n line-height: inherit;\n font-family: inherit;\n min-height: inherit;\n width: 100%;\n height: 100%;\n padding: 0;\n overflow-x: hidden;\n overflow-y: auto;\n -webkit-tap-highlight-color: transparent;\n -webkit-touch-callout: none;\n -webkit-overflow-scrolling: touch;\n}\n.ql-container .ql-editor::-webkit-scrollbar {\n width: 0 !important;\n}\n.ql-container .ql-editor.scroll-disabled {\n overflow: hidden;\n}\n.ql-container .ql-image-overlay {\n display: flex;\n position: absolute;\n box-sizing: border-box;\n border: 1px dashed #ccc;\n justify-content: center;\n align-items: center;\n -webkit-user-select: none;\n user-select: none;\n}\n.ql-container .ql-image-overlay .ql-image-size {\n position: absolute;\n padding: 4px 8px;\n text-align: center;\n background-color: #fff;\n color: #888;\n border: 1px solid #ccc;\n box-sizing: border-box;\n opacity: 0.8;\n right: 4px;\n top: 4px;\n font-size: 12px;\n display: inline-block;\n width: auto;\n}\n.ql-container .ql-image-overlay .ql-image-toolbar {\n position: relative;\n text-align: center;\n box-sizing: border-box;\n background: #000;\n border-radius: 5px;\n color: #fff;\n font-size: 0;\n min-height: 24px;\n z-index: 100;\n}\n.ql-container .ql-image-overlay .ql-image-toolbar span {\n display: inline-block;\n cursor: pointer;\n padding: 5px;\n font-size: 12px;\n border-right: 1px solid #fff;\n}\n.ql-container .ql-image-overlay .ql-image-toolbar span:last-child {\n border-right: 0;\n}\n.ql-container .ql-image-overlay .ql-image-toolbar span.triangle-up {\n padding: 0;\n position: absolute;\n top: -12px;\n left: 50%;\n transform: translatex(-50%);\n width: 0;\n height: 0;\n border-width: 6px;\n border-style: solid;\n border-color: transparent transparent black transparent;\n}\n.ql-container .ql-image-overlay .ql-image-handle {\n position: absolute;\n height: 12px;\n width: 12px;\n border-radius: 50%;\n border: 1px solid #ccc;\n box-sizing: border-box;\n background: #fff;\n}\n.ql-container img {\n display: inline-block;\n max-width: 100%;\n}\n.ql-clipboard p {\n margin: 0;\n padding: 0;\n}\n.ql-editor {\n box-sizing: border-box;\n height: 100%;\n outline: none;\n overflow-y: auto;\n tab-size: 4;\n -moz-tab-size: 4;\n text-align: left;\n white-space: pre-wrap;\n word-wrap: break-word;\n}\n.ql-editor > * {\n cursor: text;\n}\n.ql-editor p,\n.ql-editor ol,\n.ql-editor ul,\n.ql-editor pre,\n.ql-editor blockquote,\n.ql-editor h1,\n.ql-editor h2,\n.ql-editor h3,\n.ql-editor h4,\n.ql-editor h5,\n.ql-editor h6 {\n margin: 0;\n padding: 0;\n counter-reset: list-1 list-2 list-3 list-4 list-5 list-6 list-7 list-8 list-9;\n}\n.ql-editor ol > li,\n.ql-editor ul > li {\n list-style-type: none;\n}\n.ql-editor ul > li::before {\n content: '\\2022';\n}\n.ql-editor ul[data-checked=true],\n.ql-editor ul[data-checked=false] {\n pointer-events: none;\n}\n.ql-editor ul[data-checked=true] > li *,\n.ql-editor ul[data-checked=false] > li * {\n pointer-events: all;\n}\n.ql-editor ul[data-checked=true] > li::before,\n.ql-editor ul[data-checked=false] > li::before {\n color: #777;\n cursor: pointer;\n pointer-events: all;\n}\n.ql-editor ul[data-checked=true] > li::before {\n content: '\\2611';\n}\n.ql-editor ul[data-checked=false] > li::before {\n content: '\\2610';\n}\n.ql-editor li::before {\n display: inline-block;\n white-space: nowrap;\n width: 2em;\n}\n.ql-editor ol li {\n counter-reset: list-1 list-2 list-3 list-4 list-5 list-6 list-7 list-8 list-9;\n counter-increment: list-0;\n}\n.ql-editor ol li:before {\n content: counter(list-0, decimal) '. ';\n}\n.ql-editor ol li.ql-indent-1 {\n counter-increment: list-1;\n}\n.ql-editor ol li.ql-indent-1:before {\n content: counter(list-1, lower-alpha) '. ';\n}\n.ql-editor ol li.ql-indent-1 {\n counter-reset: list-2 list-3 list-4 list-5 list-6 list-7 list-8 list-9;\n}\n.ql-editor ol li.ql-indent-2 {\n counter-increment: list-2;\n}\n.ql-editor ol li.ql-indent-2:before {\n content: counter(list-2, lower-roman) '. ';\n}\n.ql-editor ol li.ql-indent-2 {\n counter-reset: list-3 list-4 list-5 list-6 list-7 list-8 list-9;\n}\n.ql-editor ol li.ql-indent-3 {\n counter-increment: list-3;\n}\n.ql-editor ol li.ql-indent-3:before {\n content: counter(list-3, decimal) '. ';\n}\n.ql-editor ol li.ql-indent-3 {\n counter-reset: list-4 list-5 list-6 list-7 list-8 list-9;\n}\n.ql-editor ol li.ql-indent-4 {\n counter-increment: list-4;\n}\n.ql-editor ol li.ql-indent-4:before {\n content: counter(list-4, lower-alpha) '. ';\n}\n.ql-editor ol li.ql-indent-4 {\n counter-reset: list-5 list-6 list-7 list-8 list-9;\n}\n.ql-editor ol li.ql-indent-5 {\n counter-increment: list-5;\n}\n.ql-editor ol li.ql-indent-5:before {\n content: counter(list-5, lower-roman) '. ';\n}\n.ql-editor ol li.ql-indent-5 {\n counter-reset: list-6 list-7 list-8 list-9;\n}\n.ql-editor ol li.ql-indent-6 {\n counter-increment: list-6;\n}\n.ql-editor ol li.ql-indent-6:before {\n content: counter(list-6, decimal) '. ';\n}\n.ql-editor ol li.ql-indent-6 {\n counter-reset: list-7 list-8 list-9;\n}\n.ql-editor ol li.ql-indent-7 {\n counter-increment: list-7;\n}\n.ql-editor ol li.ql-indent-7:before {\n content: counter(list-7, lower-alpha) '. ';\n}\n.ql-editor ol li.ql-indent-7 {\n counter-reset: list-8 list-9;\n}\n.ql-editor ol li.ql-indent-8 {\n counter-increment: list-8;\n}\n.ql-editor ol li.ql-indent-8:before {\n content: counter(list-8, lower-roman) '. ';\n}\n.ql-editor ol li.ql-indent-8 {\n counter-reset: list-9;\n}\n.ql-editor ol li.ql-indent-9 {\n counter-increment: list-9;\n}\n.ql-editor ol li.ql-indent-9:before {\n content: counter(list-9, decimal) '. ';\n}\n.ql-editor .ql-indent-1:not(.ql-direction-rtl) {\n padding-left: 2em;\n}\n.ql-editor li.ql-indent-1:not(.ql-direction-rtl) {\n padding-left: 2em;\n}\n.ql-editor .ql-indent-1.ql-direction-rtl.ql-align-right {\n padding-right: 2em;\n}\n.ql-editor li.ql-indent-1.ql-direction-rtl.ql-align-right {\n padding-right: 2em;\n}\n.ql-editor .ql-indent-2:not(.ql-direction-rtl) {\n padding-left: 4em;\n}\n.ql-editor li.ql-indent-2:not(.ql-direction-rtl) {\n padding-left: 4em;\n}\n.ql-editor .ql-indent-2.ql-direction-rtl.ql-align-right {\n padding-right: 4em;\n}\n.ql-editor li.ql-indent-2.ql-direction-rtl.ql-align-right {\n padding-right: 4em;\n}\n.ql-editor .ql-indent-3:not(.ql-direction-rtl) {\n padding-left: 6em;\n}\n.ql-editor li.ql-indent-3:not(.ql-direction-rtl) {\n padding-left: 6em;\n}\n.ql-editor .ql-indent-3.ql-direction-rtl.ql-align-right {\n padding-right: 6em;\n}\n.ql-editor li.ql-indent-3.ql-direction-rtl.ql-align-right {\n padding-right: 6em;\n}\n.ql-editor .ql-indent-4:not(.ql-direction-rtl) {\n padding-left: 8em;\n}\n.ql-editor li.ql-indent-4:not(.ql-direction-rtl) {\n padding-left: 8em;\n}\n.ql-editor .ql-indent-4.ql-direction-rtl.ql-align-right {\n padding-right: 8em;\n}\n.ql-editor li.ql-indent-4.ql-direction-rtl.ql-align-right {\n padding-right: 8em;\n}\n.ql-editor .ql-indent-5:not(.ql-direction-rtl) {\n padding-left: 10em;\n}\n.ql-editor li.ql-indent-5:not(.ql-direction-rtl) {\n padding-left: 10em;\n}\n.ql-editor .ql-indent-5.ql-direction-rtl.ql-align-right {\n padding-right: 10em;\n}\n.ql-editor li.ql-indent-5.ql-direction-rtl.ql-align-right {\n padding-right: 10em;\n}\n.ql-editor .ql-indent-6:not(.ql-direction-rtl) {\n padding-left: 12em;\n}\n.ql-editor li.ql-indent-6:not(.ql-direction-rtl) {\n padding-left: 12em;\n}\n.ql-editor .ql-indent-6.ql-direction-rtl.ql-align-right {\n padding-right: 12em;\n}\n.ql-editor li.ql-indent-6.ql-direction-rtl.ql-align-right {\n padding-right: 12em;\n}\n.ql-editor .ql-indent-7:not(.ql-direction-rtl) {\n padding-left: 14em;\n}\n.ql-editor li.ql-indent-7:not(.ql-direction-rtl) {\n padding-left: 14em;\n}\n.ql-editor .ql-indent-7.ql-direction-rtl.ql-align-right {\n padding-right: 14em;\n}\n.ql-editor li.ql-indent-7.ql-direction-rtl.ql-align-right {\n padding-right: 14em;\n}\n.ql-editor .ql-indent-8:not(.ql-direction-rtl) {\n padding-left: 16em;\n}\n.ql-editor li.ql-indent-8:not(.ql-direction-rtl) {\n padding-left: 16em;\n}\n.ql-editor .ql-indent-8.ql-direction-rtl.ql-align-right {\n padding-right: 16em;\n}\n.ql-editor li.ql-indent-8.ql-direction-rtl.ql-align-right {\n padding-right: 16em;\n}\n.ql-editor .ql-indent-9:not(.ql-direction-rtl) {\n padding-left: 18em;\n}\n.ql-editor li.ql-indent-9:not(.ql-direction-rtl) {\n padding-left: 18em;\n}\n.ql-editor .ql-indent-9.ql-direction-rtl.ql-align-right {\n padding-right: 18em;\n}\n.ql-editor li.ql-indent-9.ql-direction-rtl.ql-align-right {\n padding-right: 18em;\n}\n.ql-editor .ql-direction-rtl {\n direction: rtl;\n text-align: inherit;\n}\n.ql-editor .ql-align-center {\n text-align: center;\n}\n.ql-editor .ql-align-justify {\n text-align: justify;\n}\n.ql-editor .ql-align-right {\n text-align: right;\n}\n.ql-editor.ql-blank::before {\n color: rgba(0, 0, 0, 0.6);\n content: attr(data-placeholder);\n font-style: italic;\n pointer-events: none;\n position: absolute;\n}\n.ql-container.ql-disabled .ql-editor ul[data-checked] > li::before {\n pointer-events: none;\n}\n.ql-clipboard {\n left: -100000px;\n height: 1px;\n overflow-y: hidden;\n position: absolute;\n top: 50%;\n}\n"; -var index_vue_vue_type_style_index_1_lang = "\n"; -const _sfc_main$p = { - name: "Editor", - mixins: [subscriber, emitter, keyboard], - props: { - id: { - type: String, - default: "" - }, - readOnly: { - type: [Boolean, String], - default: false - }, - placeholder: { - type: String, - default: "" - }, - showImgSize: { - type: [Boolean, String], - default: false - }, - showImgToolbar: { - type: [Boolean, String], - default: false - }, - showImgResize: { - type: [Boolean, String], - default: false - } - }, - data() { +}; +Friction$1.prototype.dt = function() { + return -this._x_v / this._x_a; +}; +Friction$1.prototype.done = function() { + var t2 = e(this.s().x, this._endPositionX) || e(this.s().y, this._endPositionY) || this._lastDt === this._t; + this._lastDt = null; + return t2; +}; +Friction$1.prototype.setEnd = function(x, y) { + this._endPositionX = x; + this._endPositionY = y; +}; +Friction$1.prototype.reconfigure = function(m, f2) { + this._m = m; + this._f = 1e3 * f2; +}; +function Spring$1(m, k, c) { + this._m = m; + this._k = k; + this._c = c; + this._solution = null; + this._endPosition = 0; + this._startTime = 0; +} +Spring$1.prototype._solve = function(e2, t2) { + var n = this._c; + var i = this._m; + var r = this._k; + var o2 = n * n - 4 * i * r; + if (o2 === 0) { + const a2 = -n / (2 * i); + const s = e2; + const l = t2 / (a2 * e2); return { - quillReady: false + x: function(e3) { + return (s + l * e3) * Math.pow(Math.E, a2 * e3); + }, + dx: function(e3) { + var t3 = Math.pow(Math.E, a2 * e3); + return a2 * (s + l * e3) * t3 + l * t3; + } }; - }, - computed: {}, - watch: { - readOnly(value) { - if (this.quillReady) { - const quill = this.quill; - quill.enable(!value); - if (!value) { - quill.blur(); + } + if (o2 > 0) { + const c = (-n - Math.sqrt(o2)) / (2 * i); + const u = (-n + Math.sqrt(o2)) / (2 * i); + const d = (t2 - c * e2) / (u - c); + const h = e2 - d; + return { + x: function(e3) { + var t3; + var n2; + if (e3 === this._t) { + t3 = this._powER1T; + n2 = this._powER2T; + } + this._t = e3; + if (!t3) { + t3 = this._powER1T = Math.pow(Math.E, c * e3); + } + if (!n2) { + n2 = this._powER2T = Math.pow(Math.E, u * e3); + } + return h * t3 + d * n2; + }, + dx: function(e3) { + var t3; + var n2; + if (e3 === this._t) { + t3 = this._powER1T; + n2 = this._powER2T; + } + this._t = e3; + if (!t3) { + t3 = this._powER1T = Math.pow(Math.E, c * e3); + } + if (!n2) { + n2 = this._powER2T = Math.pow(Math.E, u * e3); } + return h * c * t3 + d * u * n2; } + }; + } + var p2 = Math.sqrt(4 * i * r - n * n) / (2 * i); + var f2 = -n / 2 * i; + var v2 = e2; + var g2 = (t2 - f2 * e2) / p2; + return { + x: function(e3) { + return Math.pow(Math.E, f2 * e3) * (v2 * Math.cos(p2 * e3) + g2 * Math.sin(p2 * e3)); }, - placeholder(value) { - if (this.quillReady) { - this.quill.root.setAttribute("data-placeholder", value); - } - } - }, - mounted() { - const imageResizeModules = []; - if (this.showImgSize) { - imageResizeModules.push("DisplaySize"); - } - if (this.showImgToolbar) { - imageResizeModules.push("Toolbar"); - } - if (this.showImgResize) { - imageResizeModules.push("Resize"); + dx: function(e3) { + var t3 = Math.pow(Math.E, f2 * e3); + var n2 = Math.cos(p2 * e3); + var i2 = Math.sin(p2 * e3); + return t3 * (g2 * p2 * n2 - v2 * p2 * i2) + f2 * t3 * (g2 * i2 + v2 * n2); } - this.loadQuill(() => { - if (imageResizeModules.length) { - this.loadImageResizeModule(() => { - this.initQuill(imageResizeModules); - }); - } else { - this.initQuill(imageResizeModules); - } - }); - }, - methods: { - _handleSubscribe({ - type, - data - }) { - const {options, callbackId} = data; - const quill = this.quill; - const Quill = window.Quill; - let res; - let range; - let errMsg; - if (this.quillReady) { - switch (type) { - case "format": - { - let {name = "", value = false} = options; - range = quill.getSelection(true); - let format = quill.getFormat(range)[name] || false; - if (["bold", "italic", "underline", "strike", "ins"].includes(name)) { - value = !format; - } else if (name === "direction") { - value = value === "rtl" && format ? false : value; - const align2 = quill.getFormat(range).align; - if (value === "rtl" && !align2) { - quill.format("align", "right", Quill.sources.USER); - } else if (!value && align2 === "right") { - quill.format("align", false, Quill.sources.USER); - } - } else if (name === "indent") { - const rtl = quill.getFormat(range).direction === "rtl"; - value = value === "+1"; - if (rtl) { - value = !value; - } - value = value ? "+1" : "-1"; - } else { - if (name === "list") { - value = value === "check" ? "unchecked" : value; - format = format === "checked" ? "unchecked" : format; - } - value = format && format !== (value || false) || !format && value ? value : !format; - } - quill.format(name, value, Quill.sources.USER); - } - break; - case "insertDivider": - range = quill.getSelection(true); - quill.insertText(range.index, "\n", Quill.sources.USER); - quill.insertEmbed(range.index + 1, "divider", true, Quill.sources.USER); - quill.setSelection(range.index + 2, Quill.sources.SILENT); - break; - case "insertImage": - { - range = quill.getSelection(true); - const {src = "", alt = "", width = "", height = "", extClass = "", data: data2 = {}} = options; - const path = this.$getRealPath(src); - quill.insertEmbed(range.index, "image", path, Quill.sources.USER); - const local = /^(file|blob):/.test(path) ? path : false; - quill.formatText(range.index, 1, "data-local", local); - quill.formatText(range.index, 1, "alt", alt); - quill.formatText(range.index, 1, "width", width); - quill.formatText(range.index, 1, "height", height); - quill.formatText(range.index, 1, "class", extClass); - quill.formatText(range.index, 1, "data-custom", Object.keys(data2).map((key) => `${key}=${data2[key]}`).join("&")); - quill.setSelection(range.index + 1, Quill.sources.SILENT); - } - break; - case "insertText": - { - range = quill.getSelection(true); - const {text: text2 = ""} = options; - quill.insertText(range.index, text2, Quill.sources.USER); - quill.setSelection(range.index + text2.length, 0, Quill.sources.SILENT); - } - break; - case "setContents": - { - const {delta, html} = options; - if (typeof delta === "object") { - quill.setContents(delta, Quill.sources.SILENT); - } else if (typeof html === "string") { - quill.setContents(this.html2delta(html), Quill.sources.SILENT); - } else { - errMsg = "contents is missing"; - } - } - break; - case "getContents": - res = this.getContents(); - break; - case "clear": - quill.setContents([]); - break; - case "removeFormat": - { - range = quill.getSelection(true); - const parchment = Quill.import("parchment"); - if (range.length) { - quill.removeFormat(range, Quill.sources.USER); - } else { - Object.keys(quill.getFormat(range)).forEach((key) => { - if (parchment.query(key, parchment.Scope.INLINE)) { - quill.format(key, false); - } - }); - } - } - break; - case "undo": - quill.history.undo(); - break; - case "redo": - quill.history.redo(); - break; - } - this.updateStatus(range); - } else { - errMsg = "not ready"; + }; +}; +Spring$1.prototype.x = function(e2) { + if (e2 === void 0) { + e2 = (new Date().getTime() - this._startTime) / 1e3; + } + return this._solution ? this._endPosition + this._solution.x(e2) : 0; +}; +Spring$1.prototype.dx = function(e2) { + if (e2 === void 0) { + e2 = (new Date().getTime() - this._startTime) / 1e3; + } + return this._solution ? this._solution.dx(e2) : 0; +}; +Spring$1.prototype.setEnd = function(e2, n, i) { + if (!i) { + i = new Date().getTime(); + } + if (e2 !== this._endPosition || !t(n, 0.1)) { + n = n || 0; + var r = this._endPosition; + if (this._solution) { + if (t(n, 0.1)) { + n = this._solution.dx((i - this._startTime) / 1e3); } - if (callbackId) { - UniViewJSBridge.publishHandler("onEditorMethodCallback", { - callbackId, - data: Object.assign({}, res, { - errMsg: `${type}:${errMsg ? "fail " + errMsg : "ok"}` - }) - }, this.$page.id); + r = this._solution.x((i - this._startTime) / 1e3); + if (t(n, 0.1)) { + n = 0; } - }, - loadQuill(callback) { - if (typeof window.Quill === "function") { - if (typeof callback === "function") { - callback(); - } - return; + if (t(r, 0.1)) { + r = 0; } - const script = document.createElement("script"); - script.src = window.plus ? "./__uniappquill.js" : "https://unpkg.com/quill@1.3.7/dist/quill.min.js"; - document.body.appendChild(script); - script.onload = callback; + r += this._endPosition; + } + if (!(this._solution && t(r - e2, 0.1) && t(n, 0.1))) { + this._endPosition = e2; + this._solution = this._solve(r - this._endPosition, n); + this._startTime = i; + } + } +}; +Spring$1.prototype.snap = function(e2) { + this._startTime = new Date().getTime(); + this._endPosition = e2; + this._solution = { + x: function() { + return 0; }, - loadImageResizeModule(callback) { - if (typeof window.ImageResize === "function") { - if (typeof callback === "function") { - callback(); + dx: function() { + return 0; + } + }; +}; +Spring$1.prototype.done = function(n) { + if (!n) { + n = new Date().getTime(); + } + return e(this.x(), this._endPosition, 0.1) && t(this.dx(), 0.1); +}; +Spring$1.prototype.reconfigure = function(m, t2, c) { + this._m = m; + this._k = t2; + this._c = c; + if (!this.done()) { + this._solution = this._solve(this.x() - this._endPosition, this.dx()); + this._startTime = new Date().getTime(); + } +}; +Spring$1.prototype.springConstant = function() { + return this._k; +}; +Spring$1.prototype.damping = function() { + return this._c; +}; +Spring$1.prototype.configuration = function() { + function e2(e3, t3) { + e3.reconfigure(1, t3, e3.damping()); + } + function t2(e3, t3) { + e3.reconfigure(1, e3.springConstant(), t3); + } + return [ + { + label: "Spring Constant", + read: this.springConstant.bind(this), + write: e2.bind(this, this), + min: 100, + max: 1e3 + }, + { + label: "Damping", + read: this.damping.bind(this), + write: t2.bind(this, this), + min: 1, + max: 500 + } + ]; +}; +function STD(e2, t2, n) { + this._springX = new Spring$1(e2, t2, n); + this._springY = new Spring$1(e2, t2, n); + this._springScale = new Spring$1(e2, t2, n); + this._startTime = 0; +} +STD.prototype.setEnd = function(e2, t2, n, i) { + var r = new Date().getTime(); + this._springX.setEnd(e2, i, r); + this._springY.setEnd(t2, i, r); + this._springScale.setEnd(n, i, r); + this._startTime = r; +}; +STD.prototype.x = function() { + var e2 = (new Date().getTime() - this._startTime) / 1e3; + return { + x: this._springX.x(e2), + y: this._springY.x(e2), + scale: this._springScale.x(e2) + }; +}; +STD.prototype.done = function() { + var e2 = new Date().getTime(); + return this._springX.done(e2) && this._springY.done(e2) && this._springScale.done(e2); +}; +STD.prototype.reconfigure = function(e2, t2, n) { + this._springX.reconfigure(e2, t2, n); + this._springY.reconfigure(e2, t2, n); + this._springScale.reconfigure(e2, t2, n); +}; +var index_vue_vue_type_style_index_0_lang$d = "\nuni-movable-view {\n display: inline-block;\n width: 10px;\n height: 10px;\n top: 0px;\n left: 0px;\n position: absolute;\n cursor: grab;\n}\nuni-movable-view[hidden] {\n display: none;\n}\n"; +var requesting = false; +function _requestAnimationFrame(e2) { + if (!requesting) { + requesting = true; + requestAnimationFrame(function() { + e2(); + requesting = false; + }); + } +} +function p(t2, n) { + if (t2 === n) { + return 0; + } + var i = t2.offsetLeft; + return t2.offsetParent ? i += p(t2.offsetParent, n) : 0; +} +function f(t2, n) { + if (t2 === n) { + return 0; + } + var i = t2.offsetTop; + return t2.offsetParent ? i += f(t2.offsetParent, n) : 0; +} +function v(a2, b) { + return +((1e3 * a2 - 1e3 * b) / 1e3).toFixed(1); +} +function g(e2, t2, n) { + var i = function(e3) { + if (e3 && e3.id) { + cancelAnimationFrame(e3.id); + } + if (e3) { + e3.cancelled = true; + } + }; + var r = { + id: 0, + cancelled: false + }; + function fn(n2, i2, r2, o2) { + if (!n2 || !n2.cancelled) { + r2(i2); + var a2 = e2.done(); + if (!a2) { + if (!n2.cancelled) { + n2.id = requestAnimationFrame(fn.bind(null, n2, i2, r2, o2)); } - return; } - const script = document.createElement("script"); - script.src = window.plus ? "./__uniappquillimageresize.js" : "https://unpkg.com/quill-image-resize-mp@3.0.1/image-resize.min.js"; - document.body.appendChild(script); - script.onload = callback; - }, - initQuill(imageResizeModules) { - const Quill = window.Quill; - register(Quill); - const options = { - toolbar: false, - readOnly: this.readOnly, - placeholder: this.placeholder, - modules: {} - }; - if (imageResizeModules.length) { - Quill.register("modules/ImageResize", window.ImageResize.default); - options.modules.ImageResize = { - modules: imageResizeModules - }; + if (a2 && o2) { + o2(i2); } - const quill = this.quill = new Quill(this.$el, options); - const $el = quill.root; - const events = ["focus", "blur", "input"]; - events.forEach((name) => { - $el.addEventListener(name, ($event) => { - if (name === "input") { - $event.stopPropagation(); - } else { - this.$trigger(name, $event, this.getContents()); - } - }); - }); - quill.on(Quill.events.TEXT_CHANGE, () => { - this.$trigger("input", {}, this.getContents()); - }); - quill.on(Quill.events.SELECTION_CHANGE, this.updateStatus.bind(this)); - quill.on(Quill.events.SCROLL_OPTIMIZE, () => { - const range = quill.selection.getRange()[0]; - this.updateStatus(range); - }); - quill.clipboard.addMatcher(Node.ELEMENT_NODE, (node, delta) => { - if (this.skipMatcher) { - return delta; - } - delta.ops = delta.ops.filter(({insert}) => typeof insert === "string").map(({insert}) => ({insert})); - return delta; - }); - this.initKeyboard($el); - this.quillReady = true; - this.$trigger("ready", event, {}); + } + } + fn(r, e2, t2, n); + return { + cancel: i.bind(null, r), + model: e2 + }; +} +const _sfc_main$j = { + name: "MovableView", + mixins: [touchtrack], + props: { + direction: { + type: String, + default: "none" }, - getContents() { - const quill = this.quill; - const html = quill.root.innerHTML; - const text2 = quill.getText(); - const delta = quill.getContents(); - return { - html, - text: text2, - delta - }; + inertia: { + type: [Boolean, String], + default: false + }, + outOfBounds: { + type: [Boolean, String], + default: false + }, + x: { + type: [Number, String], + default: 0 + }, + y: { + type: [Number, String], + default: 0 + }, + damping: { + type: [Number, String], + default: 20 + }, + friction: { + type: [Number, String], + default: 2 + }, + disabled: { + type: [Boolean, String], + default: false + }, + scale: { + type: [Boolean, String], + default: false + }, + scaleMin: { + type: [Number, String], + default: 0.5 }, - html2delta(html) { - const tags = ["span", "strong", "b", "ins", "em", "i", "u", "a", "del", "s", "sub", "sup", "img", "div", "p", "h1", "h2", "h3", "h4", "h5", "h6", "hr", "ol", "ul", "li", "br"]; - let content = ""; - let disable; - HTMLParser(html, { - start: function(tag, attrs2, unary) { - if (!tags.includes(tag)) { - disable = !unary; - return; - } - disable = false; - const arrts = attrs2.map(({name, value}) => `${name}="${value}"`).join(" "); - const start = `<${tag} ${arrts} ${unary ? "/" : ""}>`; - content += start; - }, - end: function(tag) { - if (!disable) { - content += ``; - } - }, - chars: function(text2) { - if (!disable) { - content += text2; - } - } - }); - this.skipMatcher = true; - const delta = this.quill.clipboard.convert(content); - this.skipMatcher = false; - return delta; + scaleMax: { + type: [Number, String], + default: 10 }, - updateStatus(range) { - const status = range ? this.quill.getFormat(range) : {}; - const keys = Object.keys(status); - if (keys.length !== Object.keys(this.__status || {}).length || keys.find((key) => status[key] !== this.__status[key])) { - this.__status = status; - this.$trigger("statuschange", {}, status); - } + scaleValue: { + type: [Number, String], + default: 1 + }, + animation: { + type: [Boolean, String], + default: true } - } -}; -function _sfc_render$n(_ctx, _cache, $props, $setup, $data, $options) { - return openBlock(), createBlock("uni-editor", mergeProps({ - id: $props.id, - class: "ql-container" - }, _ctx.$attrs), null, 16, ["id"]); -} -_sfc_main$p.render = _sfc_render$n; -var index_vue_vue_type_style_index_0_lang$i = "\r\n"; -const _sfc_main$o = { - name: "Form", - mixins: [listeners], + }, data() { return { - childrenList: [] + xSync: this._getPx(this.x), + ySync: this._getPx(this.y), + scaleValueSync: Number(this.scaleValue) || 1, + width: 0, + height: 0, + minX: 0, + minY: 0, + maxX: 0, + maxY: 0 }; }, - listeners: { - "@form-submit": "_onSubmit", - "@form-reset": "_onReset", - "@form-group-update": "_formGroupUpdateHandler" - }, - methods: { - _onSubmit($event) { - const data = {}; - this.childrenList.forEach((vm) => { - if (vm._getFormData && vm._getFormData().key) { - data[vm._getFormData().key] = vm._getFormData().value; - } - }); - this.$trigger("submit", $event, { - value: data - }); + computed: { + dampingNumber() { + var val = Number(this.damping); + return isNaN(val) ? 20 : val; }, - _onReset($event) { - this.$trigger("reset", $event, {}); - this.childrenList.forEach((vm) => { - vm._resetFormData && vm._resetFormData(); - }); + frictionNumber() { + var val = Number(this.friction); + return isNaN(val) || val <= 0 ? 2 : val; }, - _formGroupUpdateHandler($event) { - if ($event.type === "add") { - this.childrenList.push($event.vm); - } else { - const index2 = this.childrenList.indexOf($event.vm); - this.childrenList.splice(index2, 1); - } + scaleMinNumber() { + var val = Number(this.scaleMin); + return isNaN(val) ? 0.5 : val; + }, + scaleMaxNumber() { + var val = Number(this.scaleMax); + return isNaN(val) ? 10 : val; + }, + xMove() { + return this.direction === "all" || this.direction === "horizontal"; + }, + yMove() { + return this.direction === "all" || this.direction === "vertical"; } - } -}; -function _sfc_render$m(_ctx, _cache, $props, $setup, $data, $options) { - return openBlock(), createBlock("uni-form", _ctx.$attrs, [ - createVNode("span", null, [ - renderSlot(_ctx.$slots, "default") - ]) - ], 16); -} -_sfc_main$o.render = _sfc_render$m; -var index_vue_vue_type_style_index_0_lang$h = "\nuni-icon {\r\n display: inline-block;\r\n font-size: 0;\r\n box-sizing: border-box;\n}\nuni-icon[hidden] {\r\n display: none;\n}\nuni-icon > i {\r\n font: normal normal normal 14px/1 'weui';\n}\nuni-icon > i:before {\r\n margin: 0;\r\n box-sizing: border-box;\n}\n@font-face {\r\n font-weight: normal;\r\n font-style: normal;\r\n font-family: 'weui';\r\n src: url('data:application/octet-stream;base64,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')\r\n format('truetype');\n}\n.uni-icon-success:before {\r\n content: '\\EA06';\n}\n.uni-icon-success_circle:before {\r\n content: '\\EA07';\n}\n.uni-icon-success_no_circle:before {\r\n content: '\\EA08';\n}\n.uni-icon-safe_success:before {\r\n content: '\\EA04';\n}\n.uni-icon-safe_warn:before {\r\n content: '\\EA05';\n}\n.uni-icon-info:before {\r\n content: '\\EA03';\n}\n.uni-icon-info_circle:before {\r\n content: '\\EA0C';\n}\n.uni-icon-warn:before {\r\n content: '\\EA0B';\n}\n.uni-icon-waiting:before {\r\n content: '\\EA09';\n}\n.uni-icon-waiting_circle:before {\r\n content: '\\EA0A';\n}\n.uni-icon-circle:before {\r\n content: '\\EA01';\n}\n.uni-icon-cancel:before {\r\n content: '\\EA0D';\n}\n.uni-icon-download:before {\r\n content: '\\EA02';\n}\n.uni-icon-search:before {\r\n content: '\\EA0E';\n}\n.uni-icon-clear:before {\r\n content: '\\EA0F';\n}\n.uni-icon-success {\r\n color: #007aff;\n}\n.uni-icon-success_circle {\r\n color: #007aff;\n}\n.uni-icon-success_no_circle {\r\n color: #007aff;\n}\n.uni-icon-safe_success {\r\n color: #007aff;\n}\n.uni-icon-safe_warn {\r\n color: #ffbe00;\n}\n.uni-icon-info {\r\n color: #10aeff;\n}\n.uni-icon-info_circle {\r\n color: #007aff;\n}\n.uni-icon-warn {\r\n color: #f76260;\n}\n.uni-icon-waiting {\r\n color: #10aeff;\n}\n.uni-icon-waiting_circle {\r\n color: #10aeff;\n}\n.uni-icon-circle {\r\n color: #c9c9c9;\n}\n.uni-icon-cancel {\r\n color: #f43530;\n}\n.uni-icon-download {\r\n color: #007aff;\n}\n.uni-icon-search {\r\n color: #b2b2b2;\n}\n.uni-icon-clear {\r\n color: #b2b2b2;\n}\r\n"; -const _sfc_main$n = { - name: "Icon", - props: { - type: { - type: String, - required: true, - default: "" + }, + watch: { + x(val) { + this.xSync = this._getPx(val); }, - size: { - type: [String, Number], - default: 23 + xSync(val) { + this._setX(val); }, - color: { - type: String, - default: "" + y(val) { + this.ySync = this._getPx(val); + }, + ySync(val) { + this._setY(val); + }, + scaleValue(val) { + this.scaleValueSync = Number(val) || 0; + }, + scaleValueSync(val) { + this._setScaleValue(val); + }, + scaleMinNumber() { + this._setScaleMinOrMax(); + }, + scaleMaxNumber() { + this._setScaleMinOrMax(); } }, + created: function() { + this._offset = { + x: 0, + y: 0 + }; + this._scaleOffset = { + x: 0, + y: 0 + }; + this._translateX = 0; + this._translateY = 0; + this._scale = 1; + this._oldScale = 1; + this._STD = new STD(1, 9 * Math.pow(this.dampingNumber, 2) / 40, this.dampingNumber); + this._friction = new Friction$1(1, this.frictionNumber); + this._declineX = new Decline(); + this._declineY = new Decline(); + this.__touchInfo = { + historyX: [0, 0], + historyY: [0, 0], + historyT: [0, 0] + }; + }, + mounted: function() { + this.touchtrack(this.$el, "_onTrack"); + this.setParent(); + this._friction.reconfigure(1, this.frictionNumber); + this._STD.reconfigure(1, 9 * Math.pow(this.dampingNumber, 2) / 40, this.dampingNumber); + this.$el.style.transformOrigin = "center"; + }, methods: { - _converPx(value) { - if (/^-?\d+[ur]px$/i.test(value)) { - return value.replace(/(^-?\d+)[ur]px$/i, (text2, num) => { - return `${uni.upx2px(parseFloat(num))}px`; - }); - } else if (/^-?[\d\.]+$/.test(value)) { - return `${value}px`; + _getPx(val) { + if (/\d+[ur]px$/i.test(val)) { + return uni.upx2px(parseFloat(val)); } - return value || ""; - } - } -}; -function _sfc_render$l(_ctx, _cache, $props, $setup, $data, $options) { - return openBlock(), createBlock("uni-icon", _ctx.$attrs, [ - createVNode("i", { - class: `uni-icon-${$props.type}`, - style: {"font-size": $options._converPx($props.size), color: $props.color}, - role: "img" - }, null, 6) - ], 16); -} -_sfc_main$n.render = _sfc_render$l; -var index_vue_vue_type_style_index_0_lang$g = "\nuni-image {\r\n width: 320px;\r\n height: 240px;\r\n display: inline-block;\r\n overflow: hidden;\r\n position: relative;\n}\nuni-image[hidden] {\r\n display: none;\n}\nuni-image>div {\r\n width: 100%;\r\n height: 100%;\n}\nuni-image>img {\r\n -webkit-touch-callout: none;\r\n -webkit-user-select: none;\r\n -moz-user-select: none;\r\n display: block;\r\n position: absolute;\r\n top: 0;\r\n left: 0;\r\n width: 100%;\r\n height: 100%;\r\n opacity: 0;\n}\nuni-image>.uni-image-will-change {\r\n will-change: transform;\n}\r\n"; -const _sfc_main$m = { - name: "Image", - props: { - src: { - type: String, - default: "" + return Number(val) || 0; }, - mode: { - type: String, - default: "scaleToFill" + _setX: function(val) { + if (this.xMove) { + if (val + this._scaleOffset.x === this._translateX) { + return this._translateX; + } else { + if (this._SFA) { + this._SFA.cancel(); + } + this._animationTo(val + this._scaleOffset.x, this.ySync + this._scaleOffset.y, this._scale); + } + } + return val; + }, + _setY: function(val) { + if (this.yMove) { + if (val + this._scaleOffset.y === this._translateY) { + return this._translateY; + } else { + if (this._SFA) { + this._SFA.cancel(); + } + this._animationTo(this.xSync + this._scaleOffset.x, val + this._scaleOffset.y, this._scale); + } + } + return val; }, - lazyLoad: { - type: [Boolean, String], - default: false - } - }, - data() { - return { - originalWidth: 0, - originalHeight: 0, - availHeight: "" - }; - }, - computed: { - ratio() { - return this.originalWidth && this.originalHeight ? this.originalWidth / this.originalHeight : 0; + _setScaleMinOrMax: function() { + if (!this.scale) { + return false; + } + this._updateScale(this._scale, true); + this._updateOldScale(this._scale); }, - realImagePath() { - return this.$getRealPath(this.src); + _setScaleValue: function(scale) { + if (!this.scale) { + return false; + } + scale = this._adjustScale(scale); + this._updateScale(scale, true); + this._updateOldScale(scale); + return scale; }, - modeStyle() { - let size = "auto"; - let position = ""; - const repeat = "no-repeat"; - switch (this.mode) { - case "aspectFit": - size = "contain"; - position = "center center"; - break; - case "aspectFill": - size = "cover"; - position = "center center"; - break; - case "widthFix": - size = "100% 100%"; - break; - case "top": - position = "center top"; - break; - case "bottom": - position = "center bottom"; - break; - case "center": - position = "center center"; - break; - case "left": - position = "left center"; - break; - case "right": - position = "right center"; - break; - case "top left": - position = "left top"; - break; - case "top right": - position = "right top"; - break; - case "bottom left": - position = "left bottom"; - break; - case "bottom right": - position = "right bottom"; - break; - default: - size = "100% 100%"; - position = "0% 0%"; - break; + __handleTouchStart: function() { + if (!this._isScaling) { + if (!this.disabled) { + if (this._FA) { + this._FA.cancel(); + } + if (this._SFA) { + this._SFA.cancel(); + } + this.__touchInfo.historyX = [0, 0]; + this.__touchInfo.historyY = [0, 0]; + this.__touchInfo.historyT = [0, 0]; + if (this.xMove) { + this.__baseX = this._translateX; + } + if (this.yMove) { + this.__baseY = this._translateY; + } + this.$el.style.willChange = "transform"; + this._checkCanMove = null; + this._firstMoveDirection = null; + this._isTouching = true; + } } - return `background-position:${position};background-size:${size};background-repeat:${repeat};`; - } - }, - watch: { - src(newValue, oldValue) { - this._setContentImage(); - this._loadImage(); }, - mode(newValue, oldValue) { - if (oldValue === "widthFix") { - this.$el.style.height = this.availHeight; + __handleTouchMove: function(event2) { + var self = this; + if (!this._isScaling && !this.disabled && this._isTouching) { + let x = this._translateX; + let y = this._translateY; + if (this._firstMoveDirection === null) { + this._firstMoveDirection = Math.abs(event2.detail.dx / event2.detail.dy) > 1 ? "htouchmove" : "vtouchmove"; + } + if (this.xMove) { + x = event2.detail.dx + this.__baseX; + this.__touchInfo.historyX.shift(); + this.__touchInfo.historyX.push(x); + if (!this.yMove && this._checkCanMove === null) { + this._checkCanMove = Math.abs(event2.detail.dx / event2.detail.dy) < 1; + } + } + if (this.yMove) { + y = event2.detail.dy + this.__baseY; + this.__touchInfo.historyY.shift(); + this.__touchInfo.historyY.push(y); + if (!this.xMove && this._checkCanMove === null) { + this._checkCanMove = Math.abs(event2.detail.dy / event2.detail.dx) < 1; + } + } + this.__touchInfo.historyT.shift(); + this.__touchInfo.historyT.push(event2.detail.timeStamp); + if (!this._checkCanMove) { + event2.preventDefault(); + let source = "touch"; + if (x < this.minX) { + if (this.outOfBounds) { + source = "touch-out-of-bounds"; + x = this.minX - this._declineX.x(this.minX - x); + } else { + x = this.minX; + } + } else if (x > this.maxX) { + if (this.outOfBounds) { + source = "touch-out-of-bounds"; + x = this.maxX + this._declineX.x(x - this.maxX); + } else { + x = this.maxX; + } + } + if (y < this.minY) { + if (this.outOfBounds) { + source = "touch-out-of-bounds"; + y = this.minY - this._declineY.x(this.minY - y); + } else { + y = this.minY; + } + } else { + if (y > this.maxY) { + if (this.outOfBounds) { + source = "touch-out-of-bounds"; + y = this.maxY + this._declineY.x(y - this.maxY); + } else { + y = this.maxY; + } + } + } + _requestAnimationFrame(function() { + self._setTransform(x, y, self._scale, source); + }); + } } - if (newValue === "widthFix" && this.ratio) { - this._fixSize(); + }, + __handleTouchEnd: function() { + var self = this; + if (!this._isScaling && !this.disabled && this._isTouching) { + this.$el.style.willChange = "auto"; + this._isTouching = false; + if (!this._checkCanMove && !this._revise("out-of-bounds") && this.inertia) { + const xv = 1e3 * (this.__touchInfo.historyX[1] - this.__touchInfo.historyX[0]) / (this.__touchInfo.historyT[1] - this.__touchInfo.historyT[0]); + const yv = 1e3 * (this.__touchInfo.historyY[1] - this.__touchInfo.historyY[0]) / (this.__touchInfo.historyT[1] - this.__touchInfo.historyT[0]); + this._friction.setV(xv, yv); + this._friction.setS(this._translateX, this._translateY); + const x0 = this._friction.delta().x; + const y0 = this._friction.delta().y; + let x = x0 + this._translateX; + let y = y0 + this._translateY; + if (x < this.minX) { + x = this.minX; + y = this._translateY + (this.minX - this._translateX) * y0 / x0; + } else { + if (x > this.maxX) { + x = this.maxX; + y = this._translateY + (this.maxX - this._translateX) * y0 / x0; + } + } + if (y < this.minY) { + y = this.minY; + x = this._translateX + (this.minY - this._translateY) * x0 / y0; + } else { + if (y > this.maxY) { + y = this.maxY; + x = this._translateX + (this.maxY - this._translateY) * x0 / y0; + } + } + this._friction.setEnd(x, y); + this._FA = g(this._friction, function() { + var t2 = self._friction.s(); + var x2 = t2.x; + var y2 = t2.y; + self._setTransform(x2, y2, self._scale, "friction"); + }, function() { + self._FA.cancel(); + }); + } } - } - }, - mounted() { - this.availHeight = this.$el.style.height || ""; - this._setContentImage(); - if (!this.realImagePath) { - return; - } - this._loadImage(); - }, - methods: { - _resize() { - if (this.mode === "widthFix") { - this._fixSize(); + }, + _onTrack: function(event2) { + switch (event2.detail.state) { + case "start": + this.__handleTouchStart(); + break; + case "move": + this.__handleTouchMove(event2); + break; + case "end": + this.__handleTouchEnd(); } }, - _fixSize() { - const elWidth = this._getWidth(); - if (elWidth) { - let height = elWidth / this.ratio; - if (typeof navigator && navigator.vendor === "Google Inc." && height > 10) { - height = Math.round(height / 2) * 2; + _getLimitXY: function(x, y) { + var outOfBounds = false; + if (x > this.maxX) { + x = this.maxX; + outOfBounds = true; + } else { + if (x < this.minX) { + x = this.minX; + outOfBounds = true; } - this.$el.style.height = height + "px"; } - }, - _setContentImage() { - this.$refs.content.style.backgroundImage = this.src ? `url("${this.realImagePath}")` : "none"; - }, - _loadImage() { - const _self = this; - const img = new Image(); - img.onload = function($event) { - _self.originalWidth = this.width; - _self.originalHeight = this.height; - if (_self.mode === "widthFix") { - _self._fixSize(); + if (y > this.maxY) { + y = this.maxY; + outOfBounds = true; + } else { + if (y < this.minY) { + y = this.minY; + outOfBounds = true; } - _self.$trigger("load", $event, { - width: this.width, - height: this.height - }); - }; - img.onerror = function($event) { - _self.$trigger("error", $event, { - errMsg: `GET ${_self.src} 404 (Not Found)` - }); + } + return { + x, + y, + outOfBounds }; - img.src = this.realImagePath; - }, - _getWidth() { - const computedStyle = window.getComputedStyle(this.$el); - const borderWidth = (parseFloat(computedStyle.borderLeftWidth, 10) || 0) + (parseFloat(computedStyle.borderRightWidth, 10) || 0); - const paddingWidth = (parseFloat(computedStyle.paddingLeft, 10) || 0) + (parseFloat(computedStyle.paddingRight, 10) || 0); - return this.$el.offsetWidth - borderWidth - paddingWidth; - } - } -}; -function _sfc_render$k(_ctx, _cache, $props, $setup, $data, $options) { - const _component_v_uni_resize_sensor = resolveComponent("v-uni-resize-sensor"); - return openBlock(), createBlock("uni-image", _ctx.$attrs, [ - createVNode("div", { - ref: "content", - style: $options.modeStyle - }, null, 4), - createVNode("img", {src: $options.realImagePath}, null, 8, ["src"]), - $props.mode === "widthFix" ? (openBlock(), createBlock(_component_v_uni_resize_sensor, { - key: 0, - ref: "sensor", - onResize: $options._resize - }, null, 8, ["onResize"])) : createCommentVNode("", true) - ], 16); -} -_sfc_main$m.render = _sfc_render$k; -var index_vue_vue_type_style_index_0_lang$f = '\nuni-input {\r\n display: block;\r\n font-size: 16px;\r\n line-height: 1.4em;\r\n height: 1.4em;\r\n min-height: 1.4em;\r\n overflow: hidden;\n}\nuni-input[hidden] {\r\n display: none;\n}\n.uni-input-wrapper,\r\n.uni-input-placeholder,\r\n.uni-input-form,\r\n.uni-input-input {\r\n outline: none;\r\n border: none;\r\n padding: 0;\r\n margin: 0;\r\n text-decoration: inherit;\n}\n.uni-input-wrapper,\r\n.uni-input-form {\r\n display: flex;\r\n position: relative;\r\n width: 100%;\r\n height: 100%;\r\n flex-direction: column;\r\n justify-content: center;\n}\n.uni-input-placeholder,\r\n.uni-input-input {\r\n width: 100%;\n}\n.uni-input-placeholder {\r\n position: absolute;\r\n top: auto !important;\r\n left: 0;\r\n color: gray;\r\n overflow: hidden;\r\n text-overflow: clip;\r\n white-space: pre;\r\n word-break: keep-all;\r\n pointer-events: none;\r\n line-height: inherit;\n}\n.uni-input-input {\r\n display: block;\r\n height: 100%;\r\n background: none;\r\n color: inherit;\r\n opacity: 1;\r\n -webkit-text-fill-color: currentcolor;\r\n font: inherit;\r\n line-height: inherit;\r\n letter-spacing: inherit;\r\n text-align: inherit;\r\n text-indent: inherit;\r\n text-transform: inherit;\r\n text-shadow: inherit;\n}\n.uni-input-input[type="search"]::-webkit-search-cancel-button {\r\n display: none;\n}\n.uni-input-input::-webkit-outer-spin-button,\r\n.uni-input-input::-webkit-inner-spin-button {\r\n -webkit-appearance: none;\r\n margin: 0;\n}\n.uni-input-input[type="number"] {\r\n -moz-appearance: textfield;\n}\r\n'; -const INPUT_TYPES = ["text", "number", "idcard", "digit", "password"]; -const NUMBER_TYPES = ["number", "digit"]; -const _sfc_main$l = { - name: "Input", - mixins: [baseInput], - props: { - name: { - type: String, - default: "" - }, - type: { - type: String, - default: "text" }, - password: { - type: [Boolean, String], - default: false - }, - placeholder: { - type: String, - default: "" - }, - placeholderStyle: { - type: String, - default: "" - }, - placeholderClass: { - type: String, - default: "input-placeholder" + setParent: function() { + if (!this.$parent._isMounted) { + return; + } + if (this._FA) { + this._FA.cancel(); + } + if (this._SFA) { + this._SFA.cancel(); + } + var scale = this.scale ? this.scaleValueSync : 1; + this._updateOffset(); + this._updateWH(scale); + this._updateBoundary(); + this._translateX = this.xSync + this._scaleOffset.x; + this._translateY = this.ySync + this._scaleOffset.y; + var limitXY = this._getLimitXY(this._translateX, this._translateY); + var x = limitXY.x; + var y = limitXY.y; + this._setTransform(x, y, scale, "", true); + this._updateOldScale(scale); }, - disabled: { - type: [Boolean, String], - default: false + _updateOffset: function() { + this._offset.x = p(this.$el, this.$parent.$el); + this._offset.y = f(this.$el, this.$parent.$el); }, - maxlength: { - type: [Number, String], - default: 140 + _updateWH: function(scale) { + scale = scale || this._scale; + scale = this._adjustScale(scale); + var rect = this.$el.getBoundingClientRect(); + this.height = rect.height / this._scale; + this.width = rect.width / this._scale; + var height = this.height * scale; + var width = this.width * scale; + this._scaleOffset.x = (width - this.width) / 2; + this._scaleOffset.y = (height - this.height) / 2; }, - focus: { - type: [Boolean, String], - default: false + _updateBoundary: function() { + var x = 0 - this._offset.x + this._scaleOffset.x; + var width = this.$parent.width - this.width - this._offset.x - this._scaleOffset.x; + this.minX = Math.min(x, width); + this.maxX = Math.max(x, width); + var y = 0 - this._offset.y + this._scaleOffset.y; + var height = this.$parent.height - this.height - this._offset.y - this._scaleOffset.y; + this.minY = Math.min(y, height); + this.maxY = Math.max(y, height); }, - confirmType: { - type: String, - default: "done" - } - }, - data() { - return { - composing: false, - wrapperHeight: 0, - cachedValue: "" - }; - }, - computed: { - inputType: function() { - let type = ""; - switch (this.type) { - case "text": - this.confirmType === "search" && (type = "search"); - break; - case "idcard": - type = "text"; - break; - case "digit": - type = "number"; - break; - default: - type = ~INPUT_TYPES.indexOf(this.type) ? this.type : "text"; - break; - } - return this.password ? "password" : type; + _beginScale: function() { + this._isScaling = true; }, - step() { - return ~NUMBER_TYPES.indexOf(this.type) ? "0.000000000000000001" : ""; - } - }, - watch: { - focus(val) { - this.$refs.input && this.$refs.input[val ? "focus" : "blur"](); + _endScale: function() { + this._isScaling = false; + this._updateOldScale(this._scale); }, - maxlength(value) { - const realValue = this.valueSync.slice(0, parseInt(value, 10)); - realValue !== this.valueSync && (this.valueSync = realValue); - } - }, - created() { - this.$dispatch("Form", "uni-form-group-update", { - type: "add", - vm: this - }); - }, - mounted() { - if (this.confirmType === "search") { - const formElem = document.createElement("form"); - formElem.action = ""; - formElem.onsubmit = function() { - return false; - }; - formElem.className = "uni-input-form"; - formElem.appendChild(this.$refs.input); - this.$refs.wrapper.appendChild(formElem); - } - let $vm = this; - while ($vm) { - const scopeId = $vm.$options._scopeId; - if (scopeId) { - this.$refs.placeholder.setAttribute(scopeId, ""); - } - $vm = $vm.$parent; - } - this.initKeyboard(this.$refs.input); - }, - beforeDestroy() { - this.$dispatch("Form", "uni-form-group-update", { - type: "remove", - vm: this - }); - }, - methods: { - _onKeyup($event) { - if ($event.keyCode === 13) { - this.$trigger("confirm", $event, { - value: $event.target.value - }); + _setScale: function(scale) { + if (this.scale) { + scale = this._adjustScale(scale); + scale = this._oldScale * scale; + this._beginScale(); + this._updateScale(scale); } }, - _onInput($event) { - if (this.composing) { - return; - } - if (~NUMBER_TYPES.indexOf(this.type)) { - if (this.$refs.input.validity && !this.$refs.input.validity.valid) { - $event.target.value = this.cachedValue; - this.valueSync = $event.target.value; - return; + _updateScale: function(scale, animat) { + var self = this; + if (this.scale) { + scale = this._adjustScale(scale); + this._updateWH(scale); + this._updateBoundary(); + const limitXY = this._getLimitXY(this._translateX, this._translateY); + const x = limitXY.x; + const y = limitXY.y; + if (animat) { + this._animationTo(x, y, scale, "", true, true); } else { - this.cachedValue = this.valueSync; - } - } - if (this.inputType === "number") { - const maxlength = parseInt(this.maxlength, 10); - if (maxlength > 0 && $event.target.value.length > maxlength) { - $event.target.value = $event.target.value.slice(0, maxlength); - this.valueSync = $event.target.value; - return; + _requestAnimationFrame(function() { + self._setTransform(x, y, scale, "", true, true); + }); } } - this.$triggerInput($event, { - value: this.valueSync - }); }, - _onFocus($event) { - this.$trigger("focus", $event, { - value: $event.target.value - }); + _updateOldScale: function(scale) { + this._oldScale = scale; }, - _onBlur($event) { - this.$trigger("blur", $event, { - value: $event.target.value - }); + _adjustScale: function(scale) { + scale = Math.max(0.5, this.scaleMinNumber, scale); + scale = Math.min(10, this.scaleMaxNumber, scale); + return scale; }, - _onComposition($event) { - if ($event.type === "compositionstart") { - this.composing = true; - } else { - this.composing = false; + _animationTo: function(x, y, scale, source, r, o2) { + var self = this; + if (this._FA) { + this._FA.cancel(); } - }, - _resetFormData() { - this.valueSync = ""; - }, - _getFormData() { - return this.name ? { - value: this.valueSync, - key: this.name - } : {}; - } - } -}; -const _hoisted_1$a = { - ref: "wrapper", - class: "uni-input-wrapper" -}; -function _sfc_render$j(_ctx, _cache, $props, $setup, $data, $options) { - return openBlock(), createBlock("uni-input", mergeProps({ - onChange: _cache[8] || (_cache[8] = withModifiers(() => { - }, ["stop"])) - }, _ctx.$attrs), [ - createVNode("div", _hoisted_1$a, [ - withDirectives(createVNode("div", { - ref: "placeholder", - style: $props.placeholderStyle, - class: [$props.placeholderClass, "uni-input-placeholder"], - textContent: toDisplayString($props.placeholder) - }, null, 14, ["textContent"]), [ - [vShow, !($data.composing || _ctx.valueSync.length)] - ]), - withDirectives(createVNode("input", { - ref: "input", - "onUpdate:modelValue": _cache[1] || (_cache[1] = ($event) => _ctx.valueSync = $event), - disabled: $props.disabled, - type: $options.inputType, - maxlength: $props.maxlength, - step: $options.step, - autofocus: $props.focus, - class: "uni-input-input", - autocomplete: "off", - onFocus: _cache[2] || (_cache[2] = (...args) => $options._onFocus && $options._onFocus(...args)), - onBlur: _cache[3] || (_cache[3] = (...args) => $options._onBlur && $options._onBlur(...args)), - onInput: _cache[4] || (_cache[4] = withModifiers((...args) => $options._onInput && $options._onInput(...args), ["stop"])), - onCompositionstart: _cache[5] || (_cache[5] = (...args) => $options._onComposition && $options._onComposition(...args)), - onCompositionend: _cache[6] || (_cache[6] = (...args) => $options._onComposition && $options._onComposition(...args)), - onKeyup: _cache[7] || (_cache[7] = withModifiers((...args) => $options._onKeyup && $options._onKeyup(...args), ["stop"])) - }, null, 40, ["disabled", "type", "maxlength", "step", "autofocus"]), [ - [vModelDynamic, _ctx.valueSync] - ]) - ], 512) - ], 16); -} -_sfc_main$l.render = _sfc_render$j; -var index_vue_vue_type_style_index_0_lang$e = "\n.uni-label-pointer {\r\n cursor: pointer;\n}\r\n"; -const _sfc_main$k = { - name: "Label", - mixins: [emitter], - props: { - for: { - type: String, - default: "" - } - }, - computed: { - pointer() { - return this.for || this.$slots.default && this.$slots.default.length; - } - }, - methods: { - _onClick($event) { - let stopPropagation = /^uni-(checkbox|radio|switch)-/.test($event.target.className); - if (!stopPropagation) { - stopPropagation = /^uni-(checkbox|radio|switch|button)$/i.test($event.target.tagName); + if (this._SFA) { + this._SFA.cancel(); } - if (stopPropagation) { - return; + if (!this.xMove) { + x = this._translateX; } - if (this.for) { - UniViewJSBridge.emit("uni-label-click-" + this.$page.id + "-" + this.for, $event, true); - } else { - this.$broadcast(["Checkbox", "Radio", "Switch", "Button"], "uni-label-click", $event, true); + if (!this.yMove) { + y = this._translateY; } - } - } -}; -function _sfc_render$i(_ctx, _cache, $props, $setup, $data, $options) { - return openBlock(), createBlock("uni-label", mergeProps({ - class: {"uni-label-pointer": $options.pointer} - }, _ctx.$attrs, { - onClick: _cache[1] || (_cache[1] = (...args) => $options._onClick && $options._onClick(...args)) - }), [ - renderSlot(_ctx.$slots, "default") - ], 16); -} -_sfc_main$k.render = _sfc_render$i; -const addListenerToElement = function(element, type, callback, capture) { - element.addEventListener(type, ($event) => { - if (typeof callback === "function") { - if (callback($event) === false) { - $event.preventDefault(); - $event.stopPropagation(); + if (!this.scale) { + scale = this._scale; } - } - }, { - passive: false - }); -}; -var touchtrack = { - beforeDestroy() { - document.removeEventListener("mousemove", this.__mouseMoveEventListener); - document.removeEventListener("mouseup", this.__mouseUpEventListener); - }, - methods: { - touchtrack: function(element, method, useCancel) { - const self = this; - let x0 = 0; - let y0 = 0; - let x1 = 0; - let y1 = 0; - const fn = function($event, state, x, y) { - if (self[method]({ - target: $event.target, - currentTarget: $event.currentTarget, - preventDefault: $event.preventDefault.bind($event), - stopPropagation: $event.stopPropagation.bind($event), - touches: $event.touches, - changedTouches: $event.changedTouches, - detail: { - state, - x0: x, - y0: y, - dx: x - x0, - dy: y - y0, - ddx: x - x1, - ddy: y - y1, - timeStamp: $event.timeStamp - } - }) === false) { - return false; - } - }; - let $eventOld = null; - let hasTouchStart; - let hasMouseDown; - addListenerToElement(element, "touchstart", function($event) { - hasTouchStart = true; - if ($event.touches.length === 1 && !$eventOld) { - $eventOld = $event; - x0 = x1 = $event.touches[0].pageX; - y0 = y1 = $event.touches[0].pageY; - return fn($event, "start", x0, y0); - } - }); - addListenerToElement(element, "mousedown", function($event) { - hasMouseDown = true; - if (!hasTouchStart && !$eventOld) { - $eventOld = $event; - x0 = x1 = $event.pageX; - y0 = y1 = $event.pageY; - return fn($event, "start", x0, y0); - } - }); - addListenerToElement(element, "touchmove", function($event) { - if ($event.touches.length === 1 && $eventOld) { - const res = fn($event, "move", $event.touches[0].pageX, $event.touches[0].pageY); - x1 = $event.touches[0].pageX; - y1 = $event.touches[0].pageY; - return res; - } - }); - const mouseMoveEventListener = this.__mouseMoveEventListener = function($event) { - if (!hasTouchStart && hasMouseDown && $eventOld) { - const res = fn($event, "move", $event.pageX, $event.pageY); - x1 = $event.pageX; - y1 = $event.pageY; - return res; - } - }; - document.addEventListener("mousemove", mouseMoveEventListener); - addListenerToElement(element, "touchend", function($event) { - if ($event.touches.length === 0 && $eventOld) { - hasTouchStart = false; - $eventOld = null; - return fn($event, "end", $event.changedTouches[0].pageX, $event.changedTouches[0].pageY); - } - }); - const mouseUpEventListener = this.__mouseUpEventListener = function($event) { - hasMouseDown = false; - if (!hasTouchStart && $eventOld) { - $eventOld = null; - return fn($event, "end", $event.pageX, $event.pageY); - } - }; - document.addEventListener("mouseup", mouseUpEventListener); - addListenerToElement(element, "touchcancel", function($event) { - if ($eventOld) { - hasTouchStart = false; - const $eventTemp = $eventOld; - $eventOld = null; - return fn($event, useCancel ? "cancel" : "end", $eventTemp.touches[0].pageX, $eventTemp.touches[0].pageY); - } + var limitXY = this._getLimitXY(x, y); + x = limitXY.x; + y = limitXY.y; + if (!this.animation) { + this._setTransform(x, y, scale, source, r, o2); + return; + } + this._STD._springX._solution = null; + this._STD._springY._solution = null; + this._STD._springScale._solution = null; + this._STD._springX._endPosition = this._translateX; + this._STD._springY._endPosition = this._translateY; + this._STD._springScale._endPosition = this._scale; + this._STD.setEnd(x, y, scale, 1); + this._SFA = g(this._STD, function() { + var data = self._STD.x(); + var x2 = data.x; + var y2 = data.y; + var scale2 = data.scale; + self._setTransform(x2, y2, scale2, source, r, o2); + }, function() { + self._SFA.cancel(); }); + }, + _revise: function(source) { + var limitXY = this._getLimitXY(this._translateX, this._translateY); + var x = limitXY.x; + var y = limitXY.y; + var outOfBounds = limitXY.outOfBounds; + if (outOfBounds) { + this._animationTo(x, y, this._scale, source); + } + return outOfBounds; + }, + _setTransform: function(x, y, scale, source = "", r, o2) { + if (!(x !== null && x.toString() !== "NaN" && typeof x === "number")) { + x = this._translateX || 0; + } + if (!(y !== null && y.toString() !== "NaN" && typeof y === "number")) { + y = this._translateY || 0; + } + x = Number(x.toFixed(1)); + y = Number(y.toFixed(1)); + scale = Number(scale.toFixed(1)); + if (!(this._translateX === x && this._translateY === y)) { + if (!r) { + this.$trigger("change", {}, { + x: v(x, this._scaleOffset.x), + y: v(y, this._scaleOffset.y), + source + }); + } + } + if (!this.scale) { + scale = this._scale; + } + scale = this._adjustScale(scale); + scale = +scale.toFixed(3); + if (o2 && scale !== this._scale) { + this.$trigger("scale", {}, { + x, + y, + scale + }); + } + var transform = "translateX(" + x + "px) translateY(" + y + "px) translateZ(0px) scale(" + scale + ")"; + this.$el.style.transform = transform; + this.$el.style.webkitTransform = transform; + this._translateX = x; + this._translateY = y; + this._scale = scale; } } }; -function e(e2, t2, n) { - return e2 > t2 - n && e2 < t2 + n; -} -function t(t2, n) { - return e(t2, 0, n); -} -function Decline() { -} -Decline.prototype.x = function(e2) { - return Math.sqrt(e2); -}; -function Friction$1(e2, t2) { - this._m = e2; - this._f = 1e3 * t2; - this._startTime = 0; - this._v = 0; -} -Friction$1.prototype.setV = function(x, y) { - var n = Math.pow(Math.pow(x, 2) + Math.pow(y, 2), 0.5); - this._x_v = x; - this._y_v = y; - this._x_a = -this._f * this._x_v / n; - this._y_a = -this._f * this._y_v / n; - this._t = Math.abs(x / this._x_a) || Math.abs(y / this._y_a); - this._lastDt = null; - this._startTime = new Date().getTime(); -}; -Friction$1.prototype.setS = function(x, y) { - this._x_s = x; - this._y_s = y; -}; -Friction$1.prototype.s = function(t2) { - if (t2 === void 0) { - t2 = (new Date().getTime() - this._startTime) / 1e3; - } - if (t2 > this._t) { - t2 = this._t; - this._lastDt = t2; - } - var x = this._x_v * t2 + 0.5 * this._x_a * Math.pow(t2, 2) + this._x_s; - var y = this._y_v * t2 + 0.5 * this._y_a * Math.pow(t2, 2) + this._y_s; - if (this._x_a > 0 && x < this._endPositionX || this._x_a < 0 && x > this._endPositionX) { - x = this._endPositionX; - } - if (this._y_a > 0 && y < this._endPositionY || this._y_a < 0 && y > this._endPositionY) { - y = this._endPositionY; - } - return { - x, - y - }; -}; -Friction$1.prototype.ds = function(t2) { - if (t2 === void 0) { - t2 = (new Date().getTime() - this._startTime) / 1e3; - } - if (t2 > this._t) { - t2 = this._t; - } - return { - dx: this._x_v + this._x_a * t2, - dy: this._y_v + this._y_a * t2 - }; -}; -Friction$1.prototype.delta = function() { - return { - x: -1.5 * Math.pow(this._x_v, 2) / this._x_a || 0, - y: -1.5 * Math.pow(this._y_v, 2) / this._y_a || 0 - }; -}; -Friction$1.prototype.dt = function() { - return -this._x_v / this._x_a; -}; -Friction$1.prototype.done = function() { - var t2 = e(this.s().x, this._endPositionX) || e(this.s().y, this._endPositionY) || this._lastDt === this._t; - this._lastDt = null; - return t2; -}; -Friction$1.prototype.setEnd = function(x, y) { - this._endPositionX = x; - this._endPositionY = y; -}; -Friction$1.prototype.reconfigure = function(m, f2) { - this._m = m; - this._f = 1e3 * f2; -}; -function Spring$1(m, k, c) { - this._m = m; - this._k = k; - this._c = c; - this._solution = null; - this._endPosition = 0; - this._startTime = 0; +function _sfc_render$h(_ctx, _cache, $props, $setup, $data, $options) { + const _component_v_uni_resize_sensor = resolveComponent("v-uni-resize-sensor"); + return openBlock(), createBlock("uni-movable-view", _ctx.$attrs, [ + createVNode(_component_v_uni_resize_sensor, {onResize: $options.setParent}, null, 8, ["onResize"]), + renderSlot(_ctx.$slots, "default") + ], 16); } -Spring$1.prototype._solve = function(e2, t2) { - var n = this._c; - var i2 = this._m; - var r = this._k; - var o2 = n * n - 4 * i2 * r; - if (o2 === 0) { - const a2 = -n / (2 * i2); - const s = e2; - const l = t2 / (a2 * e2); - return { - x: function(e3) { - return (s + l * e3) * Math.pow(Math.E, a2 * e3); - }, - dx: function(e3) { - var t3 = Math.pow(Math.E, a2 * e3); - return a2 * (s + l * e3) * t3 + l * t3; +_sfc_main$j.render = _sfc_render$h; +var index_vue_vue_type_style_index_0_lang$c = "\nuni-navigator {\r\n height: auto;\r\n width: auto;\r\n display: block;\r\n cursor: pointer;\n}\nuni-navigator[hidden] {\r\n display: none;\n}\n.navigator-hover {\r\n background-color: rgba(0, 0, 0, 0.1);\r\n opacity: 0.7;\n}\r\n"; +const OPEN_TYPES = ["navigate", "redirect", "switchTab", "reLaunch", "navigateBack"]; +const _sfc_main$i = { + name: "Navigator", + mixins: [hover], + props: { + hoverClass: { + type: String, + default: "navigator-hover" + }, + url: { + type: String, + default: "" + }, + openType: { + type: String, + default: "navigate", + validator(value) { + return ~OPEN_TYPES.indexOf(value); } - }; - } - if (o2 > 0) { - const c = (-n - Math.sqrt(o2)) / (2 * i2); - const u = (-n + Math.sqrt(o2)) / (2 * i2); - const d = (t2 - c * e2) / (u - c); - const h = e2 - d; - return { - x: function(e3) { - var t3; - var n2; - if (e3 === this._t) { - t3 = this._powER1T; - n2 = this._powER2T; - } - this._t = e3; - if (!t3) { - t3 = this._powER1T = Math.pow(Math.E, c * e3); - } - if (!n2) { - n2 = this._powER2T = Math.pow(Math.E, u * e3); - } - return h * t3 + d * n2; - }, - dx: function(e3) { - var t3; - var n2; - if (e3 === this._t) { - t3 = this._powER1T; - n2 = this._powER2T; - } - this._t = e3; - if (!t3) { - t3 = this._powER1T = Math.pow(Math.E, c * e3); - } - if (!n2) { - n2 = this._powER2T = Math.pow(Math.E, u * e3); - } - return h * c * t3 + d * u * n2; + }, + delta: { + type: Number, + default: 1 + }, + hoverStartTime: { + type: [Number, String], + default: 20 + }, + hoverStayTime: { + type: [Number, String], + default: 600 + } + }, + methods: { + _onClick($event) { + if (this.openType !== "navigateBack" && !this.url) { + console.error(" should have url attribute when using navigateTo, redirectTo, reLaunch or switchTab"); + return; + } + switch (this.openType) { + case "navigate": + uni.navigateTo({ + url: this.url + }); + break; + case "redirect": + uni.redirectTo({ + url: this.url + }); + break; + case "switchTab": + uni.switchTab({ + url: this.url + }); + break; + case "reLaunch": + uni.reLaunch({ + url: this.url + }); + break; + case "navigateBack": + uni.navigateBack({ + delta: this.delta + }); + break; } - }; - } - var p2 = Math.sqrt(4 * i2 * r - n * n) / (2 * i2); - var f2 = -n / 2 * i2; - var v2 = e2; - var g2 = (t2 - f2 * e2) / p2; - return { - x: function(e3) { - return Math.pow(Math.E, f2 * e3) * (v2 * Math.cos(p2 * e3) + g2 * Math.sin(p2 * e3)); - }, - dx: function(e3) { - var t3 = Math.pow(Math.E, f2 * e3); - var n2 = Math.cos(p2 * e3); - var i3 = Math.sin(p2 * e3); - return t3 * (g2 * p2 * n2 - v2 * p2 * i3) + f2 * t3 * (g2 * i3 + v2 * n2); } - }; -}; -Spring$1.prototype.x = function(e2) { - if (e2 === void 0) { - e2 = (new Date().getTime() - this._startTime) / 1e3; } - return this._solution ? this._endPosition + this._solution.x(e2) : 0; }; -Spring$1.prototype.dx = function(e2) { - if (e2 === void 0) { - e2 = (new Date().getTime() - this._startTime) / 1e3; - } - return this._solution ? this._solution.dx(e2) : 0; +function _sfc_render$g(_ctx, _cache, $props, $setup, $data, $options) { + return $props.hoverClass && $props.hoverClass !== "none" ? (openBlock(), createBlock("uni-navigator", mergeProps({ + key: 0, + class: [_ctx.hovering ? $props.hoverClass : ""], + onTouchstart: _cache[1] || (_cache[1] = (...args) => _ctx._hoverTouchStart && _ctx._hoverTouchStart(...args)), + onTouchend: _cache[2] || (_cache[2] = (...args) => _ctx._hoverTouchEnd && _ctx._hoverTouchEnd(...args)), + onTouchcancel: _cache[3] || (_cache[3] = (...args) => _ctx._hoverTouchCancel && _ctx._hoverTouchCancel(...args)), + onClick: _cache[4] || (_cache[4] = (...args) => $options._onClick && $options._onClick(...args)) + }, _ctx.$attrs), [ + renderSlot(_ctx.$slots, "default") + ], 16)) : (openBlock(), createBlock("uni-navigator", mergeProps({ + key: 1, + onClick: _cache[5] || (_cache[5] = (...args) => $options._onClick && $options._onClick(...args)) + }, _ctx.$attrs), [ + renderSlot(_ctx.$slots, "default") + ], 16)); +} +_sfc_main$i.render = _sfc_render$g; +const VALUES = { + activeColor: "#007AFF", + backgroundColor: "#EBEBEB", + activeMode: "backwards" }; -Spring$1.prototype.setEnd = function(e2, n, i2) { - if (!i2) { - i2 = new Date().getTime(); - } - if (e2 !== this._endPosition || !t(n, 0.1)) { - n = n || 0; - var r = this._endPosition; - if (this._solution) { - if (t(n, 0.1)) { - n = this._solution.dx((i2 - this._startTime) / 1e3); - } - r = this._solution.x((i2 - this._startTime) / 1e3); - if (t(n, 0.1)) { - n = 0; +const _sfc_main$h = { + name: "Progress", + props: { + percent: { + type: [Number, String], + default: 0, + validator(value) { + return !isNaN(parseFloat(value, 10)); } - if (t(r, 0.1)) { - r = 0; + }, + showInfo: { + type: [Boolean, String], + default: false + }, + strokeWidth: { + type: [Number, String], + default: 6, + validator(value) { + return !isNaN(parseFloat(value, 10)); } - r += this._endPosition; - } - if (!(this._solution && t(r - e2, 0.1) && t(n, 0.1))) { - this._endPosition = e2; - this._solution = this._solve(r - this._endPosition, n); - this._startTime = i2; - } - } -}; -Spring$1.prototype.snap = function(e2) { - this._startTime = new Date().getTime(); - this._endPosition = e2; - this._solution = { - x: function() { - return 0; }, - dx: function() { - return 0; - } - }; -}; -Spring$1.prototype.done = function(n) { - if (!n) { - n = new Date().getTime(); - } - return e(this.x(), this._endPosition, 0.1) && t(this.dx(), 0.1); -}; -Spring$1.prototype.reconfigure = function(m, t2, c) { - this._m = m; - this._k = t2; - this._c = c; - if (!this.done()) { - this._solution = this._solve(this.x() - this._endPosition, this.dx()); - this._startTime = new Date().getTime(); - } -}; -Spring$1.prototype.springConstant = function() { - return this._k; -}; -Spring$1.prototype.damping = function() { - return this._c; -}; -Spring$1.prototype.configuration = function() { - function e2(e3, t3) { - e3.reconfigure(1, t3, e3.damping()); - } - function t2(e3, t3) { - e3.reconfigure(1, e3.springConstant(), t3); - } - return [ - { - label: "Spring Constant", - read: this.springConstant.bind(this), - write: e2.bind(this, this), - min: 100, - max: 1e3 + color: { + type: String, + default: VALUES.activeColor }, - { - label: "Damping", - read: this.damping.bind(this), - write: t2.bind(this, this), - min: 1, - max: 500 - } - ]; -}; -function STD(e2, t2, n) { - this._springX = new Spring$1(e2, t2, n); - this._springY = new Spring$1(e2, t2, n); - this._springScale = new Spring$1(e2, t2, n); - this._startTime = 0; -} -STD.prototype.setEnd = function(e2, t2, n, i2) { - var r = new Date().getTime(); - this._springX.setEnd(e2, i2, r); - this._springY.setEnd(t2, i2, r); - this._springScale.setEnd(n, i2, r); - this._startTime = r; -}; -STD.prototype.x = function() { - var e2 = (new Date().getTime() - this._startTime) / 1e3; - return { - x: this._springX.x(e2), - y: this._springY.x(e2), - scale: this._springScale.x(e2) - }; -}; -STD.prototype.done = function() { - var e2 = new Date().getTime(); - return this._springX.done(e2) && this._springY.done(e2) && this._springScale.done(e2); -}; -STD.prototype.reconfigure = function(e2, t2, n) { - this._springX.reconfigure(e2, t2, n); - this._springY.reconfigure(e2, t2, n); - this._springScale.reconfigure(e2, t2, n); -}; -var index_vue_vue_type_style_index_0_lang$d = "\nuni-movable-view {\n display: inline-block;\n width: 10px;\n height: 10px;\n top: 0px;\n left: 0px;\n position: absolute;\n cursor: grab;\n}\nuni-movable-view[hidden] {\n display: none;\n}\n"; -var requesting = false; -function _requestAnimationFrame(e2) { - if (!requesting) { - requesting = true; - requestAnimationFrame(function() { - e2(); - requesting = false; - }); - } -} -function p(t2, n) { - if (t2 === n) { - return 0; - } - var i2 = t2.offsetLeft; - return t2.offsetParent ? i2 += p(t2.offsetParent, n) : 0; -} -function f(t2, n) { - if (t2 === n) { - return 0; - } - var i2 = t2.offsetTop; - return t2.offsetParent ? i2 += f(t2.offsetParent, n) : 0; -} -function v(a2, b) { - return +((1e3 * a2 - 1e3 * b) / 1e3).toFixed(1); -} -function g(e2, t2, n) { - var i2 = function(e3) { - if (e3 && e3.id) { - cancelAnimationFrame(e3.id); - } - if (e3) { - e3.cancelled = true; + activeColor: { + type: String, + default: VALUES.activeColor + }, + backgroundColor: { + type: String, + default: VALUES.backgroundColor + }, + active: { + type: [Boolean, String], + default: false + }, + activeMode: { + type: String, + default: VALUES.activeMode } - }; - var r = { - id: 0, - cancelled: false - }; - function fn(n2, i3, r2, o2) { - if (!n2 || !n2.cancelled) { - r2(i3); - var a2 = e2.done(); - if (!a2) { - if (!n2.cancelled) { - n2.id = requestAnimationFrame(fn.bind(null, n2, i3, r2, o2)); - } + }, + data() { + return { + currentPercent: 0, + strokeTimer: 0, + lastPercent: 0 + }; + }, + computed: { + outerBarStyle() { + return `background-color: ${this.backgroundColor}; height: ${this.strokeWidth}px;`; + }, + innerBarStyle() { + let backgroundColor = ""; + if (this.color !== VALUES.activeColor && this.activeColor === VALUES.activeColor) { + backgroundColor = this.color; + } else { + backgroundColor = this.activeColor; } - if (a2 && o2) { - o2(i3); + return `width: ${this.currentPercent}%;background-color: ${backgroundColor}`; + }, + realPercent() { + let realValue = parseFloat(this.percent, 10); + realValue < 0 && (realValue = 0); + realValue > 100 && (realValue = 100); + return realValue; + } + }, + watch: { + realPercent(newValue, oldValue) { + this.strokeTimer && clearInterval(this.strokeTimer); + this.lastPercent = oldValue || 0; + this._activeAnimation(); + } + }, + created() { + this._activeAnimation(); + }, + methods: { + _activeAnimation() { + if (this.active) { + this.currentPercent = this.activeMode === VALUES.activeMode ? 0 : this.lastPercent; + this.strokeTimer = setInterval(() => { + if (this.currentPercent + 1 > this.realPercent) { + this.currentPercent = this.realPercent; + this.strokeTimer && clearInterval(this.strokeTimer); + } else { + this.currentPercent += 1; + } + }, 30); + } else { + this.currentPercent = this.realPercent; } } } - fn(r, e2, t2, n); - return { - cancel: i2.bind(null, r), - model: e2 - }; +}; +const _hoisted_1$9 = { + key: 0, + class: "uni-progress-info" +}; +function _sfc_render$f(_ctx, _cache, $props, $setup, $data, $options) { + return openBlock(), createBlock("uni-progress", mergeProps({class: "uni-progress"}, _ctx.$attrs), [ + createVNode("div", { + style: $options.outerBarStyle, + class: "uni-progress-bar" + }, [ + createVNode("div", { + style: $options.innerBarStyle, + class: "uni-progress-inner-bar" + }, null, 4) + ], 4), + $props.showInfo ? (openBlock(), createBlock("p", _hoisted_1$9, toDisplayString($data.currentPercent) + "% ", 1)) : createCommentVNode("", true) + ], 16); } -const _sfc_main$j = { - name: "MovableView", - mixins: [touchtrack], +_sfc_main$h.render = _sfc_render$f; +var index_vue_vue_type_style_index_0_lang$b = '\nuni-radio {\r\n -webkit-tap-highlight-color: transparent;\r\n display: inline-block;\r\n cursor: pointer;\n}\nuni-radio[hidden] {\r\n display: none;\n}\nuni-radio[disabled] {\r\n cursor: not-allowed;\n}\nuni-radio .uni-radio-wrapper {\r\n display: -webkit-inline-flex;\r\n display: inline-flex;\r\n -webkit-align-items: center;\r\n align-items: center;\r\n vertical-align: middle;\n}\nuni-radio .uni-radio-input {\r\n -webkit-appearance: none;\r\n appearance: none;\r\n margin-right: 5px;\r\n outline: 0;\r\n border: 1px solid #D1D1D1;\r\n background-color: #ffffff;\r\n border-radius: 50%;\r\n width: 22px;\r\n height: 22px;\r\n position: relative;\n}\nuni-radio:not([disabled]) .uni-radio-input:hover {\r\n border-color: #007aff;\n}\nuni-radio .uni-radio-input.uni-radio-input-checked:before {\r\n font: normal normal normal 14px/1 "uni";\r\n content: "\\EA08";\r\n color: #ffffff;\r\n font-size: 18px;\r\n position: absolute;\r\n top: 50%;\r\n left: 50%;\r\n transform: translate(-50%, -48%) scale(0.73);\r\n -webkit-transform: translate(-50%, -48%) scale(0.73);\n}\nuni-radio .uni-radio-input.uni-radio-input-disabled {\r\n background-color: #E1E1E1;\r\n border-color: #D1D1D1;\n}\nuni-radio .uni-radio-input.uni-radio-input-disabled:before {\r\n color: #ADADAD;\n}\nuni-radio-group {\r\n display: block;\n}\r\n'; +const _sfc_main$g = { + name: "Radio", + mixins: [emitter, listeners], props: { - direction: { - type: String, - default: "none" - }, - inertia: { - type: [Boolean, String], - default: false - }, - outOfBounds: { + checked: { type: [Boolean, String], default: false }, - x: { - type: [Number, String], - default: 0 - }, - y: { - type: [Number, String], - default: 0 - }, - damping: { - type: [Number, String], - default: 20 - }, - friction: { - type: [Number, String], - default: 2 + id: { + type: String, + default: "" }, disabled: { type: [Boolean, String], default: false }, - scale: { - type: [Boolean, String], - default: false - }, - scaleMin: { - type: [Number, String], - default: 0.5 - }, - scaleMax: { - type: [Number, String], - default: 10 - }, - scaleValue: { - type: [Number, String], - default: 1 + color: { + type: String, + default: "#007AFF" }, - animation: { - type: [Boolean, String], - default: true + value: { + type: String, + default: "" } }, data() { return { - xSync: this._getPx(this.x), - ySync: this._getPx(this.y), - scaleValueSync: Number(this.scaleValue) || 1, - width: 0, - height: 0, - minX: 0, - minY: 0, - maxX: 0, - maxY: 0 + radioChecked: this.checked, + radioValue: this.value }; }, computed: { - dampingNumber() { - var val = Number(this.damping); - return isNaN(val) ? 20 : val; - }, - frictionNumber() { - var val = Number(this.friction); - return isNaN(val) || val <= 0 ? 2 : val; - }, - scaleMinNumber() { - var val = Number(this.scaleMin); - return isNaN(val) ? 0.5 : val; - }, - scaleMaxNumber() { - var val = Number(this.scaleMax); - return isNaN(val) ? 10 : val; - }, - xMove() { - return this.direction === "all" || this.direction === "horizontal"; - }, - yMove() { - return this.direction === "all" || this.direction === "vertical"; + checkedStyle() { + return `background-color: ${this.color};border-color: ${this.color};`; } }, watch: { - x(val) { - this.xSync = this._getPx(val); - }, - xSync(val) { - this._setX(val); - }, - y(val) { - this.ySync = this._getPx(val); - }, - ySync(val) { - this._setY(val); - }, - scaleValue(val) { - this.scaleValueSync = Number(val) || 0; - }, - scaleValueSync(val) { - this._setScaleValue(val); - }, - scaleMinNumber() { - this._setScaleMinOrMax(); + checked(val) { + this.radioChecked = val; }, - scaleMaxNumber() { - this._setScaleMinOrMax(); + value(val) { + this.radioValue = val; } }, - created: function() { - this._offset = { - x: 0, - y: 0 - }; - this._scaleOffset = { - x: 0, - y: 0 - }; - this._translateX = 0; - this._translateY = 0; - this._scale = 1; - this._oldScale = 1; - this._STD = new STD(1, 9 * Math.pow(this.dampingNumber, 2) / 40, this.dampingNumber); - this._friction = new Friction$1(1, this.frictionNumber); - this._declineX = new Decline(); - this._declineY = new Decline(); - this.__touchInfo = { - historyX: [0, 0], - historyY: [0, 0], - historyT: [0, 0] + listeners: { + "label-click": "_onClick", + "@label-click": "_onClick" + }, + created() { + this.$dispatch("RadioGroup", "uni-radio-group-update", { + type: "add", + vm: this + }); + this.$dispatch("Form", "uni-form-group-update", { + type: "add", + vm: this + }); + }, + beforeDestroy() { + this.$dispatch("RadioGroup", "uni-radio-group-update", { + type: "remove", + vm: this + }); + this.$dispatch("Form", "uni-form-group-update", { + type: "remove", + vm: this + }); + }, + methods: { + _onClick($event) { + if (this.disabled || this.radioChecked) { + return; + } + this.radioChecked = true; + this.$dispatch("RadioGroup", "uni-radio-change", $event, this); + }, + _resetFormData() { + this.radioChecked = this.min; + } + } +}; +const _hoisted_1$8 = {class: "uni-radio-wrapper"}; +function _sfc_render$e(_ctx, _cache, $props, $setup, $data, $options) { + return openBlock(), createBlock("uni-radio", mergeProps({disabled: $props.disabled}, _ctx.$attrs, { + onClick: _cache[1] || (_cache[1] = (...args) => $options._onClick && $options._onClick(...args)) + }), [ + createVNode("div", _hoisted_1$8, [ + createVNode("div", { + class: [$data.radioChecked ? "uni-radio-input-checked" : "", "uni-radio-input"], + style: $data.radioChecked ? $options.checkedStyle : "" + }, null, 6), + renderSlot(_ctx.$slots, "default") + ]) + ], 16, ["disabled"]); +} +_sfc_main$g.render = _sfc_render$e; +var index_vue_vue_type_style_index_0_lang$a = "\nuni-radio-group[hidden] {\r\n display: none;\n}\r\n"; +const _sfc_main$f = { + name: "RadioGroup", + mixins: [emitter, listeners], + props: { + name: { + type: String, + default: "" + } + }, + data() { + return { + radioList: [] }; }, - mounted: function() { - this.touchtrack(this.$el, "_onTrack"); - this.setParent(); - this._friction.reconfigure(1, this.frictionNumber); - this._STD.reconfigure(1, 9 * Math.pow(this.dampingNumber, 2) / 40, this.dampingNumber); - this.$el.style.transformOrigin = "center"; + listeners: { + "@radio-change": "_changeHandler", + "@radio-group-update": "_radioGroupUpdateHandler" + }, + mounted() { + this._resetRadioGroupValue(this.radioList.length - 1); + }, + created() { + this.$dispatch("Form", "uni-form-group-update", { + type: "add", + vm: this + }); + }, + beforeDestroy() { + this.$dispatch("Form", "uni-form-group-update", { + type: "remove", + vm: this + }); }, methods: { - _getPx(val) { - if (/\d+[ur]px$/i.test(val)) { - return uni.upx2px(parseFloat(val)); - } - return Number(val) || 0; - }, - _setX: function(val) { - if (this.xMove) { - if (val + this._scaleOffset.x === this._translateX) { - return this._translateX; - } else { - if (this._SFA) { - this._SFA.cancel(); - } - this._animationTo(val + this._scaleOffset.x, this.ySync + this._scaleOffset.y, this._scale); - } - } - return val; - }, - _setY: function(val) { - if (this.yMove) { - if (val + this._scaleOffset.y === this._translateY) { - return this._translateY; - } else { - if (this._SFA) { - this._SFA.cancel(); - } - this._animationTo(this.xSync + this._scaleOffset.x, val + this._scaleOffset.y, this._scale); - } - } - return val; - }, - _setScaleMinOrMax: function() { - if (!this.scale) { - return false; - } - this._updateScale(this._scale, true); - this._updateOldScale(this._scale); - }, - _setScaleValue: function(scale) { - if (!this.scale) { - return false; - } - scale = this._adjustScale(scale); - this._updateScale(scale, true); - this._updateOldScale(scale); - return scale; + _changeHandler($event, vm) { + const index2 = this.radioList.indexOf(vm); + this._resetRadioGroupValue(index2, true); + this.$trigger("change", $event, { + value: vm.radioValue + }); }, - __handleTouchStart: function() { - if (!this._isScaling) { - if (!this.disabled) { - if (this._FA) { - this._FA.cancel(); - } - if (this._SFA) { - this._SFA.cancel(); - } - this.__touchInfo.historyX = [0, 0]; - this.__touchInfo.historyY = [0, 0]; - this.__touchInfo.historyT = [0, 0]; - if (this.xMove) { - this.__baseX = this._translateX; - } - if (this.yMove) { - this.__baseY = this._translateY; - } - this.$el.style.willChange = "transform"; - this._checkCanMove = null; - this._firstMoveDirection = null; - this._isTouching = true; - } + _radioGroupUpdateHandler($event) { + if ($event.type === "add") { + this.radioList.push($event.vm); + } else { + const index2 = this.radioList.indexOf($event.vm); + this.radioList.splice(index2, 1); } }, - __handleTouchMove: function(event2) { - var self = this; - if (!this._isScaling && !this.disabled && this._isTouching) { - let x = this._translateX; - let y = this._translateY; - if (this._firstMoveDirection === null) { - this._firstMoveDirection = Math.abs(event2.detail.dx / event2.detail.dy) > 1 ? "htouchmove" : "vtouchmove"; - } - if (this.xMove) { - x = event2.detail.dx + this.__baseX; - this.__touchInfo.historyX.shift(); - this.__touchInfo.historyX.push(x); - if (!this.yMove && this._checkCanMove === null) { - this._checkCanMove = Math.abs(event2.detail.dx / event2.detail.dy) < 1; - } - } - if (this.yMove) { - y = event2.detail.dy + this.__baseY; - this.__touchInfo.historyY.shift(); - this.__touchInfo.historyY.push(y); - if (!this.xMove && this._checkCanMove === null) { - this._checkCanMove = Math.abs(event2.detail.dy / event2.detail.dx) < 1; - } + _resetRadioGroupValue(key, change) { + this.radioList.forEach((value, index2) => { + if (index2 === key) { + return; } - this.__touchInfo.historyT.shift(); - this.__touchInfo.historyT.push(event2.detail.timeStamp); - if (!this._checkCanMove) { - event2.preventDefault(); - let source = "touch"; - if (x < this.minX) { - if (this.outOfBounds) { - source = "touch-out-of-bounds"; - x = this.minX - this._declineX.x(this.minX - x); - } else { - x = this.minX; - } - } else if (x > this.maxX) { - if (this.outOfBounds) { - source = "touch-out-of-bounds"; - x = this.maxX + this._declineX.x(x - this.maxX); - } else { - x = this.maxX; - } - } - if (y < this.minY) { - if (this.outOfBounds) { - source = "touch-out-of-bounds"; - y = this.minY - this._declineY.x(this.minY - y); - } else { - y = this.minY; + if (change) { + this.radioList[index2].radioChecked = false; + } else { + this.radioList.forEach((v2, i) => { + if (index2 >= i) { + return; } - } else { - if (y > this.maxY) { - if (this.outOfBounds) { - source = "touch-out-of-bounds"; - y = this.maxY + this._declineY.x(y - this.maxY); - } else { - y = this.maxY; - } + if (this.radioList[i].radioChecked) { + this.radioList[index2].radioChecked = false; } - } - _requestAnimationFrame(function() { - self._setTransform(x, y, self._scale, source); }); } - } + }); }, - __handleTouchEnd: function() { - var self = this; - if (!this._isScaling && !this.disabled && this._isTouching) { - this.$el.style.willChange = "auto"; - this._isTouching = false; - if (!this._checkCanMove && !this._revise("out-of-bounds") && this.inertia) { - const xv = 1e3 * (this.__touchInfo.historyX[1] - this.__touchInfo.historyX[0]) / (this.__touchInfo.historyT[1] - this.__touchInfo.historyT[0]); - const yv = 1e3 * (this.__touchInfo.historyY[1] - this.__touchInfo.historyY[0]) / (this.__touchInfo.historyT[1] - this.__touchInfo.historyT[0]); - this._friction.setV(xv, yv); - this._friction.setS(this._translateX, this._translateY); - const x0 = this._friction.delta().x; - const y0 = this._friction.delta().y; - let x = x0 + this._translateX; - let y = y0 + this._translateY; - if (x < this.minX) { - x = this.minX; - y = this._translateY + (this.minX - this._translateX) * y0 / x0; - } else { - if (x > this.maxX) { - x = this.maxX; - y = this._translateY + (this.maxX - this._translateX) * y0 / x0; - } - } - if (y < this.minY) { - y = this.minY; - x = this._translateX + (this.minY - this._translateY) * x0 / y0; - } else { - if (y > this.maxY) { - y = this.maxY; - x = this._translateX + (this.maxY - this._translateY) * x0 / y0; - } + _getFormData() { + const data = {}; + if (this.name !== "") { + let value = ""; + this.radioList.forEach((vm) => { + if (vm.radioChecked) { + value = vm.value; } - this._friction.setEnd(x, y); - this._FA = g(this._friction, function() { - var t2 = self._friction.s(); - var x2 = t2.x; - var y2 = t2.y; - self._setTransform(x2, y2, self._scale, "friction"); - }, function() { - self._FA.cancel(); - }); - } + }); + data.value = value; + data.key = this.name; + } + return data; + } + } +}; +function _sfc_render$d(_ctx, _cache, $props, $setup, $data, $options) { + return openBlock(), createBlock("uni-radio-group", _ctx.$attrs, [ + renderSlot(_ctx.$slots, "default") + ], 16); +} +_sfc_main$f.render = _sfc_render$d; +var index_vue_vue_type_style_index_0_lang$9 = "\n@keyframes once-show {\nfrom {\n top: 0;\n}\n}\nuni-resize-sensor,\nuni-resize-sensor > div {\n position: absolute;\n left: 0;\n top: 0;\n right: 0;\n bottom: 0;\n overflow: hidden;\n}\nuni-resize-sensor {\n display: block;\n z-index: -1;\n visibility: hidden;\n animation: once-show 1ms;\n}\nuni-resize-sensor > div > div {\n position: absolute;\n left: 0;\n top: 0;\n}\nuni-resize-sensor > div:first-child > div {\n width: 100000px;\n height: 100000px;\n}\nuni-resize-sensor > div:last-child > div {\n width: 200%;\n height: 200%;\n}\n"; +const _sfc_main$e = { + name: "ResizeSensor", + props: { + initial: { + type: [Boolean, String], + default: false + } + }, + data: function() { + return { + size: { + width: -1, + height: -1 } - }, - _onTrack: function(event2) { - switch (event2.detail.state) { - case "start": - this.__handleTouchStart(); - break; - case "move": - this.__handleTouchMove(event2); - break; - case "end": - this.__handleTouchEnd(); + }; + }, + watch: { + size: { + deep: true, + handler: function(size) { + this.$emit("resize", Object.assign({}, size)); } + } + }, + mounted: function() { + if (this.initial === true) { + this.$nextTick(this.update); + } + if (this.$el.offsetParent !== this.$el.parentNode) { + this.$el.parentNode.style.position = "relative"; + } + if (!("AnimationEvent" in window)) { + this.reset(); + } + }, + methods: { + reset: function() { + var expand = this.$el.firstChild; + var shrink = this.$el.lastChild; + expand.scrollLeft = 1e5; + expand.scrollTop = 1e5; + shrink.scrollLeft = 1e5; + shrink.scrollTop = 1e5; }, - _getLimitXY: function(x, y) { - var outOfBounds = false; - if (x > this.maxX) { - x = this.maxX; - outOfBounds = true; - } else { - if (x < this.minX) { - x = this.minX; - outOfBounds = true; - } + update: function() { + this.size.width = this.$el.offsetWidth; + this.size.height = this.$el.offsetHeight; + this.reset(); + } + }, + render: function(create) { + return create("uni-resize-sensor", { + on: { + "~animationstart": this.update } - if (y > this.maxY) { - y = this.maxY; - outOfBounds = true; - } else { - if (y < this.minY) { - y = this.minY; - outOfBounds = true; + }, [ + create("div", { + on: { + scroll: this.update + } + }, [ + create("div") + ]), + create("div", { + on: { + scroll: this.update } + }, [ + create("div") + ]) + ]); + } +}; +function removeDOCTYPE(html) { + return html.replace(/<\?xml.*\?>\n/, "").replace(/\n/, "").replace(/\n/, ""); +} +function parseAttrs(attrs2) { + return attrs2.reduce(function(pre, attr2) { + let value = attr2.value; + const name = attr2.name; + if (value.match(/ /) && name !== "style") { + value = value.split(" "); + } + if (pre[name]) { + if (Array.isArray(pre[name])) { + pre[name].push(value); + } else { + pre[name] = [pre[name], value]; } - return { - x, - y, - outOfBounds + } else { + pre[name] = value; + } + return pre; + }, {}); +} +function parseHtml(html) { + html = removeDOCTYPE(html); + const stacks = []; + const results = { + node: "root", + children: [] + }; + HTMLParser(html, { + start: function(tag, attrs2, unary) { + const node = { + name: tag }; - }, - setParent: function() { - if (!this.$parent._isMounted) { - return; - } - if (this._FA) { - this._FA.cancel(); + if (attrs2.length !== 0) { + node.attrs = parseAttrs(attrs2); } - if (this._SFA) { - this._SFA.cancel(); + if (unary) { + const parent = stacks[0] || results; + if (!parent.children) { + parent.children = []; + } + parent.children.push(node); + } else { + stacks.unshift(node); } - var scale = this.scale ? this.scaleValueSync : 1; - this._updateOffset(); - this._updateWH(scale); - this._updateBoundary(); - this._translateX = this.xSync + this._scaleOffset.x; - this._translateY = this.ySync + this._scaleOffset.y; - var limitXY = this._getLimitXY(this._translateX, this._translateY); - var x = limitXY.x; - var y = limitXY.y; - this._setTransform(x, y, scale, "", true); - this._updateOldScale(scale); - }, - _updateOffset: function() { - this._offset.x = p(this.$el, this.$parent.$el); - this._offset.y = f(this.$el, this.$parent.$el); - }, - _updateWH: function(scale) { - scale = scale || this._scale; - scale = this._adjustScale(scale); - var rect = this.$el.getBoundingClientRect(); - this.height = rect.height / this._scale; - this.width = rect.width / this._scale; - var height = this.height * scale; - var width = this.width * scale; - this._scaleOffset.x = (width - this.width) / 2; - this._scaleOffset.y = (height - this.height) / 2; - }, - _updateBoundary: function() { - var x = 0 - this._offset.x + this._scaleOffset.x; - var width = this.$parent.width - this.width - this._offset.x - this._scaleOffset.x; - this.minX = Math.min(x, width); - this.maxX = Math.max(x, width); - var y = 0 - this._offset.y + this._scaleOffset.y; - var height = this.$parent.height - this.height - this._offset.y - this._scaleOffset.y; - this.minY = Math.min(y, height); - this.maxY = Math.max(y, height); - }, - _beginScale: function() { - this._isScaling = true; - }, - _endScale: function() { - this._isScaling = false; - this._updateOldScale(this._scale); }, - _setScale: function(scale) { - if (this.scale) { - scale = this._adjustScale(scale); - scale = this._oldScale * scale; - this._beginScale(); - this._updateScale(scale); + end: function(tag) { + const node = stacks.shift(); + if (node.name !== tag) + console.error("invalid state: mismatch end tag"); + if (stacks.length === 0) { + results.children.push(node); + } else { + const parent = stacks[0]; + if (!parent.children) { + parent.children = []; + } + parent.children.push(node); } }, - _updateScale: function(scale, animat) { - var self = this; - if (this.scale) { - scale = this._adjustScale(scale); - this._updateWH(scale); - this._updateBoundary(); - const limitXY = this._getLimitXY(this._translateX, this._translateY); - const x = limitXY.x; - const y = limitXY.y; - if (animat) { - this._animationTo(x, y, scale, "", true, true); - } else { - _requestAnimationFrame(function() { - self._setTransform(x, y, scale, "", true, true); - }); + chars: function(text2) { + const node = { + type: "text", + text: text2 + }; + if (stacks.length === 0) { + results.children.push(node); + } else { + const parent = stacks[0]; + if (!parent.children) { + parent.children = []; } + parent.children.push(node); } }, - _updateOldScale: function(scale) { - this._oldScale = scale; - }, - _adjustScale: function(scale) { - scale = Math.max(0.5, this.scaleMinNumber, scale); - scale = Math.min(10, this.scaleMaxNumber, scale); - return scale; - }, - _animationTo: function(x, y, scale, source, r, o2) { - var self = this; - if (this._FA) { - this._FA.cancel(); + comment: function(text2) { + const node = { + node: "comment", + text: text2 + }; + const parent = stacks[0]; + if (!parent.children) { + parent.children = []; + } + parent.children.push(node); + } + }); + return results.children; +} +const TAGS = { + a: "", + abbr: "", + b: "", + blockquote: "", + br: "", + code: "", + col: ["span", "width"], + colgroup: ["span", "width"], + dd: "", + del: "", + div: "", + dl: "", + dt: "", + em: "", + fieldset: "", + h1: "", + h2: "", + h3: "", + h4: "", + h5: "", + h6: "", + hr: "", + i: "", + img: ["alt", "src", "height", "width"], + ins: "", + label: "", + legend: "", + li: "", + ol: ["start", "type"], + p: "", + q: "", + span: "", + strong: "", + sub: "", + sup: "", + table: ["width"], + tbody: "", + td: ["colspan", "rowspan", "height", "width"], + tfoot: "", + th: ["colspan", "rowspan", "height", "width"], + thead: "", + tr: "", + ul: "" +}; +const CHARS = { + amp: "&", + gt: ">", + lt: "<", + nbsp: " ", + quot: '"', + apos: "'" +}; +function decodeEntities(htmlString) { + return htmlString.replace(/&(([a-zA-Z]+)|(#x{0,1}[\da-zA-Z]+));/gi, function(match, stage) { + if (hasOwn$1(CHARS, stage) && CHARS[stage]) { + return CHARS[stage]; + } + if (/^#[0-9]{1,4}$/.test(stage)) { + return String.fromCharCode(stage.slice(1)); + } + if (/^#x[0-9a-f]{1,4}$/i.test(stage)) { + return String.fromCharCode("0" + stage.slice(1)); + } + const wrap = document.createElement("div"); + wrap.innerHTML = match; + return wrap.innerText || wrap.textContent; + }); +} +function parseNodes(nodes, parentNode) { + nodes.forEach(function(node) { + if (!isPlainObject(node)) { + return; + } + if (!hasOwn$1(node, "type") || node.type === "node") { + if (!(typeof node.name === "string" && node.name)) { + return; } - if (this._SFA) { - this._SFA.cancel(); + const tagName = node.name.toLowerCase(); + if (!hasOwn$1(TAGS, tagName)) { + return; } - if (!this.xMove) { - x = this._translateX; + const elem = document.createElement(tagName); + if (!elem) { + return; } - if (!this.yMove) { - y = this._translateY; + const attrs2 = node.attrs; + if (isPlainObject(attrs2)) { + const tagAttrs = TAGS[tagName] || []; + Object.keys(attrs2).forEach(function(name) { + let value = attrs2[name]; + switch (name) { + case "class": + Array.isArray(value) && (value = value.join(" ")); + case "style": + elem.setAttribute(name, value); + break; + default: + if (tagAttrs.indexOf(name) !== -1) { + elem.setAttribute(name, value); + } + } + }); } - if (!this.scale) { - scale = this._scale; + const children = node.children; + if (Array.isArray(children) && children.length) { + parseNodes(node.children, elem); } - var limitXY = this._getLimitXY(x, y); - x = limitXY.x; - y = limitXY.y; - if (!this.animation) { - this._setTransform(x, y, scale, source, r, o2); - return; + parentNode.appendChild(elem); + } else { + if (node.type === "text" && typeof node.text === "string" && node.text !== "") { + parentNode.appendChild(document.createTextNode(decodeEntities(node.text))); } - this._STD._springX._solution = null; - this._STD._springY._solution = null; - this._STD._springScale._solution = null; - this._STD._springX._endPosition = this._translateX; - this._STD._springY._endPosition = this._translateY; - this._STD._springScale._endPosition = this._scale; - this._STD.setEnd(x, y, scale, 1); - this._SFA = g(this._STD, function() { - var data = self._STD.x(); - var x2 = data.x; - var y2 = data.y; - var scale2 = data.scale; - self._setTransform(x2, y2, scale2, source, r, o2); - }, function() { - self._SFA.cancel(); - }); - }, - _revise: function(source) { - var limitXY = this._getLimitXY(this._translateX, this._translateY); - var x = limitXY.x; - var y = limitXY.y; - var outOfBounds = limitXY.outOfBounds; - if (outOfBounds) { - this._animationTo(x, y, this._scale, source); + } + }); + return parentNode; +} +const _sfc_main$d = { + name: "RichText", + props: { + nodes: { + type: [Array, String], + default: function() { + return []; } - return outOfBounds; - }, - _setTransform: function(x, y, scale, source = "", r, o2) { - if (!(x !== null && x.toString() !== "NaN" && typeof x === "number")) { - x = this._translateX || 0; + } + }, + watch: { + nodes(value) { + this._renderNodes(value); + } + }, + mounted() { + this._renderNodes(this.nodes); + }, + methods: { + _renderNodes(nodes) { + if (typeof nodes === "string") { + nodes = parseHtml(nodes); } - if (!(y !== null && y.toString() !== "NaN" && typeof y === "number")) { - y = this._translateY || 0; + const nodeList = parseNodes(nodes, document.createDocumentFragment()); + this.$el.firstChild.innerHTML = ""; + this.$el.firstChild.appendChild(nodeList); + } + } +}; +const _hoisted_1$7 = /* @__PURE__ */ createVNode("div", null, null, -1); +function _sfc_render$c(_ctx, _cache, $props, $setup, $data, $options) { + return openBlock(), createBlock("uni-rich-text", _ctx.$attrs, [ + _hoisted_1$7 + ], 16); +} +_sfc_main$d.render = _sfc_render$c; +function Friction(e2) { + this._drag = e2; + this._dragLog = Math.log(e2); + this._x = 0; + this._v = 0; + this._startTime = 0; +} +Friction.prototype.set = function(e2, t2) { + this._x = e2; + this._v = t2; + this._startTime = new Date().getTime(); +}; +Friction.prototype.setVelocityByEnd = function(e2) { + this._v = (e2 - this._x) * this._dragLog / (Math.pow(this._drag, 100) - 1); +}; +Friction.prototype.x = function(e2) { + if (e2 === void 0) { + e2 = (new Date().getTime() - this._startTime) / 1e3; + } + var t2; + t2 = e2 === this._dt && this._powDragDt ? this._powDragDt : this._powDragDt = Math.pow(this._drag, e2); + this._dt = e2; + return this._x + this._v * t2 / this._dragLog - this._v / this._dragLog; +}; +Friction.prototype.dx = function(e2) { + if (e2 === void 0) { + e2 = (new Date().getTime() - this._startTime) / 1e3; + } + var t2; + t2 = e2 === this._dt && this._powDragDt ? this._powDragDt : this._powDragDt = Math.pow(this._drag, e2); + this._dt = e2; + return this._v * t2; +}; +Friction.prototype.done = function() { + return Math.abs(this.dx()) < 3; +}; +Friction.prototype.reconfigure = function(e2) { + var t2 = this.x(); + var n = this.dx(); + this._drag = e2; + this._dragLog = Math.log(e2); + this.set(t2, n); +}; +Friction.prototype.configuration = function() { + var e2 = this; + return [ + { + label: "Friction", + read: function() { + return e2._drag; + }, + write: function(t2) { + e2.reconfigure(t2); + }, + min: 1e-3, + max: 0.1, + step: 1e-3 + } + ]; +}; +function o(e2, t2, n) { + return e2 > t2 - n && e2 < t2 + n; +} +function a(e2, t2) { + return o(e2, 0, t2); +} +function Spring(e2, t2, n) { + this._m = e2; + this._k = t2; + this._c = n; + this._solution = null; + this._endPosition = 0; + this._startTime = 0; +} +Spring.prototype._solve = function(e2, t2) { + var n = this._c; + var i = this._m; + var r = this._k; + var o2 = n * n - 4 * i * r; + if (o2 === 0) { + const a3 = -n / (2 * i); + const s2 = e2; + const l2 = t2 / (a3 * e2); + return { + x: function(e3) { + return (s2 + l2 * e3) * Math.pow(Math.E, a3 * e3); + }, + dx: function(e3) { + var t3 = Math.pow(Math.E, a3 * e3); + return a3 * (s2 + l2 * e3) * t3 + l2 * t3; } - x = Number(x.toFixed(1)); - y = Number(y.toFixed(1)); - scale = Number(scale.toFixed(1)); - if (!(this._translateX === x && this._translateY === y)) { - if (!r) { - this.$trigger("change", {}, { - x: v(x, this._scaleOffset.x), - y: v(y, this._scaleOffset.y), - source - }); + }; + } + if (o2 > 0) { + const c = (-n - Math.sqrt(o2)) / (2 * i); + const u = (-n + Math.sqrt(o2)) / (2 * i); + const l2 = (t2 - c * e2) / (u - c); + const s2 = e2 - l2; + return { + x: function(e3) { + let t3; + let n2; + if (e3 === this._t) { + t3 = this._powER1T; + n2 = this._powER2T; + } + this._t = e3; + if (!t3) { + t3 = this._powER1T = Math.pow(Math.E, c * e3); + } + if (!n2) { + n2 = this._powER2T = Math.pow(Math.E, u * e3); + } + return s2 * t3 + l2 * n2; + }, + dx: function(e3) { + let t3; + let n2; + if (e3 === this._t) { + t3 = this._powER1T; + n2 = this._powER2T; } + this._t = e3; + if (!t3) { + t3 = this._powER1T = Math.pow(Math.E, c * e3); + } + if (!n2) { + n2 = this._powER2T = Math.pow(Math.E, u * e3); + } + return s2 * c * t3 + l2 * u * n2; } - if (!this.scale) { - scale = this._scale; + }; + } + var d = Math.sqrt(4 * i * r - n * n) / (2 * i); + var a2 = -n / 2 * i; + var s = e2; + var l = (t2 - a2 * e2) / d; + return { + x: function(e3) { + return Math.pow(Math.E, a2 * e3) * (s * Math.cos(d * e3) + l * Math.sin(d * e3)); + }, + dx: function(e3) { + var t3 = Math.pow(Math.E, a2 * e3); + var n2 = Math.cos(d * e3); + var i2 = Math.sin(d * e3); + return t3 * (l * d * n2 - s * d * i2) + a2 * t3 * (l * i2 + s * n2); + } + }; +}; +Spring.prototype.x = function(e2) { + if (e2 === void 0) { + e2 = (new Date().getTime() - this._startTime) / 1e3; + } + return this._solution ? this._endPosition + this._solution.x(e2) : 0; +}; +Spring.prototype.dx = function(e2) { + if (e2 === void 0) { + e2 = (new Date().getTime() - this._startTime) / 1e3; + } + return this._solution ? this._solution.dx(e2) : 0; +}; +Spring.prototype.setEnd = function(e2, t2, n) { + if (!n) { + n = new Date().getTime(); + } + if (e2 !== this._endPosition || !a(t2, 0.4)) { + t2 = t2 || 0; + var i = this._endPosition; + if (this._solution) { + if (a(t2, 0.4)) { + t2 = this._solution.dx((n - this._startTime) / 1e3); } - scale = this._adjustScale(scale); - scale = +scale.toFixed(3); - if (o2 && scale !== this._scale) { - this.$trigger("scale", {}, { - x, - y, - scale - }); + i = this._solution.x((n - this._startTime) / 1e3); + if (a(t2, 0.4)) { + t2 = 0; } - var transform = "translateX(" + x + "px) translateY(" + y + "px) translateZ(0px) scale(" + scale + ")"; - this.$el.style.transform = transform; - this.$el.style.webkitTransform = transform; - this._translateX = x; - this._translateY = y; - this._scale = scale; + if (a(i, 0.4)) { + i = 0; + } + i += this._endPosition; + } + if (!(this._solution && a(i - e2, 0.4) && a(t2, 0.4))) { + this._endPosition = e2; + this._solution = this._solve(i - this._endPosition, t2); + this._startTime = n; } } }; -function _sfc_render$h(_ctx, _cache, $props, $setup, $data, $options) { - const _component_v_uni_resize_sensor = resolveComponent("v-uni-resize-sensor"); - return openBlock(), createBlock("uni-movable-view", _ctx.$attrs, [ - createVNode(_component_v_uni_resize_sensor, {onResize: $options.setParent}, null, 8, ["onResize"]), - renderSlot(_ctx.$slots, "default") - ], 16); -} -_sfc_main$j.render = _sfc_render$h; -var index_vue_vue_type_style_index_0_lang$c = "\nuni-navigator {\r\n height: auto;\r\n width: auto;\r\n display: block;\r\n cursor: pointer;\n}\nuni-navigator[hidden] {\r\n display: none;\n}\n.navigator-hover {\r\n background-color: rgba(0, 0, 0, 0.1);\r\n opacity: 0.7;\n}\r\n"; -const OPEN_TYPES = ["navigate", "redirect", "switchTab", "reLaunch", "navigateBack"]; -const _sfc_main$i = { - name: "Navigator", - mixins: [hover], - props: { - hoverClass: { - type: String, - default: "navigator-hover" - }, - url: { - type: String, - default: "" - }, - openType: { - type: String, - default: "navigate", - validator(value) { - return ~OPEN_TYPES.indexOf(value); - } - }, - delta: { - type: Number, - default: 1 +Spring.prototype.snap = function(e2) { + this._startTime = new Date().getTime(); + this._endPosition = e2; + this._solution = { + x: function() { + return 0; }, - hoverStartTime: { - type: [Number, String], - default: 20 + dx: function() { + return 0; + } + }; +}; +Spring.prototype.done = function(e2) { + if (!e2) { + e2 = new Date().getTime(); + } + return o(this.x(), this._endPosition, 0.4) && a(this.dx(), 0.4); +}; +Spring.prototype.reconfigure = function(e2, t2, n) { + this._m = e2; + this._k = t2; + this._c = n; + if (!this.done()) { + this._solution = this._solve(this.x() - this._endPosition, this.dx()); + this._startTime = new Date().getTime(); + } +}; +Spring.prototype.springConstant = function() { + return this._k; +}; +Spring.prototype.damping = function() { + return this._c; +}; +Spring.prototype.configuration = function() { + function e2(e3, t3) { + e3.reconfigure(1, t3, e3.damping()); + } + function t2(e3, t3) { + e3.reconfigure(1, e3.springConstant(), t3); + } + return [ + { + label: "Spring Constant", + read: this.springConstant.bind(this), + write: e2.bind(this, this), + min: 100, + max: 1e3 }, - hoverStayTime: { - type: [Number, String], - default: 600 + { + label: "Damping", + read: this.damping.bind(this), + write: t2.bind(this, this), + min: 1, + max: 500 } - }, - methods: { - _onClick($event) { - if (this.openType !== "navigateBack" && !this.url) { - console.error(" should have url attribute when using navigateTo, redirectTo, reLaunch or switchTab"); - return; - } - switch (this.openType) { - case "navigate": - uni.navigateTo({ - url: this.url - }); - break; - case "redirect": - uni.redirectTo({ - url: this.url - }); - break; - case "switchTab": - uni.switchTab({ - url: this.url - }); - break; - case "reLaunch": - uni.reLaunch({ - url: this.url - }); - break; - case "navigateBack": - uni.navigateBack({ - delta: this.delta - }); - break; - } + ]; +}; +function Scroll(extent, friction, spring) { + this._extent = extent; + this._friction = friction || new Friction(0.01); + this._spring = spring || new Spring(1, 90, 20); + this._startTime = 0; + this._springing = false; + this._springOffset = 0; +} +Scroll.prototype.snap = function(e2, t2) { + this._springOffset = 0; + this._springing = true; + this._spring.snap(e2); + this._spring.setEnd(t2); +}; +Scroll.prototype.set = function(e2, t2) { + this._friction.set(e2, t2); + if (e2 > 0 && t2 >= 0) { + this._springOffset = 0; + this._springing = true; + this._spring.snap(e2); + this._spring.setEnd(0); + } else { + if (e2 < -this._extent && t2 <= 0) { + this._springOffset = 0; + this._springing = true; + this._spring.snap(e2); + this._spring.setEnd(-this._extent); + } else { + this._springing = false; } } + this._startTime = new Date().getTime(); }; -function _sfc_render$g(_ctx, _cache, $props, $setup, $data, $options) { - return $props.hoverClass && $props.hoverClass !== "none" ? (openBlock(), createBlock("uni-navigator", mergeProps({ - key: 0, - class: [_ctx.hovering ? $props.hoverClass : ""], - onTouchstart: _cache[1] || (_cache[1] = (...args) => _ctx._hoverTouchStart && _ctx._hoverTouchStart(...args)), - onTouchend: _cache[2] || (_cache[2] = (...args) => _ctx._hoverTouchEnd && _ctx._hoverTouchEnd(...args)), - onTouchcancel: _cache[3] || (_cache[3] = (...args) => _ctx._hoverTouchCancel && _ctx._hoverTouchCancel(...args)), - onClick: _cache[4] || (_cache[4] = (...args) => $options._onClick && $options._onClick(...args)) - }, _ctx.$attrs), [ - renderSlot(_ctx.$slots, "default") - ], 16)) : (openBlock(), createBlock("uni-navigator", mergeProps({ - key: 1, - onClick: _cache[5] || (_cache[5] = (...args) => $options._onClick && $options._onClick(...args)) - }, _ctx.$attrs), [ - renderSlot(_ctx.$slots, "default") - ], 16)); -} -_sfc_main$i.render = _sfc_render$g; -const VALUES = { - activeColor: "#007AFF", - backgroundColor: "#EBEBEB", - activeMode: "backwards" +Scroll.prototype.x = function(e2) { + if (!this._startTime) { + return 0; + } + if (!e2) { + e2 = (new Date().getTime() - this._startTime) / 1e3; + } + if (this._springing) { + return this._spring.x() + this._springOffset; + } + var t2 = this._friction.x(e2); + var n = this.dx(e2); + if (t2 > 0 && n >= 0 || t2 < -this._extent && n <= 0) { + this._springing = true; + this._spring.setEnd(0, n); + if (t2 < -this._extent) { + this._springOffset = -this._extent; + } else { + this._springOffset = 0; + } + t2 = this._spring.x() + this._springOffset; + } + return t2; }; -const _sfc_main$h = { - name: "Progress", - props: { - percent: { - type: [Number, String], - default: 0, - validator(value) { - return !isNaN(parseFloat(value, 10)); - } - }, - showInfo: { - type: [Boolean, String], - default: false - }, - strokeWidth: { - type: [Number, String], - default: 6, - validator(value) { - return !isNaN(parseFloat(value, 10)); +Scroll.prototype.dx = function(e2) { + var t2 = 0; + t2 = this._lastTime === e2 ? this._lastDx : this._springing ? this._spring.dx(e2) : this._friction.dx(e2); + this._lastTime = e2; + this._lastDx = t2; + return t2; +}; +Scroll.prototype.done = function() { + return this._springing ? this._spring.done() : this._friction.done(); +}; +Scroll.prototype.setVelocityByEnd = function(e2) { + this._friction.setVelocityByEnd(e2); +}; +Scroll.prototype.configuration = function() { + var e2 = this._friction.configuration(); + e2.push.apply(e2, this._spring.configuration()); + return e2; +}; +function i$1(scroll, t2, n) { + function i(t3, scroll2, r2, o3) { + if (!t3 || !t3.cancelled) { + r2(scroll2); + var a2 = scroll2.done(); + if (!a2) { + if (!t3.cancelled) { + t3.id = requestAnimationFrame(i.bind(null, t3, scroll2, r2, o3)); + } } - }, - color: { - type: String, - default: VALUES.activeColor - }, - activeColor: { - type: String, - default: VALUES.activeColor - }, - backgroundColor: { - type: String, - default: VALUES.backgroundColor - }, - active: { - type: [Boolean, String], - default: false - }, - activeMode: { - type: String, - default: VALUES.activeMode - } - }, - data() { - return { - currentPercent: 0, - strokeTimer: 0, - lastPercent: 0 - }; - }, - computed: { - outerBarStyle() { - return `background-color: ${this.backgroundColor}; height: ${this.strokeWidth}px;`; - }, - innerBarStyle() { - let backgroundColor = ""; - if (this.color !== VALUES.activeColor && this.activeColor === VALUES.activeColor) { - backgroundColor = this.color; - } else { - backgroundColor = this.activeColor; + if (a2 && o3) { + o3(scroll2); } - return `width: ${this.currentPercent}%;background-color: ${backgroundColor}`; - }, - realPercent() { - let realValue = parseFloat(this.percent, 10); - realValue < 0 && (realValue = 0); - realValue > 100 && (realValue = 100); - return realValue; } - }, - watch: { - realPercent(newValue, oldValue) { - this.strokeTimer && clearInterval(this.strokeTimer); - this.lastPercent = oldValue || 0; - this._activeAnimation(); + } + function r(scroll2) { + if (scroll2 && scroll2.id) { + cancelAnimationFrame(scroll2.id); } - }, - created() { - this._activeAnimation(); - }, - methods: { - _activeAnimation() { - if (this.active) { - this.currentPercent = this.activeMode === VALUES.activeMode ? 0 : this.lastPercent; - this.strokeTimer = setInterval(() => { - if (this.currentPercent + 1 > this.realPercent) { - this.currentPercent = this.realPercent; - this.strokeTimer && clearInterval(this.strokeTimer); - } else { - this.currentPercent += 1; - } - }, 30); - } else { - this.currentPercent = this.realPercent; - } + if (scroll2) { + scroll2.cancelled = true; } } -}; -const _hoisted_1$9 = { - key: 0, - class: "uni-progress-info" -}; -function _sfc_render$f(_ctx, _cache, $props, $setup, $data, $options) { - return openBlock(), createBlock("uni-progress", mergeProps({class: "uni-progress"}, _ctx.$attrs), [ - createVNode("div", { - style: $options.outerBarStyle, - class: "uni-progress-bar" - }, [ - createVNode("div", { - style: $options.innerBarStyle, - class: "uni-progress-inner-bar" - }, null, 4) - ], 4), - $props.showInfo ? (openBlock(), createBlock("p", _hoisted_1$9, toDisplayString($data.currentPercent) + "% ", 1)) : createCommentVNode("", true) - ], 16); + var o2 = { + id: 0, + cancelled: false + }; + i(o2, scroll, t2, n); + return { + cancel: r.bind(null, o2), + model: scroll + }; } -_sfc_main$h.render = _sfc_render$f; -var index_vue_vue_type_style_index_0_lang$b = '\nuni-radio {\r\n -webkit-tap-highlight-color: transparent;\r\n display: inline-block;\r\n cursor: pointer;\n}\nuni-radio[hidden] {\r\n display: none;\n}\nuni-radio[disabled] {\r\n cursor: not-allowed;\n}\nuni-radio .uni-radio-wrapper {\r\n display: -webkit-inline-flex;\r\n display: inline-flex;\r\n -webkit-align-items: center;\r\n align-items: center;\r\n vertical-align: middle;\n}\nuni-radio .uni-radio-input {\r\n -webkit-appearance: none;\r\n appearance: none;\r\n margin-right: 5px;\r\n outline: 0;\r\n border: 1px solid #D1D1D1;\r\n background-color: #ffffff;\r\n border-radius: 50%;\r\n width: 22px;\r\n height: 22px;\r\n position: relative;\n}\nuni-radio:not([disabled]) .uni-radio-input:hover {\r\n border-color: #007aff;\n}\nuni-radio .uni-radio-input.uni-radio-input-checked:before {\r\n font: normal normal normal 14px/1 "uni";\r\n content: "\\EA08";\r\n color: #ffffff;\r\n font-size: 18px;\r\n position: absolute;\r\n top: 50%;\r\n left: 50%;\r\n transform: translate(-50%, -48%) scale(0.73);\r\n -webkit-transform: translate(-50%, -48%) scale(0.73);\n}\nuni-radio .uni-radio-input.uni-radio-input-disabled {\r\n background-color: #E1E1E1;\r\n border-color: #D1D1D1;\n}\nuni-radio .uni-radio-input.uni-radio-input-disabled:before {\r\n color: #ADADAD;\n}\nuni-radio-group {\r\n display: block;\n}\r\n'; -const _sfc_main$g = { - name: "Radio", - mixins: [emitter, listeners], - props: { - checked: { - type: [Boolean, String], - default: false - }, - id: { - type: String, - default: "" - }, - disabled: { - type: [Boolean, String], - default: false - }, - color: { - type: String, - default: "#007AFF" - }, - value: { - type: String, - default: "" +function Scroller(element, options) { + options = options || {}; + this._element = element; + this._options = options; + this._enableSnap = options.enableSnap || false; + this._itemSize = options.itemSize || 0; + this._enableX = options.enableX || false; + this._enableY = options.enableY || false; + this._shouldDispatchScrollEvent = !!options.onScroll; + if (this._enableX) { + this._extent = (options.scrollWidth || this._element.offsetWidth) - this._element.parentElement.offsetWidth; + this._scrollWidth = options.scrollWidth; + } else { + this._extent = (options.scrollHeight || this._element.offsetHeight) - this._element.parentElement.offsetHeight; + this._scrollHeight = options.scrollHeight; + } + this._position = 0; + this._scroll = new Scroll(this._extent, options.friction, options.spring); + this._onTransitionEnd = this.onTransitionEnd.bind(this); + this.updatePosition(); +} +Scroller.prototype.onTouchStart = function() { + this._startPosition = this._position; + this._lastChangePos = this._startPosition; + if (this._startPosition > 0) { + this._startPosition /= 0.5; + } else { + if (this._startPosition < -this._extent) { + this._startPosition = (this._startPosition + this._extent) / 0.5 - this._extent; } - }, - data() { - return { - radioChecked: this.checked, - radioValue: this.value - }; - }, - computed: { - checkedStyle() { - return `background-color: ${this.color};border-color: ${this.color};`; + } + if (this._animation) { + this._animation.cancel(); + this._scrolling = false; + } + this.updatePosition(); +}; +Scroller.prototype.onTouchMove = function(x, y) { + var startPosition = this._startPosition; + if (this._enableX) { + startPosition += x; + } else if (this._enableY) { + startPosition += y; + } + if (startPosition > 0) { + startPosition *= 0.5; + } else if (startPosition < -this._extent) { + startPosition = 0.5 * (startPosition + this._extent) - this._extent; + } + this._position = startPosition; + this.updatePosition(); + this.dispatchScroll(); +}; +Scroller.prototype.onTouchEnd = function(e2, r, o2) { + if (this._enableSnap && this._position > -this._extent && this._position < 0) { + if (this._enableY && (Math.abs(r) < this._itemSize && Math.abs(o2.y) < 300 || Math.abs(o2.y) < 150)) { + this.snap(); + return; } - }, - watch: { - checked(val) { - this.radioChecked = val; - }, - value(val) { - this.radioValue = val; + if (this._enableX && (Math.abs(e2) < this._itemSize && Math.abs(o2.x) < 300 || Math.abs(o2.x) < 150)) { + this.snap(); + return; } - }, - listeners: { - "label-click": "_onClick", - "@label-click": "_onClick" - }, - created() { - this.$dispatch("RadioGroup", "uni-radio-group-update", { - type: "add", - vm: this - }); - this.$dispatch("Form", "uni-form-group-update", { - type: "add", - vm: this - }); - }, - beforeDestroy() { - this.$dispatch("RadioGroup", "uni-radio-group-update", { - type: "remove", - vm: this - }); - this.$dispatch("Form", "uni-form-group-update", { - type: "remove", - vm: this - }); - }, - methods: { - _onClick($event) { - if (this.disabled || this.radioChecked) { - return; - } - this.radioChecked = true; - this.$dispatch("RadioGroup", "uni-radio-change", $event, this); - }, - _resetFormData() { - this.radioChecked = this.min; + } + if (this._enableX) { + this._scroll.set(this._position, o2.x); + } else if (this._enableY) { + this._scroll.set(this._position, o2.y); + } + if (this._enableSnap) { + var s = this._scroll._friction.x(100); + var l = s % this._itemSize; + var c = Math.abs(l) > this._itemSize / 2 ? s - (this._itemSize - Math.abs(l)) : s - l; + if (c <= 0 && c >= -this._extent) { + this._scroll.setVelocityByEnd(c); } } -}; -const _hoisted_1$8 = {class: "uni-radio-wrapper"}; -function _sfc_render$e(_ctx, _cache, $props, $setup, $data, $options) { - return openBlock(), createBlock("uni-radio", mergeProps({disabled: $props.disabled}, _ctx.$attrs, { - onClick: _cache[1] || (_cache[1] = (...args) => $options._onClick && $options._onClick(...args)) - }), [ - createVNode("div", _hoisted_1$8, [ - createVNode("div", { - class: [$data.radioChecked ? "uni-radio-input-checked" : "", "uni-radio-input"], - style: $data.radioChecked ? $options.checkedStyle : "" - }, null, 6), - renderSlot(_ctx.$slots, "default") - ]) - ], 16, ["disabled"]); -} -_sfc_main$g.render = _sfc_render$e; -var index_vue_vue_type_style_index_0_lang$a = "\nuni-radio-group[hidden] {\r\n display: none;\n}\r\n"; -const _sfc_main$f = { - name: "RadioGroup", - mixins: [emitter, listeners], - props: { - name: { - type: String, - default: "" + this._lastTime = Date.now(); + this._lastDelay = 0; + this._scrolling = true; + this._lastChangePos = this._position; + this._lastIdx = Math.floor(Math.abs(this._position / this._itemSize)); + this._animation = i$1(this._scroll, () => { + var e3 = Date.now(); + var i = (e3 - this._scroll._startTime) / 1e3; + var r2 = this._scroll.x(i); + this._position = r2; + this.updatePosition(); + var o3 = this._scroll.dx(i); + if (this._shouldDispatchScrollEvent && e3 - this._lastTime > this._lastDelay) { + this.dispatchScroll(); + this._lastDelay = Math.abs(2e3 / o3); + this._lastTime = e3; } - }, - data() { - return { - radioList: [] - }; - }, - listeners: { - "@radio-change": "_changeHandler", - "@radio-group-update": "_radioGroupUpdateHandler" - }, - mounted() { - this._resetRadioGroupValue(this.radioList.length - 1); - }, - created() { - this.$dispatch("Form", "uni-form-group-update", { - type: "add", - vm: this - }); - }, - beforeDestroy() { - this.$dispatch("Form", "uni-form-group-update", { - type: "remove", - vm: this - }); - }, - methods: { - _changeHandler($event, vm) { - const index2 = this.radioList.indexOf(vm); - this._resetRadioGroupValue(index2, true); - this.$trigger("change", $event, { - value: vm.radioValue - }); - }, - _radioGroupUpdateHandler($event) { - if ($event.type === "add") { - this.radioList.push($event.vm); - } else { - const index2 = this.radioList.indexOf($event.vm); - this.radioList.splice(index2, 1); + }, () => { + if (this._enableSnap) { + if (c <= 0 && c >= -this._extent) { + this._position = c; + this.updatePosition(); } - }, - _resetRadioGroupValue(key, change) { - this.radioList.forEach((value, index2) => { - if (index2 === key) { - return; - } - if (change) { - this.radioList[index2].radioChecked = false; - } else { - this.radioList.forEach((v2, i2) => { - if (index2 >= i2) { - return; - } - if (this.radioList[i2].radioChecked) { - this.radioList[index2].radioChecked = false; - } - }); - } - }); - }, - _getFormData() { - const data = {}; - if (this.name !== "") { - let value = ""; - this.radioList.forEach((vm) => { - if (vm.radioChecked) { - value = vm.value; - } - }); - data.value = value; - data.key = this.name; + if (typeof this._options.onSnap === "function") { + this._options.onSnap(Math.floor(Math.abs(this._position) / this._itemSize)); } - return data; + } + if (this._shouldDispatchScrollEvent) { + this.dispatchScroll(); + } + this._scrolling = false; + }); +}; +Scroller.prototype.onTransitionEnd = function() { + this._element.style.transition = ""; + this._element.style.webkitTransition = ""; + this._element.removeEventListener("transitionend", this._onTransitionEnd); + this._element.removeEventListener("webkitTransitionEnd", this._onTransitionEnd); + if (this._snapping) { + this._snapping = false; + } + this.dispatchScroll(); +}; +Scroller.prototype.snap = function() { + var e2 = this._itemSize; + var t2 = this._position % e2; + var i = Math.abs(t2) > this._itemSize / 2 ? this._position - (e2 - Math.abs(t2)) : this._position - t2; + if (this._position !== i) { + this._snapping = true; + this.scrollTo(-i); + if (typeof this._options.onSnap === "function") { + this._options.onSnap(Math.floor(Math.abs(this._position) / this._itemSize)); } } }; -function _sfc_render$d(_ctx, _cache, $props, $setup, $data, $options) { - return openBlock(), createBlock("uni-radio-group", _ctx.$attrs, [ - renderSlot(_ctx.$slots, "default") - ], 16); -} -_sfc_main$f.render = _sfc_render$d; -var index_vue_vue_type_style_index_0_lang$9 = "\n@keyframes once-show {\nfrom {\n top: 0;\n}\n}\nuni-resize-sensor,\nuni-resize-sensor > div {\n position: absolute;\n left: 0;\n top: 0;\n right: 0;\n bottom: 0;\n overflow: hidden;\n}\nuni-resize-sensor {\n display: block;\n z-index: -1;\n visibility: hidden;\n animation: once-show 1ms;\n}\nuni-resize-sensor > div > div {\n position: absolute;\n left: 0;\n top: 0;\n}\nuni-resize-sensor > div:first-child > div {\n width: 100000px;\n height: 100000px;\n}\nuni-resize-sensor > div:last-child > div {\n width: 200%;\n height: 200%;\n}\n"; -const _sfc_main$e = { - name: "ResizeSensor", - props: { - initial: { - type: [Boolean, String], - default: false +Scroller.prototype.scrollTo = function(e2, t2) { + if (this._animation) { + this._animation.cancel(); + this._scrolling = false; + } + if (typeof e2 === "number") { + this._position = -e2; + } + if (this._position < -this._extent) { + this._position = -this._extent; + } else { + if (this._position > 0) { + this._position = 0; } - }, - data: function() { - return { - size: { - width: -1, - height: -1 + } + this._element.style.transition = "transform " + (t2 || 0.2) + "s ease-out"; + this._element.style.webkitTransition = "-webkit-transform " + (t2 || 0.2) + "s ease-out"; + this.updatePosition(); + this._element.addEventListener("transitionend", this._onTransitionEnd); + this._element.addEventListener("webkitTransitionEnd", this._onTransitionEnd); +}; +Scroller.prototype.dispatchScroll = function() { + if (typeof this._options.onScroll === "function" && Math.round(this._lastPos) !== Math.round(this._position)) { + this._lastPos = this._position; + var e2 = { + target: { + scrollLeft: this._enableX ? -this._position : 0, + scrollTop: this._enableY ? -this._position : 0, + scrollHeight: this._scrollHeight || this._element.offsetHeight, + scrollWidth: this._scrollWidth || this._element.offsetWidth, + offsetHeight: this._element.parentElement.offsetHeight, + offsetWidth: this._element.parentElement.offsetWidth } }; - }, - watch: { - size: { - deep: true, - handler: function(size) { - this.$emit("resize", Object.assign({}, size)); - } - } - }, - mounted: function() { - if (this.initial === true) { - this.$nextTick(this.update); + this._options.onScroll(e2); + } +}; +Scroller.prototype.update = function(e2, t2, n) { + var i = 0; + var r = this._position; + if (this._enableX) { + i = this._element.childNodes.length ? (t2 || this._element.offsetWidth) - this._element.parentElement.offsetWidth : 0; + this._scrollWidth = t2; + } else { + i = this._element.childNodes.length ? (t2 || this._element.offsetHeight) - this._element.parentElement.offsetHeight : 0; + this._scrollHeight = t2; + } + if (typeof e2 === "number") { + this._position = -e2; + } + if (this._position < -i) { + this._position = -i; + } else { + if (this._position > 0) { + this._position = 0; } - if (this.$el.offsetParent !== this.$el.parentNode) { - this.$el.parentNode.style.position = "relative"; + } + this._itemSize = n || this._itemSize; + this.updatePosition(); + if (r !== this._position) { + this.dispatchScroll(); + if (typeof this._options.onSnap === "function") { + this._options.onSnap(Math.floor(Math.abs(this._position) / this._itemSize)); } - if (!("AnimationEvent" in window)) { - this.reset(); + } + this._extent = i; + this._scroll._extent = i; +}; +Scroller.prototype.updatePosition = function() { + var transform = ""; + if (this._enableX) { + transform = "translateX(" + this._position + "px) translateZ(0)"; + } else { + if (this._enableY) { + transform = "translateY(" + this._position + "px) translateZ(0)"; } - }, + } + this._element.style.webkitTransform = transform; + this._element.style.transform = transform; +}; +Scroller.prototype.isScrolling = function() { + return this._scrolling || this._snapping; +}; +var scroller = { methods: { - reset: function() { - var expand = this.$el.firstChild; - var shrink = this.$el.lastChild; - expand.scrollLeft = 1e5; - expand.scrollTop = 1e5; - shrink.scrollLeft = 1e5; - shrink.scrollTop = 1e5; + initScroller: function(element, options) { + this._touchInfo = { + trackingID: -1, + maxDy: 0, + maxDx: 0 + }; + this._scroller = new Scroller(element, options); + this.__handleTouchStart = this._handleTouchStart.bind(this); + this.__handleTouchMove = this._handleTouchMove.bind(this); + this.__handleTouchEnd = this._handleTouchEnd.bind(this); + this._initedScroller = true; }, - update: function() { - this.size.width = this.$el.offsetWidth; - this.size.height = this.$el.offsetHeight; - this.reset(); - } - }, - render: function(create) { - return create("uni-resize-sensor", { - on: { - "~animationstart": this.update - } - }, [ - create("div", { - on: { - scroll: this.update + _findDelta: function(event2) { + var touchInfo = this._touchInfo; + return event2.detail.state === "move" || event2.detail.state === "end" ? { + x: event2.detail.dx, + y: event2.detail.dy + } : { + x: event2.screenX - touchInfo.x, + y: event2.screenY - touchInfo.y + }; + }, + _handleTouchStart: function(e2) { + var t2 = this._touchInfo; + var n = this._scroller; + if (n) { + if (e2.detail.state === "start") { + t2.trackingID = "touch"; + t2.x = e2.detail.x; + t2.y = e2.detail.y; + } else { + t2.trackingID = "mouse"; + t2.x = e2.screenX; + t2.y = e2.screenY; } - }, [ - create("div") - ]), - create("div", { - on: { - scroll: this.update + t2.maxDx = 0; + t2.maxDy = 0; + t2.historyX = [0]; + t2.historyY = [0]; + t2.historyTime = [e2.detail.timeStamp]; + t2.listener = n; + if (n.onTouchStart) { + n.onTouchStart(); } - }, [ - create("div") - ]) - ]); - } -}; -function removeDOCTYPE(html) { - return html.replace(/<\?xml.*\?>\n/, "").replace(/\n/, "").replace(/\n/, ""); -} -function parseAttrs(attrs2) { - return attrs2.reduce(function(pre, attr2) { - let value = attr2.value; - const name = attr2.name; - if (value.match(/ /) && name !== "style") { - value = value.split(" "); - } - if (pre[name]) { - if (Array.isArray(pre[name])) { - pre[name].push(value); - } else { - pre[name] = [pre[name], value]; + event.preventDefault(); } - } else { - pre[name] = value; - } - return pre; - }, {}); -} -function parseHtml(html) { - html = removeDOCTYPE(html); - const stacks = []; - const results = { - node: "root", - children: [] - }; - HTMLParser(html, { - start: function(tag, attrs2, unary) { - const node = { - name: tag - }; - if (attrs2.length !== 0) { - node.attrs = parseAttrs(attrs2); + }, + _handleTouchMove: function(event2) { + var touchInfo = this._touchInfo; + if (touchInfo.trackingID !== -1) { + event2.preventDefault(); + var delta = this._findDelta(event2); + if (delta) { + for (touchInfo.maxDy = Math.max(touchInfo.maxDy, Math.abs(delta.y)), touchInfo.maxDx = Math.max(touchInfo.maxDx, Math.abs(delta.x)), touchInfo.historyX.push(delta.x), touchInfo.historyY.push(delta.y), touchInfo.historyTime.push(event2.detail.timeStamp); touchInfo.historyTime.length > 10; ) { + touchInfo.historyTime.shift(); + touchInfo.historyX.shift(); + touchInfo.historyY.shift(); + } + if (touchInfo.listener && touchInfo.listener.onTouchMove) { + touchInfo.listener.onTouchMove(delta.x, delta.y, event2.detail.timeStamp); + } + } } - if (unary) { - const parent = stacks[0] || results; - if (!parent.children) { - parent.children = []; + }, + _handleTouchEnd: function(event2) { + var touchInfo = this._touchInfo; + if (touchInfo.trackingID !== -1) { + event2.preventDefault(); + var delta = this._findDelta(event2); + if (delta) { + var listener = touchInfo.listener; + touchInfo.trackingID = -1; + touchInfo.listener = null; + var r = touchInfo.historyTime.length; + var o2 = { + x: 0, + y: 0 + }; + if (r > 2) { + for (var a2 = touchInfo.historyTime.length - 1, s = touchInfo.historyTime[a2], l = touchInfo.historyX[a2], c = touchInfo.historyY[a2]; a2 > 0; ) { + a2--; + var u = touchInfo.historyTime[a2]; + var d = s - u; + if (d > 30 && d < 50) { + o2.x = (l - touchInfo.historyX[a2]) / (d / 1e3); + o2.y = (c - touchInfo.historyY[a2]) / (d / 1e3); + break; + } + } + } + touchInfo.historyTime = []; + touchInfo.historyX = []; + touchInfo.historyY = []; + if (listener && listener.onTouchEnd) { + listener.onTouchEnd(delta.x, delta.y, o2); + } } - parent.children.push(node); - } else { - stacks.unshift(node); } + } + } +}; +var index_vue_vue_type_style_index_0_lang$8 = "\nuni-scroll-view {\n display: block;\n width: 100%;\n}\nuni-scroll-view[hidden] {\n display: none;\n}\n.uni-scroll-view {\n position: relative;\n -webkit-overflow-scrolling: touch;\n width: 100%;\n /* display: flex; \u65F6\u5728\u5B89\u5353\u4E0B\u4F1A\u5BFC\u81F4scrollWidth\u548CoffsetWidth\u4E00\u6837 */\n height: 100%;\n max-height: inherit;\n}\n.uni-scroll-view-content {\n width: 100%;\n height: 100%;\n}\n.uni-scroll-view-refresher {\n position: relative;\n overflow: hidden;\n}\n.uni-scroll-view-refresh {\n position: absolute;\n top: 0;\n left: 0;\n right: 0;\n bottom: 0;\n display: flex;\n flex-direction: row;\n justify-content: center;\n align-items: center;\n}\n.uni-scroll-view-refresh-inner {\n display: flex;\n align-items: center;\n justify-content: center;\n line-height: 0;\n width: 40px;\n height: 40px;\n border-radius: 50%;\n background-color: #fff;\n box-shadow: 0 1px 6px rgba(0, 0, 0, 0.117647),\n 0 1px 4px rgba(0, 0, 0, 0.117647);\n}\n.uni-scroll-view-refresh__spinner {\n transform-origin: center center;\n animation: uni-scroll-view-refresh-rotate 2s linear infinite;\n}\n.uni-scroll-view-refresh__spinner > circle {\n stroke: currentColor;\n stroke-linecap: round;\n animation: uni-scroll-view-refresh-dash 2s linear infinite;\n}\n@keyframes uni-scroll-view-refresh-rotate {\n0% {\n transform: rotate(0deg);\n}\n100% {\n transform: rotate(360deg);\n}\n}\n@keyframes uni-scroll-view-refresh-dash {\n0% {\n stroke-dasharray: 1, 200;\n stroke-dashoffset: 0;\n}\n50% {\n stroke-dasharray: 89, 200;\n stroke-dashoffset: -35px;\n}\n100% {\n stroke-dasharray: 89, 200;\n stroke-dashoffset: -124px;\n}\n}\n"; +const _sfc_main$c = { + name: "ScrollView", + mixins: [scroller], + props: { + scrollX: { + type: [Boolean, String], + default: false }, - end: function(tag) { - const node = stacks.shift(); - if (node.name !== tag) - console.error("invalid state: mismatch end tag"); - if (stacks.length === 0) { - results.children.push(node); - } else { - const parent = stacks[0]; - if (!parent.children) { - parent.children = []; - } - parent.children.push(node); - } + scrollY: { + type: [Boolean, String], + default: false }, - chars: function(text2) { - const node = { - type: "text", - text: text2 - }; - if (stacks.length === 0) { - results.children.push(node); - } else { - const parent = stacks[0]; - if (!parent.children) { - parent.children = []; - } - parent.children.push(node); - } + upperThreshold: { + type: [Number, String], + default: 50 }, - comment: function(text2) { - const node = { - node: "comment", - text: text2 - }; - const parent = stacks[0]; - if (!parent.children) { - parent.children = []; - } - parent.children.push(node); - } - }); - return results.children; -} -const TAGS = { - a: "", - abbr: "", - b: "", - blockquote: "", - br: "", - code: "", - col: ["span", "width"], - colgroup: ["span", "width"], - dd: "", - del: "", - div: "", - dl: "", - dt: "", - em: "", - fieldset: "", - h1: "", - h2: "", - h3: "", - h4: "", - h5: "", - h6: "", - hr: "", - i: "", - img: ["alt", "src", "height", "width"], - ins: "", - label: "", - legend: "", - li: "", - ol: ["start", "type"], - p: "", - q: "", - span: "", - strong: "", - sub: "", - sup: "", - table: ["width"], - tbody: "", - td: ["colspan", "rowspan", "height", "width"], - tfoot: "", - th: ["colspan", "rowspan", "height", "width"], - thead: "", - tr: "", - ul: "" -}; -const CHARS = { - amp: "&", - gt: ">", - lt: "<", - nbsp: " ", - quot: '"', - apos: "'" -}; -function decodeEntities(htmlString) { - return htmlString.replace(/&(([a-zA-Z]+)|(#x{0,1}[\da-zA-Z]+));/gi, function(match, stage) { - if (hasOwn(CHARS, stage) && CHARS[stage]) { - return CHARS[stage]; - } - if (/^#[0-9]{1,4}$/.test(stage)) { - return String.fromCharCode(stage.slice(1)); - } - if (/^#x[0-9a-f]{1,4}$/i.test(stage)) { - return String.fromCharCode("0" + stage.slice(1)); + lowerThreshold: { + type: [Number, String], + default: 50 + }, + scrollTop: { + type: [Number, String], + default: 0 + }, + scrollLeft: { + type: [Number, String], + default: 0 + }, + scrollIntoView: { + type: String, + default: "" + }, + scrollWithAnimation: { + type: [Boolean, String], + default: false + }, + enableBackToTop: { + type: [Boolean, String], + default: false + }, + refresherEnabled: { + type: [Boolean, String], + default: false + }, + refresherThreshold: { + type: Number, + default: 45 + }, + refresherDefaultStyle: { + type: String, + default: "back" + }, + refresherBackground: { + type: String, + default: "#fff" + }, + refresherTriggered: { + type: [Boolean, String], + default: false } - const wrap = document.createElement("div"); - wrap.innerHTML = match; - return wrap.innerText || wrap.textContent; - }); -} -function parseNodes(nodes, parentNode) { - nodes.forEach(function(node) { - if (!isPlainObject(node)) { - return; + }, + data() { + return { + lastScrollTop: this.scrollTopNumber, + lastScrollLeft: this.scrollLeftNumber, + lastScrollToUpperTime: 0, + lastScrollToLowerTime: 0, + refresherHeight: 0, + refreshRotate: 0, + refreshState: "" + }; + }, + computed: { + upperThresholdNumber() { + var val = Number(this.upperThreshold); + return isNaN(val) ? 50 : val; + }, + lowerThresholdNumber() { + var val = Number(this.lowerThreshold); + return isNaN(val) ? 50 : val; + }, + scrollTopNumber() { + return Number(this.scrollTop) || 0; + }, + scrollLeftNumber() { + return Number(this.scrollLeft) || 0; } - if (!hasOwn(node, "type") || node.type === "node") { - if (!(typeof node.name === "string" && node.name)) { - return; + }, + watch: { + scrollTopNumber(val) { + this._scrollTopChanged(val); + }, + scrollLeftNumber(val) { + this._scrollLeftChanged(val); + }, + scrollIntoView(val) { + this._scrollIntoViewChanged(val); + }, + refresherTriggered(val) { + if (val === true) { + this._setRefreshState("refreshing"); + } else if (val === false) { + this._setRefreshState("restore"); } - const tagName = node.name.toLowerCase(); - if (!hasOwn(TAGS, tagName)) { - return; + } + }, + mounted() { + var self = this; + this._attached = true; + this._scrollTopChanged(this.scrollTopNumber); + this._scrollLeftChanged(this.scrollLeftNumber); + this._scrollIntoViewChanged(this.scrollIntoView); + this.__handleScroll = function(e2) { + event.preventDefault(); + event.stopPropagation(); + self._handleScroll.bind(self, event)(); + }; + var touchStart = null; + var needStop = null; + this.__handleTouchMove = function(event2) { + var x = event2.touches[0].pageX; + var y = event2.touches[0].pageY; + var main = self.$refs.main; + if (needStop === null) { + if (Math.abs(x - touchStart.x) > Math.abs(y - touchStart.y)) { + if (self.scrollX) { + if (main.scrollLeft === 0 && x > touchStart.x) { + needStop = false; + return; + } else if (main.scrollWidth === main.offsetWidth + main.scrollLeft && x < touchStart.x) { + needStop = false; + return; + } + needStop = true; + } else { + needStop = false; + } + } else { + if (self.scrollY) { + if (main.scrollTop === 0 && y > touchStart.y) { + needStop = false; + return; + } else if (main.scrollHeight === main.offsetHeight + main.scrollTop && y < touchStart.y) { + needStop = false; + return; + } + needStop = true; + } else { + needStop = false; + } + } } - const elem = document.createElement(tagName); - if (!elem) { - return; + if (needStop) { + event2.stopPropagation(); } - const attrs2 = node.attrs; - if (isPlainObject(attrs2)) { - const tagAttrs = TAGS[tagName] || []; - Object.keys(attrs2).forEach(function(name) { - let value = attrs2[name]; - switch (name) { - case "class": - Array.isArray(value) && (value = value.join(" ")); - case "style": - elem.setAttribute(name, value); - break; - default: - if (tagAttrs.indexOf(name) !== -1) { - elem.setAttribute(name, value); - } - } + if (self.refresherEnabled && self.refreshState === "pulling") { + const dy = y - touchStart.y; + self.refresherHeight = dy; + let rotate = dy / self.refresherThreshold; + if (rotate > 1) { + rotate = 1; + } else { + rotate = rotate * 360; + } + self.refreshRotate = rotate; + self.$trigger("refresherpulling", event2, { + deltaY: dy }); } - const children = node.children; - if (Array.isArray(children) && children.length) { - parseNodes(node.children, elem); - } - parentNode.appendChild(elem); - } else { - if (node.type === "text" && typeof node.text === "string" && node.text !== "") { - parentNode.appendChild(document.createTextNode(decodeEntities(node.text))); + }; + this.__handleTouchStart = function(event2) { + if (event2.touches.length === 1) { + needStop = null; + touchStart = { + x: event2.touches[0].pageX, + y: event2.touches[0].pageY + }; + if (self.refresherEnabled && self.refreshState !== "refreshing" && self.$refs.main.scrollTop === 0) { + self.refreshState = "pulling"; + } } - } - }); - return parentNode; -} -const _sfc_main$d = { - name: "RichText", - props: { - nodes: { - type: [Array, String], - default: function() { - return []; + }; + this.__handleTouchEnd = function(event2) { + touchStart = null; + if (self.refresherHeight >= self.refresherThreshold) { + self._setRefreshState("refreshing"); + } else { + self.refresherHeight = 0; + self.$trigger("refresherabort", event2, {}); } - } + }; + this.$refs.main.addEventListener("touchstart", this.__handleTouchStart, passiveOptions); + this.$refs.main.addEventListener("touchmove", this.__handleTouchMove, passiveOptions); + this.$refs.main.addEventListener("scroll", this.__handleScroll, supportsPassive ? { + passive: false + } : false); + this.$refs.main.addEventListener("touchend", this.__handleTouchEnd, passiveOptions); }, - watch: { - nodes(value) { - this._renderNodes(value); - } + activated() { + this.scrollY && (this.$refs.main.scrollTop = this.lastScrollTop); + this.scrollX && (this.$refs.main.scrollLeft = this.lastScrollLeft); }, - mounted() { - this._renderNodes(this.nodes); + beforeDestroy() { + this.$refs.main.removeEventListener("touchstart", this.__handleTouchStart, passiveOptions); + this.$refs.main.removeEventListener("touchmove", this.__handleTouchMove, passiveOptions); + this.$refs.main.removeEventListener("scroll", this.__handleScroll, supportsPassive ? { + passive: false + } : false); + this.$refs.main.removeEventListener("touchend", this.__handleTouchEnd, passiveOptions); }, methods: { - _renderNodes(nodes) { - if (typeof nodes === "string") { - nodes = parseHtml(nodes); - } - const nodeList = parseNodes(nodes, document.createDocumentFragment()); - this.$el.firstChild.innerHTML = ""; - this.$el.firstChild.appendChild(nodeList); - } - } -}; -const _hoisted_1$7 = /* @__PURE__ */ createVNode("div", null, null, -1); -function _sfc_render$c(_ctx, _cache, $props, $setup, $data, $options) { - return openBlock(), createBlock("uni-rich-text", _ctx.$attrs, [ - _hoisted_1$7 - ], 16); -} -_sfc_main$d.render = _sfc_render$c; -function Friction(e2) { - this._drag = e2; - this._dragLog = Math.log(e2); - this._x = 0; - this._v = 0; - this._startTime = 0; -} -Friction.prototype.set = function(e2, t2) { - this._x = e2; - this._v = t2; - this._startTime = new Date().getTime(); -}; -Friction.prototype.setVelocityByEnd = function(e2) { - this._v = (e2 - this._x) * this._dragLog / (Math.pow(this._drag, 100) - 1); -}; -Friction.prototype.x = function(e2) { - if (e2 === void 0) { - e2 = (new Date().getTime() - this._startTime) / 1e3; - } - var t2; - t2 = e2 === this._dt && this._powDragDt ? this._powDragDt : this._powDragDt = Math.pow(this._drag, e2); - this._dt = e2; - return this._x + this._v * t2 / this._dragLog - this._v / this._dragLog; -}; -Friction.prototype.dx = function(e2) { - if (e2 === void 0) { - e2 = (new Date().getTime() - this._startTime) / 1e3; - } - var t2; - t2 = e2 === this._dt && this._powDragDt ? this._powDragDt : this._powDragDt = Math.pow(this._drag, e2); - this._dt = e2; - return this._v * t2; -}; -Friction.prototype.done = function() { - return Math.abs(this.dx()) < 3; -}; -Friction.prototype.reconfigure = function(e2) { - var t2 = this.x(); - var n = this.dx(); - this._drag = e2; - this._dragLog = Math.log(e2); - this.set(t2, n); -}; -Friction.prototype.configuration = function() { - var e2 = this; - return [ - { - label: "Friction", - read: function() { - return e2._drag; - }, - write: function(t2) { - e2.reconfigure(t2); - }, - min: 1e-3, - max: 0.1, - step: 1e-3 - } - ]; -}; -function o(e2, t2, n) { - return e2 > t2 - n && e2 < t2 + n; -} -function a(e2, t2) { - return o(e2, 0, t2); -} -function Spring(e2, t2, n) { - this._m = e2; - this._k = t2; - this._c = n; - this._solution = null; - this._endPosition = 0; - this._startTime = 0; -} -Spring.prototype._solve = function(e2, t2) { - var n = this._c; - var i2 = this._m; - var r = this._k; - var o2 = n * n - 4 * i2 * r; - if (o2 === 0) { - const a3 = -n / (2 * i2); - const s2 = e2; - const l2 = t2 / (a3 * e2); - return { - x: function(e3) { - return (s2 + l2 * e3) * Math.pow(Math.E, a3 * e3); - }, - dx: function(e3) { - var t3 = Math.pow(Math.E, a3 * e3); - return a3 * (s2 + l2 * e3) * t3 + l2 * t3; - } - }; - } - if (o2 > 0) { - const c = (-n - Math.sqrt(o2)) / (2 * i2); - const u = (-n + Math.sqrt(o2)) / (2 * i2); - const l2 = (t2 - c * e2) / (u - c); - const s2 = e2 - l2; - return { - x: function(e3) { - let t3; - let n2; - if (e3 === this._t) { - t3 = this._powER1T; - n2 = this._powER2T; - } - this._t = e3; - if (!t3) { - t3 = this._powER1T = Math.pow(Math.E, c * e3); - } - if (!n2) { - n2 = this._powER2T = Math.pow(Math.E, u * e3); + scrollTo: function(t2, n) { + var i = this.$refs.main; + t2 < 0 ? t2 = 0 : n === "x" && t2 > i.scrollWidth - i.offsetWidth ? t2 = i.scrollWidth - i.offsetWidth : n === "y" && t2 > i.scrollHeight - i.offsetHeight && (t2 = i.scrollHeight - i.offsetHeight); + var r = 0; + var o2 = ""; + n === "x" ? r = i.scrollLeft - t2 : n === "y" && (r = i.scrollTop - t2); + if (r !== 0) { + this.$refs.content.style.transition = "transform .3s ease-out"; + this.$refs.content.style.webkitTransition = "-webkit-transform .3s ease-out"; + if (n === "x") { + o2 = "translateX(" + r + "px) translateZ(0)"; + } else { + n === "y" && (o2 = "translateY(" + r + "px) translateZ(0)"); } - return s2 * t3 + l2 * n2; - }, - dx: function(e3) { - let t3; - let n2; - if (e3 === this._t) { - t3 = this._powER1T; - n2 = this._powER2T; + this.$refs.content.removeEventListener("transitionend", this.__transitionEnd); + this.$refs.content.removeEventListener("webkitTransitionEnd", this.__transitionEnd); + this.__transitionEnd = this._transitionEnd.bind(this, t2, n); + this.$refs.content.addEventListener("transitionend", this.__transitionEnd); + this.$refs.content.addEventListener("webkitTransitionEnd", this.__transitionEnd); + if (n === "x") { + i.style.overflowX = "hidden"; + } else if (n === "y") { + i.style.overflowY = "hidden"; } - this._t = e3; - if (!t3) { - t3 = this._powER1T = Math.pow(Math.E, c * e3); + this.$refs.content.style.transform = o2; + this.$refs.content.style.webkitTransform = o2; + } + }, + _handleTrack: function($event) { + if ($event.detail.state === "start") { + this._x = $event.detail.x; + this._y = $event.detail.y; + this._noBubble = null; + return; + } + if ($event.detail.state === "end") { + this._noBubble = false; + } + if (this._noBubble === null && this.scrollY) { + if (Math.abs(this._y - $event.detail.y) / Math.abs(this._x - $event.detail.x) > 1) { + this._noBubble = true; + } else { + this._noBubble = false; } - if (!n2) { - n2 = this._powER2T = Math.pow(Math.E, u * e3); + } + if (this._noBubble === null && this.scrollX) { + if (Math.abs(this._x - $event.detail.x) / Math.abs(this._y - $event.detail.y) > 1) { + this._noBubble = true; + } else { + this._noBubble = false; } - return s2 * c * t3 + l2 * u * n2; } - }; - } - var d = Math.sqrt(4 * i2 * r - n * n) / (2 * i2); - var a2 = -n / 2 * i2; - var s = e2; - var l = (t2 - a2 * e2) / d; - return { - x: function(e3) { - return Math.pow(Math.E, a2 * e3) * (s * Math.cos(d * e3) + l * Math.sin(d * e3)); - }, - dx: function(e3) { - var t3 = Math.pow(Math.E, a2 * e3); - var n2 = Math.cos(d * e3); - var i3 = Math.sin(d * e3); - return t3 * (l * d * n2 - s * d * i3) + a2 * t3 * (l * i3 + s * n2); - } - }; -}; -Spring.prototype.x = function(e2) { - if (e2 === void 0) { - e2 = (new Date().getTime() - this._startTime) / 1e3; - } - return this._solution ? this._endPosition + this._solution.x(e2) : 0; -}; -Spring.prototype.dx = function(e2) { - if (e2 === void 0) { - e2 = (new Date().getTime() - this._startTime) / 1e3; - } - return this._solution ? this._solution.dx(e2) : 0; -}; -Spring.prototype.setEnd = function(e2, t2, n) { - if (!n) { - n = new Date().getTime(); - } - if (e2 !== this._endPosition || !a(t2, 0.4)) { - t2 = t2 || 0; - var i2 = this._endPosition; - if (this._solution) { - if (a(t2, 0.4)) { - t2 = this._solution.dx((n - this._startTime) / 1e3); + this._x = $event.detail.x; + this._y = $event.detail.y; + if (this._noBubble) { + $event.stopPropagation(); } - i2 = this._solution.x((n - this._startTime) / 1e3); - if (a(t2, 0.4)) { - t2 = 0; + }, + _handleScroll: function($event) { + if (!($event.timeStamp - this._lastScrollTime < 20)) { + this._lastScrollTime = $event.timeStamp; + const target = $event.target; + this.$trigger("scroll", $event, { + scrollLeft: target.scrollLeft, + scrollTop: target.scrollTop, + scrollHeight: target.scrollHeight, + scrollWidth: target.scrollWidth, + deltaX: this.lastScrollLeft - target.scrollLeft, + deltaY: this.lastScrollTop - target.scrollTop + }); + if (this.scrollY) { + if (target.scrollTop <= this.upperThresholdNumber && this.lastScrollTop - target.scrollTop > 0 && $event.timeStamp - this.lastScrollToUpperTime > 200) { + this.$trigger("scrolltoupper", $event, { + direction: "top" + }); + this.lastScrollToUpperTime = $event.timeStamp; + } + if (target.scrollTop + target.offsetHeight + this.lowerThresholdNumber >= target.scrollHeight && this.lastScrollTop - target.scrollTop < 0 && $event.timeStamp - this.lastScrollToLowerTime > 200) { + this.$trigger("scrolltolower", $event, { + direction: "bottom" + }); + this.lastScrollToLowerTime = $event.timeStamp; + } + } + if (this.scrollX) { + if (target.scrollLeft <= this.upperThresholdNumber && this.lastScrollLeft - target.scrollLeft > 0 && $event.timeStamp - this.lastScrollToUpperTime > 200) { + this.$trigger("scrolltoupper", $event, { + direction: "left" + }); + this.lastScrollToUpperTime = $event.timeStamp; + } + if (target.scrollLeft + target.offsetWidth + this.lowerThresholdNumber >= target.scrollWidth && this.lastScrollLeft - target.scrollLeft < 0 && $event.timeStamp - this.lastScrollToLowerTime > 200) { + this.$trigger("scrolltolower", $event, { + direction: "right" + }); + this.lastScrollToLowerTime = $event.timeStamp; + } + } + this.lastScrollTop = target.scrollTop; + this.lastScrollLeft = target.scrollLeft; } - if (a(i2, 0.4)) { - i2 = 0; + }, + _scrollTopChanged: function(val) { + if (this.scrollY) { + if (this._innerSetScrollTop) { + this._innerSetScrollTop = false; + } else { + if (this.scrollWithAnimation) { + this.scrollTo(val, "y"); + } else { + this.$refs.main.scrollTop = val; + } + } } - i2 += this._endPosition; - } - if (!(this._solution && a(i2 - e2, 0.4) && a(t2, 0.4))) { - this._endPosition = e2; - this._solution = this._solve(i2 - this._endPosition, t2); - this._startTime = n; - } - } -}; -Spring.prototype.snap = function(e2) { - this._startTime = new Date().getTime(); - this._endPosition = e2; - this._solution = { - x: function() { - return 0; }, - dx: function() { - return 0; - } - }; -}; -Spring.prototype.done = function(e2) { - if (!e2) { - e2 = new Date().getTime(); - } - return o(this.x(), this._endPosition, 0.4) && a(this.dx(), 0.4); -}; -Spring.prototype.reconfigure = function(e2, t2, n) { - this._m = e2; - this._k = t2; - this._c = n; - if (!this.done()) { - this._solution = this._solve(this.x() - this._endPosition, this.dx()); - this._startTime = new Date().getTime(); - } -}; -Spring.prototype.springConstant = function() { - return this._k; -}; -Spring.prototype.damping = function() { - return this._c; -}; -Spring.prototype.configuration = function() { - function e2(e3, t3) { - e3.reconfigure(1, t3, e3.damping()); - } - function t2(e3, t3) { - e3.reconfigure(1, e3.springConstant(), t3); - } - return [ - { - label: "Spring Constant", - read: this.springConstant.bind(this), - write: e2.bind(this, this), - min: 100, - max: 1e3 + _scrollLeftChanged: function(val) { + if (this.scrollX) { + if (this._innerSetScrollLeft) { + this._innerSetScrollLeft = false; + } else { + if (this.scrollWithAnimation) { + this.scrollTo(val, "x"); + } else { + this.$refs.main.scrollLeft = val; + } + } + } }, - { - label: "Damping", - read: this.damping.bind(this), - write: t2.bind(this, this), - min: 1, - max: 500 - } - ]; -}; -function Scroll(extent, friction, spring) { - this._extent = extent; - this._friction = friction || new Friction(0.01); - this._spring = spring || new Spring(1, 90, 20); - this._startTime = 0; - this._springing = false; - this._springOffset = 0; -} -Scroll.prototype.snap = function(e2, t2) { - this._springOffset = 0; - this._springing = true; - this._spring.snap(e2); - this._spring.setEnd(t2); -}; -Scroll.prototype.set = function(e2, t2) { - this._friction.set(e2, t2); - if (e2 > 0 && t2 >= 0) { - this._springOffset = 0; - this._springing = true; - this._spring.snap(e2); - this._spring.setEnd(0); - } else { - if (e2 < -this._extent && t2 <= 0) { - this._springOffset = 0; - this._springing = true; - this._spring.snap(e2); - this._spring.setEnd(-this._extent); - } else { - this._springing = false; - } - } - this._startTime = new Date().getTime(); -}; -Scroll.prototype.x = function(e2) { - if (!this._startTime) { - return 0; - } - if (!e2) { - e2 = (new Date().getTime() - this._startTime) / 1e3; - } - if (this._springing) { - return this._spring.x() + this._springOffset; - } - var t2 = this._friction.x(e2); - var n = this.dx(e2); - if (t2 > 0 && n >= 0 || t2 < -this._extent && n <= 0) { - this._springing = true; - this._spring.setEnd(0, n); - if (t2 < -this._extent) { - this._springOffset = -this._extent; - } else { - this._springOffset = 0; + _scrollIntoViewChanged: function(val) { + if (val) { + if (!/^[_a-zA-Z][-_a-zA-Z0-9:]*$/.test(val)) { + console.group('scroll-into-view="' + val + '" \u6709\u8BEF'); + console.error("id \u5C5E\u6027\u503C\u683C\u5F0F\u9519\u8BEF\u3002\u5982\u4E0D\u80FD\u4EE5\u6570\u5B57\u5F00\u5934\u3002"); + console.groupEnd(); + return; + } + var element = this.$el.querySelector("#" + val); + if (element) { + var mainRect = this.$refs.main.getBoundingClientRect(); + var elRect = element.getBoundingClientRect(); + if (this.scrollX) { + var left = elRect.left - mainRect.left; + var scrollLeft = this.$refs.main.scrollLeft; + var x = scrollLeft + left; + if (this.scrollWithAnimation) { + this.scrollTo(x, "x"); + } else { + this.$refs.main.scrollLeft = x; + } + } + if (this.scrollY) { + var top = elRect.top - mainRect.top; + var scrollTop = this.$refs.main.scrollTop; + var y = scrollTop + top; + if (this.scrollWithAnimation) { + this.scrollTo(y, "y"); + } else { + this.$refs.main.scrollTop = y; + } + } + } + } + }, + _transitionEnd: function(val, type) { + this.$refs.content.style.transition = ""; + this.$refs.content.style.webkitTransition = ""; + this.$refs.content.style.transform = ""; + this.$refs.content.style.webkitTransform = ""; + var main = this.$refs.main; + if (type === "x") { + main.style.overflowX = this.scrollX ? "auto" : "hidden"; + main.scrollLeft = val; + } else if (type === "y") { + main.style.overflowY = this.scrollY ? "auto" : "hidden"; + main.scrollTop = val; + } + this.$refs.content.removeEventListener("transitionend", this.__transitionEnd); + this.$refs.content.removeEventListener("webkitTransitionEnd", this.__transitionEnd); + }, + _setRefreshState(state) { + switch (state) { + case "refreshing": + this.refresherHeight = this.refresherThreshold; + this.$trigger("refresherrefresh", event, {}); + break; + case "restore": + this.refresherHeight = 0; + this.$trigger("refresherrestore", {}, {}); + break; + } + this.refreshState = state; + }, + getScrollPosition() { + const main = this.$refs.main; + return { + scrollLeft: main.scrollLeft, + scrollTop: main.scrollTop + }; } - t2 = this._spring.x() + this._springOffset; } - return t2; }; -Scroll.prototype.dx = function(e2) { - var t2 = 0; - t2 = this._lastTime === e2 ? this._lastDx : this._springing ? this._spring.dx(e2) : this._friction.dx(e2); - this._lastTime = e2; - this._lastDx = t2; - return t2; +const _hoisted_1$6 = { + ref: "wrap", + class: "uni-scroll-view" }; -Scroll.prototype.done = function() { - return this._springing ? this._spring.done() : this._friction.done(); +const _hoisted_2$5 = { + ref: "content", + class: "uni-scroll-view-content" }; -Scroll.prototype.setVelocityByEnd = function(e2) { - this._friction.setVelocityByEnd(e2); +const _hoisted_3$2 = { + key: 0, + class: "uni-scroll-view-refresh" }; -Scroll.prototype.configuration = function() { - var e2 = this._friction.configuration(); - e2.push.apply(e2, this._spring.configuration()); - return e2; +const _hoisted_4$2 = {class: "uni-scroll-view-refresh-inner"}; +const _hoisted_5 = /* @__PURE__ */ createVNode("path", {d: "M17.65 6.35C16.2 4.9 14.21 4 12 4c-4.42 0-7.99 3.58-7.99 8s3.57 8 7.99 8c3.73 0 6.84-2.55 7.73-6h-2.08c-.82 2.33-3.04 4-5.65 4-3.31 0-6-2.69-6-6s2.69-6 6-6c1.66 0 3.14.69 4.22 1.78L13 11h7V4l-2.35 2.35z"}, null, -1); +const _hoisted_6 = /* @__PURE__ */ createVNode("path", { + d: "M0 0h24v24H0z", + fill: "none" +}, null, -1); +const _hoisted_7 = { + key: 1, + class: "uni-scroll-view-refresh__spinner", + width: "24", + height: "24", + viewBox: "25 25 50 50" }; -function i(scroll, t2, n) { - function i2(t3, scroll2, r2, o3) { - if (!t3 || !t3.cancelled) { - r2(scroll2); - var a2 = scroll2.done(); - if (!a2) { - if (!t3.cancelled) { - t3.id = requestAnimationFrame(i2.bind(null, t3, scroll2, r2, o3)); - } - } - if (a2 && o3) { - o3(scroll2); - } - } - } - function r(scroll2) { - if (scroll2 && scroll2.id) { - cancelAnimationFrame(scroll2.id); - } - if (scroll2) { - scroll2.cancelled = true; - } - } - var o2 = { - id: 0, - cancelled: false - }; - i2(o2, scroll, t2, n); - return { - cancel: r.bind(null, o2), - model: scroll - }; -} -function Scroller(element, options) { - options = options || {}; - this._element = element; - this._options = options; - this._enableSnap = options.enableSnap || false; - this._itemSize = options.itemSize || 0; - this._enableX = options.enableX || false; - this._enableY = options.enableY || false; - this._shouldDispatchScrollEvent = !!options.onScroll; - if (this._enableX) { - this._extent = (options.scrollWidth || this._element.offsetWidth) - this._element.parentElement.offsetWidth; - this._scrollWidth = options.scrollWidth; - } else { - this._extent = (options.scrollHeight || this._element.offsetHeight) - this._element.parentElement.offsetHeight; - this._scrollHeight = options.scrollHeight; - } - this._position = 0; - this._scroll = new Scroll(this._extent, options.friction, options.spring); - this._onTransitionEnd = this.onTransitionEnd.bind(this); - this.updatePosition(); +const _hoisted_8 = /* @__PURE__ */ createVNode("circle", { + cx: "50", + cy: "50", + r: "20", + fill: "none", + style: {color: "#2BD009"}, + "stroke-width": "3" +}, null, -1); +function _sfc_render$b(_ctx, _cache, $props, $setup, $data, $options) { + return openBlock(), createBlock("uni-scroll-view", _ctx.$attrs, [ + createVNode("div", _hoisted_1$6, [ + createVNode("div", { + ref: "main", + style: {"overflow-x": $props.scrollX ? "auto" : "hidden", "overflow-y": $props.scrollY ? "auto" : "hidden"}, + class: "uni-scroll-view" + }, [ + createVNode("div", _hoisted_2$5, [ + $props.refresherEnabled ? (openBlock(), createBlock("div", { + key: 0, + ref: "refresherinner", + style: {"background-color": $props.refresherBackground, height: $data.refresherHeight + "px"}, + class: "uni-scroll-view-refresher" + }, [ + $props.refresherDefaultStyle !== "none" ? (openBlock(), createBlock("div", _hoisted_3$2, [ + createVNode("div", _hoisted_4$2, [ + $data.refreshState == "pulling" ? (openBlock(), createBlock("svg", { + key: 0, + style: {transform: "rotate(" + $data.refreshRotate + "deg)"}, + fill: "#2BD009", + class: "uni-scroll-view-refresh__icon", + width: "24", + height: "24", + viewBox: "0 0 24 24" + }, [ + _hoisted_5, + _hoisted_6 + ], 4)) : createCommentVNode("", true), + $data.refreshState == "refreshing" ? (openBlock(), createBlock("svg", _hoisted_7, [ + _hoisted_8 + ])) : createCommentVNode("", true) + ]) + ])) : createCommentVNode("", true), + $props.refresherDefaultStyle == "none" ? renderSlot(_ctx.$slots, "refresher", {key: 1}) : createCommentVNode("", true) + ], 4)) : createCommentVNode("", true), + renderSlot(_ctx.$slots, "default") + ], 512) + ], 4) + ], 512) + ], 16); } -Scroller.prototype.onTouchStart = function() { - this._startPosition = this._position; - this._lastChangePos = this._startPosition; - if (this._startPosition > 0) { - this._startPosition /= 0.5; - } else { - if (this._startPosition < -this._extent) { - this._startPosition = (this._startPosition + this._extent) / 0.5 - this._extent; - } - } - if (this._animation) { - this._animation.cancel(); - this._scrolling = false; - } - this.updatePosition(); -}; -Scroller.prototype.onTouchMove = function(x, y) { - var startPosition = this._startPosition; - if (this._enableX) { - startPosition += x; - } else if (this._enableY) { - startPosition += y; - } - if (startPosition > 0) { - startPosition *= 0.5; - } else if (startPosition < -this._extent) { - startPosition = 0.5 * (startPosition + this._extent) - this._extent; - } - this._position = startPosition; - this.updatePosition(); - this.dispatchScroll(); -}; -Scroller.prototype.onTouchEnd = function(e2, r, o2) { - if (this._enableSnap && this._position > -this._extent && this._position < 0) { - if (this._enableY && (Math.abs(r) < this._itemSize && Math.abs(o2.y) < 300 || Math.abs(o2.y) < 150)) { - this.snap(); - return; - } - if (this._enableX && (Math.abs(e2) < this._itemSize && Math.abs(o2.x) < 300 || Math.abs(o2.x) < 150)) { - this.snap(); - return; +_sfc_main$c.render = _sfc_render$b; +const _sfc_main$b = { + name: "Slider", + mixins: [emitter, listeners, touchtrack], + props: { + name: { + type: String, + default: "" + }, + min: { + type: [Number, String], + default: 0 + }, + max: { + type: [Number, String], + default: 100 + }, + value: { + type: [Number, String], + default: 0 + }, + step: { + type: [Number, String], + default: 1 + }, + disabled: { + type: [Boolean, String], + default: false + }, + color: { + type: String, + default: "#e9e9e9" + }, + backgroundColor: { + type: String, + default: "#e9e9e9" + }, + activeColor: { + type: String, + default: "#007aff" + }, + selectedColor: { + type: String, + default: "#007aff" + }, + blockColor: { + type: String, + default: "#ffffff" + }, + blockSize: { + type: [Number, String], + default: 28 + }, + showValue: { + type: [Boolean, String], + default: false } - } - if (this._enableX) { - this._scroll.set(this._position, o2.x); - } else if (this._enableY) { - this._scroll.set(this._position, o2.y); - } - if (this._enableSnap) { - var s = this._scroll._friction.x(100); - var l = s % this._itemSize; - var c = Math.abs(l) > this._itemSize / 2 ? s - (this._itemSize - Math.abs(l)) : s - l; - if (c <= 0 && c >= -this._extent) { - this._scroll.setVelocityByEnd(c); + }, + data() { + return { + sliderValue: Number(this.value) + }; + }, + computed: { + setBlockStyle() { + return { + width: this.blockSize + "px", + height: this.blockSize + "px", + marginLeft: -this.blockSize / 2 + "px", + marginTop: -this.blockSize / 2 + "px", + left: this._getValueWidth(), + backgroundColor: this.blockColor + }; + }, + setBgColor() { + return { + backgroundColor: this._getBgColor() + }; + }, + setBlockBg() { + return { + left: this._getValueWidth() + }; + }, + setActiveColor() { + return { + backgroundColor: this._getActiveColor(), + width: this._getValueWidth() + }; } - } - this._lastTime = Date.now(); - this._lastDelay = 0; - this._scrolling = true; - this._lastChangePos = this._position; - this._lastIdx = Math.floor(Math.abs(this._position / this._itemSize)); - this._animation = i(this._scroll, () => { - var e3 = Date.now(); - var i2 = (e3 - this._scroll._startTime) / 1e3; - var r2 = this._scroll.x(i2); - this._position = r2; - this.updatePosition(); - var o3 = this._scroll.dx(i2); - if (this._shouldDispatchScrollEvent && e3 - this._lastTime > this._lastDelay) { - this.dispatchScroll(); - this._lastDelay = Math.abs(2e3 / o3); - this._lastTime = e3; + }, + watch: { + value(val) { + this.sliderValue = Number(val); } - }, () => { - if (this._enableSnap) { - if (c <= 0 && c >= -this._extent) { - this._position = c; - this.updatePosition(); - } - if (typeof this._options.onSnap === "function") { - this._options.onSnap(Math.floor(Math.abs(this._position) / this._itemSize)); + }, + mounted() { + this.touchtrack(this.$refs["uni-slider-handle"], "_onTrack"); + }, + created() { + this.$dispatch("Form", "uni-form-group-update", { + type: "add", + vm: this + }); + }, + beforeDestroy() { + this.$dispatch("Form", "uni-form-group-update", { + type: "remove", + vm: this + }); + }, + methods: { + _onUserChangedValue(e2) { + const slider = this.$refs["uni-slider"]; + const offsetWidth = slider.offsetWidth; + const boxLeft = slider.getBoundingClientRect().left; + const value = (e2.x - boxLeft) * (this.max - this.min) / offsetWidth + Number(this.min); + this.sliderValue = this._filterValue(value); + }, + _filterValue(e2) { + return e2 < this.min ? this.min : e2 > this.max ? this.max : Math.round((e2 - this.min) / this.step) * this.step + Number(this.min); + }, + _getValueWidth() { + return 100 * (this.sliderValue - this.min) / (this.max - this.min) + "%"; + }, + _getBgColor() { + return this.backgroundColor !== "#e9e9e9" ? this.backgroundColor : this.color !== "#007aff" ? this.color : "#007aff"; + }, + _getActiveColor() { + return this.activeColor !== "#007aff" ? this.activeColor : this.selectedColor !== "#e9e9e9" ? this.selectedColor : "#e9e9e9"; + }, + _onTrack: function(e2) { + if (!this.disabled) { + return e2.detail.state === "move" ? (this._onUserChangedValue({ + x: e2.detail.x0 + }), this.$trigger("changing", e2, { + value: this.sliderValue + }), false) : e2.detail.state === "end" && this.$trigger("change", e2, { + value: this.sliderValue + }); } - } - if (this._shouldDispatchScrollEvent) { - this.dispatchScroll(); - } - this._scrolling = false; - }); -}; -Scroller.prototype.onTransitionEnd = function() { - this._element.style.transition = ""; - this._element.style.webkitTransition = ""; - this._element.removeEventListener("transitionend", this._onTransitionEnd); - this._element.removeEventListener("webkitTransitionEnd", this._onTransitionEnd); - if (this._snapping) { - this._snapping = false; - } - this.dispatchScroll(); -}; -Scroller.prototype.snap = function() { - var e2 = this._itemSize; - var t2 = this._position % e2; - var i2 = Math.abs(t2) > this._itemSize / 2 ? this._position - (e2 - Math.abs(t2)) : this._position - t2; - if (this._position !== i2) { - this._snapping = true; - this.scrollTo(-i2); - if (typeof this._options.onSnap === "function") { - this._options.onSnap(Math.floor(Math.abs(this._position) / this._itemSize)); - } - } -}; -Scroller.prototype.scrollTo = function(e2, t2) { - if (this._animation) { - this._animation.cancel(); - this._scrolling = false; - } - if (typeof e2 === "number") { - this._position = -e2; - } - if (this._position < -this._extent) { - this._position = -this._extent; - } else { - if (this._position > 0) { - this._position = 0; - } - } - this._element.style.transition = "transform " + (t2 || 0.2) + "s ease-out"; - this._element.style.webkitTransition = "-webkit-transform " + (t2 || 0.2) + "s ease-out"; - this.updatePosition(); - this._element.addEventListener("transitionend", this._onTransitionEnd); - this._element.addEventListener("webkitTransitionEnd", this._onTransitionEnd); -}; -Scroller.prototype.dispatchScroll = function() { - if (typeof this._options.onScroll === "function" && Math.round(this._lastPos) !== Math.round(this._position)) { - this._lastPos = this._position; - var e2 = { - target: { - scrollLeft: this._enableX ? -this._position : 0, - scrollTop: this._enableY ? -this._position : 0, - scrollHeight: this._scrollHeight || this._element.offsetHeight, - scrollWidth: this._scrollWidth || this._element.offsetWidth, - offsetHeight: this._element.parentElement.offsetHeight, - offsetWidth: this._element.parentElement.offsetWidth + }, + _onClick($event) { + if (this.disabled) { + return; } - }; - this._options.onScroll(e2); - } -}; -Scroller.prototype.update = function(e2, t2, n) { - var i2 = 0; - var r = this._position; - if (this._enableX) { - i2 = this._element.childNodes.length ? (t2 || this._element.offsetWidth) - this._element.parentElement.offsetWidth : 0; - this._scrollWidth = t2; - } else { - i2 = this._element.childNodes.length ? (t2 || this._element.offsetHeight) - this._element.parentElement.offsetHeight : 0; - this._scrollHeight = t2; - } - if (typeof e2 === "number") { - this._position = -e2; - } - if (this._position < -i2) { - this._position = -i2; - } else { - if (this._position > 0) { - this._position = 0; - } - } - this._itemSize = n || this._itemSize; - this.updatePosition(); - if (r !== this._position) { - this.dispatchScroll(); - if (typeof this._options.onSnap === "function") { - this._options.onSnap(Math.floor(Math.abs(this._position) / this._itemSize)); + this._onUserChangedValue($event); + this.$trigger("change", $event, { + value: this.sliderValue + }); + }, + _resetFormData() { + this.sliderValue = this.min; + }, + _getFormData() { + const data = {}; + if (this.name !== "") { + data.value = this.sliderValue; + data.key = this.name; + } + return data; } } - this._extent = i2; - this._scroll._extent = i2; }; -Scroller.prototype.updatePosition = function() { - var transform = ""; - if (this._enableX) { - transform = "translateX(" + this._position + "px) translateZ(0)"; - } else { - if (this._enableY) { - transform = "translateY(" + this._position + "px) translateZ(0)"; +const _hoisted_1$5 = {class: "uni-slider-wrapper"}; +const _hoisted_2$4 = {class: "uni-slider-tap-area"}; +function _sfc_render$a(_ctx, _cache, $props, $setup, $data, $options) { + return openBlock(), createBlock("uni-slider", mergeProps({ref: "uni-slider"}, _ctx.$attrs, { + onClick: _cache[1] || (_cache[1] = (...args) => $options._onClick && $options._onClick(...args)) + }), [ + createVNode("div", _hoisted_1$5, [ + createVNode("div", _hoisted_2$4, [ + createVNode("div", { + style: $options.setBgColor, + class: "uni-slider-handle-wrapper" + }, [ + createVNode("div", { + ref: "uni-slider-handle", + style: $options.setBlockBg, + class: "uni-slider-handle" + }, null, 4), + createVNode("div", { + style: $options.setBlockStyle, + class: "uni-slider-thumb" + }, null, 4), + createVNode("div", { + style: $options.setActiveColor, + class: "uni-slider-track" + }, null, 4) + ], 4) + ]), + withDirectives(createVNode("span", {class: "uni-slider-value"}, toDisplayString($data.sliderValue), 513), [ + [vShow, $props.showValue] + ]) + ]), + renderSlot(_ctx.$slots, "default") + ], 16); +} +_sfc_main$b.render = _sfc_render$a; +var index_vue_vue_type_style_index_0_lang$7 = "\nuni-swiper-item {\n display: block;\n overflow: hidden;\n will-change: transform;\n position: absolute;\n width: 100%;\n height: 100%;\n cursor: grab;\n}\nuni-swiper-item[hidden] {\n display: none;\n}\n"; +const _sfc_main$a = { + name: "SwiperItem", + props: { + itemId: { + type: String, + default: "" + } + }, + mounted: function() { + var $el = this.$el; + $el.style.position = "absolute"; + $el.style.width = "100%"; + $el.style.height = "100%"; + var callbacks2 = this.$vnode._callbacks; + if (callbacks2) { + callbacks2.forEach((callback) => { + callback(); + }); } } - this._element.style.webkitTransform = transform; - this._element.style.transform = transform; -}; -Scroller.prototype.isScrolling = function() { - return this._scrolling || this._snapping; }; -var scroller = { - methods: { - initScroller: function(element, options) { - this._touchInfo = { - trackingID: -1, - maxDy: 0, - maxDx: 0 - }; - this._scroller = new Scroller(element, options); - this.__handleTouchStart = this._handleTouchStart.bind(this); - this.__handleTouchMove = this._handleTouchMove.bind(this); - this.__handleTouchEnd = this._handleTouchEnd.bind(this); - this._initedScroller = true; +function _sfc_render$9(_ctx, _cache, $props, $setup, $data, $options) { + return openBlock(), createBlock("uni-swiper-item", _ctx.$attrs, [ + renderSlot(_ctx.$slots, "default") + ], 16); +} +_sfc_main$a.render = _sfc_render$9; +var index_vue_vue_type_style_index_0_lang$6 = '\nuni-switch {\r\n -webkit-tap-highlight-color: transparent;\r\n display: inline-block;\r\n cursor: pointer;\n}\nuni-switch[hidden] {\r\n display: none;\n}\nuni-switch[disabled] {\r\n cursor: not-allowed;\n}\nuni-switch .uni-switch-wrapper {\r\n display: -webkit-inline-flex;\r\n display: inline-flex;\r\n -webkit-align-items: center;\r\n align-items: center;\r\n vertical-align: middle;\n}\nuni-switch .uni-switch-input {\r\n -webkit-appearance: none;\r\n appearance: none;\r\n position: relative;\r\n width: 52px;\r\n height: 32px;\r\n margin-right: 5px;\r\n border: 1px solid #DFDFDF;\r\n outline: 0;\r\n border-radius: 16px;\r\n box-sizing: border-box;\r\n background-color: #DFDFDF;\r\n transition: background-color 0.1s, border 0.1s;\n}\nuni-switch[disabled] .uni-switch-input {\r\n opacity: .7;\n}\nuni-switch .uni-switch-input:before {\r\n content: " ";\r\n position: absolute;\r\n top: 0;\r\n left: 0;\r\n width: 50px;\r\n height: 30px;\r\n border-radius: 15px;\r\n background-color: #FDFDFD;\r\n transition: -webkit-transform 0.3s;\r\n transition: transform 0.3s;\r\n transition: transform 0.3s, -webkit-transform 0.3s;\n}\nuni-switch .uni-switch-input:after {\r\n content: " ";\r\n position: absolute;\r\n top: 0;\r\n left: 0;\r\n width: 30px;\r\n height: 30px;\r\n border-radius: 15px;\r\n background-color: #FFFFFF;\r\n box-shadow: 0 1px 3px rgba(0, 0, 0, 0.4);\r\n transition: -webkit-transform 0.3s;\r\n transition: transform 0.3s;\r\n transition: transform 0.3s, -webkit-transform 0.3s;\n}\nuni-switch .uni-switch-input.uni-switch-input-checked {\r\n border-color: #007aff;\r\n background-color: #007aff;\n}\nuni-switch .uni-switch-input.uni-switch-input-checked:before {\r\n -webkit-transform: scale(0);\r\n transform: scale(0);\n}\nuni-switch .uni-switch-input.uni-switch-input-checked:after {\r\n -webkit-transform: translateX(20px);\r\n transform: translateX(20px);\n}\nuni-switch .uni-checkbox-input {\r\n margin-right: 5px;\r\n -webkit-appearance: none;\r\n appearance: none;\r\n outline: 0;\r\n border: 1px solid #D1D1D1;\r\n background-color: #FFFFFF;\r\n border-radius: 3px;\r\n width: 22px;\r\n height: 22px;\r\n position: relative;\r\n color: #007aff;\n}\nuni-switch:not([disabled]) .uni-checkbox-input:hover {\r\n border-color: #007aff;\n}\nuni-switch .uni-checkbox-input.uni-checkbox-input-checked:before {\r\n font: normal normal normal 14px/1 "uni";\r\n content: "\\EA08";\r\n color: inherit;\r\n font-size: 22px;\r\n position: absolute;\r\n top: 50%;\r\n left: 50%;\r\n transform: translate(-50%, -48%) scale(0.73);\r\n -webkit-transform: translate(-50%, -48%) scale(0.73);\n}\nuni-switch .uni-checkbox-input.uni-checkbox-input-disabled {\r\n background-color: #E1E1E1;\n}\nuni-switch .uni-checkbox-input.uni-checkbox-input-disabled:before {\r\n color: #ADADAD;\n}\r\n'; +const _sfc_main$9 = { + name: "Switch", + mixins: [emitter, listeners], + props: { + name: { + type: String, + default: "" }, - _findDelta: function(event2) { - var touchInfo = this._touchInfo; - return event2.detail.state === "move" || event2.detail.state === "end" ? { - x: event2.detail.dx, - y: event2.detail.dy - } : { - x: event2.screenX - touchInfo.x, - y: event2.screenY - touchInfo.y - }; + checked: { + type: [Boolean, String], + default: false }, - _handleTouchStart: function(e2) { - var t2 = this._touchInfo; - var n = this._scroller; - if (n) { - if (e2.detail.state === "start") { - t2.trackingID = "touch"; - t2.x = e2.detail.x; - t2.y = e2.detail.y; - } else { - t2.trackingID = "mouse"; - t2.x = e2.screenX; - t2.y = e2.screenY; - } - t2.maxDx = 0; - t2.maxDy = 0; - t2.historyX = [0]; - t2.historyY = [0]; - t2.historyTime = [e2.detail.timeStamp]; - t2.listener = n; - if (n.onTouchStart) { - n.onTouchStart(); - } - event.preventDefault(); - } + type: { + type: String, + default: "switch" }, - _handleTouchMove: function(event2) { - var touchInfo = this._touchInfo; - if (touchInfo.trackingID !== -1) { - event2.preventDefault(); - var delta = this._findDelta(event2); - if (delta) { - for (touchInfo.maxDy = Math.max(touchInfo.maxDy, Math.abs(delta.y)), touchInfo.maxDx = Math.max(touchInfo.maxDx, Math.abs(delta.x)), touchInfo.historyX.push(delta.x), touchInfo.historyY.push(delta.y), touchInfo.historyTime.push(event2.detail.timeStamp); touchInfo.historyTime.length > 10; ) { - touchInfo.historyTime.shift(); - touchInfo.historyX.shift(); - touchInfo.historyY.shift(); - } - if (touchInfo.listener && touchInfo.listener.onTouchMove) { - touchInfo.listener.onTouchMove(delta.x, delta.y, event2.detail.timeStamp); - } - } + id: { + type: String, + default: "" + }, + disabled: { + type: [Boolean, String], + default: false + }, + color: { + type: String, + default: "#007aff" + } + }, + data() { + return { + switchChecked: this.checked + }; + }, + watch: { + checked(val) { + this.switchChecked = val; + } + }, + created() { + this.$dispatch("Form", "uni-form-group-update", { + type: "add", + vm: this + }); + }, + beforeDestroy() { + this.$dispatch("Form", "uni-form-group-update", { + type: "remove", + vm: this + }); + }, + listeners: { + "label-click": "_onClick", + "@label-click": "_onClick" + }, + methods: { + _onClick($event) { + if (this.disabled) { + return; } + this.switchChecked = !this.switchChecked; + this.$trigger("change", $event, { + value: this.switchChecked + }); }, - _handleTouchEnd: function(event2) { - var touchInfo = this._touchInfo; - if (touchInfo.trackingID !== -1) { - event2.preventDefault(); - var delta = this._findDelta(event2); - if (delta) { - var listener = touchInfo.listener; - touchInfo.trackingID = -1; - touchInfo.listener = null; - var r = touchInfo.historyTime.length; - var o2 = { - x: 0, - y: 0 - }; - if (r > 2) { - for (var a2 = touchInfo.historyTime.length - 1, s = touchInfo.historyTime[a2], l = touchInfo.historyX[a2], c = touchInfo.historyY[a2]; a2 > 0; ) { - a2--; - var u = touchInfo.historyTime[a2]; - var d = s - u; - if (d > 30 && d < 50) { - o2.x = (l - touchInfo.historyX[a2]) / (d / 1e3); - o2.y = (c - touchInfo.historyY[a2]) / (d / 1e3); - break; - } - } - } - touchInfo.historyTime = []; - touchInfo.historyX = []; - touchInfo.historyY = []; - if (listener && listener.onTouchEnd) { - listener.onTouchEnd(delta.x, delta.y, o2); - } - } + _resetFormData() { + this.switchChecked = false; + }, + _getFormData() { + const data = {}; + if (this.name !== "") { + data.value = this.switchChecked; + data.key = this.name; } + return data; } } }; -var index_vue_vue_type_style_index_0_lang$8 = "\nuni-scroll-view {\n display: block;\n width: 100%;\n}\nuni-scroll-view[hidden] {\n display: none;\n}\n.uni-scroll-view {\n position: relative;\n -webkit-overflow-scrolling: touch;\n width: 100%;\n /* display: flex; \u65F6\u5728\u5B89\u5353\u4E0B\u4F1A\u5BFC\u81F4scrollWidth\u548CoffsetWidth\u4E00\u6837 */\n height: 100%;\n max-height: inherit;\n}\n.uni-scroll-view-content {\n width: 100%;\n height: 100%;\n}\n.uni-scroll-view-refresher {\n position: relative;\n overflow: hidden;\n}\n.uni-scroll-view-refresh {\n position: absolute;\n top: 0;\n left: 0;\n right: 0;\n bottom: 0;\n display: flex;\n flex-direction: row;\n justify-content: center;\n align-items: center;\n}\n.uni-scroll-view-refresh-inner {\n display: flex;\n align-items: center;\n justify-content: center;\n line-height: 0;\n width: 40px;\n height: 40px;\n border-radius: 50%;\n background-color: #fff;\n box-shadow: 0 1px 6px rgba(0, 0, 0, 0.117647),\n 0 1px 4px rgba(0, 0, 0, 0.117647);\n}\n.uni-scroll-view-refresh__spinner {\n transform-origin: center center;\n animation: uni-scroll-view-refresh-rotate 2s linear infinite;\n}\n.uni-scroll-view-refresh__spinner > circle {\n stroke: currentColor;\n stroke-linecap: round;\n animation: uni-scroll-view-refresh-dash 2s linear infinite;\n}\n@keyframes uni-scroll-view-refresh-rotate {\n0% {\n transform: rotate(0deg);\n}\n100% {\n transform: rotate(360deg);\n}\n}\n@keyframes uni-scroll-view-refresh-dash {\n0% {\n stroke-dasharray: 1, 200;\n stroke-dashoffset: 0;\n}\n50% {\n stroke-dasharray: 89, 200;\n stroke-dashoffset: -35px;\n}\n100% {\n stroke-dasharray: 89, 200;\n stroke-dashoffset: -124px;\n}\n}\n"; -const _sfc_main$c = { - name: "ScrollView", - mixins: [scroller], +const _hoisted_1$4 = {class: "uni-switch-wrapper"}; +function _sfc_render$8(_ctx, _cache, $props, $setup, $data, $options) { + return openBlock(), createBlock("uni-switch", mergeProps({disabled: $props.disabled}, _ctx.$attrs, { + onClick: _cache[1] || (_cache[1] = (...args) => $options._onClick && $options._onClick(...args)) + }), [ + createVNode("div", _hoisted_1$4, [ + withDirectives(createVNode("div", { + class: [[$data.switchChecked ? "uni-switch-input-checked" : ""], "uni-switch-input"], + style: {backgroundColor: $data.switchChecked ? $props.color : "#DFDFDF", borderColor: $data.switchChecked ? $props.color : "#DFDFDF"} + }, null, 6), [ + [vShow, $props.type === "switch"] + ]), + withDirectives(createVNode("div", { + class: [[$data.switchChecked ? "uni-checkbox-input-checked" : ""], "uni-checkbox-input"], + style: {color: $props.color} + }, null, 6), [ + [vShow, $props.type === "checkbox"] + ]) + ]) + ], 16, ["disabled"]); +} +_sfc_main$9.render = _sfc_render$8; +var index_vue_vue_type_style_index_0_lang$5 = "\nuni-text[selectable] {\r\n cursor: auto;\r\n user-select: text;\r\n -webkit-user-select: text;\n}\r\n"; +const SPACE_UNICODE = { + ensp: "\u2002", + emsp: "\u2003", + nbsp: "\xA0" +}; +const _sfc_main$8 = { + name: "Text", props: { - scrollX: { + selectable: { type: [Boolean, String], default: false }, - scrollY: { + space: { + type: String, + default: "" + }, + decode: { type: [Boolean, String], default: false + } + }, + methods: { + _decodeHtml(htmlString) { + if (this.space && SPACE_UNICODE[this.space]) { + htmlString = htmlString.replace(/ /g, SPACE_UNICODE[this.space]); + } + if (this.decode) { + htmlString = htmlString.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, "'"); + } + return htmlString; + } + }, + render(createElement) { + const nodeList = []; + this.$slots.default && this.$slots.default.forEach((vnode) => { + if (vnode.text) { + const nodeText = vnode.text.replace(/\\n/g, "\n"); + const texts = nodeText.split("\n"); + texts.forEach((text2, index2) => { + nodeList.push(this._decodeHtml(text2)); + if (index2 !== texts.length - 1) { + nodeList.push(createElement("br")); + } + }); + } else { + if (vnode.componentOptions && vnode.componentOptions.tag !== "v-uni-text") { + console.warn(" \u7EC4\u4EF6\u5185\u53EA\u652F\u6301\u5D4C\u5957 \uFF0C\u4E0D\u652F\u6301\u5176\u5B83\u7EC4\u4EF6\u6216\u81EA\u5B9A\u4E49\u7EC4\u4EF6\uFF0C\u5426\u5219\u4F1A\u5F15\u53D1\u5728\u4E0D\u540C\u5E73\u53F0\u7684\u6E32\u67D3\u5DEE\u5F02\u3002"); + } + nodeList.push(vnode); + } + }); + return createElement("uni-text", { + on: this.$listeners, + attrs: { + selectable: !!this.selectable + } + }, [ + createElement("span", {}, nodeList) + ]); + } +}; +var index_vue_vue_type_style_index_0_lang$4 = "\nuni-textarea {\n width: 300px;\n height: 150px;\n display: block;\n position: relative;\n font-size: 16px;\n line-height: normal;\n white-space: pre-wrap;\n word-break: break-all;\n}\nuni-textarea[hidden] {\n display: none;\n}\n.uni-textarea-wrapper,\n.uni-textarea-placeholder,\n.uni-textarea-line,\n.uni-textarea-compute,\n.uni-textarea-textarea {\n outline: none;\n border: none;\n padding: 0;\n margin: 0;\n text-decoration: inherit;\n}\n.uni-textarea-wrapper {\n display: block;\n position: relative;\n width: 100%;\n height: 100%;\n}\n.uni-textarea-placeholder,\n.uni-textarea-line,\n.uni-textarea-compute,\n.uni-textarea-textarea {\n position: absolute;\n width: 100%;\n height: 100%;\n left: 0;\n top: 0;\n white-space: inherit;\n word-break: inherit;\n}\n.uni-textarea-placeholder {\n color: grey;\n overflow: hidden;\n}\n.uni-textarea-line,\n.uni-textarea-compute {\n visibility: hidden;\n height: auto;\n}\n.uni-textarea-line {\n width: 1em;\n}\n.uni-textarea-textarea {\n resize: none;\n background: none;\n color: inherit;\n opacity: 1;\n -webkit-text-fill-color: currentcolor;\n font: inherit;\n line-height: inherit;\n letter-spacing: inherit;\n text-align: inherit;\n text-indent: inherit;\n text-transform: inherit;\n text-shadow: inherit;\n}\n/* \u7528\u4E8E\u89E3\u51B3 iOS textarea \u5185\u90E8\u9ED8\u8BA4\u8FB9\u8DDD */\n.uni-textarea-textarea-fix-margin {\n width: auto;\n right: 0;\n margin: 0 -3px;\n}\n"; +const DARK_TEST_STRING = "(prefers-color-scheme: dark)"; +const _sfc_main$7 = { + name: "Textarea", + mixins: [baseInput], + props: { + name: { + type: String, + default: "" }, - upperThreshold: { - type: [Number, String], - default: 50 - }, - lowerThreshold: { - type: [Number, String], - default: 50 - }, - scrollTop: { - type: [Number, String], - default: 0 - }, - scrollLeft: { + maxlength: { type: [Number, String], - default: 0 + default: 140 }, - scrollIntoView: { + placeholder: { type: String, default: "" }, - scrollWithAnimation: { + disabled: { type: [Boolean, String], default: false }, - enableBackToTop: { + focus: { type: [Boolean, String], default: false }, - refresherEnabled: { + autoFocus: { type: [Boolean, String], default: false }, - refresherThreshold: { - type: Number, - default: 45 - }, - refresherDefaultStyle: { + placeholderClass: { type: String, - default: "back" + default: "textarea-placeholder" }, - refresherBackground: { + placeholderStyle: { type: String, - default: "#fff" + default: "" }, - refresherTriggered: { + autoHeight: { type: [Boolean, String], default: false - } - }, - data() { - return { - lastScrollTop: this.scrollTopNumber, - lastScrollLeft: this.scrollLeftNumber, - lastScrollToUpperTime: 0, - lastScrollToLowerTime: 0, - refresherHeight: 0, - refreshRotate: 0, - refreshState: "" - }; - }, - computed: { - upperThresholdNumber() { - var val = Number(this.upperThreshold); - return isNaN(val) ? 50 : val; - }, - lowerThresholdNumber() { - var val = Number(this.lowerThreshold); - return isNaN(val) ? 50 : val; - }, - scrollTopNumber() { - return Number(this.scrollTop) || 0; - }, - scrollLeftNumber() { - return Number(this.scrollLeft) || 0; - } - }, - watch: { - scrollTopNumber(val) { - this._scrollTopChanged(val); }, - scrollLeftNumber(val) { - this._scrollLeftChanged(val); + cursor: { + type: [Number, String], + default: -1 }, - scrollIntoView(val) { - this._scrollIntoViewChanged(val); + selectionStart: { + type: [Number, String], + default: -1 }, - refresherTriggered(val) { - if (val === true) { - this._setRefreshState("refreshing"); - } else if (val === false) { - this._setRefreshState("restore"); - } + selectionEnd: { + type: [Number, String], + default: -1 } }, - mounted() { - var self = this; - this._attached = true; - this._scrollTopChanged(this.scrollTopNumber); - this._scrollLeftChanged(this.scrollLeftNumber); - this._scrollIntoViewChanged(this.scrollIntoView); - this.__handleScroll = function(e2) { - event.preventDefault(); - event.stopPropagation(); - self._handleScroll.bind(self, event)(); - }; - var touchStart = null; - var needStop = null; - this.__handleTouchMove = function(event2) { - var x = event2.touches[0].pageX; - var y = event2.touches[0].pageY; - var main = self.$refs.main; - if (needStop === null) { - if (Math.abs(x - touchStart.x) > Math.abs(y - touchStart.y)) { - if (self.scrollX) { - if (main.scrollLeft === 0 && x > touchStart.x) { - needStop = false; - return; - } else if (main.scrollWidth === main.offsetWidth + main.scrollLeft && x < touchStart.x) { - needStop = false; - return; - } - needStop = true; - } else { - needStop = false; - } - } else { - if (self.scrollY) { - if (main.scrollTop === 0 && y > touchStart.y) { - needStop = false; - return; - } else if (main.scrollHeight === main.offsetHeight + main.scrollTop && y < touchStart.y) { - needStop = false; - return; - } - needStop = true; - } else { - needStop = false; - } - } - } - if (needStop) { - event2.stopPropagation(); - } - if (self.refresherEnabled && self.refreshState === "pulling") { - const dy = y - touchStart.y; - self.refresherHeight = dy; - let rotate = dy / self.refresherThreshold; - if (rotate > 1) { - rotate = 1; - } else { - rotate = rotate * 360; - } - self.refreshRotate = rotate; - self.$trigger("refresherpulling", event2, { - deltaY: dy - }); - } - }; - this.__handleTouchStart = function(event2) { - if (event2.touches.length === 1) { - needStop = null; - touchStart = { - x: event2.touches[0].pageX, - y: event2.touches[0].pageY - }; - if (self.refresherEnabled && self.refreshState !== "refreshing" && self.$refs.main.scrollTop === 0) { - self.refreshState = "pulling"; - } - } - }; - this.__handleTouchEnd = function(event2) { - touchStart = null; - if (self.refresherHeight >= self.refresherThreshold) { - self._setRefreshState("refreshing"); - } else { - self.refresherHeight = 0; - self.$trigger("refresherabort", event2, {}); - } + data() { + return { + valueComposition: "", + composition: false, + focusSync: this.focus, + height: 0, + focusChangeSource: "", + fixMargin: String(navigator.platform).indexOf("iP") === 0 && String(navigator.vendor).indexOf("Apple") === 0 && window.matchMedia(DARK_TEST_STRING).media !== DARK_TEST_STRING }; - this.$refs.main.addEventListener("touchstart", this.__handleTouchStart, passiveOptions); - this.$refs.main.addEventListener("touchmove", this.__handleTouchMove, passiveOptions); - this.$refs.main.addEventListener("scroll", this.__handleScroll, supportsPassive ? { - passive: false - } : false); - this.$refs.main.addEventListener("touchend", this.__handleTouchEnd, passiveOptions); - }, - activated() { - this.scrollY && (this.$refs.main.scrollTop = this.lastScrollTop); - this.scrollX && (this.$refs.main.scrollLeft = this.lastScrollLeft); }, - beforeDestroy() { - this.$refs.main.removeEventListener("touchstart", this.__handleTouchStart, passiveOptions); - this.$refs.main.removeEventListener("touchmove", this.__handleTouchMove, passiveOptions); - this.$refs.main.removeEventListener("scroll", this.__handleScroll, supportsPassive ? { - passive: false - } : false); - this.$refs.main.removeEventListener("touchend", this.__handleTouchEnd, passiveOptions); + computed: { + maxlengthNumber() { + var maxlength = Number(this.maxlength); + return isNaN(maxlength) ? 140 : maxlength; + }, + cursorNumber() { + var cursor = Number(this.cursor); + return isNaN(cursor) ? -1 : cursor; + }, + selectionStartNumber() { + var selectionStart = Number(this.selectionStart); + return isNaN(selectionStart) ? -1 : selectionStart; + }, + selectionEndNumber() { + var selectionEnd = Number(this.selectionEnd); + return isNaN(selectionEnd) ? -1 : selectionEnd; + }, + valueCompute() { + return (this.composition ? this.valueComposition : this.valueSync).split("\n"); + } }, - methods: { - scrollTo: function(t2, n) { - var i2 = this.$refs.main; - t2 < 0 ? t2 = 0 : n === "x" && t2 > i2.scrollWidth - i2.offsetWidth ? t2 = i2.scrollWidth - i2.offsetWidth : n === "y" && t2 > i2.scrollHeight - i2.offsetHeight && (t2 = i2.scrollHeight - i2.offsetHeight); - var r = 0; - var o2 = ""; - n === "x" ? r = i2.scrollLeft - t2 : n === "y" && (r = i2.scrollTop - t2); - if (r !== 0) { - this.$refs.content.style.transition = "transform .3s ease-out"; - this.$refs.content.style.webkitTransition = "-webkit-transform .3s ease-out"; - if (n === "x") { - o2 = "translateX(" + r + "px) translateZ(0)"; - } else { - n === "y" && (o2 = "translateY(" + r + "px) translateZ(0)"); + watch: { + focus(val) { + if (val) { + this.focusChangeSource = "focus"; + if (this.$refs.textarea) { + this.$refs.textarea.focus(); } - this.$refs.content.removeEventListener("transitionend", this.__transitionEnd); - this.$refs.content.removeEventListener("webkitTransitionEnd", this.__transitionEnd); - this.__transitionEnd = this._transitionEnd.bind(this, t2, n); - this.$refs.content.addEventListener("transitionend", this.__transitionEnd); - this.$refs.content.addEventListener("webkitTransitionEnd", this.__transitionEnd); - if (n === "x") { - i2.style.overflowX = "hidden"; - } else if (n === "y") { - i2.style.overflowY = "hidden"; + } else { + if (this.$refs.textarea) { + this.$refs.textarea.blur(); } - this.$refs.content.style.transform = o2; - this.$refs.content.style.webkitTransform = o2; } }, - _handleTrack: function($event) { - if ($event.detail.state === "start") { - this._x = $event.detail.x; - this._y = $event.detail.y; - this._noBubble = null; - return; - } - if ($event.detail.state === "end") { - this._noBubble = false; - } - if (this._noBubble === null && this.scrollY) { - if (Math.abs(this._y - $event.detail.y) / Math.abs(this._x - $event.detail.x) > 1) { - this._noBubble = true; - } else { - this._noBubble = false; - } - } - if (this._noBubble === null && this.scrollX) { - if (Math.abs(this._x - $event.detail.x) / Math.abs(this._y - $event.detail.y) > 1) { - this._noBubble = true; - } else { - this._noBubble = false; - } - } - this._x = $event.detail.x; - this._y = $event.detail.y; - if (this._noBubble) { - $event.stopPropagation(); - } + focusSync(val) { + this.$emit("update:focus", val); + this._checkSelection(); + this._checkCursor(); }, - _handleScroll: function($event) { - if (!($event.timeStamp - this._lastScrollTime < 20)) { - this._lastScrollTime = $event.timeStamp; - const target = $event.target; - this.$trigger("scroll", $event, { - scrollLeft: target.scrollLeft, - scrollTop: target.scrollTop, - scrollHeight: target.scrollHeight, - scrollWidth: target.scrollWidth, - deltaX: this.lastScrollLeft - target.scrollLeft, - deltaY: this.lastScrollTop - target.scrollTop - }); - if (this.scrollY) { - if (target.scrollTop <= this.upperThresholdNumber && this.lastScrollTop - target.scrollTop > 0 && $event.timeStamp - this.lastScrollToUpperTime > 200) { - this.$trigger("scrolltoupper", $event, { - direction: "top" - }); - this.lastScrollToUpperTime = $event.timeStamp; - } - if (target.scrollTop + target.offsetHeight + this.lowerThresholdNumber >= target.scrollHeight && this.lastScrollTop - target.scrollTop < 0 && $event.timeStamp - this.lastScrollToLowerTime > 200) { - this.$trigger("scrolltolower", $event, { - direction: "bottom" - }); - this.lastScrollToLowerTime = $event.timeStamp; - } - } - if (this.scrollX) { - if (target.scrollLeft <= this.upperThresholdNumber && this.lastScrollLeft - target.scrollLeft > 0 && $event.timeStamp - this.lastScrollToUpperTime > 200) { - this.$trigger("scrolltoupper", $event, { - direction: "left" - }); - this.lastScrollToUpperTime = $event.timeStamp; - } - if (target.scrollLeft + target.offsetWidth + this.lowerThresholdNumber >= target.scrollWidth && this.lastScrollLeft - target.scrollLeft < 0 && $event.timeStamp - this.lastScrollToLowerTime > 200) { - this.$trigger("scrolltolower", $event, { - direction: "right" - }); - this.lastScrollToLowerTime = $event.timeStamp; - } - } - this.lastScrollTop = target.scrollTop; - this.lastScrollLeft = target.scrollLeft; - } + cursorNumber() { + this._checkCursor(); }, - _scrollTopChanged: function(val) { - if (this.scrollY) { - if (this._innerSetScrollTop) { - this._innerSetScrollTop = false; - } else { - if (this.scrollWithAnimation) { - this.scrollTo(val, "y"); - } else { - this.$refs.main.scrollTop = val; - } - } + selectionStartNumber() { + this._checkSelection(); + }, + selectionEndNumber() { + this._checkSelection(); + }, + height(height) { + let lineHeight = parseFloat(getComputedStyle(this.$el).lineHeight); + if (isNaN(lineHeight)) { + lineHeight = this.$refs.line.offsetHeight; + } + var lineCount = Math.round(height / lineHeight); + this.$trigger("linechange", {}, { + height, + heightRpx: 750 / window.innerWidth * height, + lineCount + }); + if (this.autoHeight) { + this.$el.style.height = this.height + "px"; + } + } + }, + created() { + this.$dispatch("Form", "uni-form-group-update", { + type: "add", + vm: this + }); + }, + mounted() { + this._resize({ + height: this.$refs.sensor.$el.offsetHeight + }); + let $vm = this; + while ($vm) { + const scopeId = $vm.$options._scopeId; + if (scopeId) { + this.$refs.placeholder.setAttribute(scopeId, ""); } + $vm = $vm.$parent; + } + this.initKeyboard(this.$refs.textarea); + }, + beforeDestroy() { + this.$dispatch("Form", "uni-form-group-update", { + type: "remove", + vm: this + }); + }, + methods: { + _focus: function($event) { + this.focusSync = true; + this.$trigger("focus", $event, { + value: this.valueSync + }); }, - _scrollLeftChanged: function(val) { - if (this.scrollX) { - if (this._innerSetScrollLeft) { - this._innerSetScrollLeft = false; - } else { - if (this.scrollWithAnimation) { - this.scrollTo(val, "x"); - } else { - this.$refs.main.scrollLeft = val; - } - } + _checkSelection() { + if (this.focusSync && !this.focusChangeSource && this.selectionStartNumber > -1 && this.selectionEndNumber > -1) { + this.$refs.textarea.selectionStart = this.selectionStartNumber; + this.$refs.textarea.selectionEnd = this.selectionEndNumber; } }, - _scrollIntoViewChanged: function(val) { - if (val) { - if (!/^[_a-zA-Z][-_a-zA-Z0-9:]*$/.test(val)) { - console.group('scroll-into-view="' + val + '" \u6709\u8BEF'); - console.error("id \u5C5E\u6027\u503C\u683C\u5F0F\u9519\u8BEF\u3002\u5982\u4E0D\u80FD\u4EE5\u6570\u5B57\u5F00\u5934\u3002"); - console.groupEnd(); - return; - } - var element = this.$el.querySelector("#" + val); - if (element) { - var mainRect = this.$refs.main.getBoundingClientRect(); - var elRect = element.getBoundingClientRect(); - if (this.scrollX) { - var left = elRect.left - mainRect.left; - var scrollLeft = this.$refs.main.scrollLeft; - var x = scrollLeft + left; - if (this.scrollWithAnimation) { - this.scrollTo(x, "x"); - } else { - this.$refs.main.scrollLeft = x; - } - } - if (this.scrollY) { - var top = elRect.top - mainRect.top; - var scrollTop = this.$refs.main.scrollTop; - var y = scrollTop + top; - if (this.scrollWithAnimation) { - this.scrollTo(y, "y"); - } else { - this.$refs.main.scrollTop = y; - } - } - } + _checkCursor() { + if (this.focusSync && (this.focusChangeSource === "focus" || !this.focusChangeSource && this.selectionStartNumber < 0 && this.selectionEndNumber < 0) && this.cursorNumber > -1) { + this.$refs.textarea.selectionEnd = this.$refs.textarea.selectionStart = this.cursorNumber; } }, - _transitionEnd: function(val, type) { - this.$refs.content.style.transition = ""; - this.$refs.content.style.webkitTransition = ""; - this.$refs.content.style.transform = ""; - this.$refs.content.style.webkitTransform = ""; - var main = this.$refs.main; - if (type === "x") { - main.style.overflowX = this.scrollX ? "auto" : "hidden"; - main.scrollLeft = val; - } else if (type === "y") { - main.style.overflowY = this.scrollY ? "auto" : "hidden"; - main.scrollTop = val; + _blur: function($event) { + this.focusSync = false; + this.$trigger("blur", $event, { + value: this.valueSync, + cursor: this.$refs.textarea.selectionEnd + }); + }, + _compositionstart($event) { + this.composition = true; + }, + _compositionend($event) { + this.composition = false; + }, + _confirm($event) { + this.$trigger("confirm", $event, { + value: this.valueSync + }); + }, + _linechange($event) { + this.$trigger("linechange", $event, { + value: this.valueSync + }); + }, + _touchstart() { + this.focusChangeSource = "touch"; + }, + _resize({height}) { + this.height = height; + }, + _input($event) { + if (this.composition) { + this.valueComposition = $event.target.value; + return; } - this.$refs.content.removeEventListener("transitionend", this.__transitionEnd); - this.$refs.content.removeEventListener("webkitTransitionEnd", this.__transitionEnd); + this.$triggerInput($event, { + value: this.valueSync, + cursor: this.$refs.textarea.selectionEnd + }); }, - _setRefreshState(state) { - switch (state) { - case "refreshing": - this.refresherHeight = this.refresherThreshold; - this.$trigger("refresherrefresh", event, {}); - break; - case "restore": - this.refresherHeight = 0; - this.$trigger("refresherrestore", {}, {}); - break; + _getFormData() { + return { + value: this.valueSync, + key: this.name + }; + }, + _resetFormData() { + this.valueSync = ""; + } + } +}; +const _hoisted_1$3 = {class: "uni-textarea-wrapper"}; +const _hoisted_2$3 = {class: "uni-textarea-compute"}; +function _sfc_render$7(_ctx, _cache, $props, $setup, $data, $options) { + const _component_v_uni_resize_sensor = resolveComponent("v-uni-resize-sensor"); + return openBlock(), createBlock("uni-textarea", mergeProps({ + onChange: _cache[8] || (_cache[8] = withModifiers(() => { + }, ["stop"])) + }, _ctx.$attrs), [ + createVNode("div", _hoisted_1$3, [ + withDirectives(createVNode("div", { + ref: "placeholder", + style: $props.placeholderStyle, + class: [$props.placeholderClass, "uni-textarea-placeholder"], + textContent: toDisplayString($props.placeholder) + }, null, 14, ["textContent"]), [ + [vShow, !($data.composition || _ctx.valueSync.length)] + ]), + createVNode("div", { + ref: "line", + class: "uni-textarea-line", + textContent: toDisplayString(" ") + }, null, 8, ["textContent"]), + createVNode("div", _hoisted_2$3, [ + (openBlock(true), createBlock(Fragment, null, renderList($options.valueCompute, (item, index2) => { + return openBlock(), createBlock("div", { + key: index2, + textContent: toDisplayString(item.trim() ? item : ".") + }, null, 8, ["textContent"]); + }), 128)), + createVNode(_component_v_uni_resize_sensor, { + ref: "sensor", + onResize: $options._resize + }, null, 8, ["onResize"]) + ]), + withDirectives(createVNode("textarea", { + ref: "textarea", + "onUpdate:modelValue": _cache[1] || (_cache[1] = ($event) => _ctx.valueSync = $event), + disabled: $props.disabled, + maxlength: $options.maxlengthNumber, + autofocus: $props.autoFocus || $props.focus, + class: [{"uni-textarea-textarea-fix-margin": $data.fixMargin}, "uni-textarea-textarea"], + style: {"overflow-y": $props.autoHeight ? "hidden" : "auto"}, + onCompositionstart: _cache[2] || (_cache[2] = (...args) => $options._compositionstart && $options._compositionstart(...args)), + onCompositionend: _cache[3] || (_cache[3] = (...args) => $options._compositionend && $options._compositionend(...args)), + onInput: _cache[4] || (_cache[4] = withModifiers((...args) => $options._input && $options._input(...args), ["stop"])), + onFocus: _cache[5] || (_cache[5] = (...args) => $options._focus && $options._focus(...args)), + onBlur: _cache[6] || (_cache[6] = (...args) => $options._blur && $options._blur(...args)), + onTouchstartPassive: _cache[7] || (_cache[7] = (...args) => $options._touchstart && $options._touchstart(...args)) + }, null, 46, ["disabled", "maxlength", "autofocus"]), [ + [vModelText, _ctx.valueSync] + ]) + ]) + ], 16); +} +_sfc_main$7.render = _sfc_render$7; +var index_vue_vue_type_style_index_0_lang$3 = "\nuni-view {\r\n display: block;\n}\nuni-view[hidden] {\r\n display: none;\n}\r\n"; +const _sfc_main$6 = { + name: "View", + mixins: [hover], + listeners: { + "label-click": "clickHandler" + } +}; +function _sfc_render$6(_ctx, _cache, $props, $setup, $data, $options) { + return _ctx.hoverClass && _ctx.hoverClass !== "none" ? (openBlock(), createBlock("uni-view", mergeProps({ + key: 0, + class: [_ctx.hovering ? _ctx.hoverClass : ""], + onTouchstart: _cache[1] || (_cache[1] = (...args) => _ctx._hoverTouchStart && _ctx._hoverTouchStart(...args)), + onTouchend: _cache[2] || (_cache[2] = (...args) => _ctx._hoverTouchEnd && _ctx._hoverTouchEnd(...args)), + onTouchcancel: _cache[3] || (_cache[3] = (...args) => _ctx._hoverTouchCancel && _ctx._hoverTouchCancel(...args)) + }, _ctx.$attrs), [ + renderSlot(_ctx.$slots, "default") + ], 16)) : (openBlock(), createBlock("uni-view", mergeProps({key: 1}, _ctx.$attrs), [ + renderSlot(_ctx.$slots, "default") + ], 16)); +} +_sfc_main$6.render = _sfc_render$6; +const UniViewJSBridge$1 = extend(ViewJSBridge, { + publishHandler(event2, args, pageId) { + window.UniServiceJSBridge.subscribeHandler(event2, args, pageId); + } +}); +var chars = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/"; +var lookup = new Uint8Array(256); +for (var i = 0; i < chars.length; i++) { + lookup[chars.charCodeAt(i)] = i; +} +function encode(arraybuffer) { + var bytes = new Uint8Array(arraybuffer), i, len = bytes.length, base64 = ""; + for (i = 0; i < len; i += 3) { + base64 += chars[bytes[i] >> 2]; + base64 += chars[(bytes[i] & 3) << 4 | bytes[i + 1] >> 4]; + base64 += chars[(bytes[i + 1] & 15) << 2 | bytes[i + 2] >> 6]; + base64 += chars[bytes[i + 2] & 63]; + } + if (len % 3 === 2) { + base64 = base64.substring(0, base64.length - 1) + "="; + } else if (len % 3 === 1) { + base64 = base64.substring(0, base64.length - 2) + "=="; + } + return base64; +} +function decode(base64) { + var bufferLength = base64.length * 0.75, len = base64.length, i, p2 = 0, encoded1, encoded2, encoded3, encoded4; + if (base64[base64.length - 1] === "=") { + bufferLength--; + if (base64[base64.length - 2] === "=") { + bufferLength--; + } + } + var arraybuffer = new ArrayBuffer(bufferLength), bytes = new Uint8Array(arraybuffer); + for (i = 0; i < len; i += 4) { + encoded1 = lookup[base64.charCodeAt(i)]; + encoded2 = lookup[base64.charCodeAt(i + 1)]; + encoded3 = lookup[base64.charCodeAt(i + 2)]; + encoded4 = lookup[base64.charCodeAt(i + 3)]; + bytes[p2++] = encoded1 << 2 | encoded2 >> 4; + bytes[p2++] = (encoded2 & 15) << 4 | encoded3 >> 2; + bytes[p2++] = (encoded3 & 3) << 6 | encoded4 & 63; + } + return arraybuffer; +} +function validateProtocolFail(name, msg) { + const errMsg = `${name}:fail ${msg}`; + { + console.error(errMsg); + } + return { + errMsg + }; +} +function validateProtocol(name, data, protocol) { + for (const key in protocol) { + const errMsg = validateProp(key, data[key], protocol[key], !hasOwn$1(data, key)); + if (errMsg) { + return validateProtocolFail(name, errMsg); + } + } +} +function validateProtocols(name, args, protocol) { + if (!protocol) { + return; + } + if (isArray(protocol)) { + const len = protocol.length; + const argsLen = args.length; + for (let i = 0; i < len; i++) { + const opts = protocol[i]; + const data = Object.create(null); + if (argsLen > i) { + data[opts.name] = args[i]; + } + const errMsg = validateProtocol(name, data, {[opts.name]: opts}); + if (errMsg) { + return errMsg; + } + } + return; + } + return validateProtocol(name, args[0] || Object.create(null), protocol); +} +function validateProp(name, value, prop, isAbsent) { + const {type, required, validator} = prop; + if (required && isAbsent) { + return 'Missing required args: "' + name + '"'; + } + if (value == null && !prop.required) { + return; + } + if (type != null && type !== true) { + let isValid = false; + const types = isArray(type) ? type : [type]; + const expectedTypes = []; + for (let i = 0; i < types.length && !isValid; i++) { + const {valid, expectedType} = assertType(value, types[i]); + expectedTypes.push(expectedType || ""); + isValid = valid; + } + if (!isValid) { + return getInvalidTypeMessage(name, value, expectedTypes); + } + } + if (validator && !validator(value)) { + return 'Invalid args: custom validator check failed for args "' + name + '".'; + } +} +const isSimpleType = /* @__PURE__ */ makeMap$1("String,Number,Boolean,Function,Symbol"); +function assertType(value, type) { + let valid; + const expectedType = getType(type); + if (isSimpleType(expectedType)) { + const t2 = typeof value; + valid = t2 === expectedType.toLowerCase(); + if (!valid && t2 === "object") { + valid = value instanceof type; + } + } else if (expectedType === "Object") { + valid = isObject$1(value); + } else if (expectedType === "Array") { + valid = isArray(value); + } else { + { + valid = value instanceof type; + } + } + return { + valid, + expectedType + }; +} +function getInvalidTypeMessage(name, value, expectedTypes) { + let message = `Invalid args: type check failed for args "${name}". Expected ${expectedTypes.map(capitalize).join(", ")}`; + const expectedType = expectedTypes[0]; + const receivedType = toRawType(value); + const expectedValue = styleValue(value, expectedType); + const receivedValue = styleValue(value, receivedType); + if (expectedTypes.length === 1 && isExplicable(expectedType) && !isBoolean(expectedType, receivedType)) { + message += ` with value ${expectedValue}`; + } + message += `, got ${receivedType} `; + if (isExplicable(receivedType)) { + message += `with value ${receivedValue}.`; + } + return message; +} +function getType(ctor) { + const match = ctor && ctor.toString().match(/^\s*function (\w+)/); + return match ? match[1] : ""; +} +function styleValue(value, type) { + if (type === "String") { + return `"${value}"`; + } else if (type === "Number") { + return `${Number(value)}`; + } else { + return `${value}`; + } +} +function isExplicable(type) { + const explicitTypes = ["string", "number", "boolean"]; + return explicitTypes.some((elem) => type.toLowerCase() === elem); +} +function isBoolean(...args) { + return args.some((elem) => elem.toLowerCase() === "boolean"); +} +function tryCatch(fn) { + return function() { + try { + return fn.apply(fn, arguments); + } catch (e2) { + console.error(e2); + } + }; +} +let invokeCallbackId = 1; +const invokeCallbacks = {}; +function createInvokeCallbackName(name, callbackId) { + return "api." + name + "." + callbackId; +} +function addInvokeCallback(id2, name, callback, keepAlive = false) { + invokeCallbacks[id2] = { + name, + keepAlive, + callback + }; + return id2; +} +function invokeCallback(id2, res, extras) { + if (typeof id2 === "number") { + const opts = invokeCallbacks[id2]; + if (opts) { + if (!opts.keepAlive) { + delete invokeCallbacks[id2]; } - this.refreshState = state; - }, - getScrollPosition() { - const main = this.$refs.main; - return { - scrollLeft: main.scrollLeft, - scrollTop: main.scrollTop - }; + return opts.callback(res, extras); } } -}; -const _hoisted_1$6 = { - ref: "wrap", - class: "uni-scroll-view" -}; -const _hoisted_2$5 = { - ref: "content", - class: "uni-scroll-view-content" -}; -const _hoisted_3$2 = { - key: 0, - class: "uni-scroll-view-refresh" -}; -const _hoisted_4$2 = {class: "uni-scroll-view-refresh-inner"}; -const _hoisted_5 = /* @__PURE__ */ createVNode("path", {d: "M17.65 6.35C16.2 4.9 14.21 4 12 4c-4.42 0-7.99 3.58-7.99 8s3.57 8 7.99 8c3.73 0 6.84-2.55 7.73-6h-2.08c-.82 2.33-3.04 4-5.65 4-3.31 0-6-2.69-6-6s2.69-6 6-6c1.66 0 3.14.69 4.22 1.78L13 11h7V4l-2.35 2.35z"}, null, -1); -const _hoisted_6 = /* @__PURE__ */ createVNode("path", { - d: "M0 0h24v24H0z", - fill: "none" -}, null, -1); -const _hoisted_7 = { - key: 1, - class: "uni-scroll-view-refresh__spinner", - width: "24", - height: "24", - viewBox: "25 25 50 50" -}; -const _hoisted_8 = /* @__PURE__ */ createVNode("circle", { - cx: "50", - cy: "50", - r: "20", - fill: "none", - style: {color: "#2BD009"}, - "stroke-width": "3" -}, null, -1); -function _sfc_render$b(_ctx, _cache, $props, $setup, $data, $options) { - return openBlock(), createBlock("uni-scroll-view", _ctx.$attrs, [ - createVNode("div", _hoisted_1$6, [ - createVNode("div", { - ref: "main", - style: {"overflow-x": $props.scrollX ? "auto" : "hidden", "overflow-y": $props.scrollY ? "auto" : "hidden"}, - class: "uni-scroll-view" - }, [ - createVNode("div", _hoisted_2$5, [ - $props.refresherEnabled ? (openBlock(), createBlock("div", { - key: 0, - ref: "refresherinner", - style: {"background-color": $props.refresherBackground, height: $data.refresherHeight + "px"}, - class: "uni-scroll-view-refresher" - }, [ - $props.refresherDefaultStyle !== "none" ? (openBlock(), createBlock("div", _hoisted_3$2, [ - createVNode("div", _hoisted_4$2, [ - $data.refreshState == "pulling" ? (openBlock(), createBlock("svg", { - key: 0, - style: {transform: "rotate(" + $data.refreshRotate + "deg)"}, - fill: "#2BD009", - class: "uni-scroll-view-refresh__icon", - width: "24", - height: "24", - viewBox: "0 0 24 24" - }, [ - _hoisted_5, - _hoisted_6 - ], 4)) : createCommentVNode("", true), - $data.refreshState == "refreshing" ? (openBlock(), createBlock("svg", _hoisted_7, [ - _hoisted_8 - ])) : createCommentVNode("", true) - ]) - ])) : createCommentVNode("", true), - $props.refresherDefaultStyle == "none" ? renderSlot(_ctx.$slots, "refresher", {key: 1}) : createCommentVNode("", true) - ], 4)) : createCommentVNode("", true), - renderSlot(_ctx.$slots, "default") - ], 512) - ], 4) - ], 512) - ], 16); + return res; } -_sfc_main$c.render = _sfc_render$b; -const _sfc_main$b = { - name: "Slider", - mixins: [emitter, listeners, touchtrack], - props: { - name: { - type: String, - default: "" - }, - min: { - type: [Number, String], - default: 0 - }, - max: { - type: [Number, String], - default: 100 - }, - value: { - type: [Number, String], - default: 0 - }, - step: { - type: [Number, String], - default: 1 - }, - disabled: { - type: [Boolean, String], - default: false - }, - color: { - type: String, - default: "#e9e9e9" - }, - backgroundColor: { - type: String, - default: "#e9e9e9" - }, - activeColor: { - type: String, - default: "#007aff" - }, - selectedColor: { - type: String, - default: "#007aff" - }, - blockColor: { - type: String, - default: "#ffffff" - }, - blockSize: { - type: [Number, String], - default: 28 - }, - showValue: { - type: [Boolean, String], - default: false +function getKeepAliveApiCallback(name, callback) { + const onName = "api." + name.replace("off", "on"); + for (const key in invokeCallbacks) { + const item = invokeCallbacks[key]; + if (item.callback === callback && item.name.indexOf(onName) === 0) { + delete invokeCallbacks[key]; + return Number(key); + } + } + return -1; +} +function createKeepAliveApiCallback(name, callback) { + if (name.indexOf("off") === 0) { + return getKeepAliveApiCallback(name, callback); + } + const id2 = invokeCallbackId++; + return addInvokeCallback(id2, createInvokeCallbackName(name, id2), callback, true); +} +const API_SUCCESS = "success"; +const API_FAIL = "fail"; +const API_COMPLETE = "complete"; +function getApiCallbacks(args) { + const apiCallbacks = {}; + for (const name in args) { + const fn = args[name]; + if (isFunction(fn)) { + apiCallbacks[name] = tryCatch(fn); + delete args[name]; + } + } + return apiCallbacks; +} +function normalizeErrMsg(errMsg, name) { + if (!errMsg || errMsg.indexOf(":fail") === -1) { + return name + ":ok"; + } + return name + errMsg.substring(errMsg.indexOf(":fail")); +} +function createAsyncApiCallback(name, args = {}, {beforeAll, beforeSuccess} = {}) { + if (!isPlainObject(args)) { + args = {}; + } + const {success, fail, complete} = getApiCallbacks(args); + const hasSuccess = isFunction(success); + const hasFail = isFunction(fail); + const hasComplete = isFunction(complete); + const callbackId = invokeCallbackId++; + addInvokeCallback(callbackId, createInvokeCallbackName(name, callbackId), (res) => { + res = res || {}; + res.errMsg = normalizeErrMsg(res.errMsg, name); + isFunction(beforeAll) && beforeAll(res); + if (res.errMsg === name + ":ok") { + isFunction(beforeSuccess) && beforeSuccess(res); + hasSuccess && success(res); + } else { + hasFail && fail(res); } - }, - data() { - return { - sliderValue: Number(this.value) - }; - }, - computed: { - setBlockStyle() { - return { - width: this.blockSize + "px", - height: this.blockSize + "px", - marginLeft: -this.blockSize / 2 + "px", - marginTop: -this.blockSize / 2 + "px", - left: this._getValueWidth(), - backgroundColor: this.blockColor - }; - }, - setBgColor() { - return { - backgroundColor: this._getBgColor() - }; - }, - setBlockBg() { - return { - left: this._getValueWidth() - }; - }, - setActiveColor() { - return { - backgroundColor: this._getActiveColor(), - width: this._getValueWidth() - }; + hasComplete && complete(res); + }); + return callbackId; +} +const callbacks = [API_SUCCESS, API_FAIL, API_COMPLETE]; +function hasCallback(args) { + if (isPlainObject(args) && callbacks.find((cb) => isFunction(args[cb]))) { + return true; + } + return false; +} +function handlePromise(promise) { + if (__UNI_FEATURE_PROMISE__) { + return promise.then((data) => { + return [null, data]; + }).catch((err) => [err]); + } + return promise; +} +function promisify(fn) { + return (args = {}) => { + if (hasCallback(args)) { + return fn(args); } - }, - watch: { - value(val) { - this.sliderValue = Number(val); + return handlePromise(new Promise((resolve, reject) => { + fn(Object.assign(args, {success: resolve, fail: reject})); + })); + }; +} +const API_TYPE_ON = 0; +const API_TYPE_TASK = 1; +const API_TYPE_SYNC = 2; +const API_TYPE_ASYNC = 3; +function formatApiArgs(args, options) { + return args; +} +function wrapperOnApi(name, fn) { + return (callback) => fn.apply(null, createKeepAliveApiCallback(name, callback)); +} +function wrapperTaskApi(name, fn, options) { + return (args) => fn.apply(null, [args, createAsyncApiCallback(name, args, options)]); +} +function wrapperSyncApi(fn) { + return (...args) => fn.apply(null, args); +} +function wrapperAsyncApi(name, fn, options) { + return (args) => { + const callbackId = createAsyncApiCallback(name, args, options); + const res = fn.apply(null, [args, callbackId]); + if (res) { + invokeCallback(callbackId, res); } - }, - mounted() { - this.touchtrack(this.$refs["uni-slider-handle"], "_onTrack"); - }, - created() { - this.$dispatch("Form", "uni-form-group-update", { - type: "add", - vm: this - }); - }, - beforeDestroy() { - this.$dispatch("Form", "uni-form-group-update", { - type: "remove", - vm: this - }); - }, - methods: { - _onUserChangedValue(e2) { - const slider = this.$refs["uni-slider"]; - const offsetWidth = slider.offsetWidth; - const boxLeft = slider.getBoundingClientRect().left; - const value = (e2.x - boxLeft) * (this.max - this.min) / offsetWidth + Number(this.min); - this.sliderValue = this._filterValue(value); - }, - _filterValue(e2) { - return e2 < this.min ? this.min : e2 > this.max ? this.max : Math.round((e2 - this.min) / this.step) * this.step + Number(this.min); - }, - _getValueWidth() { - return 100 * (this.sliderValue - this.min) / (this.max - this.min) + "%"; - }, - _getBgColor() { - return this.backgroundColor !== "#e9e9e9" ? this.backgroundColor : this.color !== "#007aff" ? this.color : "#007aff"; - }, - _getActiveColor() { - return this.activeColor !== "#007aff" ? this.activeColor : this.selectedColor !== "#e9e9e9" ? this.selectedColor : "#e9e9e9"; - }, - _onTrack: function(e2) { - if (!this.disabled) { - return e2.detail.state === "move" ? (this._onUserChangedValue({ - x: e2.detail.x0 - }), this.$trigger("changing", e2, { - value: this.sliderValue - }), false) : e2.detail.state === "end" && this.$trigger("change", e2, { - value: this.sliderValue - }); - } - }, - _onClick($event) { - if (this.disabled) { - return; - } - this._onUserChangedValue($event); - this.$trigger("change", $event, { - value: this.sliderValue - }); - }, - _resetFormData() { - this.sliderValue = this.min; - }, - _getFormData() { - const data = {}; - if (this.name !== "") { - data.value = this.sliderValue; - data.key = this.name; + }; +} +function wrapperApi(fn, name, protocol, options) { + return function(...args) { + if (process.env.NODE_ENV !== "production") { + const errMsg = validateProtocols(name, args, protocol); + if (errMsg) { + return errMsg; } - return data; } + return fn.apply(null, formatApiArgs(args)); + }; +} +function createSyncApi(name, fn, protocol, options) { + return createApi(API_TYPE_SYNC, name, fn, process.env.NODE_ENV !== "production" ? protocol : void 0, options); +} +function createAsyncApi(name, fn, protocol, options) { + return promisify(createApi(API_TYPE_ASYNC, name, fn, process.env.NODE_ENV !== "production" ? protocol : void 0, options)); +} +function createApi(type, name, fn, protocol, options) { + switch (type) { + case API_TYPE_ON: + return wrapperApi(wrapperOnApi(name, fn), name, protocol); + case API_TYPE_TASK: + return wrapperApi(wrapperTaskApi(name, fn), name, protocol); + case API_TYPE_SYNC: + return wrapperApi(wrapperSyncApi(fn), name, protocol); + case API_TYPE_ASYNC: + return wrapperApi(wrapperAsyncApi(name, fn, options), name, protocol); + } +} +const Base64ToArrayBufferProtocol = [ + { + name: "base64", + type: String, + required: true + } +]; +const ArrayBufferToBase64Protocol = [ + { + name: "arrayBuffer", + type: [ArrayBuffer, Uint8Array], + required: true + } +]; +const base64ToArrayBuffer = /* @__PURE__ */ createSyncApi("base64ToArrayBuffer", (base64) => { + return decode(base64); +}, Base64ToArrayBufferProtocol); +const arrayBufferToBase64 = /* @__PURE__ */ createSyncApi("arrayBufferToBase64", (arrayBuffer) => { + return encode(arrayBuffer); +}, ArrayBufferToBase64Protocol); +const Upx2pxProtocol = [ + { + name: "upx", + type: [Number, String], + required: true + } +]; +const EPS = 1e-4; +const BASE_DEVICE_WIDTH = 750; +let isIOS$1 = false; +let deviceWidth = 0; +let deviceDPR = 0; +function checkDeviceWidth() { + const {platform, pixelRatio: pixelRatio2, windowWidth} = __GLOBAL__.getSystemInfoSync(); + deviceWidth = windowWidth; + deviceDPR = pixelRatio2; + isIOS$1 = platform === "ios"; +} +const upx2px = /* @__PURE__ */ createSyncApi("upx2px", (number, newDeviceWidth) => { + if (deviceWidth === 0) { + checkDeviceWidth(); + } + number = Number(number); + if (number === 0) { + return 0; + } + let result = number / BASE_DEVICE_WIDTH * (newDeviceWidth || deviceWidth); + if (result < 0) { + result = -result; + } + result = Math.floor(result + EPS); + if (result === 0) { + if (deviceDPR === 1 || !isIOS$1) { + result = 1; + } else { + result = 0.5; + } + } + return number < 0 ? -result : result; +}, Upx2pxProtocol); +var HOOKS; +(function(HOOKS2) { + HOOKS2["INVOKE"] = "invoke"; + HOOKS2["SUCCESS"] = "success"; + HOOKS2["FAIL"] = "fail"; + HOOKS2["COMPLETE"] = "complete"; + HOOKS2["RETURN_VALUE"] = "returnValue"; +})(HOOKS || (HOOKS = {})); +const globalInterceptors = {}; +const scopedInterceptors = {}; +const AddInterceptorProtocol = [ + { + name: "method", + type: [String, Object], + required: true + } +]; +const RemoveInterceptorProtocol = AddInterceptorProtocol; +function mergeInterceptorHook(interceptors, interceptor) { + Object.keys(interceptor).forEach((hook) => { + if (isFunction(interceptor[hook])) { + interceptors[hook] = mergeHook(interceptors[hook], interceptor[hook]); + } + }); +} +function removeInterceptorHook(interceptors, interceptor) { + if (!interceptors || !interceptor) { + return; } -}; -const _hoisted_1$5 = {class: "uni-slider-wrapper"}; -const _hoisted_2$4 = {class: "uni-slider-tap-area"}; -function _sfc_render$a(_ctx, _cache, $props, $setup, $data, $options) { - return openBlock(), createBlock("uni-slider", mergeProps({ref: "uni-slider"}, _ctx.$attrs, { - onClick: _cache[1] || (_cache[1] = (...args) => $options._onClick && $options._onClick(...args)) - }), [ - createVNode("div", _hoisted_1$5, [ - createVNode("div", _hoisted_2$4, [ - createVNode("div", { - style: $options.setBgColor, - class: "uni-slider-handle-wrapper" - }, [ - createVNode("div", { - ref: "uni-slider-handle", - style: $options.setBlockBg, - class: "uni-slider-handle" - }, null, 4), - createVNode("div", { - style: $options.setBlockStyle, - class: "uni-slider-thumb" - }, null, 4), - createVNode("div", { - style: $options.setActiveColor, - class: "uni-slider-track" - }, null, 4) - ], 4) - ]), - withDirectives(createVNode("span", {class: "uni-slider-value"}, toDisplayString($data.sliderValue), 513), [ - [vShow, $props.showValue] - ]) - ]), - renderSlot(_ctx.$slots, "default") - ], 16); + Object.keys(interceptor).forEach((hook) => { + if (isFunction(interceptor[hook])) { + removeHook(interceptors[hook], interceptor[hook]); + } + }); } -_sfc_main$b.render = _sfc_render$a; -var index_vue_vue_type_style_index_0_lang$7 = "\nuni-swiper-item {\n display: block;\n overflow: hidden;\n will-change: transform;\n position: absolute;\n width: 100%;\n height: 100%;\n cursor: grab;\n}\nuni-swiper-item[hidden] {\n display: none;\n}\n"; -const _sfc_main$a = { - name: "SwiperItem", - props: { - itemId: { - type: String, - default: "" +function mergeHook(parentVal, childVal) { + const res = childVal ? parentVal ? parentVal.concat(childVal) : isArray(childVal) ? childVal : [childVal] : parentVal; + return res ? dedupeHooks(res) : res; +} +function dedupeHooks(hooks) { + const res = []; + for (let i = 0; i < hooks.length; i++) { + if (res.indexOf(hooks[i]) === -1) { + res.push(hooks[i]); } - }, - mounted: function() { - var $el = this.$el; - $el.style.position = "absolute"; - $el.style.width = "100%"; - $el.style.height = "100%"; - var callbacks2 = this.$vnode._callbacks; - if (callbacks2) { - callbacks2.forEach((callback) => { - callback(); - }); + } + return res; +} +function removeHook(hooks, hook) { + if (!hooks) { + return; + } + const index2 = hooks.indexOf(hook); + if (index2 !== -1) { + hooks.splice(index2, 1); + } +} +const addInterceptor = /* @__PURE__ */ createSyncApi("addInterceptor", (method, interceptor) => { + if (typeof method === "string" && isPlainObject(interceptor)) { + mergeInterceptorHook(scopedInterceptors[method] || (scopedInterceptors[method] = {}), interceptor); + } else if (isPlainObject(method)) { + mergeInterceptorHook(globalInterceptors, method); + } +}, AddInterceptorProtocol); +const removeInterceptor = /* @__PURE__ */ createSyncApi("removeInterceptor", (method, interceptor) => { + if (typeof method === "string") { + if (isPlainObject(interceptor)) { + removeInterceptorHook(scopedInterceptors[method], interceptor); + } else { + delete scopedInterceptors[method]; } + } else if (isPlainObject(method)) { + removeInterceptorHook(globalInterceptors, method); + } +}, RemoveInterceptorProtocol); +const promiseInterceptor = { + returnValue(res) { + if (!isPromise(res)) { + return res; + } + return res.then((res2) => { + return res2[1]; + }).catch((res2) => { + return res2[0]; + }); } }; -function _sfc_render$9(_ctx, _cache, $props, $setup, $data, $options) { - return openBlock(), createBlock("uni-swiper-item", _ctx.$attrs, [ - renderSlot(_ctx.$slots, "default") - ], 16); +function getCurrentPageVm() { + const pages = getCurrentPages(); + const len = pages.length; + const page = pages[len - 1]; + return page && page.$vm; } -_sfc_main$a.render = _sfc_render$9; -var index_vue_vue_type_style_index_0_lang$6 = '\nuni-switch {\r\n -webkit-tap-highlight-color: transparent;\r\n display: inline-block;\r\n cursor: pointer;\n}\nuni-switch[hidden] {\r\n display: none;\n}\nuni-switch[disabled] {\r\n cursor: not-allowed;\n}\nuni-switch .uni-switch-wrapper {\r\n display: -webkit-inline-flex;\r\n display: inline-flex;\r\n -webkit-align-items: center;\r\n align-items: center;\r\n vertical-align: middle;\n}\nuni-switch .uni-switch-input {\r\n -webkit-appearance: none;\r\n appearance: none;\r\n position: relative;\r\n width: 52px;\r\n height: 32px;\r\n margin-right: 5px;\r\n border: 1px solid #DFDFDF;\r\n outline: 0;\r\n border-radius: 16px;\r\n box-sizing: border-box;\r\n background-color: #DFDFDF;\r\n transition: background-color 0.1s, border 0.1s;\n}\nuni-switch[disabled] .uni-switch-input {\r\n opacity: .7;\n}\nuni-switch .uni-switch-input:before {\r\n content: " ";\r\n position: absolute;\r\n top: 0;\r\n left: 0;\r\n width: 50px;\r\n height: 30px;\r\n border-radius: 15px;\r\n background-color: #FDFDFD;\r\n transition: -webkit-transform 0.3s;\r\n transition: transform 0.3s;\r\n transition: transform 0.3s, -webkit-transform 0.3s;\n}\nuni-switch .uni-switch-input:after {\r\n content: " ";\r\n position: absolute;\r\n top: 0;\r\n left: 0;\r\n width: 30px;\r\n height: 30px;\r\n border-radius: 15px;\r\n background-color: #FFFFFF;\r\n box-shadow: 0 1px 3px rgba(0, 0, 0, 0.4);\r\n transition: -webkit-transform 0.3s;\r\n transition: transform 0.3s;\r\n transition: transform 0.3s, -webkit-transform 0.3s;\n}\nuni-switch .uni-switch-input.uni-switch-input-checked {\r\n border-color: #007aff;\r\n background-color: #007aff;\n}\nuni-switch .uni-switch-input.uni-switch-input-checked:before {\r\n -webkit-transform: scale(0);\r\n transform: scale(0);\n}\nuni-switch .uni-switch-input.uni-switch-input-checked:after {\r\n -webkit-transform: translateX(20px);\r\n transform: translateX(20px);\n}\nuni-switch .uni-checkbox-input {\r\n margin-right: 5px;\r\n -webkit-appearance: none;\r\n appearance: none;\r\n outline: 0;\r\n border: 1px solid #D1D1D1;\r\n background-color: #FFFFFF;\r\n border-radius: 3px;\r\n width: 22px;\r\n height: 22px;\r\n position: relative;\r\n color: #007aff;\n}\nuni-switch:not([disabled]) .uni-checkbox-input:hover {\r\n border-color: #007aff;\n}\nuni-switch .uni-checkbox-input.uni-checkbox-input-checked:before {\r\n font: normal normal normal 14px/1 "uni";\r\n content: "\\EA08";\r\n color: inherit;\r\n font-size: 22px;\r\n position: absolute;\r\n top: 50%;\r\n left: 50%;\r\n transform: translate(-50%, -48%) scale(0.73);\r\n -webkit-transform: translate(-50%, -48%) scale(0.73);\n}\nuni-switch .uni-checkbox-input.uni-checkbox-input-disabled {\r\n background-color: #E1E1E1;\n}\nuni-switch .uni-checkbox-input.uni-checkbox-input-disabled:before {\r\n color: #ADADAD;\n}\r\n'; -const _sfc_main$9 = { - name: "Switch", - mixins: [emitter, listeners], - props: { - name: { - type: String, - default: "" - }, - checked: { - type: [Boolean, String], - default: false - }, - type: { - type: String, - default: "switch" - }, - id: { - type: String, - default: "" - }, - disabled: { - type: [Boolean, String], - default: false - }, - color: { - type: String, - default: "#007aff" +const defaultOptions = { + thresholds: [0], + initialRatio: 0, + observeAll: false +}; +let reqComponentObserverId = 1; +const reqComponentObserverCallbacks = {}; +ServiceJSBridge.subscribe("requestComponentObserver", ({reqId, reqEnd, res}) => { + const callback = reqComponentObserverCallbacks[reqId]; + if (callback) { + if (reqEnd) { + return delete reqComponentObserverCallbacks[reqId]; } - }, - data() { - return { - switchChecked: this.checked - }; - }, - watch: { - checked(val) { - this.switchChecked = val; + callback(res); + } +}); +class ServiceIntersectionObserver { + constructor(component, options) { + this._pageId = component.$page.id; + this._component = component._$id || component; + this._options = extend({}, defaultOptions, options || {}); + this._relativeInfo = []; + } + relativeTo(selector, margins) { + if (this._reqId) { + throw new Error('Relative nodes cannot be added after "observe" call in IntersectionObserver'); } - }, - created() { - this.$dispatch("Form", "uni-form-group-update", { - type: "add", - vm: this - }); - }, - beforeDestroy() { - this.$dispatch("Form", "uni-form-group-update", { - type: "remove", - vm: this + this._relativeInfo.push({ + selector, + margins }); - }, - listeners: { - "label-click": "_onClick", - "@label-click": "_onClick" - }, - methods: { - _onClick($event) { - if (this.disabled) { - return; - } - this.switchChecked = !this.switchChecked; - this.$trigger("change", $event, { - value: this.switchChecked - }); - }, - _resetFormData() { - this.switchChecked = false; - }, - _getFormData() { - const data = {}; - if (this.name !== "") { - data.value = this.switchChecked; - data.key = this.name; - } - return data; + return this; + } + relativeToViewport(margins) { + return this.relativeTo(null, margins); + } + observe(selector, callback) { + if (typeof callback !== "function") { + return; + } + if (this._reqId) { + throw new Error('"observe" call can be only called once in IntersectionObserver'); } + this._reqId = reqComponentObserverId++; + reqComponentObserverCallbacks[this._reqId] = callback; + UniServiceJSBridge.publishHandler("addIntersectionObserver", { + selector, + reqId: this._reqId, + component: this._component, + options: this._options, + relativeInfo: this._relativeInfo + }, this._pageId); + } + disconnect() { + UniServiceJSBridge.publishHandler("removeIntersectionObserver", { + reqId: this._reqId + }, this._pageId); } -}; -const _hoisted_1$4 = {class: "uni-switch-wrapper"}; -function _sfc_render$8(_ctx, _cache, $props, $setup, $data, $options) { - return openBlock(), createBlock("uni-switch", mergeProps({disabled: $props.disabled}, _ctx.$attrs, { - onClick: _cache[1] || (_cache[1] = (...args) => $options._onClick && $options._onClick(...args)) - }), [ - createVNode("div", _hoisted_1$4, [ - withDirectives(createVNode("div", { - class: [[$data.switchChecked ? "uni-switch-input-checked" : ""], "uni-switch-input"], - style: {backgroundColor: $data.switchChecked ? $props.color : "#DFDFDF", borderColor: $data.switchChecked ? $props.color : "#DFDFDF"} - }, null, 6), [ - [vShow, $props.type === "switch"] - ]), - withDirectives(createVNode("div", { - class: [[$data.switchChecked ? "uni-checkbox-input-checked" : ""], "uni-checkbox-input"], - style: {color: $props.color} - }, null, 6), [ - [vShow, $props.type === "checkbox"] - ]) - ]) - ], 16, ["disabled"]); } -_sfc_main$9.render = _sfc_render$8; -var index_vue_vue_type_style_index_0_lang$5 = "\nuni-text[selectable] {\r\n cursor: auto;\r\n user-select: text;\r\n -webkit-user-select: text;\n}\r\n"; -const SPACE_UNICODE = { - ensp: "\u2002", - emsp: "\u2003", - nbsp: "\xA0" +const createIntersectionObserver = /* @__PURE__ */ createSyncApi("createIntersectionObserver", (context, options) => { + if (!context) { + context = getCurrentPageVm(); + } + return new ServiceIntersectionObserver(context, options); +}); +const createSelectorQuery = () => { }; -const _sfc_main$8 = { - name: "Text", - props: { - selectable: { - type: [Boolean, String], - default: false - }, - space: { - type: String, - default: "" - }, - decode: { - type: [Boolean, String], - default: false - } - }, - methods: { - _decodeHtml(htmlString) { - if (this.space && SPACE_UNICODE[this.space]) { - htmlString = htmlString.replace(/ /g, SPACE_UNICODE[this.space]); - } - if (this.decode) { - htmlString = htmlString.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, "'"); +const CanIUseProtocol = [ + { + name: "schema", + type: String, + required: true + } +]; +const MakePhoneCallProtocol = { + phoneNumber: { + type: String, + required: true, + validator(phoneNumber) { + if (!phoneNumber) { + return "makePhoneCall:fail parameter error: parameter.phoneNumber should not be empty String;"; } - return htmlString; } + } +}; +const OpenDocumentProtocol = { + filePath: { + type: String, + required: true }, - render(createElement) { - const nodeList = []; - this.$slots.default && this.$slots.default.forEach((vnode) => { - if (vnode.text) { - const nodeText = vnode.text.replace(/\\n/g, "\n"); - const texts = nodeText.split("\n"); - texts.forEach((text2, index2) => { - nodeList.push(this._decodeHtml(text2)); - if (index2 !== texts.length - 1) { - nodeList.push(createElement("br")); - } - }); - } else { - if (vnode.componentOptions && vnode.componentOptions.tag !== "v-uni-text") { - console.warn(" \u7EC4\u4EF6\u5185\u53EA\u652F\u6301\u5D4C\u5957 \uFF0C\u4E0D\u652F\u6301\u5176\u5B83\u7EC4\u4EF6\u6216\u81EA\u5B9A\u4E49\u7EC4\u4EF6\uFF0C\u5426\u5219\u4F1A\u5F15\u53D1\u5728\u4E0D\u540C\u5E73\u53F0\u7684\u6E32\u67D3\u5DEE\u5F02\u3002"); - } - nodeList.push(vnode); - } - }); - return createElement("uni-text", { - on: this.$listeners, - attrs: { - selectable: !!this.selectable - } - }, [ - createElement("span", {}, nodeList) - ]); + fileType: { + type: String } }; -var index_vue_vue_type_style_index_0_lang$4 = "\nuni-textarea {\n width: 300px;\n height: 150px;\n display: block;\n position: relative;\n font-size: 16px;\n line-height: normal;\n white-space: pre-wrap;\n word-break: break-all;\n}\nuni-textarea[hidden] {\n display: none;\n}\n.uni-textarea-wrapper,\n.uni-textarea-placeholder,\n.uni-textarea-line,\n.uni-textarea-compute,\n.uni-textarea-textarea {\n outline: none;\n border: none;\n padding: 0;\n margin: 0;\n text-decoration: inherit;\n}\n.uni-textarea-wrapper {\n display: block;\n position: relative;\n width: 100%;\n height: 100%;\n}\n.uni-textarea-placeholder,\n.uni-textarea-line,\n.uni-textarea-compute,\n.uni-textarea-textarea {\n position: absolute;\n width: 100%;\n height: 100%;\n left: 0;\n top: 0;\n white-space: inherit;\n word-break: inherit;\n}\n.uni-textarea-placeholder {\n color: grey;\n overflow: hidden;\n}\n.uni-textarea-line,\n.uni-textarea-compute {\n visibility: hidden;\n height: auto;\n}\n.uni-textarea-line {\n width: 1em;\n}\n.uni-textarea-textarea {\n resize: none;\n background: none;\n color: inherit;\n opacity: 1;\n -webkit-text-fill-color: currentcolor;\n font: inherit;\n line-height: inherit;\n letter-spacing: inherit;\n text-align: inherit;\n text-indent: inherit;\n text-transform: inherit;\n text-shadow: inherit;\n}\n/* \u7528\u4E8E\u89E3\u51B3 iOS textarea \u5185\u90E8\u9ED8\u8BA4\u8FB9\u8DDD */\n.uni-textarea-textarea-fix-margin {\n width: auto;\n right: 0;\n margin: 0 -3px;\n}\n"; -const DARK_TEST_STRING = "(prefers-color-scheme: dark)"; -const _sfc_main$7 = { - name: "Textarea", - mixins: [baseInput], - props: { - name: { - type: String, - default: "" - }, - maxlength: { - type: [Number, String], - default: 140 - }, - placeholder: { - type: String, - default: "" - }, - disabled: { - type: [Boolean, String], - default: false - }, - focus: { - type: [Boolean, String], - default: false - }, - autoFocus: { - type: [Boolean, String], - default: false - }, - placeholderClass: { - type: String, - default: "textarea-placeholder" - }, - placeholderStyle: { - type: String, - default: "" - }, - autoHeight: { - type: [Boolean, String], - default: false - }, - cursor: { - type: [Number, String], - default: -1 - }, - selectionStart: { - type: [Number, String], - default: -1 - }, - selectionEnd: { - type: [Number, String], - default: -1 +const GetImageInfoOptions = { + formatArgs: { + src(src, params) { + params.src = uni.getRealPath(src); } - }, - data() { - return { - valueComposition: "", - composition: false, - focusSync: this.focus, - height: 0, - focusChangeSource: "", - fixMargin: String(navigator.platform).indexOf("iP") === 0 && String(navigator.vendor).indexOf("Apple") === 0 && window.matchMedia(DARK_TEST_STRING).media !== DARK_TEST_STRING - }; - }, - computed: { - maxlengthNumber() { - var maxlength = Number(this.maxlength); - return isNaN(maxlength) ? 140 : maxlength; - }, - cursorNumber() { - var cursor = Number(this.cursor); - return isNaN(cursor) ? -1 : cursor; - }, - selectionStartNumber() { - var selectionStart = Number(this.selectionStart); - return isNaN(selectionStart) ? -1 : selectionStart; - }, - selectionEndNumber() { - var selectionEnd = Number(this.selectionEnd); - return isNaN(selectionEnd) ? -1 : selectionEnd; - }, - valueCompute() { - return (this.composition ? this.valueComposition : this.valueSync).split("\n"); + } +}; +const GetImageInfoProtocol = { + src: { + type: String, + required: true + } +}; +function cssSupports(css) { + return window.CSS && window.CSS.supports && window.CSS.supports(css); +} +const SCHEMA_CSS = { + "css.var": cssSupports("--a:0"), + "css.env": cssSupports("top:env(a)"), + "css.constant": cssSupports("top:constant(a)") +}; +const canIUse = /* @__PURE__ */ createSyncApi("canIUse", (schema) => { + if (hasOwn$1(SCHEMA_CSS, schema)) { + return SCHEMA_CSS[schema]; + } + return true; +}, CanIUseProtocol); +const makePhoneCall = /* @__PURE__ */ createAsyncApi("makePhoneCall", (option) => { + window.location.href = `tel:${option.phoneNumber}`; +}, MakePhoneCallProtocol); +const ua = navigator.userAgent; +const isAndroid = /android/i.test(ua); +const isIOS = /iphone|ipad|ipod/i.test(ua); +const getSystemInfoSync = /* @__PURE__ */ createSyncApi("getSystemInfoSync", () => { + var screen2 = window.screen; + var pixelRatio2 = window.devicePixelRatio; + const screenFix = /^Apple/.test(navigator.vendor) && typeof window.orientation === "number"; + const landscape = screenFix && Math.abs(window.orientation) === 90; + var screenWidth = screenFix ? Math[landscape ? "max" : "min"](screen2.width, screen2.height) : screen2.width; + var screenHeight = screenFix ? Math[landscape ? "min" : "max"](screen2.height, screen2.width) : screen2.height; + var windowWidth = Math.min(window.innerWidth, document.documentElement.clientWidth, screenWidth) || screenWidth; + var windowHeight = window.innerHeight; + var language = navigator.language; + var statusBarHeight = out.top; + var osname; + var osversion; + var model; + if (isIOS) { + osname = "iOS"; + const osversionFind = ua.match(/OS\s([\w_]+)\slike/); + if (osversionFind) { + osversion = osversionFind[1].replace(/_/g, "."); } - }, - watch: { - focus(val) { - if (val) { - this.focusChangeSource = "focus"; - if (this.$refs.textarea) { - this.$refs.textarea.focus(); - } - } else { - if (this.$refs.textarea) { - this.$refs.textarea.blur(); - } + const modelFind = ua.match(/\(([a-zA-Z]+);/); + if (modelFind) { + model = modelFind[1]; + } + } else if (isAndroid) { + osname = "Android"; + const osversionFind = ua.match(/Android[\s/]([\w\.]+)[;\s]/); + if (osversionFind) { + osversion = osversionFind[1]; + } + const infoFind = ua.match(/\((.+?)\)/); + const infos = infoFind ? infoFind[1].split(";") : ua.split(" "); + const otherInfo = [ + /\bAndroid\b/i, + /\bLinux\b/i, + /\bU\b/i, + /^\s?[a-z][a-z]$/i, + /^\s?[a-z][a-z]-[a-z][a-z]$/i, + /\bwv\b/i, + /\/[\d\.,]+$/, + /^\s?[\d\.,]+$/, + /\bBrowser\b/i, + /\bMobile\b/i + ]; + for (let i = 0; i < infos.length; i++) { + const info = infos[i]; + if (info.indexOf("Build") > 0) { + model = info.split("Build")[0].trim(); + break; } - }, - focusSync(val) { - this.$emit("update:focus", val); - this._checkSelection(); - this._checkCursor(); - }, - cursorNumber() { - this._checkCursor(); - }, - selectionStartNumber() { - this._checkSelection(); - }, - selectionEndNumber() { - this._checkSelection(); - }, - height(height) { - let lineHeight = parseFloat(getComputedStyle(this.$el).lineHeight); - if (isNaN(lineHeight)) { - lineHeight = this.$refs.line.offsetHeight; + let other; + for (let o2 = 0; o2 < otherInfo.length; o2++) { + if (otherInfo[o2].test(info)) { + other = true; + break; + } } - var lineCount = Math.round(height / lineHeight); - this.$trigger("linechange", {}, { - height, - heightRpx: 750 / window.innerWidth * height, - lineCount - }); - if (this.autoHeight) { - this.$el.style.height = this.height + "px"; + if (!other) { + model = info.trim(); + break; } } - }, - created() { - this.$dispatch("Form", "uni-form-group-update", { - type: "add", - vm: this - }); - }, - mounted() { - this._resize({ - height: this.$refs.sensor.$el.offsetHeight - }); - let $vm = this; - while ($vm) { - const scopeId = $vm.$options._scopeId; - if (scopeId) { - this.$refs.placeholder.setAttribute(scopeId, ""); - } - $vm = $vm.$parent; + } else { + osname = "Other"; + osversion = "0"; + } + var system = `${osname} ${osversion}`; + var platform = osname.toLocaleLowerCase(); + var safeArea = { + left: out.left, + right: windowWidth - out.right, + top: out.top, + bottom: windowHeight - out.bottom, + width: windowWidth - out.left - out.right, + height: windowHeight - out.top - out.bottom + }; + const {top: windowTop, bottom: windowBottom} = getWindowOffset(); + windowHeight -= windowTop; + windowHeight -= windowBottom; + return { + windowTop, + windowBottom, + windowWidth, + windowHeight, + pixelRatio: pixelRatio2, + screenWidth, + screenHeight, + language, + statusBarHeight, + system, + platform, + model, + safeArea, + safeAreaInsets: { + top: out.top, + right: out.right, + bottom: out.bottom, + left: out.left } - this.initKeyboard(this.$refs.textarea); - }, - beforeDestroy() { - this.$dispatch("Form", "uni-form-group-update", { - type: "remove", - vm: this + }; +}); +const getSystemInfo = /* @__PURE__ */ createAsyncApi("getSystemInfo", () => { + return getSystemInfoSync(); +}); +const openDocument = /* @__PURE__ */ createAsyncApi("openDocument", (option) => { + window.open(option.filePath); +}, OpenDocumentProtocol); +function _getServiceAddress() { + return window.location.protocol + "//" + window.location.host; +} +const getImageInfo = /* @__PURE__ */ createAsyncApi("getImageInfo", ({src}, callback) => { + const img = new Image(); + img.onload = function() { + callback({ + errMsg: "getImageInfo:ok", + width: img.naturalWidth, + height: img.naturalHeight, + path: src.indexOf("/") === 0 ? _getServiceAddress() + src : src }); - }, - methods: { - _focus: function($event) { - this.focusSync = true; - this.$trigger("focus", $event, { - value: this.valueSync - }); - }, - _checkSelection() { - if (this.focusSync && !this.focusChangeSource && this.selectionStartNumber > -1 && this.selectionEndNumber > -1) { - this.$refs.textarea.selectionStart = this.selectionStartNumber; - this.$refs.textarea.selectionEnd = this.selectionEndNumber; - } - }, - _checkCursor() { - if (this.focusSync && (this.focusChangeSource === "focus" || !this.focusChangeSource && this.selectionStartNumber < 0 && this.selectionEndNumber < 0) && this.cursorNumber > -1) { - this.$refs.textarea.selectionEnd = this.$refs.textarea.selectionStart = this.cursorNumber; - } - }, - _blur: function($event) { - this.focusSync = false; - this.$trigger("blur", $event, { - value: this.valueSync, - cursor: this.$refs.textarea.selectionEnd - }); - }, - _compositionstart($event) { - this.composition = true; - }, - _compositionend($event) { - this.composition = false; - }, - _confirm($event) { - this.$trigger("confirm", $event, { - value: this.valueSync - }); - }, - _linechange($event) { - this.$trigger("linechange", $event, { - value: this.valueSync - }); - }, - _touchstart() { - this.focusChangeSource = "touch"; - }, - _resize({height}) { - this.height = height; - }, - _input($event) { - if (this.composition) { - this.valueComposition = $event.target.value; - return; - } - this.$triggerInput($event, { - value: this.valueSync, - cursor: this.$refs.textarea.selectionEnd - }); - }, - _getFormData() { - return { - value: this.valueSync, - key: this.name - }; - }, - _resetFormData() { - this.valueSync = ""; + }; + img.onerror = function() { + callback({ + errMsg: "getImageInfo:fail" + }); + }; + img.src = src; +}, GetImageInfoProtocol, GetImageInfoOptions); +const navigateBack = /* @__PURE__ */ createAsyncApi("navigateBack", () => { +}); +const navigateTo = /* @__PURE__ */ createAsyncApi("navigateTo", (options) => { + const router = getApp().$router; + router.push({ + path: options.url, + force: true, + state: createPageState("navigateTo") + }); +}); +const redirectTo = /* @__PURE__ */ createAsyncApi("redirectTo", () => { +}); +const reLaunch = /* @__PURE__ */ createAsyncApi("reLaunch", () => { +}); +const switchTab = /* @__PURE__ */ createAsyncApi("switchTab", () => { +}); +const getRealPath$1 = /* @__PURE__ */ createSyncApi("getRealPath", (path) => { + return path; +}); +var api = /* @__PURE__ */ Object.freeze({ + __proto__: null, + [Symbol.toStringTag]: "Module", + upx2px, + addInterceptor, + removeInterceptor, + promiseInterceptor, + arrayBufferToBase64, + base64ToArrayBuffer, + createIntersectionObserver, + createSelectorQuery, + canIUse, + makePhoneCall, + getSystemInfo, + getSystemInfoSync, + openDocument, + getImageInfo, + navigateBack, + navigateTo, + redirectTo, + reLaunch, + switchTab, + getRealPath: getRealPath$1 +}); +const uni$1 = api; +const UniServiceJSBridge$1 = extend(ServiceJSBridge, { + publishHandler(event2, args, pageId) { + window.UniViewJSBridge.subscribeHandler(event2, args, pageId); + } +}); +function mergeTitleNView(navigationBar, titleNView) { + if (isPlainObject(titleNView)) { + if (hasOwn$1(titleNView, "backgroundColor")) { + navigationBar.backgroundColor = titleNView.backgroundColor; + } + if (hasOwn$1(titleNView, "buttons")) { + navigationBar.buttons = titleNView.buttons; + } + if (hasOwn$1(titleNView, "titleColor")) { + navigationBar.textColor = titleNView.titleColor; + } + if (hasOwn$1(titleNView, "titleText")) { + navigationBar.titleText = titleNView.titleText; + } + if (hasOwn$1(titleNView, "titleSize")) { + navigationBar.titleSize = titleNView.titleSize; + } + if (hasOwn$1(titleNView, "type")) { + navigationBar.type = titleNView.type; + } + if (hasOwn$1(titleNView, "searchInput") && typeof titleNView.searchInput === "object") { + navigationBar.searchInput = Object.assign({ + autoFocus: false, + align: "center", + color: "#000000", + backgroundColor: "rgba(255,255,255,0.5)", + borderRadius: "0px", + placeholder: "", + placeholderColor: "#CCCCCC", + disabled: false + }, titleNView.searchInput); } } -}; -const _hoisted_1$3 = {class: "uni-textarea-wrapper"}; -const _hoisted_2$3 = {class: "uni-textarea-compute"}; -function _sfc_render$7(_ctx, _cache, $props, $setup, $data, $options) { - const _component_v_uni_resize_sensor = resolveComponent("v-uni-resize-sensor"); - return openBlock(), createBlock("uni-textarea", mergeProps({ - onChange: _cache[8] || (_cache[8] = withModifiers(() => { - }, ["stop"])) - }, _ctx.$attrs), [ - createVNode("div", _hoisted_1$3, [ - withDirectives(createVNode("div", { - ref: "placeholder", - style: $props.placeholderStyle, - class: [$props.placeholderClass, "uni-textarea-placeholder"], - textContent: toDisplayString($props.placeholder) - }, null, 14, ["textContent"]), [ - [vShow, !($data.composition || _ctx.valueSync.length)] - ]), - createVNode("div", { - ref: "line", - class: "uni-textarea-line", - textContent: toDisplayString(" ") - }, null, 8, ["textContent"]), - createVNode("div", _hoisted_2$3, [ - (openBlock(true), createBlock(Fragment, null, renderList($options.valueCompute, (item, index2) => { - return openBlock(), createBlock("div", { - key: index2, - textContent: toDisplayString(item.trim() ? item : ".") - }, null, 8, ["textContent"]); - }), 128)), - createVNode(_component_v_uni_resize_sensor, { - ref: "sensor", - onResize: $options._resize - }, null, 8, ["onResize"]) - ]), - withDirectives(createVNode("textarea", { - ref: "textarea", - "onUpdate:modelValue": _cache[1] || (_cache[1] = ($event) => _ctx.valueSync = $event), - disabled: $props.disabled, - maxlength: $options.maxlengthNumber, - autofocus: $props.autoFocus || $props.focus, - class: [{"uni-textarea-textarea-fix-margin": $data.fixMargin}, "uni-textarea-textarea"], - style: {"overflow-y": $props.autoHeight ? "hidden" : "auto"}, - onCompositionstart: _cache[2] || (_cache[2] = (...args) => $options._compositionstart && $options._compositionstart(...args)), - onCompositionend: _cache[3] || (_cache[3] = (...args) => $options._compositionend && $options._compositionend(...args)), - onInput: _cache[4] || (_cache[4] = withModifiers((...args) => $options._input && $options._input(...args), ["stop"])), - onFocus: _cache[5] || (_cache[5] = (...args) => $options._focus && $options._focus(...args)), - onBlur: _cache[6] || (_cache[6] = (...args) => $options._blur && $options._blur(...args)), - onTouchstartPassive: _cache[7] || (_cache[7] = (...args) => $options._touchstart && $options._touchstart(...args)) - }, null, 46, ["disabled", "maxlength", "autofocus"]), [ - [vModelText, _ctx.valueSync] - ]) - ]) - ], 16); + return navigationBar; } -_sfc_main$7.render = _sfc_render$7; -var index_vue_vue_type_style_index_0_lang$3 = "\nuni-view {\r\n display: block;\n}\nuni-view[hidden] {\r\n display: none;\n}\r\n"; -const _sfc_main$6 = { - name: "View", - mixins: [hover], - listeners: { - "label-click": "clickHandler" +const SCHEME_RE = /^([a-z-]+:)?\/\//i; +const DATA_RE = /^data:.*,.*/; +function addBase(filePath) { + const base = __uniConfig.router.base; + if (!base) { + return filePath; } -}; -function _sfc_render$6(_ctx, _cache, $props, $setup, $data, $options) { - return _ctx.hoverClass && _ctx.hoverClass !== "none" ? (openBlock(), createBlock("uni-view", mergeProps({ - key: 0, - class: [_ctx.hovering ? _ctx.hoverClass : ""], - onTouchstart: _cache[1] || (_cache[1] = (...args) => _ctx._hoverTouchStart && _ctx._hoverTouchStart(...args)), - onTouchend: _cache[2] || (_cache[2] = (...args) => _ctx._hoverTouchEnd && _ctx._hoverTouchEnd(...args)), - onTouchcancel: _cache[3] || (_cache[3] = (...args) => _ctx._hoverTouchCancel && _ctx._hoverTouchCancel(...args)) - }, _ctx.$attrs), [ - renderSlot(_ctx.$slots, "default") - ], 16)) : (openBlock(), createBlock("uni-view", mergeProps({key: 1}, _ctx.$attrs), [ - renderSlot(_ctx.$slots, "default") - ], 16)); + if (base !== "/") { + if (("/" + filePath).indexOf(base) === 0) { + return "/" + filePath; + } + } + return base + filePath; } -_sfc_main$6.render = _sfc_render$6; -function appendCss(css, cssId, replace = false) { - let style = document.getElementById(cssId); - if (style && replace) { - style.parentNode.removeChild(style); - style = null; +function getRealPath(filePath) { + if (__uniConfig.router.base === "./") { + filePath = filePath.replace(/^\.\/static\//, "/static/"); } - if (!style) { - style = document.createElement("style"); - style.type = "text/css"; - cssId && (style.id = cssId); - document.getElementsByTagName("head")[0].appendChild(style); + if (filePath.indexOf("/") === 0) { + if (filePath.indexOf("//") === 0) { + filePath = "https:" + filePath; + } else { + return addBase(filePath.substr(1)); + } } - style.appendChild(document.createTextNode(css)); + if (SCHEME_RE.test(filePath) || DATA_RE.test(filePath) || filePath.indexOf("blob:") === 0) { + return filePath; + } + const pages = getCurrentPages(); + if (pages.length) { + return addBase(getRealRoute(pages[pages.length - 1].$page.route, filePath).substr(1)); + } + return filePath; } function hexToRgba(hex) { let r; @@ -8460,14 +8266,14 @@ var transparent = { const iconElems = this.$el.querySelectorAll(".uni-btn-icon"); const iconElemsStyles = []; const textColor = this.textColor; - for (let i2 = 0; i2 < iconElems.length; i2++) { - iconElemsStyles.push(iconElems[i2].style); + for (let i = 0; i < iconElems.length; i++) { + iconElemsStyles.push(iconElems[i].style); } const borderRadiusElems = this.$el.querySelectorAll(".uni-page-head-btn"); const oldColors = []; const borderRadiusElemsStyles = []; - for (let i2 = 0; i2 < borderRadiusElems.length; i2++) { - const borderRadiusElem = borderRadiusElems[i2]; + for (let i = 0; i < borderRadiusElems.length; i++) { + const borderRadiusElem = borderRadiusElems[i]; oldColors.push(getComputedStyle(borderRadiusElem).backgroundColor); borderRadiusElemsStyles.push(borderRadiusElem.style); } @@ -8501,14 +8307,14 @@ var transparent = { } else if (this.type === "float") { const iconElems = this.$el.querySelectorAll(".uni-btn-icon"); const iconElemsStyles = []; - for (let i2 = 0; i2 < iconElems.length; i2++) { - iconElemsStyles.push(iconElems[i2].style); + for (let i = 0; i < iconElems.length; i++) { + iconElemsStyles.push(iconElems[i].style); } const borderRadiusElems = this.$el.querySelectorAll(".uni-page-head-btn"); const oldColors = []; const borderRadiusElemsStyles = []; - for (let i2 = 0; i2 < borderRadiusElems.length; i2++) { - const borderRadiusElem = borderRadiusElems[i2]; + for (let i = 0; i < borderRadiusElems.length; i++) { + const borderRadiusElem = borderRadiusElems[i]; oldColors.push(getComputedStyle(borderRadiusElem).backgroundColor); borderRadiusElemsStyles.push(borderRadiusElem.style); } @@ -8533,7 +8339,7 @@ var transparent = { } } }; -var pageHead_vue_vue_type_style_index_0_lang = "\nuni-page-head {\r\n display: block;\r\n box-sizing: border-box;\n}\nuni-page-head .uni-page-head {\r\n position: fixed;\r\n left: 0;\r\n top: 0;\r\n width: 100%;\r\n height: 44px;\r\n height: calc(44px + constant(safe-area-inset-top));\r\n height: calc(44px + env(safe-area-inset-top));\r\n padding: 7px 3px;\r\n padding-top: calc(7px + constant(safe-area-inset-top));\r\n padding-top: calc(7px + env(safe-area-inset-top));\r\n display: flex;\r\n overflow: hidden;\r\n justify-content: space-between;\r\n box-sizing: border-box;\r\n z-index: 998;\r\n color: #fff;\r\n background-color: #000;\r\n transition-property: all;\n}\nuni-page-head .uni-page-head-titlePenetrate,\r\nuni-page-head .uni-page-head-titlePenetrate .uni-page-head-bd,\r\nuni-page-head .uni-page-head-titlePenetrate .uni-page-head-bd * {\r\n pointer-events: none;\n}\nuni-page-head .uni-page-head-titlePenetrate * {\r\n pointer-events: auto;\n}\nuni-page-head .uni-page-head.uni-page-head-transparent .uni-page-head-ft > div {\r\n justify-content: center;\n}\nuni-page-head .uni-page-head ~ .uni-placeholder {\r\n width: 100%;\r\n height: 44px;\r\n height: calc(44px + constant(safe-area-inset-top));\r\n height: calc(44px + env(safe-area-inset-top));\n}\nuni-page-head .uni-placeholder-titlePenetrate {\r\n pointer-events: none;\n}\nuni-page-head .uni-page-head * {\r\n box-sizing: border-box;\n}\nuni-page-head .uni-page-head-hd {\r\n display: flex;\r\n align-items: center;\r\n font-size: 16px;\n}\nuni-page-head .uni-page-head-bd {\r\n position: absolute;\r\n left: 70px;\r\n right: 70px;\r\n min-width: 0;\r\n user-select: auto;\n}\n.uni-page-head-btn {\r\n position: relative;\r\n width: auto;\r\n margin: 0 2px;\r\n word-break: keep-all;\r\n white-space: pre;\r\n cursor: pointer;\n}\n.uni-page-head-transparent .uni-page-head-btn {\r\n display: flex;\r\n align-items: center;\r\n width: 32px;\r\n height: 32px;\r\n border-radius: 50%;\r\n background-color: rgba(0, 0, 0, 0.5);\n}\nuni-page-head .uni-btn-icon {\r\n overflow: hidden;\r\n min-width: 1em;\n}\n.uni-page-head-btn-red-dot::after {\r\n content: attr(badge-text);\r\n position: absolute;\r\n right: 0;\r\n top: 0;\r\n background-color: red;\r\n color: white;\r\n width: 18px;\r\n height: 18px;\r\n line-height: 18px;\r\n border-radius: 18px;\r\n overflow: hidden;\r\n transform: scale(0.5) translate(40%, -40%);\r\n transform-origin: 100% 0;\n}\n.uni-page-head-btn-red-dot[badge-text]::after {\r\n font-size: 12px;\r\n width: auto;\r\n min-width: 18px;\r\n max-width: 42px;\r\n text-align: center;\r\n padding: 0 3px;\r\n transform: scale(0.7) translate(40%, -40%);\n}\n.uni-page-head-btn-select > .uni-btn-icon::after {\r\n display: inline-block;\r\n font-family: 'unibtn';\r\n content: '\\e601';\r\n margin-left: 2px;\r\n transform: rotate(-90deg) scale(0.8);\n}\n.uni-page-head-search {\r\n position: relative;\r\n display: flex;\r\n flex: 1;\r\n margin: 0 2px;\r\n line-height: 30px;\r\n font-size: 15px;\n}\n.uni-page-head-search-input {\r\n width: 100%;\r\n height: 100%;\r\n padding-left: 34px;\r\n text-align: left;\n}\n.uni-page-head-search-placeholder {\r\n position: absolute;\r\n max-width: 100%;\r\n height: 100%;\r\n padding-left: 34px;\r\n overflow: hidden;\r\n word-break: keep-all;\r\n white-space: pre;\n}\n.uni-page-head-search-placeholder-right {\r\n right: 0;\n}\n.uni-page-head-search-placeholder-center {\r\n left: 50%;\r\n transform: translateX(-50%);\n}\n.uni-page-head-search-placeholder::before {\r\n position: absolute;\r\n top: 0;\r\n left: 2px;\r\n width: 30px;\r\n content: '\\ea0e';\r\n display: block;\r\n font-size: 20px;\r\n font-family: 'uni';\r\n text-align: center;\n}\nuni-page-head .uni-page-head-ft {\r\n display: flex;\r\n align-items: center;\r\n flex-direction: row-reverse;\r\n font-size: 13px;\n}\nuni-page-head .uni-page-head__title {\r\n font-weight: bold;\r\n font-size: 16px;\r\n line-height: 30px;\r\n text-align: center;\r\n overflow: hidden;\r\n white-space: nowrap;\r\n text-overflow: ellipsis;\n}\nuni-page-head .uni-page-head__title .uni-loading {\r\n width: 16px;\r\n height: 16px;\r\n margin-top: -3px;\n}\nuni-page-head .uni-page-head__title .uni-page-head__title_image {\r\n width: auto;\r\n height: 26px;\r\n vertical-align: middle;\n}\nuni-page-head .uni-page-head-shadow {\r\n overflow: visible;\n}\nuni-page-head .uni-page-head-shadow::after {\r\n content: '';\r\n position: absolute;\r\n left: 0;\r\n right: 0;\r\n top: 100%;\r\n height: 5px;\r\n background-size: 100% 100%;\n}\nuni-page-head .uni-page-head-shadow-grey::after {\r\n background-image: url('https://cdn.dcloud.net.cn/img/shadow-grey.png');\n}\nuni-page-head .uni-page-head-shadow-blue::after {\r\n background-image: url('https://cdn.dcloud.net.cn/img/shadow-blue.png');\n}\nuni-page-head .uni-page-head-shadow-green::after {\r\n background-image: url('https://cdn.dcloud.net.cn/img/shadow-green.png');\n}\nuni-page-head .uni-page-head-shadow-orange::after {\r\n background-image: url('https://cdn.dcloud.net.cn/img/shadow-orange.png');\n}\nuni-page-head .uni-page-head-shadow-red::after {\r\n background-image: url('https://cdn.dcloud.net.cn/img/shadow-red.png');\n}\nuni-page-head .uni-page-head-shadow-yellow::after {\r\n background-image: url('https://cdn.dcloud.net.cn/img/shadow-yellow.png');\n}\r\n"; +var pageHead_vue_vue_type_style_index_0_lang = "\nuni-page-head {\r\n display: block;\r\n box-sizing: border-box;\n}\nuni-page-head .uni-page-head {\r\n position: fixed;\r\n left: var(--window-left);\r\n right: var(--window-right);\r\n height: 44px;\r\n height: calc(44px + constant(safe-area-inset-top));\r\n height: calc(44px + env(safe-area-inset-top));\r\n padding: 7px 3px;\r\n padding-top: calc(7px + constant(safe-area-inset-top));\r\n padding-top: calc(7px + env(safe-area-inset-top));\r\n display: flex;\r\n overflow: hidden;\r\n justify-content: space-between;\r\n box-sizing: border-box;\r\n z-index: 998;\r\n color: #fff;\r\n background-color: #000;\r\n transition-property: all;\n}\nuni-page-head .uni-page-head-titlePenetrate,\r\nuni-page-head .uni-page-head-titlePenetrate .uni-page-head-bd,\r\nuni-page-head .uni-page-head-titlePenetrate .uni-page-head-bd * {\r\n pointer-events: none;\n}\nuni-page-head .uni-page-head-titlePenetrate * {\r\n pointer-events: auto;\n}\nuni-page-head .uni-page-head.uni-page-head-transparent .uni-page-head-ft > div {\r\n justify-content: center;\n}\nuni-page-head .uni-page-head ~ .uni-placeholder {\r\n width: 100%;\r\n height: 44px;\r\n height: calc(44px + constant(safe-area-inset-top));\r\n height: calc(44px + env(safe-area-inset-top));\n}\nuni-page-head .uni-placeholder-titlePenetrate {\r\n pointer-events: none;\n}\nuni-page-head .uni-page-head * {\r\n box-sizing: border-box;\n}\nuni-page-head .uni-page-head-hd {\r\n display: flex;\r\n align-items: center;\r\n font-size: 16px;\n}\nuni-page-head .uni-page-head-bd {\r\n position: absolute;\r\n left: 70px;\r\n right: 70px;\r\n min-width: 0;\r\n user-select: auto;\n}\n.uni-page-head-btn {\r\n position: relative;\r\n width: auto;\r\n margin: 0 2px;\r\n word-break: keep-all;\r\n white-space: pre;\r\n cursor: pointer;\n}\n.uni-page-head-transparent .uni-page-head-btn {\r\n display: flex;\r\n align-items: center;\r\n width: 32px;\r\n height: 32px;\r\n border-radius: 50%;\r\n background-color: rgba(0, 0, 0, 0.5);\n}\nuni-page-head .uni-btn-icon {\r\n overflow: hidden;\r\n min-width: 1em;\n}\n.uni-page-head-btn-red-dot::after {\r\n content: attr(badge-text);\r\n position: absolute;\r\n right: 0;\r\n top: 0;\r\n background-color: red;\r\n color: white;\r\n width: 18px;\r\n height: 18px;\r\n line-height: 18px;\r\n border-radius: 18px;\r\n overflow: hidden;\r\n transform: scale(0.5) translate(40%, -40%);\r\n transform-origin: 100% 0;\n}\n.uni-page-head-btn-red-dot[badge-text]::after {\r\n font-size: 12px;\r\n width: auto;\r\n min-width: 18px;\r\n max-width: 42px;\r\n text-align: center;\r\n padding: 0 3px;\r\n transform: scale(0.7) translate(40%, -40%);\n}\n.uni-page-head-btn-select > .uni-btn-icon::after {\r\n display: inline-block;\r\n font-family: 'unibtn';\r\n content: '\\e601';\r\n margin-left: 2px;\r\n transform: rotate(-90deg) scale(0.8);\n}\n.uni-page-head-search {\r\n position: relative;\r\n display: flex;\r\n flex: 1;\r\n margin: 0 2px;\r\n line-height: 30px;\r\n font-size: 15px;\n}\n.uni-page-head-search-input {\r\n width: 100%;\r\n height: 100%;\r\n padding-left: 34px;\r\n text-align: left;\n}\n.uni-page-head-search-placeholder {\r\n position: absolute;\r\n max-width: 100%;\r\n height: 100%;\r\n padding-left: 34px;\r\n overflow: hidden;\r\n word-break: keep-all;\r\n white-space: pre;\n}\n.uni-page-head-search-placeholder-right {\r\n right: 0;\n}\n.uni-page-head-search-placeholder-center {\r\n left: 50%;\r\n transform: translateX(-50%);\n}\n.uni-page-head-search-placeholder::before {\r\n position: absolute;\r\n top: 0;\r\n left: 2px;\r\n width: 30px;\r\n content: '\\ea0e';\r\n display: block;\r\n font-size: 20px;\r\n font-family: 'uni';\r\n text-align: center;\n}\nuni-page-head .uni-page-head-ft {\r\n display: flex;\r\n align-items: center;\r\n flex-direction: row-reverse;\r\n font-size: 13px;\n}\nuni-page-head .uni-page-head__title {\r\n font-weight: bold;\r\n font-size: 16px;\r\n line-height: 30px;\r\n text-align: center;\r\n overflow: hidden;\r\n white-space: nowrap;\r\n text-overflow: ellipsis;\n}\nuni-page-head .uni-page-head__title .uni-loading {\r\n width: 16px;\r\n height: 16px;\r\n margin-top: -3px;\n}\nuni-page-head .uni-page-head__title .uni-page-head__title_image {\r\n width: auto;\r\n height: 26px;\r\n vertical-align: middle;\n}\nuni-page-head .uni-page-head-shadow {\r\n overflow: visible;\n}\nuni-page-head .uni-page-head-shadow::after {\r\n content: '';\r\n position: absolute;\r\n left: 0;\r\n right: 0;\r\n top: 100%;\r\n height: 5px;\r\n background-size: 100% 100%;\n}\nuni-page-head .uni-page-head-shadow-grey::after {\r\n background-image: url('https://cdn.dcloud.net.cn/img/shadow-grey.png');\n}\nuni-page-head .uni-page-head-shadow-blue::after {\r\n background-image: url('https://cdn.dcloud.net.cn/img/shadow-blue.png');\n}\nuni-page-head .uni-page-head-shadow-green::after {\r\n background-image: url('https://cdn.dcloud.net.cn/img/shadow-green.png');\n}\nuni-page-head .uni-page-head-shadow-orange::after {\r\n background-image: url('https://cdn.dcloud.net.cn/img/shadow-orange.png');\n}\nuni-page-head .uni-page-head-shadow-red::after {\r\n background-image: url('https://cdn.dcloud.net.cn/img/shadow-red.png');\n}\nuni-page-head .uni-page-head-shadow-yellow::after {\r\n background-image: url('https://cdn.dcloud.net.cn/img/shadow-yellow.png');\n}\r\n"; const FONTS = { forward: "", back: "", @@ -8546,9 +8352,6 @@ const FONTS = { const _sfc_main$5 = { name: "PageHead", mixins: [transparent], - components: { - VUniInput: _sfc_main$l - }, props: { backButton: { type: Boolean, @@ -8636,7 +8439,7 @@ const _sfc_main$5 = { this.buttons.forEach((button) => { const btn = Object.assign({}, button); if (btn.fontSrc && !btn.fontFamily) { - const fontSrc = btn.fontSrc = this.$getRealPath(btn.fontSrc); + const fontSrc = btn.fontSrc = getRealPath(btn.fontSrc); let fontFamily; if (fontSrc in fonts) { fontFamily = fonts[fontSrc]; @@ -8660,12 +8463,6 @@ const _sfc_main$5 = { } return btns; }, - leftBtns() { - return this.btns.filter((btn) => btn.float === "left"); - }, - rightBtns() { - return this.btns.filter((btn) => btn.float !== "left"); - }, headClass() { const shadowColorType = this.shadow.colorType; const data = { @@ -8770,10 +8567,15 @@ const _hoisted_3$1 = { }; const _hoisted_4$1 = {class: "uni-page-head-ft"}; function _sfc_render$5(_ctx, _cache, $props, $setup, $data, $options) { - const _component_VUniInput = resolveComponent("VUniInput"); + const _component_v_uni_input = resolveComponent("v-uni-input"); return openBlock(), createBlock("uni-page-head", {"uni-page-head-type": $props.type}, [ createVNode("div", { - style: {transitionDuration: $props.duration, transitionTimingFunction: $props.timingFunc, backgroundColor: _ctx.bgColor, color: $props.textColor}, + style: { + transitionDuration: $props.duration, + transitionTimingFunction: $props.timingFunc, + backgroundColor: _ctx.bgColor, + color: $props.textColor + }, class: [$options.headClass, "uni-page-head"] }, [ createVNode("div", _hoisted_1$2, [ @@ -8788,25 +8590,36 @@ function _sfc_render$5(_ctx, _cache, $props, $setup, $data, $options) { ], 512), [ [vShow, $props.backButton] ]), - (openBlock(true), createBlock(Fragment, null, renderList($options.leftBtns, (btn, index2) => { - return openBlock(), createBlock("div", { - key: index2, - style: {backgroundColor: $props.type === "transparent" ? btn.background : "transparent", width: btn.width}, - "badge-text": btn.badgeText, - class: [{"uni-page-head-btn-red-dot": btn.redDot || btn.badgeText, "uni-page-head-btn-select": btn.select}, "uni-page-head-btn"] - }, [ - createVNode("i", { - style: $options._formatBtnStyle(btn), - class: "uni-btn-icon", - onClick: ($event) => $options._onBtnClick(index2), - innerHTML: $options._formatBtnFontText(btn) - }, null, 12, ["onClick", "innerHTML"]) - ], 14, ["badge-text"]); - }), 128)) + (openBlock(true), createBlock(Fragment, null, renderList($options.btns, (btn, index2) => { + return openBlock(), createBlock(Fragment, null, [ + btn.float === "left" ? (openBlock(), createBlock("div", { + key: index2, + style: { + backgroundColor: $props.type === "transparent" ? btn.background : "transparent", + width: btn.width + }, + "badge-text": btn.badgeText, + class: [{ + "uni-page-head-btn-red-dot": btn.redDot || btn.badgeText, + "uni-page-head-btn-select": btn.select + }, "uni-page-head-btn"] + }, [ + createVNode("i", { + style: $options._formatBtnStyle(btn), + class: "uni-btn-icon", + onClick: ($event) => $options._onBtnClick(index2), + innerHTML: $options._formatBtnFontText(btn) + }, null, 12, ["onClick", "innerHTML"]) + ], 14, ["badge-text"])) : createCommentVNode("", true) + ], 64); + }), 256)) ]), !$props.searchInput ? (openBlock(), createBlock("div", _hoisted_2$2, [ createVNode("div", { - style: {fontSize: $props.titleSize, opacity: $props.type === "transparent" ? 0 : 1}, + style: { + fontSize: $props.titleSize, + opacity: $props.type === "transparent" ? 0 : 1 + }, class: "uni-page-head__title" }, [ $props.loading ? (openBlock(), createBlock("i", _hoisted_3$1)) : createCommentVNode("", true), @@ -8821,15 +8634,20 @@ function _sfc_render$5(_ctx, _cache, $props, $setup, $data, $options) { ])) : createCommentVNode("", true), $props.searchInput ? (openBlock(), createBlock("div", { key: 1, - style: {"border-radius": $props.searchInput.borderRadius, "background-color": $props.searchInput.backgroundColor}, + style: { + "border-radius": $props.searchInput.borderRadius, + "background-color": $props.searchInput.backgroundColor + }, class: "uni-page-head-search" }, [ createVNode("div", { style: {color: $props.searchInput.placeholderColor}, - class: [[`uni-page-head-search-placeholder-${$data.focus || $data.text ? "left" : $props.searchInput.align}`], "uni-page-head-search-placeholder"], + class: [[ + `uni-page-head-search-placeholder-${$data.focus || $data.text ? "left" : $props.searchInput.align}` + ], "uni-page-head-search-placeholder"], textContent: toDisplayString($data.text || $data.composing ? "" : $props.searchInput.placeholder) }, null, 14, ["textContent"]), - createVNode(_component_VUniInput, { + createVNode(_component_v_uni_input, { ref: "input", modelValue: $data.text, "onUpdate:modelValue": _cache[2] || (_cache[2] = ($event) => $data.text = $event), @@ -8845,21 +8663,29 @@ function _sfc_render$5(_ctx, _cache, $props, $setup, $data, $options) { }, null, 8, ["modelValue", "focus", "disabled", "style", "placeholder-style", "onFocus", "onBlur", "onUpdate:value"]) ], 4)) : createCommentVNode("", true), createVNode("div", _hoisted_4$1, [ - (openBlock(true), createBlock(Fragment, null, renderList($options.rightBtns, (btn, index2) => { - return openBlock(), createBlock("div", { - key: index2, - style: {backgroundColor: $props.type === "transparent" ? btn.background : "transparent", width: btn.width}, - "badge-text": btn.badgeText, - class: [{"uni-page-head-btn-red-dot": btn.redDot || btn.badgeText, "uni-page-head-btn-select": btn.select}, "uni-page-head-btn"] - }, [ - createVNode("i", { - style: $options._formatBtnStyle(btn), - class: "uni-btn-icon", - onClick: ($event) => $options._onBtnClick(index2), - innerHTML: $options._formatBtnFontText(btn) - }, null, 12, ["onClick", "innerHTML"]) - ], 14, ["badge-text"]); - }), 128)) + (openBlock(true), createBlock(Fragment, null, renderList($options.btns, (btn, index2) => { + return openBlock(), createBlock(Fragment, null, [ + btn.float !== "left" ? (openBlock(), createBlock("div", { + key: index2, + style: { + backgroundColor: $props.type === "transparent" ? btn.background : "transparent", + width: btn.width + }, + "badge-text": btn.badgeText, + class: [{ + "uni-page-head-btn-red-dot": btn.redDot || btn.badgeText, + "uni-page-head-btn-select": btn.select + }, "uni-page-head-btn"] + }, [ + createVNode("i", { + style: $options._formatBtnStyle(btn), + class: "uni-btn-icon", + onClick: ($event) => $options._onBtnClick(index2), + innerHTML: $options._formatBtnFontText(btn) + }, null, 12, ["onClick", "innerHTML"]) + ], 14, ["badge-text"])) : createCommentVNode("", true) + ], 64); + }), 256)) ]) ], 6), $props.type !== "transparent" && $props.type !== "float" ? (openBlock(), createBlock("div", { @@ -8869,9 +8695,11 @@ function _sfc_render$5(_ctx, _cache, $props, $setup, $data, $options) { ], 8, ["uni-page-head-type"]); } _sfc_main$5.render = _sfc_render$5; -var pageBody_vue_vue_type_style_index_0_lang = '\nuni-page-wrapper {\r\n display: block;\r\n height: 100%;\r\n position: relative;\n}\nuni-page-head[uni-page-head-type="default"] ~ uni-page-wrapper {\r\n height: calc(100% - 44px);\r\n height: calc(100% - 44px - constant(safe-area-inset-top));\r\n height: calc(100% - 44px - env(safe-area-inset-top));\n}\n.uni-app--showtabbar uni-page-wrapper {\r\n display: block;\r\n height: calc(100% - 50px);\r\n height: calc(100% - 50px - constant(safe-area-inset-bottom));\r\n height: calc(100% - 50px - env(safe-area-inset-bottom));\n}\n.uni-app--showtabbar uni-page-wrapper::after {\r\n content: "";\r\n display: block;\r\n width: 100%;\r\n height: 50px;\r\n height: calc(50px + constant(safe-area-inset-bottom));\r\n height: calc(50px + env(safe-area-inset-bottom));\n}\n.uni-app--showtabbar uni-page-head[uni-page-head-type="default"] ~ uni-page-wrapper {\r\n height: calc(100% - 44px - 50px);\r\n height: calc(100% - 44px - constant(safe-area-inset-top) - 50px - constant(safe-area-inset-bottom));\r\n height: calc(100% - 44px - env(safe-area-inset-top) - 50px - env(safe-area-inset-bottom));\n}\nuni-page-body {\r\n display: block;\r\n box-sizing: border-box;\r\n width: 100%;\n}\r\n'; +var pageBody_vue_vue_type_style_index_0_lang = "\nuni-page-wrapper {\r\n display: block;\r\n height: 100%;\r\n position: relative;\n}\nuni-page-head[uni-page-head-type='default'] ~ uni-page-wrapper {\r\n height: calc(100% - 44px);\r\n height: calc(100% - 44px - constant(safe-area-inset-top));\r\n height: calc(100% - 44px - env(safe-area-inset-top));\n}\nuni-page-body {\r\n display: block;\r\n box-sizing: border-box;\r\n width: 100%;\n}\r\n"; const _sfc_main$4 = { - name: "PageBody" + name: "PageBody", + mounted() { + } }; function _sfc_render$4(_ctx, _cache, $props, $setup, $data, $options) { return openBlock(), createBlock("uni-page-wrapper", null, [ @@ -9000,7 +8828,9 @@ var pullToRefresh = { if (!processDeltaY(evt, this.touchId, this.startY)) { return; } - let {deltaY} = evt; + let { + deltaY + } = evt; if ((document.documentElement.scrollTop || document.body.scrollTop) !== 0) { this.touchId = null; return; @@ -9237,9 +9067,14 @@ const _sfc_main$2 = { default() { return {}; } + }, + topWindow: { + type: Boolean, + default: true } }, data() { + let navigationBar = {}; const titleNViewTypeList = { none: "default", auto: "transparent", @@ -9263,7 +9098,7 @@ const _sfc_main$2 = { YES: true, NO: false }; - const navigationBar = mergeTitleNView({ + navigationBar = mergeTitleNView({ loading: false, backButton: !this.isQuit && !this.$route.meta.isQuit, backgroundColor: this.navigationBarBackgroundColor, @@ -9305,9 +9140,7 @@ function _sfc_render$2(_ctx, _cache, $props, $setup, $data, $options) { const _component_page_head = resolveComponent("page-head"); const _component_page_refresh = resolveComponent("page-refresh"); const _component_page_body = resolveComponent("page-body"); - return openBlock(), createBlock("uni-page", { - "data-page": _ctx.$route.meta.pagePath - }, [ + return openBlock(), createBlock("uni-page", null, [ $data.navigationBar.type !== "none" ? (openBlock(), createBlock(_component_page_head, mergeProps({key: 0}, $data.navigationBar), null, 16)) : createCommentVNode("", true), $props.enablePullDownRefresh ? (openBlock(), createBlock(_component_page_refresh, { key: 1, @@ -9317,27 +9150,445 @@ function _sfc_render$2(_ctx, _cache, $props, $setup, $data, $options) { }, null, 8, ["color", "offset"])) : createCommentVNode("", true), $props.enablePullDownRefresh ? (openBlock(), createBlock(_component_page_body, { key: 2, - onTouchstartPassive: _ctx._touchstart, - onTouchmovePassive: _ctx._touchmove, - onTouchendPassive: _ctx._touchend, - onTouchcancelPassive: _ctx._touchend + onTouchstart: _ctx._touchstart, + onTouchmove: _ctx._touchmove, + onTouchend: _ctx._touchend, + onTouchcancel: _ctx._touchend }, { default: withCtx(() => [ renderSlot(_ctx.$slots, "page") ]), _: 3 - }, 8, ["onTouchstartPassive", "onTouchmovePassive", "onTouchendPassive", "onTouchcancelPassive"])) : (openBlock(), createBlock(_component_page_body, {key: 3}, { + }, 8, ["onTouchstart", "onTouchmove", "onTouchend", "onTouchcancel"])) : (openBlock(), createBlock(_component_page_body, {key: 3}, { default: withCtx(() => [ renderSlot(_ctx.$slots, "page") ]), _: 3 })) - ], 8, ["data-page"]); + ]); } _sfc_main$2.render = _sfc_render$2; -var index_vue_vue_type_style_index_0_lang$1 = "\n.uni-async-error {\r\n position: absolute;\r\n left: 0;\r\n right: 0;\r\n top: 0;\r\n bottom: 0;\r\n color: #999;\r\n padding: 100px 0;\r\n text-align: center;\n}\r\n"; +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 text2 = ""; + while (position < format.length) { + let char = format[position++]; + if (char === "{") { + if (text2) { + tokens.push({type: "text", value: text2}); + } + text2 = ""; + 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] !== "{") { + text2 += char; + } + } else { + text2 += char; + } + } + text2 && tokens.push({type: "text", value: text2}); + return tokens; +} +function compile(tokens, values) { + const compiled = []; + let index2 = 0; + const mode = Array.isArray(values) ? "list" : isObject(values) ? "named" : "unknown"; + if (mode === "unknown") { + return compiled; + } + while (index2 < tokens.length) { + const token = tokens[index2]; + switch (token.type) { + case "text": + compiled.push(token.value); + break; + case "list": + compiled.push(values[parseInt(token.value, 10)]); + break; + case "named": + if (mode === "named") { + compiled.push(values[token.value]); + } + break; + } + index2++; + } + return compiled; +} +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, messages2) { + if (!locale) { + return; + } + locale = locale.trim().replace(/_/g, "-"); + if (messages2[locale]) { + return locale; + } + locale = locale.toLowerCase(); + if (locale.indexOf("zh") === 0) { + if (locale.indexOf("-hans") !== -1) { + return "zh-Hans"; + } + if (locale.indexOf("-hant") !== -1) { + return "zh-Hant"; + } + if (include(locale, ["-tw", "-hk", "-mo", "-cht"])) { + return "zh-Hant"; + } + return "zh-Hans"; + } + const lang = startsWith(locale, ["en", "fr", "es"]); + if (lang) { + return lang; + } +} +class I18n { + constructor({locale, fallbackLocale: fallbackLocale2, messages: messages2, watcher, formater}) { + this.locale = "en"; + this.fallbackLocale = "en"; + this.message = {}; + this.messages = {}; + this.watchers = []; + if (fallbackLocale2) { + this.fallbackLocale = fallbackLocale2; + } + this.formater = formater || defaultFormatter; + this.messages = messages2; + this.setLocale(locale); + if (watcher) { + this.watchLocale(watcher); + } + } + setLocale(locale) { + const oldLocale = this.locale; + this.locale = normalizeLocale(locale, this.messages) || this.fallbackLocale; + this.message = this.messages[this.locale]; + this.watchers.forEach((watcher) => { + watcher(this.locale, oldLocale); + }); + } + getLocale() { + return this.locale; + } + watchLocale(fn) { + const index2 = this.watchers.push(fn) - 1; + return () => { + this.watchers.splice(index2, 1); + }; + } + mergeLocaleMessage(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(appVm2, i18n2) { + appVm2.$i18n && appVm2.$i18n.vm.$watch("locale", (newLocale) => { + i18n2.setLocale(newLocale); + }, { + immediate: true + }); +} +function getDefaultLocale() { + if (typeof navigator !== "undefined") { + return navigator.userLanguage || navigator.language; + } + if (typeof plus !== "undefined") { + return plus.os.language; + } + return uni.getSystemInfoSync().language; +} +function initVueI18n(messages2, fallbackLocale2 = "en", locale) { + const i18n2 = new I18n({ + locale: locale || fallbackLocale2, + fallbackLocale: fallbackLocale2, + messages: messages2 + }); + let t2 = (key, values) => { + if (typeof getApp !== "function") { + t2 = function(key2, values2) { + return i18n2.t(key2, values2); + }; + } else { + const appVm2 = getApp().$vm; + if (!appVm2.$t || !appVm2.$i18n) { + if (!locale) { + i18n2.setLocale(getDefaultLocale()); + } + t2 = function(key2, values2) { + return i18n2.t(key2, values2); + }; + } else { + initLocaleWatcher(appVm2, i18n2); + t2 = function(key2, values2) { + const $i18n = appVm2.$i18n; + const silentTranslationWarn = $i18n.silentTranslationWarn; + $i18n.silentTranslationWarn = true; + const msg = appVm2.$t(key2, values2); + $i18n.silentTranslationWarn = silentTranslationWarn; + if (msg !== key2) { + return msg; + } + return i18n2.t(key2, $i18n.locale, values2); + }; + } + } + return t2(key, values); + }; + return { + t(key, values) { + return t2(key, values); + }, + getLocale() { + return i18n2.getLocale(); + }, + setLocale(newLocale) { + return i18n2.setLocale(newLocale); + }, + mixin: { + beforeCreate() { + const unwatch = i18n2.watchLocale(() => { + this.$forceUpdate(); + }); + this.$once("hook:beforeDestroy", function() { + unwatch(); + }); + }, + methods: { + $$t(key, values) { + return t2(key, values); + } + } + } + }; +} +var en = { + "uni.app.quit": "Press back button again to exit", + "uni.async.error": "The connection timed out, click the screen to try again.", + "uni.showActionSheet.cancel": "Cancel", + "uni.showToast.unpaired": "Please note showToast must be paired with hideToast", + "uni.showLoading.unpaired": "Please note showLoading must be paired with hideLoading", + "uni.showModal.cancel": "Cancel", + "uni.showModal.confirm": "OK", + "uni.chooseImage.cancel": "Cancel", + "uni.chooseImage.sourceType.album": "Album", + "uni.chooseImage.sourceType.camera": "Camera", + "uni.chooseVideo.cancel": "Cancel", + "uni.chooseVideo.sourceType.album": "Album", + "uni.chooseVideo.sourceType.camera": "Camera", + "uni.previewImage.cancel": "Cancel", + "uni.previewImage.button.save": "Save Image", + "uni.previewImage.save.success": "Saved successfully", + "uni.previewImage.save.fail": "Save failed", + "uni.setClipboardData.success": "Content copied", + "uni.scanCode.title": "Scan code", + "uni.scanCode.album": "Album", + "uni.scanCode.fail": "Recognition failure", + "uni.scanCode.flash.on": "Tap to turn light on", + "uni.scanCode.flash.off": "Tap to turn light off", + "uni.startSoterAuthentication.authContent": "Fingerprint recognition", + "uni.picker.done": "Done", + "uni.picker.cancel": "Cancel", + "uni.video.danmu": "Danmu", + "uni.video.volume": "Volume", + "uni.button.feedback.title": "feedback", + "uni.button.feedback.send": "send" +}; +var es = { + "uni.app.quit": "Pulse otra vez para salir", + "uni.async.error": "Se agot\xF3 el tiempo de conexi\xF3n, haga clic en la pantalla para volver a intentarlo.", + "uni.showActionSheet.cancel": "Cancelar", + "uni.showToast.unpaired": "Tenga en cuenta que showToast debe estar emparejado con hideToast", + "uni.showLoading.unpaired": "Tenga en cuenta que showLoading debe estar emparejado con hideLoading", + "uni.showModal.cancel": "Cancelar", + "uni.showModal.confirm": "OK", + "uni.chooseImage.cancel": "Cancelar", + "uni.chooseImage.sourceType.album": "\xC1lbum", + "uni.chooseImage.sourceType.camera": "C\xE1mara", + "uni.chooseVideo.cancel": "Cancelar", + "uni.chooseVideo.sourceType.album": "\xC1lbum", + "uni.chooseVideo.sourceType.camera": "C\xE1mara", + "uni.previewImage.cancel": "Cancelar", + "uni.previewImage.button.save": "Guardar imagen", + "uni.previewImage.save.success": "Guardado exitosamente", + "uni.previewImage.save.fail": "Error al guardar", + "uni.setClipboardData.success": "Contenido copiado", + "uni.scanCode.title": "C\xF3digo de escaneo", + "uni.scanCode.album": "\xC1lbum", + "uni.scanCode.fail": "\xC9chec de la reconnaissance", + "uni.scanCode.flash.on": "Toque para encender la luz", + "uni.scanCode.flash.off": "Toque para apagar la luz", + "uni.startSoterAuthentication.authContent": "Reconocimiento de huellas dactilares", + "uni.picker.done": "OK", + "uni.picker.cancel": "Cancelar", + "uni.video.danmu": "Danmu", + "uni.video.volume": "Volumen", + "uni.button.feedback.title": "realimentaci\xF3n", + "uni.button.feedback.send": "enviar" +}; +var fr = { + "uni.app.quit": "Appuyez \xE0 nouveau pour quitter l'application", + "uni.async.error": "La connexion a expir\xE9, cliquez sur l'\xE9cran pour r\xE9essayer.", + "uni.showActionSheet.cancel": "Annuler", + "uni.showToast.unpaired": "Veuillez noter que showToast doit \xEAtre associ\xE9 \xE0 hideToast", + "uni.showLoading.unpaired": "Veuillez noter que showLoading doit \xEAtre associ\xE9 \xE0 hideLoading", + "uni.showModal.cancel": "Annuler", + "uni.showModal.confirm": "OK", + "uni.chooseImage.cancel": "Annuler", + "uni.chooseImage.sourceType.album": "Album", + "uni.chooseImage.sourceType.camera": "Cam\xE9ra", + "uni.chooseVideo.cancel": "Annuler", + "uni.chooseVideo.sourceType.album": "Album", + "uni.chooseVideo.sourceType.camera": "Cam\xE9ra", + "uni.previewImage.cancel": "Annuler", + "uni.previewImage.button.save": "Guardar imagen", + "uni.previewImage.save.success": "Enregistr\xE9 avec succ\xE8s", + "uni.previewImage.save.fail": "\xC9chec de la sauvegarde", + "uni.setClipboardData.success": "Contenu copi\xE9", + "uni.scanCode.title": "Code d\u2019analyse", + "uni.scanCode.album": "Album", + "uni.scanCode.fail": "Fallo de reconocimiento", + "uni.scanCode.flash.on": "Appuyez pour activer l'\xE9clairage", + "uni.scanCode.flash.off": "Appuyez pour d\xE9sactiver l'\xE9clairage", + "uni.startSoterAuthentication.authContent": "Reconnaissance de l'empreinte digitale", + "uni.picker.done": "OK", + "uni.picker.cancel": "Annuler", + "uni.video.danmu": "Danmu", + "uni.video.volume": "Le Volume", + "uni.button.feedback.title": "retour d'information", + "uni.button.feedback.send": "envoyer" +}; +var zhHans = { + "uni.app.quit": "\u518D\u6309\u4E00\u6B21\u9000\u51FA\u5E94\u7528", + "uni.async.error": "\u8FDE\u63A5\u670D\u52A1\u5668\u8D85\u65F6\uFF0C\u70B9\u51FB\u5C4F\u5E55\u91CD\u8BD5", + "uni.showActionSheet.cancel": "\u53D6\u6D88", + "uni.showToast.unpaired": "\u8BF7\u6CE8\u610F showToast \u4E0E hideToast \u5FC5\u987B\u914D\u5BF9\u4F7F\u7528", + "uni.showLoading.unpaired": "\u8BF7\u6CE8\u610F showLoading \u4E0E hideLoading \u5FC5\u987B\u914D\u5BF9\u4F7F\u7528", + "uni.showModal.cancel": "\u53D6\u6D88", + "uni.showModal.confirm": "\u786E\u5B9A", + "uni.chooseImage.cancel": "\u53D6\u6D88", + "uni.chooseImage.sourceType.album": "\u4ECE\u76F8\u518C\u9009\u62E9", + "uni.chooseImage.sourceType.camera": "\u62CD\u6444", + "uni.chooseVideo.cancel": "\u53D6\u6D88", + "uni.chooseVideo.sourceType.album": "\u4ECE\u76F8\u518C\u9009\u62E9", + "uni.chooseVideo.sourceType.camera": "\u62CD\u6444", + "uni.previewImage.cancel": "\u53D6\u6D88", + "uni.previewImage.button.save": "\u4FDD\u5B58\u56FE\u50CF", + "uni.previewImage.save.success": "\u4FDD\u5B58\u56FE\u50CF\u5230\u76F8\u518C\u6210\u529F", + "uni.previewImage.save.fail": "\u4FDD\u5B58\u56FE\u50CF\u5230\u76F8\u518C\u5931\u8D25", + "uni.setClipboardData.success": "\u5185\u5BB9\u5DF2\u590D\u5236", + "uni.scanCode.title": "\u626B\u7801", + "uni.scanCode.album": "\u76F8\u518C", + "uni.scanCode.fail": "\u8BC6\u522B\u5931\u8D25", + "uni.scanCode.flash.on": "\u8F7B\u89E6\u7167\u4EAE", + "uni.scanCode.flash.off": "\u8F7B\u89E6\u5173\u95ED", + "uni.startSoterAuthentication.authContent": "\u6307\u7EB9\u8BC6\u522B\u4E2D...", + "uni.picker.done": "\u5B8C\u6210", + "uni.picker.cancel": "\u53D6\u6D88", + "uni.video.danmu": "\u5F39\u5E55", + "uni.video.volume": "\u97F3\u91CF", + "uni.button.feedback.title": "\u95EE\u9898\u53CD\u9988", + "uni.button.feedback.send": "\u53D1\u9001" +}; +var zhHant = { + "uni.app.quit": "\u518D\u6309\u4E00\u6B21\u9000\u51FA\u61C9\u7528", + "uni.async.error": "\u9023\u63A5\u670D\u52D9\u5668\u8D85\u6642\uFF0C\u9EDE\u64CA\u5C4F\u5E55\u91CD\u8A66", + "uni.showActionSheet.cancel": "\u53D6\u6D88", + "uni.showToast.unpaired": "\u8ACB\u6CE8\u610F showToast \u8207 hideToast \u5FC5\u9808\u914D\u5C0D\u4F7F\u7528", + "uni.showLoading.unpaired": "\u8ACB\u6CE8\u610F showLoading \u8207 hideLoading \u5FC5\u9808\u914D\u5C0D\u4F7F\u7528", + "uni.showModal.cancel": "\u53D6\u6D88", + "uni.showModal.confirm": "\u78BA\u5B9A", + "uni.chooseImage.cancel": "\u53D6\u6D88", + "uni.chooseImage.sourceType.album": "\u5F9E\u76F8\u518A\u9078\u64C7", + "uni.chooseImage.sourceType.camera": "\u62CD\u651D", + "uni.chooseVideo.cancel": "\u53D6\u6D88", + "uni.chooseVideo.sourceType.album": "\u5F9E\u76F8\u518A\u9078\u64C7", + "uni.chooseVideo.sourceType.camera": "\u62CD\u651D", + "uni.previewImage.cancel": "\u53D6\u6D88", + "uni.previewImage.button.save": "\u4FDD\u5B58\u5716\u50CF", + "uni.previewImage.save.success": "\u4FDD\u5B58\u5716\u50CF\u5230\u76F8\u518A\u6210\u529F", + "uni.previewImage.save.fail": "\u4FDD\u5B58\u5716\u50CF\u5230\u76F8\u518A\u5931\u6557", + "uni.setClipboardData.success": "\u5167\u5BB9\u5DF2\u5FA9\u5236", + "uni.scanCode.title": "\u6383\u78BC", + "uni.scanCode.album": "\u76F8\u518A", + "uni.scanCode.fail": "\u8B58\u5225\u5931\u6557", + "uni.scanCode.flash.on": "\u8F15\u89F8\u7167\u4EAE", + "uni.scanCode.flash.off": "\u8F15\u89F8\u95DC\u9589", + "uni.startSoterAuthentication.authContent": "\u6307\u7D0B\u8B58\u5225\u4E2D...", + "uni.picker.done": "\u5B8C\u6210", + "uni.picker.cancel": "\u53D6\u6D88", + "uni.video.danmu": "\u5F48\u5E55", + "uni.video.volume": "\u97F3\u91CF", + "uni.button.feedback.title": "\u554F\u984C\u53CD\u994B", + "uni.button.feedback.send": "\u767C\u9001" +}; +const messages = { + en, + es, + fr, + "zh-Hans": zhHans, + "zh-Hant": zhHant +}; +const fallbackLocale = "en"; +const i18n = initVueI18n(messages, fallbackLocale); +const i18nMixin = i18n.mixin; +var index_vue_vue_type_style_index_0_lang$1 = "\n.uni-async-error {\r\n position: absolute;\r\n left: 0;\r\n right: 0;\r\n top: 0;\r\n bottom: 0;\r\n color: #999;\r\n padding: 100px 10px;\r\n text-align: center;\n}\r\n"; const _sfc_main$1 = { name: "AsyncError", + mixins: [i18nMixin], methods: { _onClick() { window.location.reload(); @@ -9348,10 +9599,10 @@ function _sfc_render$1(_ctx, _cache, $props, $setup, $data, $options) { return openBlock(), createBlock("div", { class: "uni-async-error", onClick: _cache[1] || (_cache[1] = (...args) => $options._onClick && $options._onClick(...args)) - }, " \u8FDE\u63A5\u670D\u52A1\u5668\u8D85\u65F6\uFF0C\u70B9\u51FB\u5C4F\u5E55\u91CD\u8BD5 "); + }, toDisplayString(_ctx.$$t("uni.async.error")), 1); } _sfc_main$1.render = _sfc_render$1; -var index_vue_vue_type_style_index_0_lang = "\n.uni-async-loading {\r\n box-sizing: border-box;\r\n width: 100%;\r\n padding: 50px;\r\n text-align: center;\n}\n.uni-async-loading .uni-loading {\r\n width: 30px;\r\n height: 30px;\n}\r\n"; +var index_vue_vue_type_style_index_0_lang = "\n.uni-async-loading {\n box-sizing: border-box;\r\n width: 100%;\r\n padding: 50px;\r\n text-align: center;\n}\n.uni-async-loading .uni-loading {\r\n width: 30px;\r\n height: 30px;\n}\r\n"; const _sfc_main = { name: "AsyncLoading" }; @@ -9363,56 +9614,4 @@ function _sfc_render(_ctx, _cache, $props, $setup, $data, $options) { ]); } _sfc_main.render = _sfc_render; -function initSystemComponents(app) { - _sfc_main$u.name = COMPONENT_NAME_PREFIX + _sfc_main$u.name; - _sfc_main$2.name = COMPONENT_NAME_PREFIX + _sfc_main$2.name; - _sfc_main$1.name = COMPONENT_NAME_PREFIX + _sfc_main$1.name; - _sfc_main.name = COMPONENT_NAME_PREFIX + _sfc_main.name; - app.component(_sfc_main$u.name, _sfc_main$u); - app.component(_sfc_main$2.name, _sfc_main$2); - app.component(_sfc_main$1.name, _sfc_main$1); - app.component(_sfc_main.name, _sfc_main); -} -function initMixin(app) { - app.mixin({ - created() { - if (isApp(this)) { - initApp(this); - } else if (isPage(this)) { - initPage(this); - this.$callHook("onLoad", {}); - this.$callHook("onShow"); - } - }, - mounted() { - if (isPage(this)) { - this.$callHook("onReady"); - } - } - }); -} -var index = { - install(app) { - app._context.config.isCustomElement = isCustomElement; - initApp$1(app); - initView(app); - initService(app); - initSystemComponents(app); - initMixin(app); - if (__UNI_FEATURE_PAGES__) { - initRouter(app); - } - } -}; -const UniViewJSBridge$1 = extend(ViewJSBridge, { - publishHandler(event2, args, pageId) { - window.UniServiceJSBridge.subscribeHandler(event2, args, pageId); - } -}); -const uni$1 = api; -const UniServiceJSBridge$1 = extend(ServiceJSBridge, { - publishHandler(event2, args, pageId) { - window.UniViewJSBridge.subscribeHandler(event2, args, pageId); - } -}); -export {_sfc_main$1 as AsyncErrorComponent, _sfc_main as AsyncLoadingComponent, _sfc_main$t as Audio, _sfc_main$s as Canvas, _sfc_main$r as Checkbox, _sfc_main$q as CheckboxGroup, _sfc_main$p as Editor, _sfc_main$o as Form, _sfc_main$n as Icon, _sfc_main$m as Image, _sfc_main$l as Input, _sfc_main$k as Label, _sfc_main$j as MovableView, _sfc_main$i as Navigator, _sfc_main$2 as PageComponent, _sfc_main$h as Progress, _sfc_main$g as Radio, _sfc_main$f as RadioGroup, _sfc_main$e as ResizeSensor, _sfc_main$d as RichText, _sfc_main$c as ScrollView, _sfc_main$b as Slider, _sfc_main$a as SwiperItem, _sfc_main$9 as Switch, _sfc_main$8 as Text, _sfc_main$7 as Textarea, UniServiceJSBridge$1 as UniServiceJSBridge, UniViewJSBridge$1 as UniViewJSBridge, _sfc_main$6 as View, addInterceptor, arrayBufferToBase64, base64ToArrayBuffer, canIUse, createIntersectionObserver, createSelectorQuery, getApp$1 as getApp, getCurrentPages$1 as getCurrentPages, getImageInfo, getRealPath, getSystemInfo, getSystemInfoSync, makePhoneCall, navigateBack, navigateTo, openDocument, index as plugin, promiseInterceptor, reLaunch, redirectTo, removeInterceptor, switchTab, uni$1 as uni, upx2px}; +export {_sfc_main$1 as AsyncErrorComponent, _sfc_main as AsyncLoadingComponent, _sfc_main$t as Audio, _sfc_main$s as Canvas, _sfc_main$r as Checkbox, _sfc_main$q as CheckboxGroup, _sfc_main$p as Editor, _sfc_main$o as Form, _sfc_main$n as Icon, _sfc_main$m as Image, _sfc_main$l as Input, _sfc_main$k as Label, _sfc_main$j as MovableView, _sfc_main$i as Navigator, _sfc_main$2 as PageComponent, _sfc_main$h as Progress, _sfc_main$g as Radio, _sfc_main$f as RadioGroup, _sfc_main$e as ResizeSensor, _sfc_main$d as RichText, _sfc_main$c as ScrollView, _sfc_main$b as Slider, _sfc_main$a as SwiperItem, _sfc_main$9 as Switch, _sfc_main$8 as Text, _sfc_main$7 as Textarea, UniServiceJSBridge$1 as UniServiceJSBridge, UniViewJSBridge$1 as UniViewJSBridge, _sfc_main$6 as View, addInterceptor, arrayBufferToBase64, base64ToArrayBuffer, canIUse, createIntersectionObserver, createSelectorQuery, getApp$1 as getApp, getCurrentPages$1 as getCurrentPages, getImageInfo, getRealPath$1 as getRealPath, getSystemInfo, getSystemInfoSync, makePhoneCall, navigateBack, navigateTo, openDocument, index as plugin, promiseInterceptor, reLaunch, redirectTo, removeInterceptor, switchTab, uni$1 as uni, upx2px}; diff --git a/packages/uni-h5/src/framework/components/app/components.js b/packages/uni-h5/src/framework/components/app/components.js deleted file mode 100644 index 2ae878fbc779bbfb7c4f7c9296af5fd911b4beba..0000000000000000000000000000000000000000 --- a/packages/uni-h5/src/framework/components/app/components.js +++ /dev/null @@ -1,7 +0,0 @@ -import TabBar from './tabBar.vue' -import Components from './popup' - -export default { - TabBar, - ...Components -} diff --git a/packages/uni-h5/src/framework/components/app/customTabBar.vue b/packages/uni-h5/src/framework/components/app/customTabBar.vue new file mode 100644 index 0000000000000000000000000000000000000000..8407c1c23a059c7057116848014b9cf96e1c1479 --- /dev/null +++ b/packages/uni-h5/src/framework/components/app/customTabBar.vue @@ -0,0 +1,143 @@ + + + + + diff --git a/packages/uni-h5/src/framework/components/app/index.css b/packages/uni-h5/src/framework/components/app/index.css deleted file mode 100644 index ed7167ec584cb799c69ebd714850be19c6cc0e8a..0000000000000000000000000000000000000000 --- a/packages/uni-h5/src/framework/components/app/index.css +++ /dev/null @@ -1,171 +0,0 @@ -* { - margin: 0; - -webkit-tap-highlight-color: transparent; -} - -@font-face { - font-weight: normal; - font-style: normal; - font-family: "uni"; - src: url('data:application/octet-stream;base64,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') format('truetype'); -} - -@font-face { - font-weight: normal; - font-style: normal; - font-family: "unibtn"; - src: url('data:application/octet-stream;base64,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') format('truetype') -} - -html, -body { - -webkit-user-select: none; - user-select: none; - width: 100%; - height: 100%; -} - -/* html { - height: 100% -} */ - -body { - overflow-x: hidden; -} - -[class^="uni-icon-"], -[class*=" uni-icon-"] { - display: inline-block; - vertical-align: middle; - font: normal normal normal 14px/1 "uni"; - font-size: inherit; - text-rendering: auto; - -webkit-font-smoothing: antialiased; -} - - - -[class^="uni-btn-icon"], -[class*=" uni-btn-icon"] { - display: inline-block; - font: normal normal normal 14px/1 "unibtn"; - font-size: inherit; - text-rendering: auto; - -webkit-font-smoothing: antialiased; -} - -[class^="uni-btn-icon"]:before, -[class*=" uni-btn-icon"]:before { - margin: 0; - box-sizing: border-box; -} - -.uni-icon-success-no-circle:before { - content: "\EA08"; -} - -.uni-loading, -uni-button[loading]:before { - background: transparent url("data:image/svg+xml;base64, PHN2ZyB4bWxucz0iaHR0cDovL3d3dy53My5vcmcvMjAwMC9zdmciIHdpZHRoPSIxMjAiIGhlaWdodD0iMTIwIiB2aWV3Qm94PSIwIDAgMTAwIDEwMCI+PHBhdGggZmlsbD0ibm9uZSIgZD0iTTAgMGgxMDB2MTAwSDB6Ii8+PHJlY3Qgd2lkdGg9IjciIGhlaWdodD0iMjAiIHg9IjQ2LjUiIHk9IjQwIiBmaWxsPSIjRTlFOUU5IiByeD0iNSIgcnk9IjUiIHRyYW5zZm9ybT0idHJhbnNsYXRlKDAgLTMwKSIvPjxyZWN0IHdpZHRoPSI3IiBoZWlnaHQ9IjIwIiB4PSI0Ni41IiB5PSI0MCIgZmlsbD0iIzk4OTY5NyIgcng9IjUiIHJ5PSI1IiB0cmFuc2Zvcm09InJvdGF0ZSgzMCAxMDUuOTggNjUpIi8+PHJlY3Qgd2lkdGg9IjciIGhlaWdodD0iMjAiIHg9IjQ2LjUiIHk9IjQwIiBmaWxsPSIjOUI5OTlBIiByeD0iNSIgcnk9IjUiIHRyYW5zZm9ybT0icm90YXRlKDYwIDc1Ljk4IDY1KSIvPjxyZWN0IHdpZHRoPSI3IiBoZWlnaHQ9IjIwIiB4PSI0Ni41IiB5PSI0MCIgZmlsbD0iI0EzQTFBMiIgcng9IjUiIHJ5PSI1IiB0cmFuc2Zvcm09InJvdGF0ZSg5MCA2NSA2NSkiLz48cmVjdCB3aWR0aD0iNyIgaGVpZ2h0PSIyMCIgeD0iNDYuNSIgeT0iNDAiIGZpbGw9IiNBQkE5QUEiIHJ4PSI1IiByeT0iNSIgdHJhbnNmb3JtPSJyb3RhdGUoMTIwIDU4LjY2IDY1KSIvPjxyZWN0IHdpZHRoPSI3IiBoZWlnaHQ9IjIwIiB4PSI0Ni41IiB5PSI0MCIgZmlsbD0iI0IyQjJCMiIgcng9IjUiIHJ5PSI1IiB0cmFuc2Zvcm09InJvdGF0ZSgxNTAgNTQuMDIgNjUpIi8+PHJlY3Qgd2lkdGg9IjciIGhlaWdodD0iMjAiIHg9IjQ2LjUiIHk9IjQwIiBmaWxsPSIjQkFCOEI5IiByeD0iNSIgcnk9IjUiIHRyYW5zZm9ybT0icm90YXRlKDE4MCA1MCA2NSkiLz48cmVjdCB3aWR0aD0iNyIgaGVpZ2h0PSIyMCIgeD0iNDYuNSIgeT0iNDAiIGZpbGw9IiNDMkMwQzEiIHJ4PSI1IiByeT0iNSIgdHJhbnNmb3JtPSJyb3RhdGUoLTE1MCA0NS45OCA2NSkiLz48cmVjdCB3aWR0aD0iNyIgaGVpZ2h0PSIyMCIgeD0iNDYuNSIgeT0iNDAiIGZpbGw9IiNDQkNCQ0IiIHJ4PSI1IiByeT0iNSIgdHJhbnNmb3JtPSJyb3RhdGUoLTEyMCA0MS4zNCA2NSkiLz48cmVjdCB3aWR0aD0iNyIgaGVpZ2h0PSIyMCIgeD0iNDYuNSIgeT0iNDAiIGZpbGw9IiNEMkQyRDIiIHJ4PSI1IiByeT0iNSIgdHJhbnNmb3JtPSJyb3RhdGUoLTkwIDM1IDY1KSIvPjxyZWN0IHdpZHRoPSI3IiBoZWlnaHQ9IjIwIiB4PSI0Ni41IiB5PSI0MCIgZmlsbD0iI0RBREFEQSIgcng9IjUiIHJ5PSI1IiB0cmFuc2Zvcm09InJvdGF0ZSgtNjAgMjQuMDIgNjUpIi8+PHJlY3Qgd2lkdGg9IjciIGhlaWdodD0iMjAiIHg9IjQ2LjUiIHk9IjQwIiBmaWxsPSIjRTJFMkUyIiByeD0iNSIgcnk9IjUiIHRyYW5zZm9ybT0icm90YXRlKC0zMCAtNS45OCA2NSkiLz48L3N2Zz4=") no-repeat; -} - -.uni-loading { - width: 20px; - height: 20px; - display: inline-block; - vertical-align: middle; - animation: uni-loading 1s steps(12, end) infinite; - background-size: 100%; -} - -@keyframes uni-loading { - 0% { - transform: rotate3d(0, 0, 1, 0deg); - } - - 100% { - transform: rotate3d(0, 0, 1, 360deg); - } -} - -/* -html, -body, -uni-app, -uni-page { - height: 100%; -} */ - -.uni-mask { - position: fixed; - z-index: 999; - top: 0; - right: 0; - left: 0; - bottom: 0; - background: rgba(0, 0, 0, 0.6); -} - - - - -.uni-fade-enter-active, -.uni-fade-leave-active { - transition-duration: 0.25s; - transition-property: opacity; - transition-timing-function: ease; -} - -.uni-fade-enter, -.uni-fade-leave-active { - opacity: 0 -} - -[nvue] uni-view, -[nvue] uni-swiper-item, -[nvue] uni-scroll-view { - display: flex; - flex-shrink: 0; - flex-grow: 0; - flex-basis: auto; - align-items: stretch; - align-content: flex-start; -} - -[nvue-dir-row] uni-view, -[nvue-dir-row] uni-swiper-item { - flex-direction: row; -} - -[nvue-dir-column] uni-view, -[nvue-dir-column] uni-swiper-item { - flex-direction: column; -} - -[nvue-dir-row-reverse] uni-view, -[nvue-dir-row-reverse] uni-swiper-item { - flex-direction: row-reverse; -} - -[nvue-dir-column-reverse] uni-view, -[nvue-dir-column-reverse] uni-swiper-item { - flex-direction: column-reverse; -} - -[nvue] uni-view, -[nvue] uni-image, -[nvue] uni-input, -[nvue] uni-scroll-view, -[nvue] uni-swiper, -[nvue] uni-swiper-item, -[nvue] uni-text, -[nvue] uni-textarea, -[nvue] uni-video { - position: relative; - border: 0px solid #000000; - box-sizing: border-box; -} - -[nvue] uni-swiper-item { - position: absolute; -} diff --git a/packages/uni-h5/src/framework/components/app/index.ts b/packages/uni-h5/src/framework/components/app/index.ts new file mode 100644 index 0000000000000000000000000000000000000000..5d13f7b55ff84fb413954a47ade64c79a07ddebd --- /dev/null +++ b/packages/uni-h5/src/framework/components/app/index.ts @@ -0,0 +1,90 @@ +import { + ref, + onMounted, + computed, + openBlock, + createBlock, + createVNode, + defineComponent, +} from 'vue' + +import Layout from './layout' + +import { updateCssVar } from '../../../helpers/dom' + +const CSS_VARS = [ + '--status-bar-height', + '--top-window-height', + '--window-left', + '--window-right', + '--window-margin', +] + +export default defineComponent({ + name: 'App', + setup() { + useCssVar() + useAppLifecycle() + const { appClass, onLayoutChange } = useAppClass() + + return () => ( + openBlock(), + createBlock( + 'uni-app', + { + class: appClass.value, + }, + [ + createVNode( + Layout, + { + onChange: onLayoutChange, + }, + null, + 8 /* PROPS */, + ['onChange'] + ), + ], + 2 /* CLASS */ + ) + ) + }, +}) + +function useCssVar() { + CSS_VARS.forEach((name) => updateCssVar(name, '0px')) +} + +function useAppLifecycle() { + onMounted(() => { + document.addEventListener('visibilitychange', function () { + if (document.visibilityState === 'visible') { + UniServiceJSBridge.emit('onAppEnterForeground') + } else { + UniServiceJSBridge.emit('onAppEnterBackground') + } + }) + }) +} + +function useAppClass() { + const showTabBar = ref(false) + const showMaxWidth = ref(false) + function onLayoutChange(type: string, value: boolean) { + if (type === 'showTabBar') { + showTabBar.value = value + } else if (type === 'showMaxWidth') { + showMaxWidth.value = value + } + } + const appClass = computed(() => { + return { + 'uni-app--showtabbar': showTabBar.value, + 'uni-app--maxwidth': showMaxWidth.value, + } + }) + return { + appClass, + onLayoutChange, + } +} diff --git a/packages/uni-h5/src/framework/components/app/index.vue b/packages/uni-h5/src/framework/components/app/index.vue deleted file mode 100644 index 38fcb6d5fb2b9aed2c8afe98b448b48e0b2aa565..0000000000000000000000000000000000000000 --- a/packages/uni-h5/src/framework/components/app/index.vue +++ /dev/null @@ -1,119 +0,0 @@ - - diff --git a/packages/uni-h5/src/framework/components/app/layout/index.ts b/packages/uni-h5/src/framework/components/app/layout/index.ts new file mode 100644 index 0000000000000000000000000000000000000000..2218405e4b36dcd22228f558e7b62a5643d295eb --- /dev/null +++ b/packages/uni-h5/src/framework/components/app/layout/index.ts @@ -0,0 +1,203 @@ +import { + vShow, + withCtx, + Fragment, + KeepAlive, + openBlock, + mergeProps, + createBlock, + createVNode, + withDirectives, + defineComponent, + resolveComponent, + ConcreteComponent, + createCommentVNode, + resolveDynamicComponent, +} from 'vue' + +import { RouteLocationNormalizedLoaded, RouterView, useRoute } from 'vue-router' + +import TabBar from '../tabBar' + +import { useKeepAliveRoute } from '../../../plugin/page' + +type KeepAliveRoute = ReturnType + +export default defineComponent({ + name: 'Layout', + emits: ['change'], + setup() { + const route = __UNI_FEATURE_TABBAR__ ? useRoute() : null + const keepAliveRoute = __UNI_FEATURE_PAGES__ ? useKeepAliveRoute() : null + const topWindow = __UNI_FEATURE_TOPWINDOW__ ? useTopWindow() : null + const leftWindow = __UNI_FEATURE_LEFTWINDOW__ ? useLeftWindow() : null + const rightWindow = __UNI_FEATURE_RIGHTWINDOW__ ? useRightWindow() : null + return () => { + return ( + openBlock(), + createBlock( + Fragment, + null, + [ + createLayoutVNode( + keepAliveRoute, + topWindow, + leftWindow, + rightWindow + ), + createTabBarVNode(route), + ], + 64 /* STABLE_FRAGMENT */ + ) + ) + } + }, +}) + +function createLayoutVNode( + keepAliveRoute: KeepAliveRoute | null, + topWindow: unknown, + leftWindow: unknown, + rightWindow: unknown +) { + const routerVNode = __UNI_FEATURE_PAGES__ + ? createRouterViewVNode(keepAliveRoute!) + : createPageVNode() + // 非响应式 + if (!__UNI_FEATURE_RESPONSIVE__) { + return routerVNode + } + const topWindowVNode = __UNI_FEATURE_TOPWINDOW__ + ? createTopWindowVNode(topWindow) + : createCommentVNode('', true) + const leftWindowVNode = __UNI_FEATURE_LEFTWINDOW__ + ? createLeftWindowVNode(leftWindow) + : createCommentVNode('', true) + const rightWindowVNode = __UNI_FEATURE_RIGHTWINDOW__ + ? createRightWindowVNode(rightWindow) + : createCommentVNode('', true) + return createVNode('uni-layout', null, [ + topWindowVNode, + createVNode('uni-content', null, [ + createVNode('uni-main', null, [routerVNode]), + leftWindowVNode, + rightWindowVNode, + ]), + ]) +} + +function createTabBarVNode(route: RouteLocationNormalizedLoaded | null) { + return __UNI_FEATURE_TABBAR__ + ? withDirectives(createVNode(TabBar, null, null, 512 /* NEED_PATCH */), [ + [vShow, route!.meta.isTabBar], // TODO mediaQuery and api + ]) + : createCommentVNode('', true) +} + +function createPageVNode() { + return createVNode(__uniRoutes[1].component) +} + +function createRouterViewVNode( + keepAliveRoute: ReturnType +) { + return createVNode(RouterView, null, { + default: withCtx(({ Component }) => [ + (openBlock(), + createBlock( + KeepAlive, + { cache: keepAliveRoute.routeCache }, + [ + (openBlock(), + createBlock(resolveDynamicComponent(Component), { + key: keepAliveRoute.routeKey.value, + })), + ], + 1032 /* PROPS, DYNAMIC_SLOTS */, + ['cache'] + )), + ]), + _: 1 /* STABLE */, + }) +} + +function useTopWindow() { + const component = resolveComponent('VUniTopWindow') as ConcreteComponent + return { + component, + style: (component as any).style, + height: 0, + show: false, + } +} +function useLeftWindow() { + const component = resolveComponent('VUniLeftWindow') as ConcreteComponent + return { + component, + style: (component as any).style, + height: 0, + } +} +function useRightWindow() { + const component = resolveComponent('VUniRightWindow') as ConcreteComponent + return { + component, + style: (component as any).style, + height: 0, + } +} + +function createTopWindowVNode(topWindow: unknown) { + if (!__UNI_FEATURE_TOPWINDOW__) { + return createCommentVNode('', true) + } + const { component, style, height, show } = useTopWindow() + return withDirectives( + createVNode( + 'uni-top-window', + null, + [ + createVNode( + 'div', + { + ref: 'topWindow', + class: 'uni-top-window', + style, + }, + [ + createVNode( + component, + mergeProps( + { + onVnodeMounted(vnode) { + // update style.offsetHeight + }, + 'navigation-bar-title-text': '', + } + //bindWindow + ), + null, + 16 /* FULL_PROPS */, + ['navigation-bar-title-text'] + ), + ], + 4 /* STYLE */ + ), + createVNode( + 'div', + { + class: 'uni-top-window--placeholder', + style: { height }, + }, + null, + 4 /* STYLE */ + ), + ], + 512 /* NEED_PATCH */ + ), + [[vShow, show]] + ) +} + +function createLeftWindowVNode(leftWindow: unknown) {} +function createRightWindowVNode(leftWindow: unknown) {} diff --git a/packages/uni-h5/src/framework/components/app/observable.js b/packages/uni-h5/src/framework/components/app/observable.js new file mode 100644 index 0000000000000000000000000000000000000000..9f29bbabab4af2bc44678ba8bfae88a56f7b13cc --- /dev/null +++ b/packages/uni-h5/src/framework/components/app/observable.js @@ -0,0 +1,3 @@ +import Vue from 'vue' +__uniConfig.tabBar = Vue.observable(__uniConfig.tabBar || {}) +export const tabBar = __uniConfig.tabBar diff --git a/packages/uni-h5/src/framework/components/app/popup/actionSheet.vue b/packages/uni-h5/src/framework/components/app/popup/actionSheet.vue index 1b3f6c6c032baf62af9fb95d4cf3497a1083acba..db063e76f1d10bf899fcfb31e38f46c62b95db4b 100644 --- a/packages/uni-h5/src/framework/components/app/popup/actionSheet.vue +++ b/packages/uni-h5/src/framework/components/app/popup/actionSheet.vue @@ -1,48 +1,117 @@ + transform: translate(0, 0); + } + + uni-actionsheet .uni-actionsheet * { + box-sizing: border-box; + } + + uni-actionsheet .uni-actionsheet__menu, + uni-actionsheet .uni-actionsheet__action { + border-radius: 5px; + background-color: #fcfcfd; + } + + uni-actionsheet .uni-actionsheet__action { + margin-top: 6px; + } + + uni-actionsheet .uni-actionsheet__cell, + uni-actionsheet .uni-actionsheet__title { + position: relative; + padding: 10px 6px; + text-align: center; + font-size: 18px; + text-overflow: ellipsis; + overflow: hidden; + cursor: pointer; + } + + uni-actionsheet .uni-actionsheet__title { + position: absolute; + top: 0; + right: 0; + left: 0; + z-index: 1; + background-color: #fff; + border-radius: 5px 5px 0 0; + border-bottom: 1px solid #e5e5e5; + } + + uni-actionsheet .uni-actionsheet__cell:before { + content: " "; + position: absolute; + left: 0; + top: 0; + right: 0; + height: 1px; + border-top: 1px solid #e5e5e5; + color: #e5e5e5; + transform-origin: 0 0; + transform: scaleY(0.5); + } + + uni-actionsheet .uni-actionsheet__cell:active { + background-color: #ececec; + } + + uni-actionsheet .uni-actionsheet__cell:first-child:before { + display: none; + } + + @media screen and (min-width: 500px) and (min-height: 500px) { + .uni-mask.uni-actionsheet__mask { + background: none; + } + + uni-actionsheet .uni-actionsheet { + width: 300px; + left: 50%; + right: auto; + top: 50%; + bottom: auto; + transform: translate(-50%, -50%); + opacity: 0; + transition: opacity 0.3s, visibility 0.3s; + } + + uni-actionsheet .uni-actionsheet.uni-actionsheet_toggle { + opacity: 1; + transform: translate(-50%, -50%); + } + + uni-actionsheet .uni-actionsheet__menu { + box-shadow: 0px 0 20px 5px rgba(0, 0, 0, 0.3); + } + + uni-actionsheet .uni-actionsheet__action { + display: none; + } + } + diff --git a/packages/uni-h5/src/framework/components/app/popup/index.js b/packages/uni-h5/src/framework/components/app/popup/index.js index 4693f8aa5b66df290063f31c928ac50c8529bc1a..866d78a28a35a5a1725a27e933de93046ccc127b 100644 --- a/packages/uni-h5/src/framework/components/app/popup/index.js +++ b/packages/uni-h5/src/framework/components/app/popup/index.js @@ -1,9 +1,9 @@ -import Toast from './toast.vue' -import Modal from './modal.vue' -import ActionSheet from './actionSheet.vue' - -export default { - Toast, - Modal, - ActionSheet -} +import Toast from './toast' +import Modal from './modal' +import ActionSheet from './actionSheet' + +export default { + Toast, + Modal, + ActionSheet, +} diff --git a/packages/uni-h5/src/framework/components/app/popup/mixins/action-sheet.js b/packages/uni-h5/src/framework/components/app/popup/mixins/action-sheet.js index 910810207153a7367fb68518e14a32b66b787422..c85b4e48835a17ae33ccd553fcf562276d49c71d 100644 --- a/packages/uni-h5/src/framework/components/app/popup/mixins/action-sheet.js +++ b/packages/uni-h5/src/framework/components/app/popup/mixins/action-sheet.js @@ -1,28 +1,28 @@ -import { isFunction } from '@vue/shared' - -export default { - data() { - return { - showActionSheet: { - visible: false - } - } - }, - created() { - UniServiceJSBridge.on('onShowActionSheet', (args, callback) => { - this.showActionSheet = args - this.onActionSheetCloseCallback = callback - }) - UniServiceJSBridge.on('onHidePopup', args => { - this.showActionSheet.visible = false - }) - }, - methods: { - // 处理 actionSheet close 回调 - _onActionSheetClose(type) { - this.showActionSheet.visible = false - isFunction(this.onActionSheetCloseCallback) && - this.onActionSheetCloseCallback(type) - } - } -} +import { isFn } from 'uni-shared' + +export default { + data() { + return { + showActionSheet: { + visible: false, + }, + } + }, + created() { + UniServiceJSBridge.on('onShowActionSheet', (args, callback) => { + this.showActionSheet = args + this.onActionSheetCloseCallback = callback + }) + UniServiceJSBridge.on('onHidePopup', (args) => { + this.showActionSheet.visible = false + }) + }, + methods: { + // 处理 actionSheet close 回调 + _onActionSheetClose(type) { + this.showActionSheet.visible = false + isFn(this.onActionSheetCloseCallback) && + this.onActionSheetCloseCallback(type) + }, + }, +} diff --git a/packages/uni-h5/src/framework/components/app/popup/mixins/index.js b/packages/uni-h5/src/framework/components/app/popup/mixins/index.js index d688b42711fc5bc00d567cc7ee3de2f19f0a9a49..61084cf1252197f0023200d9c4f7c41efe6cbb50 100644 --- a/packages/uni-h5/src/framework/components/app/popup/mixins/index.js +++ b/packages/uni-h5/src/framework/components/app/popup/mixins/index.js @@ -1,5 +1,8 @@ -import ActionSheet from './action-sheet' -import Modal from './modal' -import Toast from './toast' -import Transtion from './transition' -export default [ActionSheet, Modal, Toast, Transtion] +const mixins = [] +const context = require.context('./', false, /\.js$/) +context.keys().forEach(function (key) { + if (key !== './index.js') { + mixins.push(context(key).default) + } +}) +export default mixins diff --git a/packages/uni-h5/src/framework/components/app/popup/mixins/modal.js b/packages/uni-h5/src/framework/components/app/popup/mixins/modal.js index ecefd1b49d5923d65d279a457f63b32ece4f19c7..f84ce6991a423e6a908dfbf66e635b8cee200aa2 100644 --- a/packages/uni-h5/src/framework/components/app/popup/mixins/modal.js +++ b/packages/uni-h5/src/framework/components/app/popup/mixins/modal.js @@ -1,27 +1,27 @@ -import { isFunction } from '@vue/shared' - -export default { - data() { - return { - showModal: { - visible: false - } - } - }, - created() { - UniServiceJSBridge.on('onShowModal', (args, callback) => { - this.showModal = args - this.onModalCloseCallback = callback - }) - UniServiceJSBridge.on('onHidePopup', args => { - this.showModal.visible = false - }) - }, - methods: { - // 处理 modal close 回调 - _onModalClose(type) { - this.showModal.visible = false - isFunction(this.onModalCloseCallback) && this.onModalCloseCallback(type) - } - } -} +import { isFn } from 'uni-shared' + +export default { + data() { + return { + showModal: { + visible: false, + }, + } + }, + created() { + UniServiceJSBridge.on('onShowModal', (args, callback) => { + this.showModal = args + this.onModalCloseCallback = callback + }) + UniServiceJSBridge.on('onHidePopup', (args) => { + this.showModal.visible = false + }) + }, + methods: { + // 处理 modal close 回调 + _onModalClose(type) { + this.showModal.visible = false + isFn(this.onModalCloseCallback) && this.onModalCloseCallback(type) + }, + }, +} diff --git a/packages/uni-h5/src/framework/components/app/popup/mixins/popup.js b/packages/uni-h5/src/framework/components/app/popup/mixins/popup.js new file mode 100644 index 0000000000000000000000000000000000000000..d76cb2ae558b3883339ca7680fe0d5306a488667 --- /dev/null +++ b/packages/uni-h5/src/framework/components/app/popup/mixins/popup.js @@ -0,0 +1,70 @@ +export default { + data() { + return { + popupWidth: 0, + popupHeight: 0, + } + }, + computed: { + isDesktop() { + return this.popupWidth >= 500 && this.popupHeight >= 500 + }, + popupStyle() { + const style = {} + const contentStyle = (style.content = {}) + const triangleStyle = (style.triangle = {}) + const popover = this.popover + function getNumber(value) { + return Number(value) || 0 + } + if (this.isDesktop && popover) { + Object.assign(triangleStyle, { + position: 'absolute', + width: '0', + height: '0', + 'margin-left': '-6px', + 'border-style': 'solid', + }) + const popoverLeft = getNumber(popover.left) + const popoverWidth = getNumber(popover.width) + const popoverTop = getNumber(popover.top) + const popoverHeight = getNumber(popover.height) + const center = popoverLeft + popoverWidth / 2 + contentStyle.transform = 'none !important' + const contentLeft = Math.max(0, center - 300 / 2) + contentStyle.left = `${contentLeft}px` + let triangleLeft = Math.max(12, center - contentLeft) + triangleLeft = Math.min(300 - 12, triangleLeft) + triangleStyle.left = `${triangleLeft}px` + const vcl = this.popupHeight / 2 + if (popoverTop + popoverHeight - vcl > vcl - popoverTop) { + contentStyle.top = 'auto' + contentStyle.bottom = `${this.popupHeight - popoverTop + 6}px` + triangleStyle.bottom = '-6px' + triangleStyle['border-width'] = '6px 6px 0 6px' + triangleStyle['border-color'] = + '#fcfcfd transparent transparent transparent' + } else { + contentStyle.top = `${popoverTop + popoverHeight + 6}px` + triangleStyle.top = '-6px' + triangleStyle['border-width'] = '0 6px 6px 6px' + triangleStyle['border-color'] = + 'transparent transparent #fcfcfd transparent' + } + } + return style + }, + }, + mounted() { + const fixSize = () => { + const { windowWidth, windowHeight, windowTop } = uni.getSystemInfoSync() + this.popupWidth = windowWidth + this.popupHeight = windowHeight + windowTop + } + window.addEventListener('resize', fixSize) + fixSize() + this.$once('hook:beforeDestroy', () => { + window.removeEventListener('resize', fixSize) + }) + }, +} diff --git a/packages/uni-h5/src/framework/components/app/popup/mixins/toast.js b/packages/uni-h5/src/framework/components/app/popup/mixins/toast.js index f792cc56cae0496a54de1de05601200e07133e8a..07fd60273fca55f6bc711d9f97789f07c6a81ae8 100644 --- a/packages/uni-h5/src/framework/components/app/popup/mixins/toast.js +++ b/packages/uni-h5/src/framework/components/app/popup/mixins/toast.js @@ -1,51 +1,52 @@ -export default { - data() { - return { - showToast: { - visible: false - } - } - }, - created() { - let showType = '' - - const createOnShow = type => { - return args => { - showType = type - setTimeout(() => { - // 延迟一下 show 可解决窗口打开前调用 showToast 在 onHidePopup 之后触发 - this.showToast = args - }, 10) - } - } - - UniServiceJSBridge.on('onShowToast', createOnShow('onShowToast')) - UniServiceJSBridge.on('onShowLoading', createOnShow('onShowLoading')) - - const createOnHide = type => { - return () => { - if (!showType) { - return - } - let warnMsg = '' - if (type === 'onHideToast' && showType !== 'onShowToast') { - warnMsg = '请注意 showToast 与 hideToast 必须配对使用' - } else if (type === 'onHideLoading' && showType !== 'onShowLoading') { - warnMsg = '请注意 showLoading 与 hideLoading 必须配对使用' - } - if (warnMsg) { - return console.warn(warnMsg) - } - showType = '' - setTimeout(() => { - // 与 show 对应延迟10ms，避免快速调用 show，hide 导致无法关闭 - this.showToast.visible = false - }, 10) - } - } - - UniServiceJSBridge.on('onHidePopup', createOnHide('onHidePopup')) - UniServiceJSBridge.on('onHideToast', createOnHide('onHideToast')) - UniServiceJSBridge.on('onHideLoading', createOnHide('onHideLoading')) - } -} +import { t } from 'uni-core/helpers/i18n' +export default { + data() { + return { + showToast: { + visible: false, + }, + } + }, + created() { + let showType = '' + + const createOnShow = (type) => { + return (args) => { + showType = type + setTimeout(() => { + // 延迟一下 show 可解决窗口打开前调用 showToast 在 onHidePopup 之后触发 + this.showToast = args + }, 10) + } + } + + UniServiceJSBridge.on('onShowToast', createOnShow('onShowToast')) + UniServiceJSBridge.on('onShowLoading', createOnShow('onShowLoading')) + + const createOnHide = (type) => { + return () => { + if (!showType) { + return + } + let warnMsg = '' + if (type === 'onHideToast' && showType !== 'onShowToast') { + warnMsg = t('uni.showToast.unpaired') + } else if (type === 'onHideLoading' && showType !== 'onShowLoading') { + warnMsg = t('uni.showLoading.unpaired') + } + if (warnMsg) { + return console.warn(warnMsg) + } + showType = '' + setTimeout(() => { + // 与 show 对应延迟10ms，避免快速调用 show，hide 导致无法关闭 + this.showToast.visible = false + }, 10) + } + } + + UniServiceJSBridge.on('onHidePopup', createOnHide('onHidePopup')) + UniServiceJSBridge.on('onHideToast', createOnHide('onHideToast')) + UniServiceJSBridge.on('onHideLoading', createOnHide('onHideLoading')) + }, +} diff --git a/packages/uni-h5/src/framework/components/app/popup/mixins/transition.js b/packages/uni-h5/src/framework/components/app/popup/mixins/transition.js index 28dec1cf3403d8df6d26dd5a14a1a5ff1666d698..c641ec929e3094a0f87bb4df6e10a281c06d31ab 100644 --- a/packages/uni-h5/src/framework/components/app/popup/mixins/transition.js +++ b/packages/uni-h5/src/framework/components/app/popup/mixins/transition.js @@ -1,6 +1,6 @@ -export default { - methods: { - beforeTransition() {}, - afterTransition() {} - } -} +export default { + methods: { + beforeTransition() {}, + afterTransition() {}, + }, +} diff --git a/packages/uni-h5/src/framework/components/app/popup/modal.vue b/packages/uni-h5/src/framework/components/app/popup/modal.vue index f1acae9a5d12e922db34482255cebd45feb84ff2..44e111dd9dbc09957e996012ca385748548cb19e 100644 --- a/packages/uni-h5/src/framework/components/app/popup/modal.vue +++ b/packages/uni-h5/src/framework/components/app/popup/modal.vue @@ -2,7 +2,7 @@
@@ -17,7 +17,7 @@
@@ -38,13 +38,21 @@
+ diff --git a/packages/uni-h5/src/framework/components/async-loading/index.vue b/packages/uni-h5/src/framework/components/async-loading/index.vue index af282cd4ba39c4aa90cf4d4c50bc619e2a00c84e..36f2f9535edff9c161ba787e44d867b5568e7be4 100644 --- a/packages/uni-h5/src/framework/components/async-loading/index.vue +++ b/packages/uni-h5/src/framework/components/async-loading/index.vue @@ -4,20 +4,20 @@ + diff --git a/packages/uni-h5/src/framework/components/page/append-css.js b/packages/uni-h5/src/framework/components/page/append-css.js deleted file mode 100644 index 158e88535b6ab331f04c4f14ec478c6b807c8bd5..0000000000000000000000000000000000000000 --- a/packages/uni-h5/src/framework/components/page/append-css.js +++ /dev/null @@ -1,14 +0,0 @@ -export function appendCss(css, cssId, replace = false) { - let style = document.getElementById(cssId) - if (style && replace) { - style.parentNode.removeChild(style) - style = null - } - if (!style) { - style = document.createElement('style') - style.type = 'text/css' - cssId && (style.id = cssId) - document.getElementsByTagName('head')[0].appendChild(style) - } - style.appendChild(document.createTextNode(css)) -} diff --git a/packages/uni-h5/src/framework/components/page/index.vue b/packages/uni-h5/src/framework/components/page/index.vue index 4b00c3328555f2b9d1709cad50714a72f1cbe980..a5f4a53111b8e28150de272b529f43365e219137 100644 --- a/packages/uni-h5/src/framework/components/page/index.vue +++ b/packages/uni-h5/src/framework/components/page/index.vue @@ -1,6 +1,6 @@