From bfba2f94c8eeb3ffada5bd391eb7bee783adc9a3 Mon Sep 17 00:00:00 2001 From: fxy060608 Date: Fri, 4 Sep 2020 13:17:34 +0800 Subject: [PATCH] chore: .gitignore --- .gitignore | 3 +- .../uni-components/dist/uni-components.css | 874 ++ .../uni-components/dist/uni-components.esm.js | 7411 ++++++++++++ packages/uni-h5-vue/dist/vue.runtime.esm.js | 9965 +++++++++++++++++ packages/uni-h5-vue/lib/vue.runtime.esm.js | 285 +- packages/uni-h5/dist/uni-h5.css | 822 ++ packages/uni-h5/dist/uni-h5.esm.js | 3532 ++++++ packages/uni-mp-alipay/dist/uni.api.esm.js | 1064 ++ packages/uni-mp-alipay/dist/uni.mp.esm.js | 1110 ++ packages/uni-mp-baidu/dist/uni.api.esm.js | 636 ++ packages/uni-mp-baidu/dist/uni.mp.esm.js | 1035 ++ packages/uni-mp-qq/dist/uni.api.esm.js | 535 + packages/uni-mp-qq/dist/uni.mp.esm.js | 929 ++ packages/uni-mp-toutiao/dist/uni.api.esm.js | 603 + packages/uni-mp-toutiao/dist/uni.mp.esm.js | 1077 ++ packages/uni-mp-vue/dist/vue.runtime.esm.js | 3879 +++++++ packages/uni-mp-vue/lib/vue.runtime.esm.js | 143 +- packages/uni-mp-weixin/dist/uni.api.esm.js | 535 + packages/uni-mp-weixin/dist/uni.mp.esm.js | 929 ++ .../uni-quickapp-webview/dist/uni.api.esm.js | 542 + .../uni-quickapp-webview/dist/uni.mp.esm.js | 1062 ++ packages/uni-shared/dist/uni.shared.esm.js | 122 + 22 files changed, 36927 insertions(+), 166 deletions(-) create mode 100644 packages/uni-components/dist/uni-components.css create mode 100644 packages/uni-components/dist/uni-components.esm.js create mode 100644 packages/uni-h5-vue/dist/vue.runtime.esm.js create mode 100644 packages/uni-h5/dist/uni-h5.css create mode 100644 packages/uni-h5/dist/uni-h5.esm.js create mode 100644 packages/uni-mp-alipay/dist/uni.api.esm.js create mode 100644 packages/uni-mp-alipay/dist/uni.mp.esm.js create mode 100644 packages/uni-mp-baidu/dist/uni.api.esm.js create mode 100644 packages/uni-mp-baidu/dist/uni.mp.esm.js create mode 100644 packages/uni-mp-qq/dist/uni.api.esm.js create mode 100644 packages/uni-mp-qq/dist/uni.mp.esm.js create mode 100644 packages/uni-mp-toutiao/dist/uni.api.esm.js create mode 100644 packages/uni-mp-toutiao/dist/uni.mp.esm.js create mode 100644 packages/uni-mp-vue/dist/vue.runtime.esm.js create mode 100644 packages/uni-mp-weixin/dist/uni.api.esm.js create mode 100644 packages/uni-mp-weixin/dist/uni.mp.esm.js create mode 100644 packages/uni-quickapp-webview/dist/uni.api.esm.js create mode 100644 packages/uni-quickapp-webview/dist/uni.mp.esm.js create mode 100644 packages/uni-shared/dist/uni.shared.esm.js diff --git a/.gitignore b/.gitignore index 0a663edeb..6dcaa2b2b 100644 --- a/.gitignore +++ b/.gitignore @@ -1,4 +1,5 @@ -dist +packages/uni-cli-shared/dist +packages/vite-plugin-uni/dist .DS_Store node_modules coverage diff --git a/packages/uni-components/dist/uni-components.css b/packages/uni-components/dist/uni-components.css new file mode 100644 index 000000000..f4552b86f --- /dev/null +++ b/packages/uni-components/dist/uni-components.css @@ -0,0 +1,874 @@ + +uni-audio{ + display:none; +} +uni-audio[controls]{ + display:inline-block; +} +uni-audio[hidden]{ + display:none; +} +.uni-audio-default{ + max-width:100%; + min-width:302px; + height:65px; + background:#fcfcfc; + border:1px solid #e0e0e0; + border-radius:2.5px; + display:inline-block; + overflow:hidden; +} +.uni-audio-left{ + width:65px; + height:65px; + float:left; + background-color:#e6e6e6; + background-size:100% 100%; + background-position:50% 50%; +} +.uni-audio-button{ + width:24px; + height:24px; + margin:20.5px; + background-size:cover; +} +.uni-audio-button.play{ + background-image:url(data:image/png;base64,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); +} +.uni-audio-button.pause{ + background-image:url(data:image/png;base64,iVBORw0KGgoAAAANSUhEUgAAADAAAAAwCAYAAABXAvmHAAAAAXNSR0IArs4c6QAABatJREFUaAXVWl1IpFUYnllZGUf3wlz6MXER1ES7s83VUDJw6KpdaSTDwMnYFSK6KNirooHullKQCNzQRjZ/wom1u9ALQ0mT1ktFdEBWXLdibaH1jwmx5zme83W+z2Hm+7bZmc8X3jl/73vO837n/z3j9aSBjo6O8lBNC7gZXAUuBxeCz4FJj8APwTHwCngaPOX1evcRZocAuhAcAt8G74KdEnWoyzpobGYIjfnBn4D/BqeLWBfr9Du1wmtXAZXnQPY9cBj8HNhEe3t7sbW1tfn19fW7m5ubD5aXl7dnZmYeUKipqel8dXV1UUlJyfmysrILFRUV9X6/n8PMSveREQYPYHgdWgsTpW0ZAPDPQ3kC/JJeCUEvLi7+NDg4+EskEvldL0sVD4VCz3Z1db1SW1v7egJj7kD/Coy4l6qelAYAfB0quQ02vno8Hr8/OTkZaWtrmzo4ODhK1Uiycp/P5x0fH28JBAKh3Nxcow3osDdaYcRCMv2kBgD8O1D+BuyTlcTn5+cj7e3t0Y2NjX+SVey0rLS09OzY2Fiwvr4+BN1cqX+A8CqM+E6mTwRnTuTIDAn+FpIC/OHh4V+9vb0fNzQ0jKYbPJtknaybbbAtCYNt35JYZJY5SNgDctj8DFEBfnd3d627u/vT4eHhP8zqTybV0dHxTH9//+f5+fkVsgX2xKuJhtMJAwCeE/Y3sBiPBF9XV/fh0tISK8kY1dTU+BYWFvo0IzgnLlontmkIATyXSq42Ajy7kl8+0+D5ldgm29aGEzFNSIwUEWQyADlc59VSGe/r6/ssU8PmGI75l20TA3LjsoTYiNEgYwjBMu6CPKuIr4/Vph+TasyQzGJkbm7ubaxO1yQEDqVyDKU9pvUe+AhpAZ7rPJbKHyjgBuKyTUwSCzESqyBhAL4+D1PXZZ6Hm9STWCpV/U5DYiEmTe+6xOwRQwiJEAq/pQCPB0VFRdf+7w7LutJJ3LG3t7dvaseOdzGMImoIXVaN8WzjNvDERkzEpnAiFJjP4OvzMhJQBTyYqbjdEDov7+/vf4+6pu0wZQcGBi7arV/JWbAFiN2Lnzcg8COFuGkVFBSo2a70UoYEhC5+OqWgJoAv+mdeXt5bWpat6M7Ozk1tc7vMIfSa0lxdXf1VxZ2ETsGz7sfRoV4sFtMxNtOAF1hAugs6jrn3lxcmDV0VDTBuRrxJaYWujFowltMA40LNa6ArUWugLBgLaYByfXjUHVaTd13UgvEcDTjVRAPodBJE74GKuzW0YHxEA+gxE0TXh4q7NbRgfEgDeIQWRL+Nirs1tGCM0YAVBZZOJxV3a2jBuEIDphVYesxU3EnIY4ETeco+jg71LBinacAUWNxueFSlx4yCTmh0dPRLJ4AoOzIy8oWTNihLbNpxmpin1H2AnrcrFJqdnf0KM901tzFiUoQ94M3GxsYPZHoC94FW9gBJnEYZoa8SBy1hGNNuIWIiNg2PwKwbIPYDdhF9lZqgK6LEpA0fYv3PAHQF94IbCikdrcXFxWdVOtsh/abEpOG4ITGbvBI9EBA3f3qJo9FoUFPIapROX81zTYzEKkgNIQ8s4qwOH2d7PPQS9/T0vKjS2QqJQXqsFYSwxCrSpsmK6yVdi7zx0APmoVuvs7Pz/Wx55+jkHRoa+jonJ+cp4gHdAV+CAcbrjckASsCI0+vcpQGw7h6CVrDwRvMCTS8xvwbLM0Fsy+KZJha+1hCbiYw5oOdCkM86V1UejWBXZmJOsA22pXkeCIOvNAmfmk4MIQWaIYZTwiemYDAY3dracsUTU1IDpBGn95FP9Yac2KfzmVUzgkssHxfCYOGGR2gQvXp0jNG3lOyh+wKosrLykmWMq3q4SYXBth+6laLtEL3hqr8a2AZuFYQhrvizR8pJbAWeKA1j6OFuATeDq8D09hWClc+Jp0ceGHn/5hWWt8C0/N3mX15C4bDnCIuAAAAAAElFTkSuQmCC); +} +.uni-audio-right{ + box-sizing:border-box; + height:65px; + margin-left:65px; + padding:11px 16.5px 13.5px 15px; + overflow:hidden; +} +.uni-audio-time{ + margin-top:3.5px; + height:16.5px; + font-size:12px; + color:#888888; + float:right; +} +.uni-audio-info{ + margin-right:70px; + overflow:hidden; +} +.uni-audio-name{ + height:22.5px; + line-height:22.5px; + margin-bottom:3.5px; + font-size:14px; + color:#353535; + overflow:hidden; + white-space:nowrap; + text-overflow:ellipsis; +} +.uni-audio-author{ + height:14.5px; + line-height:14.5px; + font-size:12px; + color:#888888; + overflow:hidden; + white-space:nowrap; + text-overflow:ellipsis; +} + +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{ + -webkit-tap-highlight-color:transparent; + display:inline-block; + cursor:pointer; +} +uni-checkbox[hidden]{ + display:none; +} +uni-checkbox[disabled]{ + cursor:not-allowed; +} +uni-checkbox .uni-checkbox-wrapper{ + display:-webkit-inline-flex; + display:inline-flex; + -webkit-align-items:center; + align-items:center; + vertical-align:middle; +} +uni-checkbox .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; +} +uni-checkbox:not([disabled]) .uni-checkbox-input:hover{ + border-color:#007aff; +} +uni-checkbox .uni-checkbox-input.uni-checkbox-input-checked{ + color:#007aff; +} +uni-checkbox .uni-checkbox-input.uni-checkbox-input-checked:before{ + font:normal normal normal 14px/1 "uni"; + content:"\EA08"; + 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-checkbox .uni-checkbox-input.uni-checkbox-input-disabled{ + background-color:#E1E1E1; +} +uni-checkbox .uni-checkbox-input.uni-checkbox-input-disabled:before{ + color:#ADADAD; +} +uni-checkbox-group{ + display:block; +} + +uni-checkbox-group[hidden]{ + display:none; +} + + + +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-progress{ + display:-webkit-flex; + display:flex; + -webkit-align-items:center; + align-items:center; +} +uni-progress[hidden]{ + display:none; +} +.uni-progress-bar{ + -webkit-flex:1; + flex:1; +} +.uni-progress-inner-bar{ + width:0; + height:100%; +} +.uni-progress-info{ + margin-top:0; + margin-bottom:0; + min-width:2em; + margin-left:15px; + font-size:16px; +} + +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%; + 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-slider{ + margin:10px 18px; + padding:0; + display:block; +} +uni-slider[hidden]{ + display:none; +} +uni-slider .uni-slider-wrapper{ + display:-webkit-flex; + display:flex; + -webkit-align-items:center; + align-items:center; + min-height:16px; +} +uni-slider .uni-slider-tap-area{ + -webkit-flex:1; + flex:1; + padding:8px 0; +} +uni-slider .uni-slider-handle-wrapper{ + position:relative; + height:2px; + border-radius:5px; + background-color:#e9e9e9; + cursor:pointer; + transition:background-color 0.3s ease; + -webkit-tap-highlight-color:transparent; +} +uni-slider .uni-slider-track{ + height:100%; + border-radius:6px; + background-color:#007aff; + transition:background-color 0.3s ease; +} +uni-slider .uni-slider-handle, + uni-slider .uni-slider-thumb{ + position:absolute; + left:50%; + top:50%; + cursor:pointer; + border-radius:50%; + transition:border-color 0.3s ease; +} +uni-slider .uni-slider-handle{ + width:28px; + height:28px; + margin-top:-14px; + margin-left:-14px; + background-color:transparent; + z-index:3; + cursor:grab; +} +uni-slider .uni-slider-thumb{ + z-index:2; + box-shadow:0 0 4px rgba(0, 0, 0, 0.2); +} +uni-slider .uni-slider-step{ + position:absolute; + width:100%; + height:2px; + background:transparent; + z-index:1; +} +uni-slider .uni-slider-value{ + color:#888; + font-size:14px; + margin-left:1em; +} +uni-slider .uni-slider-disabled .uni-slider-track{ + background-color:#ccc; +} +uni-slider .uni-slider-disabled .uni-slider-thumb{ + background-color:#FFF; + border-color:#ccc; +} + +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-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; +} +.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-components/dist/uni-components.esm.js b/packages/uni-components/dist/uni-components.esm.js new file mode 100644 index 000000000..4805521ed --- /dev/null +++ b/packages/uni-components/dist/uni-components.esm.js @@ -0,0 +1,7411 @@ +import { isPlainObject, isFunction, hasOwn, hyphenate } from '@vue/shared' +import { plusReady, debounce } from '@dcloudio/uni-shared' +import { + openBlock, + createBlock, + mergeProps, + createVNode, + toDisplayString, + resolveComponent, + toHandlers, + renderSlot, + createCommentVNode, + withModifiers, + withDirectives, + vShow, + vModelDynamic, + Fragment, + renderList, + vModelText +} from 'vue' +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) { + if (typeof componentName === 'string') { + componentName = [componentName] + } + let parent = this.$parent || this.$root + let name = parent.$options.name && parent.$options.name.substr(4) + while (parent && (!name || !~componentName.indexOf(name))) { + parent = parent.$parent + if (parent) { + name = parent.$options.name && parent.$options.name.substr(4) + } + } + if (parent) { + parent.$emit.apply(parent, [eventName].concat(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) + }) + }, + beforeDestroy() { + this._removeListeners(this.id) + }, + methods: { + _addListeners(id, watch) { + if (watch && !id) { + 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.on( + `uni-${name}-${this.$page.id}-${id}`, + 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 (id) { + UniViewJSBridge.on( + `uni-${name}-${this.$page.id}-${id}`, + this[listeners2[name]] + ) + } + } + }) + }, + _removeListeners(id, watch) { + if (watch && !id) { + 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}-${id}`, + 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 (id) { + UniViewJSBridge.off( + `uni-${name}-${this.$page.id}-${id}`, + this[listeners2[name]] + ) + } + } + }) + } + } +} +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() + } + }, 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, id, watch) { + if (watch && !id) { + return + } + if (!isFunction(this._handleSubscribe)) { + return + } + UniViewJSBridge[type]( + this.$page.id + + '-' + + this.$options.name.replace(/VUni([A-Z])/, '$1').toLowerCase() + + '-' + + id, + this._handleSubscribe + ) + }, + _getContextInfo() { + const id = `context-${this._uid}` + if (!this._contextId) { + this._toggleListeners('subscribe', id) + this._contextId = id + } + return { + name: this.$options.name.replace(/VUni([A-Z])/, '$1').toLowerCase(), + id, + 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 && true) { + this.showSoftKeybord() + } + } + }, + mounted() { + if (this.autoFocus || this.focus) { + this.showSoftKeybord() + } + }, + beforeDestroy() { + this.onKeyboardHide() + }, + methods: { + initKeyboard(el) { + el.addEventListener('focus', () => { + this.hideKeyboardTemp = function() { + hideKeyboard() + } + UniViewJSBridge.subscribe('hideKeyboard', this.hideKeyboardTemp) + document.addEventListener('click', iosHideKeyboard, false) + { + this.setSoftinputNavBar() + this.setSoftinputTemporary() + } + }) + 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) + { + this.resetSoftinputNavBar() + } + if (String(navigator.vendor).indexOf('Apple') === 0) { + document.documentElement.scrollTo( + document.documentElement.scrollLeft, + document.documentElement.scrollTop + ) + } + } + } +} +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 { + valueSync: this._getValueString(this.value) + } + }, + 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) + } + }, + beforeDestroy() { + this.__valueChange.cancel() + this.__triggerInput.cancel() + }, + methods: { + _getValueString(value) { + return value === null ? '' : String(value) + } + } +} +let supportsPassive$1 = false +try { + const opts = {} + Object.defineProperty(opts, 'passive', { + get() { + supportsPassive$1 = true + } + }) + window.addEventListener('test-passive', null, opts) +} catch (e2) {} +const passiveOptions = supportsPassive$1 ? { passive: true } : false +var script = { + 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: '' + } + }, + data() { + return { + playing: false, + currentTime: this.getTime(0) + } + }, + watch: { + src(val) { + if (this.$refs.audio) { + this.$refs.audio.src = this.$getRealPath(val) + } + } + }, + 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 + } + }, + 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 + } + } +} +const _hoisted_1 = { class: 'uni-audio-default' } +const _hoisted_2 = { class: 'uni-audio-right' } +const _hoisted_3 = { class: 'uni-audio-time' } +const _hoisted_4 = { class: 'uni-audio-info' } +const _hoisted_5 = { class: 'uni-audio-name' } +const _hoisted_6 = { class: 'uni-audio-author' } +function render(_ctx, _cache, $props, $setup, $data, $options) { + return ( + openBlock(), + createBlock( + 'uni-audio', + mergeProps( + { + id: _ctx.id, + controls: !!_ctx.controls + }, + _ctx.$attrs + ), + [ + createVNode( + 'audio', + { + ref: 'audio', + loop: _ctx.loop, + style: { display: 'none' } + }, + null, + 8, + ['loop'] + ), + createVNode('div', _hoisted_1, [ + createVNode( + 'div', + { + style: + 'background-image: url(' + + _ctx.$getRealPath(_ctx.poster) + + ');', + class: 'uni-audio-left' + }, + [ + createVNode( + 'div', + { + class: [ + { play: !_ctx.playing, pause: _ctx.playing }, + 'uni-audio-button' + ], + onClick: + _cache[1] || + (_cache[1] = (...args) => _ctx.trigger(...args)) + }, + null, + 2 + ) + ], + 4 + ), + createVNode('div', _hoisted_2, [ + createVNode( + 'div', + _hoisted_3, + toDisplayString(_ctx.currentTime), + 1 + ), + createVNode('div', _hoisted_4, [ + createVNode('div', _hoisted_5, toDisplayString(_ctx.name), 1), + createVNode('div', _hoisted_6, toDisplayString(_ctx.author), 1) + ]) + ]) + ]) + ], + 16, + ['id', 'controls'] + ) + ) +} +script.render = render +script.__file = 'packages/uni-components/src/components/audio/index.vue' +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) + } + } +} +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) + } +})(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 i2 = 0; i2 < value.length; i2++) { + args[value[i2]] *= pixelRatio + } + } + 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) + } + 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 wrapper(canvas) { + canvas.width = canvas.offsetWidth * pixelRatio + canvas.height = canvas.offsetHeight * pixelRatio + canvas.getContext('2d').__hidpi__ = true +} +function resolveColor(color) { + color = color.slice(0) + color[3] = color[3] / 255 + return 'rgba(' + color.join(',') + ')' +} +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 + } + }) +} +var tempCanvas +function getTempCanvas(width = 0, height = 0) { + if (!tempCanvas) { + tempCanvas = document.createElement('canvas') + } + tempCanvas.width = width + tempCanvas.height = height + return tempCanvas +} +var script$1 = { + name: 'Canvas', + mixins: [subscriber], + props: { + canvasId: { + type: String, + default: '' + }, + disableScroll: { + type: [Boolean, String], + default: false + } + }, + data() { + return { + actionsWaiting: 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) + } + $listeners[event2] = eventHandler + }) + return $listeners + } + }, + created() { + this._actionsDefer = [] + this._images = {} + }, + mounted() { + this._resize({ + width: this.$refs.sensor.$el.offsetWidth, + height: this.$refs.sensor.$el.offsetHeight + }) + }, + 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 }) { + 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 index = 0; index < actions.length; index++) { + const action = actions[index] + 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(index + 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(index + 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 (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) + } + } + } + }) + }, + 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 + } + 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) + } + } 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' + } + }, + 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 + } + }, + 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 + } + UniViewJSBridge.publishHandler( + 'onCanvasMethodCallback', + { + callbackId, + data: { + errMsg: 'canvasPutImageData:ok' + } + }, + this.$page.id + ) + }, + 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 + } + 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 + } + } +} +const _hoisted_1$1 = { + ref: 'canvas', + width: '300', + height: '150' +} +const _hoisted_2$1 = { + style: { + position: 'absolute', + top: '0', + left: '0', + width: '100%', + height: '100%', + overflow: 'hidden' + } +} +function render$1(_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': _ctx.canvasId, + 'disable-scroll': _ctx.disableScroll + }, + toHandlers(_ctx._listeners) + ), + [ + createVNode('canvas', _hoisted_1$1, null, 512), + createVNode('div', _hoisted_2$1, [renderSlot(_ctx.$slots, 'default')]), + createVNode( + _component_v_uni_resize_sensor, + { + ref: 'sensor', + onResize: _ctx._resize + }, + null, + 8, + ['onResize'] + ) + ], + 16, + ['canvas-id', 'disable-scroll'] + ) + ) +} +script$1.render = render$1 +script$1.__file = 'packages/uni-components/src/components/canvas/index.vue' +var script$2 = { + 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, + default: '' + } + }, + data() { + return { + 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() { + 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 + } + this.checkboxChecked = !this.checkboxChecked + this.$dispatch('CheckboxGroup', 'uni-checkbox-change', $event) + }, + _resetFormData() { + this.checkboxChecked = false + } + } +} +const _hoisted_1$2 = { class: 'uni-checkbox-wrapper' } +function render$2(_ctx, _cache, $props, $setup, $data, $options) { + return ( + openBlock(), + createBlock( + 'uni-checkbox', + mergeProps({ disabled: _ctx.disabled }, _ctx.$attrs, { + onClick: _cache[1] || (_cache[1] = (...args) => _ctx._onClick(...args)) + }), + [ + createVNode('div', _hoisted_1$2, [ + createVNode( + 'div', + { + class: [ + [_ctx.checkboxChecked ? 'uni-checkbox-input-checked' : ''], + 'uni-checkbox-input' + ], + style: { color: _ctx.color } + }, + null, + 6 + ), + renderSlot(_ctx.$slots, 'default') + ]) + ], + 16, + ['disabled'] + ) + ) +} +script$2.render = render$2 +script$2.__file = 'packages/uni-components/src/components/checkbox/index.vue' +var script$3 = { + name: 'CheckboxGroup', + mixins: [emitter, listeners], + props: { + name: { + type: String, + default: '' + } + }, + data() { + return { + checkboxList: [] + } + }, + listeners: { + '@checkbox-change': '_changeHandler', + '@checkbox-group-update': '_checkboxGroupUpdateHandler' + }, + 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) { + 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 index = this.checkboxList.indexOf($event.vm) + this.checkboxList.splice(index, 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 render$3(_ctx, _cache, $props, $setup, $data, $options) { + return ( + openBlock(), + createBlock( + 'uni-checkbox-group', + _ctx.$attrs, + [renderSlot(_ctx.$slots, 'default')], + 16 + ) + ) +} +script$3.render = render$3 +script$3.__file = + 'packages/uni-components/src/components/checkbox-group/index.vue' +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 index + var chars + var match + var stack = [] + var last = html + stack.last = function() { + return this[this.length - 1] + } + while (html) { + chars = true + if (!stack.last() || !special[stack.last()]) { + if (html.indexOf('') + if (index >= 0) { + if (handler.comment) { + handler.comment(html.substring(4, index)) + } + html = html.substring(index + 3) + chars = 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 attrs = [] + rest.replace(attr, function(match2, name) { + var value = arguments[2] + ? arguments[2] + : arguments[3] + ? arguments[3] + : arguments[4] + ? arguments[4] + : fillAttrs[name] + ? name + : '' + attrs.push({ + name, + value, + escaped: value.replace(/(^|[^\\])"/g, '$1\\"') + }) + }) + if (handler.start) { + handler.start(tagName, attrs, unary) + } + } + } + function parseEndTag(tag, tagName) { + if (!tagName) { + var pos = 0 + } else { + for (var pos = stack.length - 1; pos >= 0; pos--) { + if (stack[pos] == tagName) { + break + } + } + } + if (pos >= 0) { + for (var 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') + } + 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' + } + } + 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') + } + } + domNode.addEventListener('click', listEventHandler) + } + format(name, value) { + if (this.children.length > 0) { + this.children.tail.format(name, value) + } + } + formats() { + return { [this.statics.blotName]: this.statics.formats(this.domNode) } + } + insertBefore(blot, ref) { + if (blot instanceof ListItem) { + super.insertBefore(blot, ref) + } else { + const index = ref == null ? this.length() : ref.offset(this) + const after = this.split(index) + after.parent.insertBefore(blot, after) + } + } + 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() + } + } + 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 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 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 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 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 +} +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 script$4 = { + 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() { + return { + quillReady: false + } + }, + computed: {}, + watch: { + readOnly(value) { + if (this.quillReady) { + const quill = this.quill + quill.enable(!value) + if (!value) { + quill.blur() + } + } + }, + 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') + } + 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' + } + if (callbackId) { + UniViewJSBridge.publishHandler( + 'onEditorMethodCallback', + { + callbackId, + data: Object.assign({}, res, { + errMsg: `${type}:${errMsg ? 'fail ' + errMsg : 'ok'}` + }) + }, + this.$page.id + ) + } + }, + loadQuill(callback) { + if (typeof window.Quill === 'function') { + if (typeof callback === 'function') { + callback() + } + return + } + const script2 = document.createElement('script') + script2.src = window.plus + ? './__uniappquill.js' + : 'https://unpkg.com/quill@1.3.7/dist/quill.min.js' + document.body.appendChild(script2) + script2.onload = callback + }, + loadImageResizeModule(callback) { + if (typeof window.ImageResize === 'function') { + if (typeof callback === 'function') { + callback() + } + return + } + const script2 = document.createElement('script') + script2.src = window.plus + ? './__uniappquillimageresize.js' + : 'https://unpkg.com/quill-image-resize-mp@3.0.1/image-resize.min.js' + document.body.appendChild(script2) + script2.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 { + 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, {}) + }, + getContents() { + const quill = this.quill + const html = quill.root.innerHTML + const text2 = quill.getText() + const delta = quill.getContents() + return { + html, + text: text2, + delta + } + }, + 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, attrs, unary) { + if (!tags.includes(tag)) { + disable = !unary + return + } + disable = false + const arrts = attrs + .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 + }, + 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) + } + } + } +} +function render$4(_ctx, _cache, $props, $setup, $data, $options) { + return ( + openBlock(), + createBlock( + 'uni-editor', + mergeProps( + { + id: _ctx.id, + class: 'ql-container' + }, + _ctx.$attrs + ), + null, + 16, + ['id'] + ) + ) +} +script$4.render = render$4 +script$4.__file = 'packages/uni-components/src/components/editor/index.vue' +var script$5 = { + 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.$trigger('submit', $event, { + value: data + }) + }, + _onReset($event) { + this.$trigger('reset', $event, {}) + this.childrenList.forEach(vm => { + vm._resetFormData && vm._resetFormData() + }) + }, + _formGroupUpdateHandler($event) { + if ($event.type === 'add') { + this.childrenList.push($event.vm) + } else { + const index = this.childrenList.indexOf($event.vm) + this.childrenList.splice(index, 1) + } + } + } +} +function render$5(_ctx, _cache, $props, $setup, $data, $options) { + return ( + openBlock(), + createBlock( + 'uni-form', + _ctx.$attrs, + [createVNode('span', null, [renderSlot(_ctx.$slots, 'default')])], + 16 + ) + ) +} +script$5.render = render$5 +script$5.__file = 'packages/uni-components/src/components/form/index.vue' +var script$6 = { + 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 render$6(_ctx, _cache, $props, $setup, $data, $options) { + return ( + openBlock(), + createBlock( + 'uni-icon', + _ctx.$attrs, + [ + createVNode( + 'i', + { + class: `uni-icon-${_ctx.type}`, + style: { + 'font-size': _ctx._converPx(_ctx.size), + color: _ctx.color + }, + role: 'img' + }, + null, + 6 + ) + ], + 16 + ) + ) +} +script$6.render = render$6 +script$6.__file = 'packages/uni-components/src/components/icon/index.vue' +var script$7 = { + 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 + } + if (newValue === 'widthFix' && this.ratio) { + this._fixSize() + } + } + }, + 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 = function($event) { + _self.originalWidth = this.width + _self.originalHeight = this.height + if (_self.mode === 'widthFix') { + _self._fixSize() + } + _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)` + }) + } + 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 render$7(_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: _ctx.modeStyle + }, + null, + 4 + ), + createVNode('img', { src: _ctx.realImagePath }, null, 8, ['src']), + _ctx.mode === 'widthFix' + ? createVNode( + _component_v_uni_resize_sensor, + { + key: 0, + ref: 'sensor', + onResize: _ctx._resize + }, + null, + 8, + ['onResize'] + ) + : createCommentVNode('v-if', true) + ], + 16 + ) + ) +} +script$7.render = render$7 +script$7.__file = 'packages/uni-components/src/components/image/index.vue' +const INPUT_TYPES = ['text', 'number', 'idcard', 'digit', 'password'] +const NUMBER_TYPES = ['number', 'digit'] +var script$8 = { + 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' + }, + disabled: { + type: [Boolean, String], + default: false + }, + maxlength: { + type: [Number, String], + default: 140 + }, + focus: { + type: [Boolean, String], + default: false + }, + 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 + }, + step() { + return ~NUMBER_TYPES.indexOf(this.type) ? '0.000000000000000001' : '' + } + }, + 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', { + 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 + }) + } + }, + _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 + } 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 + } + } + 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 + } + : {} + } + } +} +const _hoisted_1$3 = { + ref: 'wrapper', + class: 'uni-input-wrapper' +} +function render$8(_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$3, + [ + withDirectives( + createVNode( + 'div', + { + ref: 'placeholder', + style: _ctx.placeholderStyle, + class: [_ctx.placeholderClass, 'uni-input-placeholder'], + textContent: _ctx.placeholder + }, + null, + 14, + ['textContent'] + ), + [[vShow, !(_ctx.composing || _ctx.valueSync.length)]] + ), + withDirectives( + createVNode( + 'input', + { + ref: 'input', + 'onUpdate:modelValue': + _cache[1] || + (_cache[1] = $event => (_ctx.valueSync = $event)), + disabled: _ctx.disabled, + type: _ctx.inputType, + maxlength: _ctx.maxlength, + step: _ctx.step, + autofocus: _ctx.focus, + class: 'uni-input-input', + autocomplete: 'off', + onFocus: + _cache[2] || + (_cache[2] = (...args) => _ctx._onFocus(...args)), + onBlur: + _cache[3] || + (_cache[3] = (...args) => _ctx._onBlur(...args)), + onInput: + _cache[4] || + (_cache[4] = withModifiers( + (...args) => _ctx._onInput(...args), + ['stop'] + )), + onCompositionstart: + _cache[5] || + (_cache[5] = (...args) => _ctx._onComposition(...args)), + onCompositionend: + _cache[6] || + (_cache[6] = (...args) => _ctx._onComposition(...args)), + onKeyup: + _cache[7] || + (_cache[7] = withModifiers( + (...args) => _ctx._onKeyup(...args), + ['stop'] + )) + }, + null, + 40, + ['disabled', 'type', 'maxlength', 'step', 'autofocus'] + ), + [[vModelDynamic, _ctx.valueSync]] + ) + ], + 512 + ) + ], + 16 + ) + ) +} +script$8.render = render$8 +script$8.__file = 'packages/uni-components/src/components/input/index.vue' +var script$9 = { + 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 (stopPropagation) { + return + } + 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 + ) + } + } + } +} +function render$9(_ctx, _cache, $props, $setup, $data, $options) { + return ( + openBlock(), + createBlock( + 'uni-label', + mergeProps( + { + class: { 'uni-label-pointer': _ctx.pointer } + }, + _ctx.$attrs, + { + onClick: + _cache[1] || (_cache[1] = (...args) => _ctx._onClick(...args)) + } + ), + [renderSlot(_ctx.$slots, 'default')], + 16 + ) + ) +} +script$9.render = render$9 +script$9.__file = 'packages/uni-components/src/components/label/index.vue' +const addListenerToElement = function(element, type, callback, capture) { + element.addEventListener( + type, + $event => { + if (typeof callback === 'function') { + if (callback($event) === false) { + $event.preventDefault() + $event.stopPropagation() + } + } + }, + { + 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 + ) + } + }) + } + } +} +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(e2, t2) { + this._m = e2 + this._f = 1e3 * t2 + this._startTime = 0 + this._v = 0 +} +Friction.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.prototype.setS = function(x, y) { + this._x_s = x + this._y_s = y +} +Friction.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.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.prototype.delta = function() { + return { + x: (-1.5 * Math.pow(this._x_v, 2)) / this._x_a || 0, + y: (-1.5 * Math.pow(this._y_v, 2)) / this._y_a || 0 + } +} +Friction.prototype.dt = function() { + return -this._x_v / this._x_a +} +Friction.prototype.done = function() { + var t2 = + e(this.s().x, this._endPositionX) || + e(this.s().y, this._endPositionY) || + this._lastDt === this._t + this._lastDt = null + return t2 +} +Friction.prototype.setEnd = function(x, y) { + this._endPositionX = x + this._endPositionY = y +} +Friction.prototype.reconfigure = function(m, f2) { + this._m = m + this._f = 1e3 * f2 +} +function Spring(m, k, c) { + this._m = m + this._k = k + this._c = c + this._solution = null + this._endPosition = 0 + this._startTime = 0 +} +Spring.prototype._solve = function(e2, t2) { + 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 + } + } + } + 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 + } + } + } + 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.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, 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 + } + if (t(r, 0.1)) { + r = 0 + } + r += this._endPosition + } + if (!(this._solution && t(r - e2, 0.1) && t(n, 0.1))) { + this._endPosition = e2 + this._solution = this._solve(r - this._endPosition, n) + this._startTime = i2 + } + } +} +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(n) { + if (!n) { + n = new Date().getTime() + } + return e(this.x(), this._endPosition, 0.1) && t(this.dx(), 0.1) +} +Spring.prototype.reconfigure = function(m, t2, c) { + this._m = m + this._k = t2 + this._c = c + if (!this.done()) { + this._solution = this._solve(this.x() - this._endPosition, this.dx()) + this._startTime = new Date().getTime() + } +} +Spring.prototype.springConstant = function() { + return this._k +} +Spring.prototype.damping = function() { + return this._c +} +Spring.prototype.configuration = function() { + function e2(e3, t3) { + e3.reconfigure(1, t3, e3.damping()) + } + function t2(e3, t3) { + e3.reconfigure(1, e3.springConstant(), t3) + } + return [ + { + label: 'Spring Constant', + read: this.springConstant.bind(this), + write: e2.bind(this, this), + min: 100, + max: 1e3 + }, + { + label: 'Damping', + read: this.damping.bind(this), + write: t2.bind(this, this), + min: 1, + max: 500 + } + ] +} +function STD(e2, t2, n) { + this._springX = new Spring(e2, t2, n) + this._springY = new Spring(e2, t2, n) + this._springScale = new Spring(e2, t2, n) + this._startTime = 0 +} +STD.prototype.setEnd = function(e2, t2, n, 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) +} +let view +let pullToRefreshStyle +let disabled +const lastAction = {} +function disableScrollBounce({ disable }) { + function exec() { + if (!view) { + view = plus.webview.currentWebview() + } + if (!disabled) { + pullToRefreshStyle = (view.getStyle() || {}).pullToRefresh || {} + } + disabled = disable + if (pullToRefreshStyle.support) { + view.setPullToRefresh( + Object.assign({}, pullToRefreshStyle, { + support: !disable + }) + ) + } + } + const time = Date.now() + if (disable === lastAction.disable && time - lastAction.time < 20) { + return + } + lastAction.disable = disable + lastAction.time = time + plusReady(() => { + if (plus.os.name === 'iOS') { + setTimeout(exec, 20) + } else { + exec() + } + }) +} +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 + } + } + 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)) + } + } + if (a2 && o2) { + o2(i3) + } + } + } + fn(r, e2, t2, n) + return { + cancel: i2.bind(null, r), + model: e2 + } +} +var script$a = { + name: 'MovableView', + mixins: [touchtrack], + props: { + direction: { + type: String, + default: 'none' + }, + inertia: { + type: [Boolean, String], + default: false + }, + outOfBounds: { + type: [Boolean, String], + default: false + }, + x: { + type: [Number, String], + default: 0 + }, + y: { + type: [Number, String], + default: 0 + }, + damping: { + type: [Number, String], + default: 20 + }, + friction: { + type: [Number, String], + default: 2 + }, + disabled: { + type: [Boolean, String], + default: false + }, + scale: { + type: [Boolean, String], + default: false + }, + scaleMin: { + type: [Number, String], + default: 0.5 + }, + scaleMax: { + type: [Number, String], + default: 10 + }, + scaleValue: { + type: [Number, String], + default: 1 + }, + animation: { + type: [Boolean, String], + default: true + } + }, + 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 + } + }, + 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' + } + }, + 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() + }, + 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, 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: { + _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 + }, + __handleTouchStart: function() { + if (!this._isScaling) { + if (!this.disabled) { + disableScrollBounce({ + disable: true + }) + 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 + } + } + }, + __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) + }) + } + } + }, + __handleTouchEnd: function() { + var self = this + if (!this._isScaling && !this.disabled && this._isTouching) { + disableScrollBounce({ + disable: false + }) + 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() + } + ) + } + } + }, + _onTrack: function(event2) { + switch (event2.detail.state) { + case 'start': + this.__handleTouchStart() + break + case 'move': + this.__handleTouchMove(event2) + break + case 'end': + this.__handleTouchEnd() + } + }, + _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 + } + } + if (y > this.maxY) { + y = this.maxY + outOfBounds = true + } else { + if (y < this.minY) { + y = this.minY + outOfBounds = true + } + } + return { + x, + y, + outOfBounds + } + }, + 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) + }, + _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) + } + }, + _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) + }) + } + } + }, + _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() + } + if (this._SFA) { + this._SFA.cancel() + } + if (!this.xMove) { + x = this._translateX + } + if (!this.yMove) { + y = this._translateY + } + if (!this.scale) { + scale = this._scale + } + 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 render$a(_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: _ctx.setParent }, + null, + 8, + ['onResize'] + ), + renderSlot(_ctx.$slots, 'default') + ], + 16 + ) + ) +} +script$a.render = render$a +script$a.__file = + 'packages/uni-components/src/components/movable-view/index.vue' +const OPEN_TYPES = [ + 'navigate', + 'redirect', + 'switchTab', + 'reLaunch', + 'navigateBack' +] +var script$b = { + 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 + }, + 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 + } + } + } +} +function render$b(_ctx, _cache, $props, $setup, $data, $options) { + return _ctx.hoverClass && _ctx.hoverClass !== 'none' + ? (openBlock(), + createBlock( + 'uni-navigator', + mergeProps( + { + key: 0, + class: [_ctx.hovering ? _ctx.hoverClass : ''], + onTouchstart: + _cache[1] || + (_cache[1] = (...args) => _ctx._hoverTouchStart(...args)), + onTouchend: + _cache[2] || + (_cache[2] = (...args) => _ctx._hoverTouchEnd(...args)), + onTouchcancel: + _cache[3] || + (_cache[3] = (...args) => _ctx._hoverTouchCancel(...args)), + onClick: + _cache[4] || (_cache[4] = (...args) => _ctx._onClick(...args)) + }, + _ctx.$attrs + ), + [renderSlot(_ctx.$slots, 'default')], + 16 + )) + : (openBlock(), + createBlock( + 'uni-navigator', + mergeProps( + { + key: 1, + onClick: + _cache[5] || (_cache[5] = (...args) => _ctx._onClick(...args)) + }, + _ctx.$attrs + ), + [renderSlot(_ctx.$slots, 'default')], + 16 + )) +} +script$b.render = render$b +script$b.__file = 'packages/uni-components/src/components/navigator/index.vue' +const VALUES = { + activeColor: '#007AFF', + backgroundColor: '#EBEBEB', + activeMode: 'backwards' +} +var script$c = { + 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)) + } + }, + 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 + } + 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 + } + } + } +} +const _hoisted_1$4 = { + key: 0, + class: 'uni-progress-info' +} +function render$c(_ctx, _cache, $props, $setup, $data, $options) { + return ( + openBlock(), + createBlock( + 'uni-progress', + mergeProps({ class: 'uni-progress' }, _ctx.$attrs), + [ + createVNode( + 'div', + { + style: _ctx.outerBarStyle, + class: 'uni-progress-bar' + }, + [ + createVNode( + 'div', + { + style: _ctx.innerBarStyle, + class: 'uni-progress-inner-bar' + }, + null, + 4 + ) + ], + 4 + ), + _ctx.showInfo + ? (openBlock(), + createBlock( + 'p', + _hoisted_1$4, + toDisplayString(_ctx.currentPercent) + '% ', + 1 + )) + : createCommentVNode('v-if', true) + ], + 16 + ) + ) +} +script$c.render = render$c +script$c.__file = 'packages/uni-components/src/components/progress/index.vue' +var script$d = { + 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: '' + } + }, + data() { + return { + radioChecked: this.checked, + radioValue: this.value + } + }, + computed: { + checkedStyle() { + return `background-color: ${this.color};border-color: ${this.color};` + } + }, + watch: { + checked(val) { + this.radioChecked = val + }, + value(val) { + this.radioValue = val + } + }, + 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$5 = { class: 'uni-radio-wrapper' } +function render$d(_ctx, _cache, $props, $setup, $data, $options) { + return ( + openBlock(), + createBlock( + 'uni-radio', + mergeProps({ disabled: _ctx.disabled }, _ctx.$attrs, { + onClick: _cache[1] || (_cache[1] = (...args) => _ctx._onClick(...args)) + }), + [ + createVNode('div', _hoisted_1$5, [ + createVNode( + 'div', + { + class: [ + _ctx.radioChecked ? 'uni-radio-input-checked' : '', + 'uni-radio-input' + ], + style: _ctx.radioChecked ? _ctx.checkedStyle : '' + }, + null, + 6 + ), + renderSlot(_ctx.$slots, 'default') + ]) + ], + 16, + ['disabled'] + ) + ) +} +script$d.render = render$d +script$d.__file = 'packages/uni-components/src/components/radio/index.vue' +var script$e = { + name: 'RadioGroup', + mixins: [emitter, listeners], + props: { + name: { + type: String, + default: '' + } + }, + 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 index = this.radioList.indexOf(vm) + this._resetRadioGroupValue(index, true) + this.$trigger('change', $event, { + value: vm.radioValue + }) + }, + _radioGroupUpdateHandler($event) { + if ($event.type === 'add') { + this.radioList.push($event.vm) + } else { + const index = this.radioList.indexOf($event.vm) + this.radioList.splice(index, 1) + } + }, + _resetRadioGroupValue(key, change) { + this.radioList.forEach((value, index) => { + if (index === key) { + return + } + if (change) { + this.radioList[index].radioChecked = false + } else { + this.radioList.forEach((v2, i2) => { + if (index >= i2) { + return + } + if (this.radioList[i2].radioChecked) { + this.radioList[index].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 + } + return data + } + } +} +function render$e(_ctx, _cache, $props, $setup, $data, $options) { + return ( + openBlock(), + createBlock( + 'uni-radio-group', + _ctx.$attrs, + [renderSlot(_ctx.$slots, 'default')], + 16 + ) + ) +} +script$e.render = render$e +script$e.__file = 'packages/uni-components/src/components/radio-group/index.vue' +var script$f = { + name: 'ResizeSensor', + props: { + initial: { + type: [Boolean, String], + default: false + } + }, + data: function() { + return { + size: { + width: -1, + height: -1 + } + } + }, + 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 + }, + 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 + } + }, + [create('div')] + ), + create( + 'div', + { + on: { + scroll: this.update + } + }, + [create('div')] + ) + ] + ) + } +} +const render$f = () => {} +script$f.render = render$f +script$f.__file = + 'packages/uni-components/src/components/resize-sensor/index.vue' +function removeDOCTYPE(html) { + return html + .replace(/<\?xml.*\?>\n/, '') + .replace(/\n/, '') + .replace(/\n/, '') +} +function parseAttrs(attrs) { + return attrs.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] + } + } else { + pre[name] = value + } + return pre + }, {}) +} +function parseHtml(html) { + html = removeDOCTYPE(html) + const stacks = [] + const results = { + node: 'root', + children: [] + } + HTMLParser(html, { + start: function(tag, attrs, unary) { + const node = { + name: tag + } + if (attrs.length !== 0) { + node.attrs = parseAttrs(attrs) + } + if (unary) { + const parent = stacks[0] || results + if (!parent.children) { + parent.children = [] + } + parent.children.push(node) + } else { + stacks.unshift(node) + } + }, + 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) + } + }, + 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) + } + }, + 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)) + } + 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(node, 'type') || node.type === 'node') { + if (!(typeof node.name === 'string' && node.name)) { + return + } + const tagName = node.name.toLowerCase() + if (!hasOwn(TAGS, tagName)) { + return + } + const elem = document.createElement(tagName) + if (!elem) { + return + } + const attrs = node.attrs + if (isPlainObject(attrs)) { + const tagAttrs = TAGS[tagName] || [] + Object.keys(attrs).forEach(function(name) { + let value = attrs[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) + } + } + }) + } + 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)) + ) + } + } + }) + return parentNode +} +var script$g = { + name: 'RichText', + props: { + nodes: { + type: [Array, String], + default: function() { + return [] + } + } + }, + watch: { + nodes(value) { + this._renderNodes(value) + } + }, + mounted() { + this._renderNodes(this.nodes) + }, + 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$6 = /* @__PURE__ */ createVNode('div', null, null, -1) +function render$g(_ctx, _cache, $props, $setup, $data, $options) { + return ( + openBlock(), createBlock('uni-rich-text', _ctx.$attrs, [_hoisted_1$6], 16) + ) +} +script$g.render = render$g +script$g.__file = 'packages/uni-components/src/components/rich-text/index.vue' +function Friction$1(e2) { + this._drag = e2 + this._dragLog = Math.log(e2) + this._x = 0 + this._v = 0 + this._startTime = 0 +} +Friction$1.prototype.set = function(e2, t2) { + this._x = e2 + this._v = t2 + this._startTime = new Date().getTime() +} +Friction$1.prototype.setVelocityByEnd = function(e2) { + this._v = ((e2 - this._x) * this._dragLog) / (Math.pow(this._drag, 100) - 1) +} +Friction$1.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$1.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$1.prototype.done = function() { + return Math.abs(this.dx()) < 3 +} +Friction$1.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$1.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$1(e2, t2, n) { + this._m = e2 + this._k = t2 + this._c = n + this._solution = null + this._endPosition = 0 + this._startTime = 0 +} +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 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) + } + 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 + } + } + } + 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$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, 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) + } + i2 = this._solution.x((n - this._startTime) / 1e3) + if (a(t2, 0.4)) { + t2 = 0 + } + if (a(i2, 0.4)) { + i2 = 0 + } + 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$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(e2) { + if (!e2) { + e2 = new Date().getTime() + } + return o(this.x(), this._endPosition, 0.4) && a(this.dx(), 0.4) +} +Spring$1.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$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 Scroll(extent, friction, spring) { + this._extent = extent + this._friction = friction || new Friction$1(0.01) + this._spring = spring || new Spring$1(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 + } + 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 +} +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(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() +} +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 + } + } + 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) + } + } + 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 + } + }, + () => { + 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) + ) + } + } + 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 + } + } + 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._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)' + } + } + 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 + }, + _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 + } + 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() + } + }, + _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 + ) + } + } + } + }, + _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) + } + } + } + } + } +} +var script$h = { + name: 'ScrollView', + mixins: [scroller], + props: { + scrollX: { + type: [Boolean, String], + default: false + }, + scrollY: { + type: [Boolean, String], + default: false + }, + upperThreshold: { + type: [Number, String], + default: 50 + }, + 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 + } + }, + 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) + }, + scrollIntoView(val) { + this._scrollIntoViewChanged(val) + }, + refresherTriggered(val) { + if (val === true) { + this._setRefreshState('refreshing') + } else if (val === false) { + this._setRefreshState('restore') + } + } + }, + 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) { + disableScrollBounce({ + disable: true + }) + 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 + disableScrollBounce({ + disable: false + }) + 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 + ) + }, + 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 + ) + }, + 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)') + } + 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' + } + 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() + } + }, + _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 + } + }, + _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 + } + } + } + }, + _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 + } + } + } + }, + _scrollIntoViewChanged: function(val) { + if (val) { + if (!/^[_a-zA-Z][-_a-zA-Z0-9:]*$/.test(val)) { + console.group('scroll-into-view="' + val + '" 有误') + console.error('id 属性值格式错误。如不能以数字开头。') + 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 + } + } + } +} +const _hoisted_1$7 = { + ref: 'wrap', + class: 'uni-scroll-view' +} +const _hoisted_2$2 = { + ref: 'content', + class: 'uni-scroll-view-content' +} +const _hoisted_3$1 = { + key: 0, + class: 'uni-scroll-view-refresh' +} +const _hoisted_4$1 = { class: 'uni-scroll-view-refresh-inner' } +const _hoisted_5$1 = /* @__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$1 = /* @__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 render$h(_ctx, _cache, $props, $setup, $data, $options) { + return ( + openBlock(), + createBlock( + 'uni-scroll-view', + _ctx.$attrs, + [ + createVNode( + 'div', + _hoisted_1$7, + [ + createVNode( + 'div', + { + ref: 'main', + style: { + 'overflow-x': _ctx.scrollX ? 'auto' : 'hidden', + 'overflow-y': _ctx.scrollY ? 'auto' : 'hidden' + }, + class: 'uni-scroll-view' + }, + [ + createVNode( + 'div', + _hoisted_2$2, + [ + _ctx.refresherEnabled + ? (openBlock(), + createBlock( + 'div', + { + key: 0, + ref: 'refresherinner', + style: { + 'background-color': _ctx.refresherBackground, + height: _ctx.refresherHeight + 'px' + }, + class: 'uni-scroll-view-refresher' + }, + [ + _ctx.refresherDefaultStyle !== 'none' + ? (openBlock(), + createBlock('div', _hoisted_3$1, [ + createVNode('div', _hoisted_4$1, [ + _ctx.refreshState == 'pulling' + ? (openBlock(), + createBlock( + 'svg', + { + key: 0, + style: { + transform: + 'rotate(' + + _ctx.refreshRotate + + 'deg)' + }, + fill: '#2BD009', + class: + 'uni-scroll-view-refresh__icon', + width: '24', + height: '24', + viewBox: '0 0 24 24' + }, + [_hoisted_5$1, _hoisted_6$1], + 4 + )) + : createCommentVNode('v-if', true), + _ctx.refreshState == 'refreshing' + ? (openBlock(), + createBlock('svg', _hoisted_7, [ + _hoisted_8 + ])) + : createCommentVNode('v-if', true) + ]) + ])) + : createCommentVNode('v-if', true), + _ctx.refresherDefaultStyle == 'none' + ? renderSlot(_ctx.$slots, 'refresher', { key: 1 }) + : createCommentVNode('v-if', true) + ], + 4 + )) + : createCommentVNode('v-if', true), + renderSlot(_ctx.$slots, 'default') + ], + 512 + ) + ], + 4 + ) + ], + 512 + ) + ], + 16 + ) + ) +} +script$h.render = render$h +script$h.__file = 'packages/uni-components/src/components/scroll-view/index.vue' +var script$i = { + 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 + } + }, + 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() + } + } + }, + watch: { + value(val) { + this.sliderValue = Number(val) + } + }, + 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 + } + return data + } + } +} +const _hoisted_1$8 = { class: 'uni-slider-wrapper' } +const _hoisted_2$3 = { class: 'uni-slider-tap-area' } +function render$i(_ctx, _cache, $props, $setup, $data, $options) { + return ( + openBlock(), + createBlock( + 'uni-slider', + mergeProps({ ref: 'uni-slider' }, _ctx.$attrs, { + onClick: _cache[1] || (_cache[1] = (...args) => _ctx._onClick(...args)) + }), + [ + createVNode('div', _hoisted_1$8, [ + createVNode('div', _hoisted_2$3, [ + createVNode( + 'div', + { + style: _ctx.setBgColor, + class: 'uni-slider-handle-wrapper' + }, + [ + createVNode( + 'div', + { + ref: 'uni-slider-handle', + style: _ctx.setBlockBg, + class: 'uni-slider-handle' + }, + null, + 4 + ), + createVNode( + 'div', + { + style: _ctx.setBlockStyle, + class: 'uni-slider-thumb' + }, + null, + 4 + ), + createVNode( + 'div', + { + style: _ctx.setActiveColor, + class: 'uni-slider-track' + }, + null, + 4 + ) + ], + 4 + ) + ]), + withDirectives( + createVNode( + 'span', + { class: 'uni-slider-value' }, + toDisplayString(_ctx.sliderValue), + 513 + ), + [[vShow, _ctx.showValue]] + ) + ]), + renderSlot(_ctx.$slots, 'default') + ], + 16 + ) + ) +} +script$i.render = render$i +script$i.__file = 'packages/uni-components/src/components/slider/index.vue' +var script$j = { + 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 callbacks = this.$vnode._callbacks + if (callbacks) { + callbacks.forEach(callback => { + callback() + }) + } + } +} +function render$j(_ctx, _cache, $props, $setup, $data, $options) { + return ( + openBlock(), + createBlock( + 'uni-swiper-item', + _ctx.$attrs, + [renderSlot(_ctx.$slots, 'default')], + 16 + ) + ) +} +script$j.render = render$j +script$j.__file = 'packages/uni-components/src/components/swiper-item/index.vue' +var script$k = { + 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' + } + }, + 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 + }) + }, + _resetFormData() { + this.switchChecked = false + }, + _getFormData() { + const data = {} + if (this.name !== '') { + data.value = this.switchChecked + data.key = this.name + } + return data + } + } +} +const _hoisted_1$9 = { class: 'uni-switch-wrapper' } +function render$k(_ctx, _cache, $props, $setup, $data, $options) { + return ( + openBlock(), + createBlock( + 'uni-switch', + mergeProps({ disabled: _ctx.disabled }, _ctx.$attrs, { + onClick: _cache[1] || (_cache[1] = (...args) => _ctx._onClick(...args)) + }), + [ + createVNode('div', _hoisted_1$9, [ + withDirectives( + createVNode( + 'div', + { + class: [ + [_ctx.switchChecked ? 'uni-switch-input-checked' : ''], + 'uni-switch-input' + ], + style: { + backgroundColor: _ctx.switchChecked ? _ctx.color : '#DFDFDF', + borderColor: _ctx.switchChecked ? _ctx.color : '#DFDFDF' + } + }, + null, + 6 + ), + [[vShow, _ctx.type === 'switch']] + ), + withDirectives( + createVNode( + 'div', + { + class: [ + [_ctx.switchChecked ? 'uni-checkbox-input-checked' : ''], + 'uni-checkbox-input' + ], + style: { color: _ctx.color } + }, + null, + 6 + ), + [[vShow, _ctx.type === 'checkbox']] + ) + ]) + ], + 16, + ['disabled'] + ) + ) +} +script$k.render = render$k +script$k.__file = 'packages/uni-components/src/components/switch/index.vue' +const DARK_TEST_STRING = '(prefers-color-scheme: dark)' +var script$l = { + 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 + } + }, + 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' + ) + } + }, + 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() + } + } + }, + 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 + } + 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 + }) + }, + _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 = '' + } + } +} +const _hoisted_1$a = { class: 'uni-textarea-wrapper' } +const _hoisted_2$4 = { + ref: 'line', + class: 'uni-textarea-line', + textContent: ' ' +} +const _hoisted_3$2 = { class: 'uni-textarea-compute' } +function render$l(_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$a, [ + withDirectives( + createVNode( + 'div', + { + ref: 'placeholder', + style: _ctx.placeholderStyle, + class: [_ctx.placeholderClass, 'uni-textarea-placeholder'], + textContent: _ctx.placeholder + }, + null, + 14, + ['textContent'] + ), + [[vShow, !(_ctx.composition || _ctx.valueSync.length)]] + ), + createVNode('div', _hoisted_2$4, null, 512), + createVNode('div', _hoisted_3$2, [ + (openBlock(true), + createBlock( + Fragment, + null, + renderList(_ctx.valueCompute, (item, index) => { + return ( + openBlock(), + createBlock( + 'div', + { + key: index, + textContent: item.trim() ? item : '.' + }, + null, + 8, + ['textContent'] + ) + ) + }), + 128 + )), + createVNode( + _component_v_uni_resize_sensor, + { + ref: 'sensor', + onResize: _ctx._resize + }, + null, + 8, + ['onResize'] + ) + ]), + withDirectives( + createVNode( + 'textarea', + { + ref: 'textarea', + 'onUpdate:modelValue': + _cache[1] || + (_cache[1] = $event => (_ctx.valueSync = $event)), + disabled: _ctx.disabled, + maxlength: _ctx.maxlengthNumber, + autofocus: _ctx.autoFocus || _ctx.focus, + class: [ + { 'uni-textarea-textarea-fix-margin': _ctx.fixMargin }, + 'uni-textarea-textarea' + ], + style: { 'overflow-y': _ctx.autoHeight ? 'hidden' : 'auto' }, + onCompositionstart: + _cache[2] || + (_cache[2] = (...args) => _ctx._compositionstart(...args)), + onCompositionend: + _cache[3] || + (_cache[3] = (...args) => _ctx._compositionend(...args)), + onInput: + _cache[4] || + (_cache[4] = withModifiers( + (...args) => _ctx._input(...args), + ['stop'] + )), + onFocus: + _cache[5] || (_cache[5] = (...args) => _ctx._focus(...args)), + onBlur: + _cache[6] || (_cache[6] = (...args) => _ctx._blur(...args)), + onTouchstartPassive: + _cache[7] || + (_cache[7] = (...args) => _ctx._touchstart(...args)) + }, + null, + 46, + ['disabled', 'maxlength', 'autofocus'] + ), + [[vModelText, _ctx.valueSync]] + ) + ]) + ], + 16 + ) + ) +} +script$l.render = render$l +script$l.__file = 'packages/uni-components/src/components/textarea/index.vue' +var script$m = { + name: 'View', + mixins: [hover], + listeners: { + 'label-click': 'clickHandler' + } +} +function render$m(_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(...args)), + onTouchend: + _cache[2] || + (_cache[2] = (...args) => _ctx._hoverTouchEnd(...args)), + onTouchcancel: + _cache[3] || + (_cache[3] = (...args) => _ctx._hoverTouchCancel(...args)) + }, + _ctx.$attrs + ), + [renderSlot(_ctx.$slots, 'default')], + 16 + )) + : (openBlock(), + createBlock( + 'uni-view', + mergeProps({ key: 1 }, _ctx.$attrs), + [renderSlot(_ctx.$slots, 'default')], + 16 + )) +} +script$m.render = render$m +script$m.__file = 'packages/uni-components/src/components/view/index.vue' +export { + script as Audio, + script$1 as Canvas, + script$2 as Checkbox, + script$3 as CheckboxGroup, + script$4 as Editor, + script$5 as Form, + script$6 as Icon, + script$7 as Image, + script$8 as Input, + script$9 as Label, + script$a as MovableView, + script$b as Navigator, + script$c as Progress, + script$d as Radio, + script$e as RadioGroup, + script$f as ResizeSensor, + script$g as RichText, + script$h as ScrollView, + script$i as Slider, + script$j as SwiperItem, + script$k as Switch, + script$l as Textarea, + script$m as View, + passiveOptions, + supportsPassive$1 as supportsPassive +} diff --git a/packages/uni-h5-vue/dist/vue.runtime.esm.js b/packages/uni-h5-vue/dist/vue.runtime.esm.js new file mode 100644 index 000000000..233321895 --- /dev/null +++ b/packages/uni-h5-vue/dist/vue.runtime.esm.js @@ -0,0 +1,9965 @@ +import { + isSymbol, + extend, + isObject, + toRawType, + def, + isArray, + isString, + isFunction, + isPromise, + capitalize, + EMPTY_ARR, + normalizeClass, + normalizeStyle, + isOn, + remove, + EMPTY_OBJ, + NOOP, + isGloballyWhitelisted, + toNumber, + invokeArrayFns, + looseIndexOf, + looseEqual, + hyphenate, + isHTMLTag, + isSVGTag, + isIntegerKey, + hasOwn, + hasChanged, + camelize, + getGlobalThis, + isReservedProp, + NO, + isModelListener, + makeMap, + isSpecialBooleanAttr +} from '@vue/shared' +export { camelize, capitalize, toDisplayString } from '@vue/shared' + +const targetMap = new WeakMap() +const effectStack = [] +let activeEffect +const ITERATE_KEY = Symbol( + process.env.NODE_ENV !== 'production' ? 'iterate' : '' +) +const MAP_KEY_ITERATE_KEY = Symbol( + process.env.NODE_ENV !== 'production' ? 'Map key iterate' : '' +) +function isEffect(fn) { + return fn && fn._isEffect === true +} +function effect(fn, options = EMPTY_OBJ) { + if (isEffect(fn)) { + fn = fn.raw + } + const effect = createReactiveEffect(fn, options) + if (!options.lazy) { + effect() + } + return effect +} +function stop(effect) { + if (effect.active) { + cleanup(effect) + if (effect.options.onStop) { + effect.options.onStop() + } + effect.active = false + } +} +let uid = 0 +function createReactiveEffect(fn, options) { + const effect = function reactiveEffect() { + if (!effect.active) { + return options.scheduler ? undefined : fn() + } + if (!effectStack.includes(effect)) { + cleanup(effect) + try { + enableTracking() + effectStack.push(effect) + activeEffect = effect + return fn() + } finally { + effectStack.pop() + resetTracking() + activeEffect = effectStack[effectStack.length - 1] + } + } + } + effect.id = uid++ + effect._isEffect = true + effect.active = true + effect.raw = fn + effect.deps = [] + effect.options = options + return effect +} +function cleanup(effect) { + const { deps } = effect + if (deps.length) { + for (let i = 0; i < deps.length; i++) { + deps[i].delete(effect) + } + deps.length = 0 + } +} +let shouldTrack = true +const trackStack = [] +function pauseTracking() { + trackStack.push(shouldTrack) + shouldTrack = false +} +function enableTracking() { + trackStack.push(shouldTrack) + shouldTrack = true +} +function resetTracking() { + const last = trackStack.pop() + shouldTrack = last === undefined ? true : last +} +function track(target, type, key) { + if (!shouldTrack || activeEffect === undefined) { + return + } + let depsMap = targetMap.get(target) + if (!depsMap) { + targetMap.set(target, (depsMap = new Map())) + } + let dep = depsMap.get(key) + if (!dep) { + depsMap.set(key, (dep = new Set())) + } + if (!dep.has(activeEffect)) { + dep.add(activeEffect) + activeEffect.deps.push(dep) + if (process.env.NODE_ENV !== 'production' && activeEffect.options.onTrack) { + activeEffect.options.onTrack({ + effect: activeEffect, + target, + type, + key + }) + } + } +} +function trigger(target, type, key, newValue, oldValue, oldTarget) { + const depsMap = targetMap.get(target) + if (!depsMap) { + // never been tracked + return + } + const effects = new Set() + const add = effectsToAdd => { + if (effectsToAdd) { + effectsToAdd.forEach(effect => { + if (effect !== activeEffect) { + effects.add(effect) + } + }) + } + } + if (type === 'clear' /* CLEAR */) { + // collection being cleared + // trigger all effects for target + depsMap.forEach(add) + } else if (key === 'length' && isArray(target)) { + depsMap.forEach((dep, key) => { + if (key === 'length' || key >= newValue) { + add(dep) + } + }) + } else { + // schedule runs for SET | ADD | DELETE + if (key !== void 0) { + add(depsMap.get(key)) + } + // also run for iteration key on ADD | DELETE | Map.SET + const shouldTriggerIteration = + (type === 'add' /* ADD */ && (!isArray(target) || isIntegerKey(key))) || + (type === 'delete' /* DELETE */ && !isArray(target)) + if ( + shouldTriggerIteration || + (type === 'set' /* SET */ && target instanceof Map) + ) { + add(depsMap.get(isArray(target) ? 'length' : ITERATE_KEY)) + } + if (shouldTriggerIteration && target instanceof Map) { + add(depsMap.get(MAP_KEY_ITERATE_KEY)) + } + } + const run = effect => { + if (process.env.NODE_ENV !== 'production' && effect.options.onTrigger) { + effect.options.onTrigger({ + effect, + target, + key, + type, + newValue, + oldValue, + oldTarget + }) + } + if (effect.options.scheduler) { + effect.options.scheduler(effect) + } else { + effect() + } + } + effects.forEach(run) +} + +const builtInSymbols = new Set( + Object.getOwnPropertyNames(Symbol) + .map(key => Symbol[key]) + .filter(isSymbol) +) +const get = /*#__PURE__*/ createGetter() +const shallowGet = /*#__PURE__*/ createGetter(false, true) +const readonlyGet = /*#__PURE__*/ createGetter(true) +const shallowReadonlyGet = /*#__PURE__*/ createGetter(true, true) +const arrayInstrumentations = {} +;['includes', 'indexOf', 'lastIndexOf'].forEach(key => { + arrayInstrumentations[key] = function(...args) { + const arr = toRaw(this) + for (let i = 0, l = this.length; i < l; i++) { + track(arr, 'get' /* GET */, i + '') + } + // we run the method using the original args first (which may be reactive) + const res = arr[key](...args) + if (res === -1 || res === false) { + // if that didn't work, run it again using raw values. + return arr[key](...args.map(toRaw)) + } else { + return res + } + } +}) +function createGetter(isReadonly = false, shallow = false) { + return function get(target, key, receiver) { + if (key === '__v_isReactive' /* IS_REACTIVE */) { + return !isReadonly + } else if (key === '__v_isReadonly' /* IS_READONLY */) { + return isReadonly + } else if ( + key === '__v_raw' /* RAW */ && + receiver === (isReadonly ? readonlyMap : reactiveMap).get(target) + ) { + return target + } + const targetIsArray = isArray(target) + if (targetIsArray && hasOwn(arrayInstrumentations, key)) { + return Reflect.get(arrayInstrumentations, key, receiver) + } + const res = Reflect.get(target, key, receiver) + const keyIsSymbol = isSymbol(key) + if ( + keyIsSymbol + ? builtInSymbols.has(key) + : key === `__proto__` || key === `__v_isRef` + ) { + return res + } + if (!isReadonly) { + track(target, 'get' /* GET */, key) + } + if (shallow) { + return res + } + if (isRef(res)) { + // ref unwrapping - does not apply for Array + integer key. + const shouldUnwrap = !targetIsArray || !isIntegerKey(key) + return shouldUnwrap ? res.value : res + } + if (isObject(res)) { + // Convert returned value into a proxy as well. we do the isObject check + // here to avoid invalid value warning. Also need to lazy access readonly + // and reactive here to avoid circular dependency. + return isReadonly ? readonly(res) : reactive(res) + } + return res + } +} +const set = /*#__PURE__*/ createSetter() +const shallowSet = /*#__PURE__*/ createSetter(true) +function createSetter(shallow = false) { + return function set(target, key, value, receiver) { + const oldValue = target[key] + if (!shallow) { + value = toRaw(value) + if (!isArray(target) && isRef(oldValue) && !isRef(value)) { + oldValue.value = value + return true + } + } + const hadKey = + isArray(target) && isIntegerKey(key) + ? Number(key) < target.length + : hasOwn(target, key) + const result = Reflect.set(target, key, value, receiver) + // don't trigger if target is something up in the prototype chain of original + if (target === toRaw(receiver)) { + if (!hadKey) { + trigger(target, 'add' /* ADD */, key, value) + } else if (hasChanged(value, oldValue)) { + trigger(target, 'set' /* SET */, key, value, oldValue) + } + } + return result + } +} +function deleteProperty(target, key) { + const hadKey = hasOwn(target, key) + const oldValue = target[key] + const result = Reflect.deleteProperty(target, key) + if (result && hadKey) { + trigger(target, 'delete' /* DELETE */, key, undefined, oldValue) + } + return result +} +function has(target, key) { + const result = Reflect.has(target, key) + if (!isSymbol(key) || !builtInSymbols.has(key)) { + track(target, 'has' /* HAS */, key) + } + return result +} +function ownKeys(target) { + track(target, 'iterate' /* ITERATE */, ITERATE_KEY) + return Reflect.ownKeys(target) +} +const mutableHandlers = { + get, + set, + deleteProperty, + has, + ownKeys +} +const readonlyHandlers = { + get: readonlyGet, + set(target, key) { + if (process.env.NODE_ENV !== 'production') { + console.warn( + `Set operation on key "${String(key)}" failed: target is readonly.`, + target + ) + } + return true + }, + deleteProperty(target, key) { + if (process.env.NODE_ENV !== 'production') { + console.warn( + `Delete operation on key "${String(key)}" failed: target is readonly.`, + target + ) + } + return true + } +} +const shallowReactiveHandlers = extend({}, mutableHandlers, { + get: shallowGet, + set: shallowSet +}) +// Props handlers are special in the sense that it should not unwrap top-level +// refs (in order to allow refs to be explicitly passed down), but should +// retain the reactivity of the normal readonly object. +const shallowReadonlyHandlers = extend({}, readonlyHandlers, { + get: shallowReadonlyGet +}) + +const toReactive = value => (isObject(value) ? reactive(value) : value) +const toReadonly = value => (isObject(value) ? readonly(value) : value) +const toShallow = value => value +const getProto = v => Reflect.getPrototypeOf(v) +function get$1(target, key, isReadonly = false, isShallow = false) { + // #1772: readonly(reactive(Map)) should return readonly + reactive version + // of the value + target = target['__v_raw' /* RAW */] + const rawTarget = toRaw(target) + const rawKey = toRaw(key) + if (key !== rawKey) { + !isReadonly && track(rawTarget, 'get' /* GET */, key) + } + !isReadonly && track(rawTarget, 'get' /* GET */, rawKey) + const { has } = getProto(rawTarget) + const wrap = isReadonly ? toReadonly : isShallow ? toShallow : toReactive + if (has.call(rawTarget, key)) { + return wrap(target.get(key)) + } else if (has.call(rawTarget, rawKey)) { + return wrap(target.get(rawKey)) + } +} +function has$1(key, isReadonly = false) { + const target = this['__v_raw' /* RAW */] + const rawTarget = toRaw(target) + const rawKey = toRaw(key) + if (key !== rawKey) { + !isReadonly && track(rawTarget, 'has' /* HAS */, key) + } + !isReadonly && track(rawTarget, 'has' /* HAS */, rawKey) + return key === rawKey + ? target.has(key) + : target.has(key) || target.has(rawKey) +} +function size(target, isReadonly = false) { + target = target['__v_raw' /* RAW */] + !isReadonly && track(toRaw(target), 'iterate' /* ITERATE */, ITERATE_KEY) + return Reflect.get(target, 'size', target) +} +function add(value) { + value = toRaw(value) + const target = toRaw(this) + const proto = getProto(target) + const hadKey = proto.has.call(target, value) + const result = proto.add.call(target, value) + if (!hadKey) { + trigger(target, 'add' /* ADD */, value, value) + } + return result +} +function set$1(key, value) { + value = toRaw(value) + const target = toRaw(this) + const { has, get, set } = getProto(target) + let hadKey = has.call(target, key) + if (!hadKey) { + key = toRaw(key) + hadKey = has.call(target, key) + } else if (process.env.NODE_ENV !== 'production') { + checkIdentityKeys(target, has, key) + } + const oldValue = get.call(target, key) + const result = set.call(target, key, value) + if (!hadKey) { + trigger(target, 'add' /* ADD */, key, value) + } else if (hasChanged(value, oldValue)) { + trigger(target, 'set' /* SET */, key, value, oldValue) + } + return result +} +function deleteEntry(key) { + const target = toRaw(this) + const { has, get, delete: del } = getProto(target) + let hadKey = has.call(target, key) + if (!hadKey) { + key = toRaw(key) + hadKey = has.call(target, key) + } else if (process.env.NODE_ENV !== 'production') { + checkIdentityKeys(target, has, key) + } + const oldValue = get ? get.call(target, key) : undefined + // forward the operation before queueing reactions + const result = del.call(target, key) + if (hadKey) { + trigger(target, 'delete' /* DELETE */, key, undefined, oldValue) + } + return result +} +function clear() { + const target = toRaw(this) + const hadItems = target.size !== 0 + const oldTarget = + process.env.NODE_ENV !== 'production' + ? target instanceof Map + ? new Map(target) + : new Set(target) + : undefined + // forward the operation before queueing reactions + const result = getProto(target).clear.call(target) + if (hadItems) { + trigger(target, 'clear' /* CLEAR */, undefined, undefined, oldTarget) + } + return result +} +function createForEach(isReadonly, isShallow) { + return function forEach(callback, thisArg) { + const observed = this + const target = observed['__v_raw' /* RAW */] + const rawTarget = toRaw(target) + const wrap = isReadonly ? toReadonly : isShallow ? toShallow : toReactive + !isReadonly && track(rawTarget, 'iterate' /* ITERATE */, ITERATE_KEY) + return target.forEach((value, key) => { + // important: make sure the callback is + // 1. invoked with the reactive map as `this` and 3rd arg + // 2. the value received should be a corresponding reactive/readonly. + return callback.call(thisArg, wrap(value), wrap(key), observed) + }) + } +} +function createIterableMethod(method, isReadonly, isShallow) { + return function(...args) { + const target = this['__v_raw' /* RAW */] + const rawTarget = toRaw(target) + const isMap = rawTarget instanceof Map + const isPair = method === 'entries' || (method === Symbol.iterator && isMap) + const isKeyOnly = method === 'keys' && isMap + const innerIterator = target[method](...args) + const wrap = isReadonly ? toReadonly : isShallow ? toShallow : toReactive + !isReadonly && + track( + rawTarget, + 'iterate' /* ITERATE */, + isKeyOnly ? MAP_KEY_ITERATE_KEY : ITERATE_KEY + ) + // return a wrapped iterator which returns observed versions of the + // values emitted from the real iterator + return { + // iterator protocol + next() { + const { value, done } = innerIterator.next() + return done + ? { value, done } + : { + value: isPair ? [wrap(value[0]), wrap(value[1])] : wrap(value), + done + } + }, + // iterable protocol + [Symbol.iterator]() { + return this + } + } + } +} +function createReadonlyMethod(type) { + return function(...args) { + if (process.env.NODE_ENV !== 'production') { + const key = args[0] ? `on key "${args[0]}" ` : `` + console.warn( + `${capitalize(type)} operation ${key}failed: target is readonly.`, + toRaw(this) + ) + } + return type === 'delete' /* DELETE */ ? false : this + } +} +const mutableInstrumentations = { + get(key) { + return get$1(this, key) + }, + get size() { + return size(this) + }, + has: has$1, + add, + set: set$1, + delete: deleteEntry, + clear, + forEach: createForEach(false, false) +} +const shallowInstrumentations = { + get(key) { + return get$1(this, key, false, true) + }, + get size() { + return size(this) + }, + has: has$1, + add, + set: set$1, + delete: deleteEntry, + clear, + forEach: createForEach(false, true) +} +const readonlyInstrumentations = { + get(key) { + return get$1(this, key, true) + }, + get size() { + return size(this, true) + }, + has(key) { + return has$1.call(this, key, true) + }, + add: createReadonlyMethod('add' /* ADD */), + set: createReadonlyMethod('set' /* SET */), + delete: createReadonlyMethod('delete' /* DELETE */), + clear: createReadonlyMethod('clear' /* CLEAR */), + forEach: createForEach(true, false) +} +const iteratorMethods = ['keys', 'values', 'entries', Symbol.iterator] +iteratorMethods.forEach(method => { + mutableInstrumentations[method] = createIterableMethod(method, false, false) + readonlyInstrumentations[method] = createIterableMethod(method, true, false) + shallowInstrumentations[method] = createIterableMethod(method, false, true) +}) +function createInstrumentationGetter(isReadonly, shallow) { + const instrumentations = shallow + ? shallowInstrumentations + : isReadonly + ? readonlyInstrumentations + : mutableInstrumentations + return (target, key, receiver) => { + if (key === '__v_isReactive' /* IS_REACTIVE */) { + return !isReadonly + } else if (key === '__v_isReadonly' /* IS_READONLY */) { + return isReadonly + } else if (key === '__v_raw' /* RAW */) { + return target + } + return Reflect.get( + hasOwn(instrumentations, key) && key in target + ? instrumentations + : target, + key, + receiver + ) + } +} +const mutableCollectionHandlers = { + get: createInstrumentationGetter(false, false) +} +const shallowCollectionHandlers = { + get: createInstrumentationGetter(false, true) +} +const readonlyCollectionHandlers = { + get: createInstrumentationGetter(true, false) +} +function checkIdentityKeys(target, has, key) { + const rawKey = toRaw(key) + if (rawKey !== key && has.call(target, rawKey)) { + const type = toRawType(target) + console.warn( + `Reactive ${type} contains both the raw and reactive ` + + `versions of the same object${type === `Map` ? `as keys` : ``}, ` + + `which can lead to inconsistencies. ` + + `Avoid differentiating between the raw and reactive versions ` + + `of an object and only use the reactive version if possible.` + ) + } +} + +const reactiveMap = new WeakMap() +const readonlyMap = new WeakMap() +function targetTypeMap(rawType) { + switch (rawType) { + case 'Object': + case 'Array': + return 1 /* COMMON */ + case 'Map': + case 'Set': + case 'WeakMap': + case 'WeakSet': + return 2 /* COLLECTION */ + default: + return 0 /* INVALID */ + } +} +function getTargetType(value) { + return value['__v_skip' /* SKIP */] || !Object.isExtensible(value) + ? 0 /* INVALID */ + : targetTypeMap(toRawType(value)) +} +function reactive(target) { + // if trying to observe a readonly proxy, return the readonly version. + if (target && target['__v_isReadonly' /* IS_READONLY */]) { + return target + } + return createReactiveObject( + target, + false, + mutableHandlers, + mutableCollectionHandlers + ) +} +// Return a reactive-copy of the original object, where only the root level +// properties are reactive, and does NOT unwrap refs nor recursively convert +// returned properties. +function shallowReactive(target) { + return createReactiveObject( + target, + false, + shallowReactiveHandlers, + shallowCollectionHandlers + ) +} +function readonly(target) { + return createReactiveObject( + target, + true, + readonlyHandlers, + readonlyCollectionHandlers + ) +} +// Return a reactive-copy of the original object, where only the root level +// properties are readonly, and does NOT unwrap refs nor recursively convert +// returned properties. +// This is used for creating the props proxy object for stateful components. +function shallowReadonly(target) { + return createReactiveObject( + target, + true, + shallowReadonlyHandlers, + readonlyCollectionHandlers + ) +} +function createReactiveObject( + target, + isReadonly, + baseHandlers, + collectionHandlers +) { + if (!isObject(target)) { + if (process.env.NODE_ENV !== 'production') { + console.warn(`value cannot be made reactive: ${String(target)}`) + } + return target + } + // target is already a Proxy, return it. + // exception: calling readonly() on a reactive object + if ( + target['__v_raw' /* RAW */] && + !(isReadonly && target['__v_isReactive' /* IS_REACTIVE */]) + ) { + return target + } + // target already has corresponding Proxy + const proxyMap = isReadonly ? readonlyMap : reactiveMap + const existingProxy = proxyMap.get(target) + if (existingProxy) { + return existingProxy + } + // only a whitelist of value types can be observed. + const targetType = getTargetType(target) + if (targetType === 0 /* INVALID */) { + return target + } + const proxy = new Proxy( + target, + targetType === 2 /* COLLECTION */ ? collectionHandlers : baseHandlers + ) + proxyMap.set(target, proxy) + return proxy +} +function isReactive(value) { + if (isReadonly(value)) { + return isReactive(value['__v_raw' /* RAW */]) + } + return !!(value && value['__v_isReactive' /* IS_REACTIVE */]) +} +function isReadonly(value) { + return !!(value && value['__v_isReadonly' /* IS_READONLY */]) +} +function isProxy(value) { + return isReactive(value) || isReadonly(value) +} +function toRaw(observed) { + return (observed && toRaw(observed['__v_raw' /* RAW */])) || observed +} +function markRaw(value) { + def(value, '__v_skip' /* SKIP */, true) + return value +} + +const convert = val => (isObject(val) ? reactive(val) : val) +function isRef(r) { + return Boolean(r && r.__v_isRef === true) +} +function ref(value) { + return createRef(value) +} +function shallowRef(value) { + return createRef(value, true) +} +class RefImpl { + constructor(_rawValue, _shallow = false) { + this._rawValue = _rawValue + this._shallow = _shallow + this.__v_isRef = true + this._value = _shallow ? _rawValue : convert(_rawValue) + } + get value() { + track(toRaw(this), 'get' /* GET */, 'value') + return this._value + } + set value(newVal) { + if (hasChanged(toRaw(newVal), this._rawValue)) { + this._rawValue = newVal + this._value = this._shallow ? newVal : convert(newVal) + trigger(toRaw(this), 'set' /* SET */, 'value', newVal) + } + } +} +function createRef(rawValue, shallow = false) { + if (isRef(rawValue)) { + return rawValue + } + return new RefImpl(rawValue, shallow) +} +function triggerRef(ref) { + trigger( + ref, + 'set' /* SET */, + 'value', + process.env.NODE_ENV !== 'production' ? ref.value : void 0 + ) +} +function unref(ref) { + return isRef(ref) ? ref.value : ref +} +const shallowUnwrapHandlers = { + get: (target, key, receiver) => unref(Reflect.get(target, key, receiver)), + set: (target, key, value, receiver) => { + const oldValue = target[key] + if (isRef(oldValue) && !isRef(value)) { + oldValue.value = value + return true + } else { + return Reflect.set(target, key, value, receiver) + } + } +} +function proxyRefs(objectWithRefs) { + return isReactive(objectWithRefs) + ? objectWithRefs + : new Proxy(objectWithRefs, shallowUnwrapHandlers) +} +class CustomRefImpl { + constructor(factory) { + this.__v_isRef = true + const { get, set } = factory( + () => track(this, 'get' /* GET */, 'value'), + () => trigger(this, 'set' /* SET */, 'value') + ) + this._get = get + this._set = set + } + get value() { + return this._get() + } + set value(newVal) { + this._set(newVal) + } +} +function customRef(factory) { + return new CustomRefImpl(factory) +} +function toRefs(object) { + if (process.env.NODE_ENV !== 'production' && !isProxy(object)) { + console.warn(`toRefs() expects a reactive object but received a plain one.`) + } + const ret = isArray(object) ? new Array(object.length) : {} + for (const key in object) { + ret[key] = toRef(object, key) + } + return ret +} +class ObjectRefImpl { + constructor(_object, _key) { + this._object = _object + this._key = _key + this.__v_isRef = true + } + get value() { + return this._object[this._key] + } + set value(newVal) { + this._object[this._key] = newVal + } +} +function toRef(object, key) { + return new ObjectRefImpl(object, key) +} + +class ComputedRefImpl { + constructor(getter, _setter, isReadonly) { + this._setter = _setter + this._dirty = true + this.__v_isRef = true + this.effect = effect(getter, { + lazy: true, + scheduler: () => { + if (!this._dirty) { + this._dirty = true + trigger(toRaw(this), 'set' /* SET */, 'value') + } + } + }) + this['__v_isReadonly' /* IS_READONLY */] = isReadonly + } + get value() { + if (this._dirty) { + this._value = this.effect() + this._dirty = false + } + track(toRaw(this), 'get' /* GET */, 'value') + return this._value + } + set value(newValue) { + this._setter(newValue) + } +} +function computed(getterOrOptions) { + let getter + let setter + if (isFunction(getterOrOptions)) { + getter = getterOrOptions + setter = + process.env.NODE_ENV !== 'production' + ? () => { + console.warn('Write operation failed: computed value is readonly') + } + : NOOP + } else { + getter = getterOrOptions.get + setter = getterOrOptions.set + } + return new ComputedRefImpl( + getter, + setter, + isFunction(getterOrOptions) || !getterOrOptions.set + ) +} + +const stack = [] +function pushWarningContext(vnode) { + stack.push(vnode) +} +function popWarningContext() { + stack.pop() +} +function warn(msg, ...args) { + // avoid props formatting or warn handler tracking deps that might be mutated + // during patch, leading to infinite recursion. + pauseTracking() + const instance = stack.length ? stack[stack.length - 1].component : null + const appWarnHandler = instance && instance.appContext.config.warnHandler + const trace = getComponentTrace() + if (appWarnHandler) { + callWithErrorHandling(appWarnHandler, instance, 11 /* APP_WARN_HANDLER */, [ + msg + args.join(''), + instance && instance.proxy, + trace + .map(({ vnode }) => `at <${formatComponentName(instance, vnode.type)}>`) + .join('\n'), + trace + ]) + } else { + const warnArgs = [`[Vue warn]: ${msg}`, ...args] + /* istanbul ignore if */ + if ( + trace.length && + // avoid spamming console during tests + !false + ) { + warnArgs.push(`\n`, ...formatTrace(trace)) + } + console.warn(...warnArgs) + } + resetTracking() +} +function getComponentTrace() { + let currentVNode = stack[stack.length - 1] + if (!currentVNode) { + return [] + } + // we can't just use the stack because it will be incomplete during updates + // that did not start from the root. Re-construct the parent chain using + // instance parent pointers. + const normalizedStack = [] + while (currentVNode) { + const last = normalizedStack[0] + if (last && last.vnode === currentVNode) { + last.recurseCount++ + } else { + normalizedStack.push({ + vnode: currentVNode, + recurseCount: 0 + }) + } + const parentInstance = + currentVNode.component && currentVNode.component.parent + currentVNode = parentInstance && parentInstance.vnode + } + return normalizedStack +} +/* istanbul ignore next */ +function formatTrace(trace) { + const logs = [] + trace.forEach((entry, i) => { + logs.push(...(i === 0 ? [] : [`\n`]), ...formatTraceEntry(entry)) + }) + return logs +} +function formatTraceEntry({ vnode, recurseCount }) { + const postfix = + recurseCount > 0 ? `... (${recurseCount} recursive calls)` : `` + const isRoot = vnode.component ? vnode.component.parent == null : false + const open = ` at <${formatComponentName( + vnode.component, + vnode.type, + isRoot + )}` + const close = `>` + postfix + return vnode.props + ? [open, ...formatProps(vnode.props), close] + : [open + close] +} +/* istanbul ignore next */ +function formatProps(props) { + const res = [] + const keys = Object.keys(props) + keys.slice(0, 3).forEach(key => { + res.push(...formatProp(key, props[key])) + }) + if (keys.length > 3) { + res.push(` ...`) + } + return res +} +/* istanbul ignore next */ +function formatProp(key, value, raw) { + if (isString(value)) { + value = JSON.stringify(value) + return raw ? value : [`${key}=${value}`] + } else if ( + typeof value === 'number' || + typeof value === 'boolean' || + value == null + ) { + return raw ? value : [`${key}=${value}`] + } else if (isRef(value)) { + value = formatProp(key, toRaw(value.value), true) + return raw ? value : [`${key}=Ref<`, value, `>`] + } else if (isFunction(value)) { + return [`${key}=fn${value.name ? `<${value.name}>` : ``}`] + } else { + value = toRaw(value) + return raw ? value : [`${key}=`, value] + } +} + +const ErrorTypeStrings = { + ['bc' /* BEFORE_CREATE */]: 'beforeCreate hook', + ['c' /* CREATED */]: 'created hook', + ['bm' /* BEFORE_MOUNT */]: 'beforeMount hook', + ['m' /* MOUNTED */]: 'mounted hook', + ['bu' /* BEFORE_UPDATE */]: 'beforeUpdate hook', + ['u' /* UPDATED */]: 'updated', + ['bum' /* BEFORE_UNMOUNT */]: 'beforeUnmount hook', + ['um' /* UNMOUNTED */]: 'unmounted hook', + ['a' /* ACTIVATED */]: 'activated hook', + ['da' /* DEACTIVATED */]: 'deactivated hook', + ['ec' /* ERROR_CAPTURED */]: 'errorCaptured hook', + ['rtc' /* RENDER_TRACKED */]: 'renderTracked hook', + ['rtg' /* RENDER_TRIGGERED */]: 'renderTriggered hook', + [0 /* SETUP_FUNCTION */]: 'setup function', + [1 /* RENDER_FUNCTION */]: 'render function', + [2 /* WATCH_GETTER */]: 'watcher getter', + [3 /* WATCH_CALLBACK */]: 'watcher callback', + [4 /* WATCH_CLEANUP */]: 'watcher cleanup function', + [5 /* NATIVE_EVENT_HANDLER */]: 'native event handler', + [6 /* COMPONENT_EVENT_HANDLER */]: 'component event handler', + [7 /* VNODE_HOOK */]: 'vnode hook', + [8 /* DIRECTIVE_HOOK */]: 'directive hook', + [9 /* TRANSITION_HOOK */]: 'transition hook', + [10 /* APP_ERROR_HANDLER */]: 'app errorHandler', + [11 /* APP_WARN_HANDLER */]: 'app warnHandler', + [12 /* FUNCTION_REF */]: 'ref function', + [13 /* ASYNC_COMPONENT_LOADER */]: 'async component loader', + [14 /* SCHEDULER */]: + 'scheduler flush. This is likely a Vue internals bug. ' + + 'Please open an issue at https://new-issue.vuejs.org/?repo=vuejs/vue-next' +} +function callWithErrorHandling(fn, instance, type, args) { + let res + try { + res = args ? fn(...args) : fn() + } catch (err) { + handleError(err, instance, type) + } + return res +} +function callWithAsyncErrorHandling(fn, instance, type, args) { + if (isFunction(fn)) { + const res = callWithErrorHandling(fn, instance, type, args) + if (res && isPromise(res)) { + res.catch(err => { + handleError(err, instance, type) + }) + } + return res + } + const values = [] + for (let i = 0; i < fn.length; i++) { + values.push(callWithAsyncErrorHandling(fn[i], instance, type, args)) + } + return values +} +function handleError(err, instance, type) { + const contextVNode = instance ? instance.vnode : null + if (instance) { + let cur = instance.parent + // the exposed instance is the render proxy to keep it consistent with 2.x + const exposedInstance = instance.proxy + // in production the hook receives only the error code + const errorInfo = + process.env.NODE_ENV !== 'production' ? ErrorTypeStrings[type] : type + while (cur) { + const errorCapturedHooks = cur.ec + if (errorCapturedHooks) { + for (let i = 0; i < errorCapturedHooks.length; i++) { + if (errorCapturedHooks[i](err, exposedInstance, errorInfo)) { + return + } + } + } + cur = cur.parent + } + // app-level handling + const appErrorHandler = instance.appContext.config.errorHandler + if (appErrorHandler) { + callWithErrorHandling(appErrorHandler, null, 10 /* APP_ERROR_HANDLER */, [ + err, + exposedInstance, + errorInfo + ]) + return + } + } + logError(err, type, contextVNode) +} +function logError(err, type, contextVNode) { + if (process.env.NODE_ENV !== 'production') { + const info = ErrorTypeStrings[type] + if (contextVNode) { + pushWarningContext(contextVNode) + } + warn(`Unhandled error${info ? ` during execution of ${info}` : ``}`) + if (contextVNode) { + popWarningContext() + } + // crash in dev so it's more noticeable + throw err + } else { + // recover in prod to reduce the impact on end-user + console.error(err) + } +} + +let isFlushing = false +let isFlushPending = false +const queue = [] +let flushIndex = 0 +const pendingPreFlushCbs = [] +let activePreFlushCbs = null +let preFlushIndex = 0 +const pendingPostFlushCbs = [] +let activePostFlushCbs = null +let postFlushIndex = 0 +const resolvedPromise = Promise.resolve() +let currentFlushPromise = null +let currentPreFlushParentJob = null +const RECURSION_LIMIT = 100 +function nextTick(fn) { + const p = currentFlushPromise || resolvedPromise + return fn ? p.then(fn) : p +} +function queueJob(job) { + // the dedupe search uses the startIndex argument of Array.includes() + // by default the search index includes the current job that is being run + // so it cannot recursively trigger itself again. + // if the job is a watch() callback, the search will start with a +1 index to + // allow it recursively trigger itself - it is the user's responsibility to + // ensure it doesn't end up in an infinite loop. + if ( + (!queue.length || + !queue.includes( + job, + isFlushing && job.allowRecurse ? flushIndex + 1 : flushIndex + )) && + job !== currentPreFlushParentJob + ) { + queue.push(job) + queueFlush() + } +} +function queueFlush() { + if (!isFlushing && !isFlushPending) { + isFlushPending = true + currentFlushPromise = resolvedPromise.then(flushJobs) + } +} +function invalidateJob(job) { + const i = queue.indexOf(job) + if (i > -1) { + queue[i] = null + } +} +function queueCb(cb, activeQueue, pendingQueue, index) { + if (!isArray(cb)) { + if ( + !activeQueue || + !activeQueue.includes(cb, cb.allowRecurse ? index + 1 : index) + ) { + pendingQueue.push(cb) + } + } else { + // if cb is an array, it is a component lifecycle hook which can only be + // triggered by a job, which is already deduped in the main queue, so + // we can skip duplicate check here to improve perf + pendingQueue.push(...cb) + } + queueFlush() +} +function queuePreFlushCb(cb) { + queueCb(cb, activePreFlushCbs, pendingPreFlushCbs, preFlushIndex) +} +function queuePostFlushCb(cb) { + queueCb(cb, activePostFlushCbs, pendingPostFlushCbs, postFlushIndex) +} +function flushPreFlushCbs(seen, parentJob = null) { + if (pendingPreFlushCbs.length) { + currentPreFlushParentJob = parentJob + activePreFlushCbs = [...new Set(pendingPreFlushCbs)] + pendingPreFlushCbs.length = 0 + if (process.env.NODE_ENV !== 'production') { + seen = seen || new Map() + } + for ( + preFlushIndex = 0; + preFlushIndex < activePreFlushCbs.length; + preFlushIndex++ + ) { + if (process.env.NODE_ENV !== 'production') { + checkRecursiveUpdates(seen, activePreFlushCbs[preFlushIndex]) + } + activePreFlushCbs[preFlushIndex]() + } + activePreFlushCbs = null + preFlushIndex = 0 + currentPreFlushParentJob = null + // recursively flush until it drains + flushPreFlushCbs(seen, parentJob) + } +} +function flushPostFlushCbs(seen) { + if (pendingPostFlushCbs.length) { + const deduped = [...new Set(pendingPostFlushCbs)] + pendingPostFlushCbs.length = 0 + // #1947 already has active queue, nested flushPostFlushCbs call + if (activePostFlushCbs) { + activePostFlushCbs.push(...deduped) + return + } + activePostFlushCbs = deduped + if (process.env.NODE_ENV !== 'production') { + seen = seen || new Map() + } + activePostFlushCbs.sort((a, b) => getId(a) - getId(b)) + for ( + postFlushIndex = 0; + postFlushIndex < activePostFlushCbs.length; + postFlushIndex++ + ) { + if (process.env.NODE_ENV !== 'production') { + checkRecursiveUpdates(seen, activePostFlushCbs[postFlushIndex]) + } + activePostFlushCbs[postFlushIndex]() + } + activePostFlushCbs = null + postFlushIndex = 0 + } +} +const getId = job => (job.id == null ? Infinity : job.id) +function flushJobs(seen) { + isFlushPending = false + isFlushing = true + if (process.env.NODE_ENV !== 'production') { + seen = seen || new Map() + } + flushPreFlushCbs(seen) + // Sort queue before flush. + // This ensures that: + // 1. Components are updated from parent to child. (because parent is always + // created before the child so its render effect will have smaller + // priority number) + // 2. If a component is unmounted during a parent component's update, + // its update can be skipped. + // Jobs can never be null before flush starts, since they are only invalidated + // during execution of another flushed job. + queue.sort((a, b) => getId(a) - getId(b)) + try { + for (flushIndex = 0; flushIndex < queue.length; flushIndex++) { + const job = queue[flushIndex] + if (job) { + if (process.env.NODE_ENV !== 'production') { + checkRecursiveUpdates(seen, job) + } + callWithErrorHandling(job, null, 14 /* SCHEDULER */) + } + } + } finally { + flushIndex = 0 + queue.length = 0 + flushPostFlushCbs(seen) + isFlushing = false + currentFlushPromise = null + // some postFlushCb queued jobs! + // keep flushing until it drains. + if (queue.length || pendingPostFlushCbs.length) { + flushJobs(seen) + } + } +} +function checkRecursiveUpdates(seen, fn) { + if (!seen.has(fn)) { + seen.set(fn, 1) + } else { + const count = seen.get(fn) + if (count > RECURSION_LIMIT) { + throw new Error( + `Maximum recursive updates exceeded. ` + + `This means you have a reactive effect that is mutating its own ` + + `dependencies and thus recursively triggering itself. Possible sources ` + + `include component template, render function, updated hook or ` + + `watcher source function.` + ) + } else { + seen.set(fn, count + 1) + } + } +} + +let isHmrUpdating = false +const hmrDirtyComponents = new Set() +// Expose the HMR runtime on the global object +// This makes it entirely tree-shakable without polluting the exports and makes +// it easier to be used in toolings like vue-loader +// Note: for a component to be eligible for HMR it also needs the __hmrId option +// to be set so that its instances can be registered / removed. +if (process.env.NODE_ENV !== 'production') { + const globalObject = + typeof global !== 'undefined' + ? global + : typeof self !== 'undefined' + ? self + : typeof window !== 'undefined' + ? window + : {} + globalObject.__VUE_HMR_RUNTIME__ = { + createRecord: tryWrap(createRecord), + rerender: tryWrap(rerender), + reload: tryWrap(reload) + } +} +const map = new Map() +function registerHMR(instance) { + const id = instance.type.__hmrId + let record = map.get(id) + if (!record) { + createRecord(id) + record = map.get(id) + } + record.add(instance) +} +function unregisterHMR(instance) { + map.get(instance.type.__hmrId).delete(instance) +} +function createRecord(id) { + if (map.has(id)) { + return false + } + map.set(id, new Set()) + return true +} +function rerender(id, newRender) { + const record = map.get(id) + if (!record) return + // Array.from creates a snapshot which avoids the set being mutated during + // updates + Array.from(record).forEach(instance => { + if (newRender) { + instance.render = newRender + } + instance.renderCache = [] + // this flag forces child components with slot content to update + isHmrUpdating = true + instance.update() + isHmrUpdating = false + }) +} +function reload(id, newComp) { + const record = map.get(id) + if (!record) return + // Array.from creates a snapshot which avoids the set being mutated during + // updates + Array.from(record).forEach(instance => { + const comp = instance.type + if (!hmrDirtyComponents.has(comp)) { + // 1. Update existing comp definition to match new one + extend(comp, newComp) + for (const key in comp) { + if (!(key in newComp)) { + delete comp[key] + } + } + // 2. Mark component dirty. This forces the renderer to replace the component + // on patch. + hmrDirtyComponents.add(comp) + // 3. Make sure to unmark the component after the reload. + queuePostFlushCb(() => { + hmrDirtyComponents.delete(comp) + }) + } + if (instance.parent) { + // 4. Force the parent instance to re-render. This will cause all updated + // components to be unmounted and re-mounted. Queue the update so that we + // don't end up forcing the same parent to re-render multiple times. + queueJob(instance.parent.update) + } else if (instance.appContext.reload) { + // root instance mounted via createApp() has a reload method + instance.appContext.reload() + } else if (typeof window !== 'undefined') { + // root instance inside tree created via raw render(). Force reload. + window.location.reload() + } else { + console.warn( + '[HMR] Root or manually mounted instance modified. Full reload required.' + ) + } + }) +} +function tryWrap(fn) { + return (id, arg) => { + try { + return fn(id, arg) + } catch (e) { + console.error(e) + console.warn( + `[HMR] Something went wrong during Vue component hot-reload. ` + + `Full reload required.` + ) + } + } +} + +// mark the current rendering instance for asset resolution (e.g. +// resolveComponent, resolveDirective) during render +let currentRenderingInstance = null +function setCurrentRenderingInstance(instance) { + currentRenderingInstance = instance +} +// dev only flag to track whether $attrs was used during render. +// If $attrs was used during render then the warning for failed attrs +// fallthrough can be suppressed. +let accessedAttrs = false +function markAttrsAccessed() { + accessedAttrs = true +} +function renderComponentRoot(instance) { + const { + type: Component, + vnode, + proxy, + withProxy, + props, + propsOptions: [propsOptions], + slots, + attrs, + emit, + render, + renderCache, + data, + setupState, + ctx + } = instance + let result + currentRenderingInstance = instance + if (process.env.NODE_ENV !== 'production') { + accessedAttrs = false + } + try { + let fallthroughAttrs + if (vnode.shapeFlag & 4 /* STATEFUL_COMPONENT */) { + // withProxy is a proxy with a different `has` trap only for + // runtime-compiled render functions using `with` block. + const proxyToUse = withProxy || proxy + result = normalizeVNode( + render.call( + proxyToUse, + proxyToUse, + renderCache, + props, + setupState, + data, + ctx + ) + ) + fallthroughAttrs = attrs + } else { + // functional + const render = Component + // in dev, mark attrs accessed if optional props (attrs === props) + if (process.env.NODE_ENV !== 'production' && attrs === props) { + markAttrsAccessed() + } + result = normalizeVNode( + render.length > 1 + ? render( + props, + process.env.NODE_ENV !== 'production' + ? { + get attrs() { + markAttrsAccessed() + return attrs + }, + slots, + emit + } + : { attrs, slots, emit } + ) + : render(props, null /* we know it doesn't need it */) + ) + fallthroughAttrs = Component.props + ? attrs + : getFunctionalFallthrough(attrs) + } + // attr merging + // in dev mode, comments are preserved, and it's possible for a template + // to have comments along side the root element which makes it a fragment + let root = result + let setRoot = undefined + if (process.env.NODE_ENV !== 'production') { + ;[root, setRoot] = getChildRoot(result) + } + if (Component.inheritAttrs !== false && fallthroughAttrs) { + const keys = Object.keys(fallthroughAttrs) + const { shapeFlag } = root + if (keys.length) { + if (shapeFlag & 1 /* ELEMENT */ || shapeFlag & 6 /* COMPONENT */) { + if (propsOptions && keys.some(isModelListener)) { + // If a v-model listener (onUpdate:xxx) has a corresponding declared + // prop, it indicates this component expects to handle v-model and + // it should not fallthrough. + // related: #1543, #1643, #1989 + fallthroughAttrs = filterModelListeners( + fallthroughAttrs, + propsOptions + ) + } + root = cloneVNode(root, fallthroughAttrs) + } else if ( + process.env.NODE_ENV !== 'production' && + !accessedAttrs && + root.type !== Comment + ) { + const allAttrs = Object.keys(attrs) + const eventAttrs = [] + const extraAttrs = [] + for (let i = 0, l = allAttrs.length; i < l; i++) { + const key = allAttrs[i] + if (isOn(key)) { + // ignore v-model handlers when they fail to fallthrough + if (!isModelListener(key)) { + // remove `on`, lowercase first letter to reflect event casing + // accurately + eventAttrs.push(key[2].toLowerCase() + key.slice(3)) + } + } else { + extraAttrs.push(key) + } + } + if (extraAttrs.length) { + warn( + `Extraneous non-props attributes (` + + `${extraAttrs.join(', ')}) ` + + `were passed to component but could not be automatically inherited ` + + `because component renders fragment or text root nodes.` + ) + } + if (eventAttrs.length) { + warn( + `Extraneous non-emits event listeners (` + + `${eventAttrs.join(', ')}) ` + + `were passed to component but could not be automatically inherited ` + + `because component renders fragment or text root nodes. ` + + `If the listener is intended to be a component custom event listener only, ` + + `declare it using the "emits" option.` + ) + } + } + } + } + // inherit directives + if (vnode.dirs) { + if (process.env.NODE_ENV !== 'production' && !isElementRoot(root)) { + warn( + `Runtime directive used on component with non-element root node. ` + + `The directives will not function as intended.` + ) + } + root.dirs = vnode.dirs + } + // inherit transition data + if (vnode.transition) { + if (process.env.NODE_ENV !== 'production' && !isElementRoot(root)) { + warn( + `Component inside renders non-element root node ` + + `that cannot be animated.` + ) + } + root.transition = vnode.transition + } + if (process.env.NODE_ENV !== 'production' && setRoot) { + setRoot(root) + } else { + result = root + } + } catch (err) { + handleError(err, instance, 1 /* RENDER_FUNCTION */) + result = createVNode(Comment) + } + currentRenderingInstance = null + return result +} +/** + * dev only + */ +const getChildRoot = vnode => { + if (vnode.type !== Fragment) { + return [vnode, undefined] + } + const rawChildren = vnode.children + const dynamicChildren = vnode.dynamicChildren + const children = rawChildren.filter(child => { + return !( + isVNode(child) && + child.type === Comment && + child.children !== 'v-if' + ) + }) + if (children.length !== 1) { + return [vnode, undefined] + } + const childRoot = children[0] + const index = rawChildren.indexOf(childRoot) + const dynamicIndex = dynamicChildren ? dynamicChildren.indexOf(childRoot) : -1 + const setRoot = updatedRoot => { + rawChildren[index] = updatedRoot + if (dynamicIndex > -1) { + dynamicChildren[dynamicIndex] = updatedRoot + } else if (dynamicChildren && updatedRoot.patchFlag > 0) { + dynamicChildren.push(updatedRoot) + } + } + return [normalizeVNode(childRoot), setRoot] +} +const getFunctionalFallthrough = attrs => { + let res + for (const key in attrs) { + if (key === 'class' || key === 'style' || isOn(key)) { + ;(res || (res = {}))[key] = attrs[key] + } + } + return res +} +const filterModelListeners = (attrs, props) => { + const res = {} + for (const key in attrs) { + if (!isModelListener(key) || !(key.slice(9) in props)) { + res[key] = attrs[key] + } + } + return res +} +const isElementRoot = vnode => { + return ( + vnode.shapeFlag & 6 /* COMPONENT */ || + vnode.shapeFlag & 1 /* ELEMENT */ || + vnode.type === Comment // potential v-if branch switch + ) +} +function shouldUpdateComponent(prevVNode, nextVNode, optimized) { + const { props: prevProps, children: prevChildren } = prevVNode + const { props: nextProps, children: nextChildren, patchFlag } = nextVNode + // Parent component's render function was hot-updated. Since this may have + // caused the child component's slots content to have changed, we need to + // force the child to update as well. + if ( + process.env.NODE_ENV !== 'production' && + (prevChildren || nextChildren) && + isHmrUpdating + ) { + return true + } + // force child update for runtime directive or transition on component vnode. + if (nextVNode.dirs || nextVNode.transition) { + return true + } + if (optimized && patchFlag > 0) { + if (patchFlag & 1024 /* DYNAMIC_SLOTS */) { + // slot content that references values that might have changed, + // e.g. in a v-for + return true + } + if (patchFlag & 16 /* FULL_PROPS */) { + if (!prevProps) { + return !!nextProps + } + // presence of this flag indicates props are always non-null + return hasPropsChanged(prevProps, nextProps) + } else if (patchFlag & 8 /* PROPS */) { + const dynamicProps = nextVNode.dynamicProps + for (let i = 0; i < dynamicProps.length; i++) { + const key = dynamicProps[i] + if (nextProps[key] !== prevProps[key]) { + return true + } + } + } + } else { + // this path is only taken by manually written render functions + // so presence of any children leads to a forced update + if (prevChildren || nextChildren) { + if (!nextChildren || !nextChildren.$stable) { + return true + } + } + if (prevProps === nextProps) { + return false + } + if (!prevProps) { + return !!nextProps + } + if (!nextProps) { + return true + } + return hasPropsChanged(prevProps, nextProps) + } + return false +} +function hasPropsChanged(prevProps, nextProps) { + const nextKeys = Object.keys(nextProps) + if (nextKeys.length !== Object.keys(prevProps).length) { + return true + } + for (let i = 0; i < nextKeys.length; i++) { + const key = nextKeys[i] + if (nextProps[key] !== prevProps[key]) { + return true + } + } + return false +} +function updateHOCHostEl( + { vnode, parent }, + el // HostNode +) { + while (parent && parent.subTree === vnode) { + ;(vnode = parent.vnode).el = el + parent = parent.parent + } +} + +const isSuspense = type => type.__isSuspense +// Suspense exposes a component-like API, and is treated like a component +// in the compiler, but internally it's a special built-in type that hooks +// directly into the renderer. +const SuspenseImpl = { + // In order to make Suspense tree-shakable, we need to avoid importing it + // directly in the renderer. The renderer checks for the __isSuspense flag + // on a vnode's type and calls the `process` method, passing in renderer + // internals. + __isSuspense: true, + process( + n1, + n2, + container, + anchor, + parentComponent, + parentSuspense, + isSVG, + optimized, + // platform-specific impl passed from renderer + rendererInternals + ) { + if (n1 == null) { + mountSuspense( + n2, + container, + anchor, + parentComponent, + parentSuspense, + isSVG, + optimized, + rendererInternals + ) + } else { + patchSuspense( + n1, + n2, + container, + anchor, + parentComponent, + isSVG, + optimized, + rendererInternals + ) + } + }, + hydrate: hydrateSuspense +} +// Force-casted public typing for h and TSX props inference +const Suspense = SuspenseImpl +function mountSuspense( + n2, + container, + anchor, + parentComponent, + parentSuspense, + isSVG, + optimized, + rendererInternals +) { + const { + p: patch, + o: { createElement } + } = rendererInternals + const hiddenContainer = createElement('div') + const suspense = (n2.suspense = createSuspenseBoundary( + n2, + parentSuspense, + parentComponent, + container, + hiddenContainer, + anchor, + isSVG, + optimized, + rendererInternals + )) + // start mounting the content subtree in an off-dom container + patch( + null, + suspense.subTree, + hiddenContainer, + null, + parentComponent, + suspense, + isSVG, + optimized + ) + // now check if we have encountered any async deps + if (suspense.deps > 0) { + // mount the fallback tree + patch( + null, + suspense.fallbackTree, + container, + anchor, + parentComponent, + null, // fallback tree will not have suspense context + isSVG, + optimized + ) + n2.el = suspense.fallbackTree.el + } else { + // Suspense has no async deps. Just resolve. + suspense.resolve() + } +} +function patchSuspense( + n1, + n2, + container, + anchor, + parentComponent, + isSVG, + optimized, + { p: patch } +) { + const suspense = (n2.suspense = n1.suspense) + suspense.vnode = n2 + const { content, fallback } = normalizeSuspenseChildren(n2) + const oldSubTree = suspense.subTree + const oldFallbackTree = suspense.fallbackTree + if (!suspense.isResolved) { + patch( + oldSubTree, + content, + suspense.hiddenContainer, + null, + parentComponent, + suspense, + isSVG, + optimized + ) + if (suspense.deps > 0) { + // still pending. patch the fallback tree. + patch( + oldFallbackTree, + fallback, + container, + anchor, + parentComponent, + null, // fallback tree will not have suspense context + isSVG, + optimized + ) + n2.el = fallback.el + } + // If deps somehow becomes 0 after the patch it means the patch caused an + // async dep component to unmount and removed its dep. It will cause the + // suspense to resolve and we don't need to do anything here. + } else { + // just normal patch inner content as a fragment + patch( + oldSubTree, + content, + container, + anchor, + parentComponent, + suspense, + isSVG, + optimized + ) + n2.el = content.el + } + suspense.subTree = content + suspense.fallbackTree = fallback +} +let hasWarned = false +function createSuspenseBoundary( + vnode, + parent, + parentComponent, + container, + hiddenContainer, + anchor, + isSVG, + optimized, + rendererInternals, + isHydrating = false +) { + /* istanbul ignore if */ + if (process.env.NODE_ENV !== 'production' && !false && !hasWarned) { + hasWarned = true + // @ts-ignore `console.info` cannot be null error + console[console.info ? 'info' : 'log']( + ` is an experimental feature and its API will likely change.` + ) + } + const { + p: patch, + m: move, + um: unmount, + n: next, + o: { parentNode } + } = rendererInternals + const getCurrentTree = () => + suspense.isResolved || suspense.isHydrating + ? suspense.subTree + : suspense.fallbackTree + const { content, fallback } = normalizeSuspenseChildren(vnode) + const suspense = { + vnode, + parent, + parentComponent, + isSVG, + optimized, + container, + hiddenContainer, + anchor, + deps: 0, + subTree: content, + fallbackTree: fallback, + isHydrating, + isResolved: false, + isUnmounted: false, + effects: [], + resolve() { + if (process.env.NODE_ENV !== 'production') { + if (suspense.isResolved) { + throw new Error( + `resolveSuspense() is called on an already resolved suspense boundary.` + ) + } + if (suspense.isUnmounted) { + throw new Error( + `resolveSuspense() is called on an already unmounted suspense boundary.` + ) + } + } + const { + vnode, + subTree, + fallbackTree, + effects, + parentComponent, + container + } = suspense + if (suspense.isHydrating) { + suspense.isHydrating = false + } else { + // this is initial anchor on mount + let { anchor } = suspense + // unmount fallback tree + if (fallbackTree.el) { + // if the fallback tree was mounted, it may have been moved + // as part of a parent suspense. get the latest anchor for insertion + anchor = next(fallbackTree) + unmount(fallbackTree, parentComponent, suspense, true) + } + // move content from off-dom container to actual container + move(subTree, container, anchor, 0 /* ENTER */) + } + const el = (vnode.el = subTree.el) + // suspense as the root node of a component... + if (parentComponent && parentComponent.subTree === vnode) { + parentComponent.vnode.el = el + updateHOCHostEl(parentComponent, el) + } + // check if there is a pending parent suspense + let parent = suspense.parent + let hasUnresolvedAncestor = false + while (parent) { + if (!parent.isResolved) { + // found a pending parent suspense, merge buffered post jobs + // into that parent + parent.effects.push(...effects) + hasUnresolvedAncestor = true + break + } + parent = parent.parent + } + // no pending parent suspense, flush all jobs + if (!hasUnresolvedAncestor) { + queuePostFlushCb(effects) + } + suspense.isResolved = true + suspense.effects = [] + // invoke @resolve event + const onResolve = vnode.props && vnode.props.onResolve + if (isFunction(onResolve)) { + onResolve() + } + }, + recede() { + suspense.isResolved = false + const { + vnode, + subTree, + fallbackTree, + parentComponent, + container, + hiddenContainer, + isSVG, + optimized + } = suspense + // move content tree back to the off-dom container + const anchor = next(subTree) + move(subTree, hiddenContainer, null, 1 /* LEAVE */) + // remount the fallback tree + patch( + null, + fallbackTree, + container, + anchor, + parentComponent, + null, // fallback tree will not have suspense context + isSVG, + optimized + ) + const el = (vnode.el = fallbackTree.el) + // suspense as the root node of a component... + if (parentComponent && parentComponent.subTree === vnode) { + parentComponent.vnode.el = el + updateHOCHostEl(parentComponent, el) + } + // invoke @recede event + const onRecede = vnode.props && vnode.props.onRecede + if (isFunction(onRecede)) { + onRecede() + } + }, + move(container, anchor, type) { + move(getCurrentTree(), container, anchor, type) + suspense.container = container + }, + next() { + return next(getCurrentTree()) + }, + registerDep(instance, setupRenderEffect) { + // suspense is already resolved, need to recede. + // use queueJob so it's handled synchronously after patching the current + // suspense tree + if (suspense.isResolved) { + queueJob(() => { + suspense.recede() + }) + } + const hydratedEl = instance.vnode.el + suspense.deps++ + instance.asyncDep + .catch(err => { + handleError(err, instance, 0 /* SETUP_FUNCTION */) + }) + .then(asyncSetupResult => { + // retry when the setup() promise resolves. + // component may have been unmounted before resolve. + if (instance.isUnmounted || suspense.isUnmounted) { + return + } + suspense.deps-- + // retry from this component + instance.asyncResolved = true + const { vnode } = instance + if (process.env.NODE_ENV !== 'production') { + pushWarningContext(vnode) + } + handleSetupResult(instance, asyncSetupResult) + if (hydratedEl) { + // vnode may have been replaced if an update happened before the + // async dep is resolved. + vnode.el = hydratedEl + } + setupRenderEffect( + instance, + vnode, + // component may have been moved before resolve. + // if this is not a hydration, instance.subTree will be the comment + // placeholder. + hydratedEl + ? parentNode(hydratedEl) + : parentNode(instance.subTree.el), + // anchor will not be used if this is hydration, so only need to + // consider the comment placeholder case. + hydratedEl ? null : next(instance.subTree), + suspense, + isSVG, + optimized + ) + updateHOCHostEl(instance, vnode.el) + if (process.env.NODE_ENV !== 'production') { + popWarningContext() + } + if (suspense.deps === 0) { + suspense.resolve() + } + }) + }, + unmount(parentSuspense, doRemove) { + suspense.isUnmounted = true + unmount(suspense.subTree, parentComponent, parentSuspense, doRemove) + if (!suspense.isResolved) { + unmount( + suspense.fallbackTree, + parentComponent, + parentSuspense, + doRemove + ) + } + } + } + return suspense +} +function hydrateSuspense( + node, + vnode, + parentComponent, + parentSuspense, + isSVG, + optimized, + rendererInternals, + hydrateNode +) { + /* eslint-disable no-restricted-globals */ + const suspense = (vnode.suspense = createSuspenseBoundary( + vnode, + parentSuspense, + parentComponent, + node.parentNode, + document.createElement('div'), + null, + isSVG, + optimized, + rendererInternals, + true /* hydrating */ + )) + // there are two possible scenarios for server-rendered suspense: + // - success: ssr content should be fully resolved + // - failure: ssr content should be the fallback branch. + // however, on the client we don't really know if it has failed or not + // attempt to hydrate the DOM assuming it has succeeded, but we still + // need to construct a suspense boundary first + const result = hydrateNode( + node, + suspense.subTree, + parentComponent, + suspense, + optimized + ) + if (suspense.deps === 0) { + suspense.resolve() + } + return result + /* eslint-enable no-restricted-globals */ +} +function normalizeSuspenseChildren(vnode) { + const { shapeFlag, children } = vnode + if (shapeFlag & 32 /* SLOTS_CHILDREN */) { + const { default: d, fallback } = children + return { + content: normalizeVNode(isFunction(d) ? d() : d), + fallback: normalizeVNode(isFunction(fallback) ? fallback() : fallback) + } + } else { + return { + content: normalizeVNode(children), + fallback: normalizeVNode(null) + } + } +} +function queueEffectWithSuspense(fn, suspense) { + if (suspense && !suspense.isResolved) { + if (isArray(fn)) { + suspense.effects.push(...fn) + } else { + suspense.effects.push(fn) + } + } else { + queuePostFlushCb(fn) + } +} + +let isRenderingCompiledSlot = 0 +const setCompiledSlotRendering = n => (isRenderingCompiledSlot += n) +/** + * Compiler runtime helper for rendering `` + * @private + */ +function renderSlot( + slots, + name, + props = {}, + // this is not a user-facing function, so the fallback is always generated by + // the compiler and guaranteed to be a function returning an array + fallback +) { + let slot = slots[name] + if (process.env.NODE_ENV !== 'production' && slot && slot.length > 1) { + warn( + `SSR-optimized slot function detected in a non-SSR-optimized render ` + + `function. You need to mark this component with $dynamic-slots in the ` + + `parent template.` + ) + slot = () => [] + } + // a compiled slot disables block tracking by default to avoid manual + // invocation interfering with template-based block tracking, but in + // `renderSlot` we can be sure that it's template-based so we can force + // enable it. + isRenderingCompiledSlot++ + const rendered = (openBlock(), + createBlock( + Fragment, + { key: props.key }, + slot ? slot(props) : fallback ? fallback() : [], + slots._ === 1 /* STABLE */ ? 64 /* STABLE_FRAGMENT */ : -2 /* BAIL */ + )) + isRenderingCompiledSlot-- + return rendered +} + +/** + * Wrap a slot function to memoize current rendering instance + * @private + */ +function withCtx(fn, ctx = currentRenderingInstance) { + if (!ctx) return fn + const renderFnWithContext = (...args) => { + // If a user calls a compiled slot inside a template expression (#1745), it + // can mess up block tracking, so by default we need to push a null block to + // avoid that. This isn't necessary if rendering a compiled ``. + if (!isRenderingCompiledSlot) { + openBlock(true /* null block that disables tracking */) + } + const owner = currentRenderingInstance + setCurrentRenderingInstance(ctx) + const res = fn(...args) + setCurrentRenderingInstance(owner) + if (!isRenderingCompiledSlot) { + closeBlock() + } + return res + } + renderFnWithContext._c = true + return renderFnWithContext +} + +// SFC scoped style ID management. +let currentScopeId = null +const scopeIdStack = [] +/** + * @private + */ +function pushScopeId(id) { + scopeIdStack.push((currentScopeId = id)) +} +/** + * @private + */ +function popScopeId() { + scopeIdStack.pop() + currentScopeId = scopeIdStack[scopeIdStack.length - 1] || null +} +/** + * @private + */ +function withScopeId(id) { + return fn => + withCtx(function() { + pushScopeId(id) + const res = fn.apply(this, arguments) + popScopeId() + return res + }) +} + +const isTeleport = type => type.__isTeleport +const isTeleportDisabled = props => + props && (props.disabled || props.disabled === '') +const resolveTarget = (props, select) => { + const targetSelector = props && props.to + if (isString(targetSelector)) { + if (!select) { + process.env.NODE_ENV !== 'production' && + warn( + `Current renderer does not support string target for Teleports. ` + + `(missing querySelector renderer option)` + ) + return null + } else { + const target = select(targetSelector) + if (!target) { + process.env.NODE_ENV !== 'production' && + warn( + `Failed to locate Teleport target with selector "${targetSelector}". ` + + `Note the target element must exist before the component is mounted - ` + + `i.e. the target cannot be rendered by the component itself, and ` + + `ideally should be outside of the entire Vue component tree.` + ) + } + return target + } + } else { + if ( + process.env.NODE_ENV !== 'production' && + !targetSelector && + !isTeleportDisabled(props) + ) { + warn(`Invalid Teleport target: ${targetSelector}`) + } + return targetSelector + } +} +const TeleportImpl = { + __isTeleport: true, + process( + n1, + n2, + container, + anchor, + parentComponent, + parentSuspense, + isSVG, + optimized, + internals + ) { + const { + mc: mountChildren, + pc: patchChildren, + pbc: patchBlockChildren, + o: { insert, querySelector, createText, createComment } + } = internals + const disabled = isTeleportDisabled(n2.props) + const { shapeFlag, children } = n2 + if (n1 == null) { + // insert anchors in the main view + const placeholder = (n2.el = + process.env.NODE_ENV !== 'production' + ? createComment('teleport start') + : createText('')) + const mainAnchor = (n2.anchor = + process.env.NODE_ENV !== 'production' + ? createComment('teleport end') + : createText('')) + insert(placeholder, container, anchor) + insert(mainAnchor, container, anchor) + const target = (n2.target = resolveTarget(n2.props, querySelector)) + const targetAnchor = (n2.targetAnchor = createText('')) + if (target) { + insert(targetAnchor, target) + } else if (process.env.NODE_ENV !== 'production' && !disabled) { + warn('Invalid Teleport target on mount:', target, `(${typeof target})`) + } + const mount = (container, anchor) => { + // Teleport *always* has Array children. This is enforced in both the + // compiler and vnode children normalization. + if (shapeFlag & 16 /* ARRAY_CHILDREN */) { + mountChildren( + children, + container, + anchor, + parentComponent, + parentSuspense, + isSVG, + optimized + ) + } + } + if (disabled) { + mount(container, mainAnchor) + } else if (target) { + mount(target, targetAnchor) + } + } else { + // update content + n2.el = n1.el + const mainAnchor = (n2.anchor = n1.anchor) + const target = (n2.target = n1.target) + const targetAnchor = (n2.targetAnchor = n1.targetAnchor) + const wasDisabled = isTeleportDisabled(n1.props) + const currentContainer = wasDisabled ? container : target + const currentAnchor = wasDisabled ? mainAnchor : targetAnchor + if (n2.dynamicChildren) { + // fast path when the teleport happens to be a block root + patchBlockChildren( + n1.dynamicChildren, + n2.dynamicChildren, + currentContainer, + parentComponent, + parentSuspense, + isSVG + ) + // even in block tree mode we need to make sure all root-level nodes + // in the teleport inherit previous DOM references so that they can + // be moved in future patches. + if (n2.shapeFlag & 16 /* ARRAY_CHILDREN */) { + const oldChildren = n1.children + const children = n2.children + for (let i = 0; i < children.length; i++) { + // only inherit for non-patched nodes (i.e. static ones) + if (!children[i].el) { + children[i].el = oldChildren[i].el + } + } + } + } else if (!optimized) { + patchChildren( + n1, + n2, + currentContainer, + currentAnchor, + parentComponent, + parentSuspense, + isSVG + ) + } + if (disabled) { + if (!wasDisabled) { + // enabled -> disabled + // move into main container + moveTeleport(n2, container, mainAnchor, internals, 1 /* TOGGLE */) + } + } else { + // target changed + if ((n2.props && n2.props.to) !== (n1.props && n1.props.to)) { + const nextTarget = (n2.target = resolveTarget( + n2.props, + querySelector + )) + if (nextTarget) { + moveTeleport(n2, nextTarget, null, internals, 0 /* TARGET_CHANGE */) + } else if (process.env.NODE_ENV !== 'production') { + warn( + 'Invalid Teleport target on update:', + target, + `(${typeof target})` + ) + } + } else if (wasDisabled) { + // disabled -> enabled + // move into teleport target + moveTeleport(n2, target, targetAnchor, internals, 1 /* TOGGLE */) + } + } + } + }, + remove( + vnode, + { + r: remove, + o: { remove: hostRemove } + } + ) { + const { shapeFlag, children, anchor } = vnode + hostRemove(anchor) + if (shapeFlag & 16 /* ARRAY_CHILDREN */) { + for (let i = 0; i < children.length; i++) { + remove(children[i]) + } + } + }, + move: moveTeleport, + hydrate: hydrateTeleport +} +function moveTeleport( + vnode, + container, + parentAnchor, + { o: { insert }, m: move }, + moveType = 2 /* REORDER */ +) { + // move target anchor if this is a target change. + if (moveType === 0 /* TARGET_CHANGE */) { + insert(vnode.targetAnchor, container, parentAnchor) + } + const { el, anchor, shapeFlag, children, props } = vnode + const isReorder = moveType === 2 /* REORDER */ + // move main view anchor if this is a re-order. + if (isReorder) { + insert(el, container, parentAnchor) + } + // if this is a re-order and teleport is enabled (content is in target) + // do not move children. So the opposite is: only move children if this + // is not a reorder, or the teleport is disabled + if (!isReorder || isTeleportDisabled(props)) { + // Teleport has either Array children or no children. + if (shapeFlag & 16 /* ARRAY_CHILDREN */) { + for (let i = 0; i < children.length; i++) { + move(children[i], container, parentAnchor, 2 /* REORDER */) + } + } + } + // move main view anchor if this is a re-order. + if (isReorder) { + insert(anchor, container, parentAnchor) + } +} +function hydrateTeleport( + node, + vnode, + parentComponent, + parentSuspense, + optimized, + { o: { nextSibling, parentNode, querySelector } }, + hydrateChildren +) { + const target = (vnode.target = resolveTarget(vnode.props, querySelector)) + if (target) { + // if multiple teleports rendered to the same target element, we need to + // pick up from where the last teleport finished instead of the first node + const targetNode = target._lpa || target.firstChild + if (vnode.shapeFlag & 16 /* ARRAY_CHILDREN */) { + if (isTeleportDisabled(vnode.props)) { + vnode.anchor = hydrateChildren( + nextSibling(node), + vnode, + parentNode(node), + parentComponent, + parentSuspense, + optimized + ) + vnode.targetAnchor = targetNode + } else { + vnode.anchor = nextSibling(node) + vnode.targetAnchor = hydrateChildren( + targetNode, + vnode, + target, + parentComponent, + parentSuspense, + optimized + ) + } + target._lpa = vnode.targetAnchor && nextSibling(vnode.targetAnchor) + } + } + return vnode.anchor && nextSibling(vnode.anchor) +} +// Force-casted public typing for h and TSX props inference +const Teleport = TeleportImpl + +const COMPONENTS = 'components' +const DIRECTIVES = 'directives' +/** + * @private + */ +function resolveComponent(name) { + return resolveAsset(COMPONENTS, name) || name +} +const NULL_DYNAMIC_COMPONENT = Symbol() +/** + * @private + */ +function resolveDynamicComponent(component) { + if (isString(component)) { + return resolveAsset(COMPONENTS, component, false) || component + } else { + // invalid types will fallthrough to createVNode and raise warning + return component || NULL_DYNAMIC_COMPONENT + } +} +/** + * @private + */ +function resolveDirective(name) { + return resolveAsset(DIRECTIVES, name) +} +// implementation +function resolveAsset(type, name, warnMissing = true) { + const instance = currentRenderingInstance || currentInstance + if (instance) { + const Component = instance.type + // self name has highest priority + if (type === COMPONENTS) { + const selfName = Component.displayName || Component.name + if ( + selfName && + (selfName === name || + selfName === camelize(name) || + selfName === capitalize(camelize(name))) + ) { + return Component + } + } + const res = + // local registration + // check instance[type] first for components with mixin or extends. + resolve(instance[type] || Component[type], name) || + // global registration + resolve(instance.appContext[type], name) + if (process.env.NODE_ENV !== 'production' && warnMissing && !res) { + warn(`Failed to resolve ${type.slice(0, -1)}: ${name}`) + } + return res + } else if (process.env.NODE_ENV !== 'production') { + warn( + `resolve${capitalize(type.slice(0, -1))} ` + + `can only be used in render() or setup().` + ) + } +} +function resolve(registry, name) { + return ( + registry && + (registry[name] || + registry[camelize(name)] || + registry[capitalize(camelize(name))]) + ) +} + +const Fragment = Symbol( + process.env.NODE_ENV !== 'production' ? 'Fragment' : undefined +) +const Text = Symbol(process.env.NODE_ENV !== 'production' ? 'Text' : undefined) +const Comment = Symbol( + process.env.NODE_ENV !== 'production' ? 'Comment' : undefined +) +const Static = Symbol( + process.env.NODE_ENV !== 'production' ? 'Static' : undefined +) +// Since v-if and v-for are the two possible ways node structure can dynamically +// change, once we consider v-if branches and each v-for fragment a block, we +// can divide a template into nested blocks, and within each block the node +// structure would be stable. This allows us to skip most children diffing +// and only worry about the dynamic nodes (indicated by patch flags). +const blockStack = [] +let currentBlock = null +/** + * Open a block. + * This must be called before `createBlock`. It cannot be part of `createBlock` + * because the children of the block are evaluated before `createBlock` itself + * is called. The generated code typically looks like this: + * + * ```js + * function render() { + * return (openBlock(),createBlock('div', null, [...])) + * } + * ``` + * disableTracking is true when creating a v-for fragment block, since a v-for + * fragment always diffs its children. + * + * @private + */ +function openBlock(disableTracking = false) { + blockStack.push((currentBlock = disableTracking ? null : [])) +} +function closeBlock() { + blockStack.pop() + currentBlock = blockStack[blockStack.length - 1] || null +} +// Whether we should be tracking dynamic child nodes inside a block. +// Only tracks when this value is > 0 +// We are not using a simple boolean because this value may need to be +// incremented/decremented by nested usage of v-once (see below) +let shouldTrack$1 = 1 +/** + * Block tracking sometimes needs to be disabled, for example during the + * creation of a tree that needs to be cached by v-once. The compiler generates + * code like this: + * + * ``` js + * _cache[1] || ( + * setBlockTracking(-1), + * _cache[1] = createVNode(...), + * setBlockTracking(1), + * _cache[1] + * ) + * ``` + * + * @private + */ +function setBlockTracking(value) { + shouldTrack$1 += value +} +/** + * Create a block root vnode. Takes the same exact arguments as `createVNode`. + * A block root keeps track of dynamic nodes within the block in the + * `dynamicChildren` array. + * + * @private + */ +function createBlock(type, props, children, patchFlag, dynamicProps) { + const vnode = createVNode( + type, + props, + children, + patchFlag, + dynamicProps, + true /* isBlock: prevent a block from tracking itself */ + ) + // save current block children on the block vnode + vnode.dynamicChildren = currentBlock || EMPTY_ARR + // close block + closeBlock() + // a block is always going to be patched, so track it as a child of its + // parent block + if (shouldTrack$1 > 0 && currentBlock) { + currentBlock.push(vnode) + } + return vnode +} +function isVNode(value) { + return value ? value.__v_isVNode === true : false +} +function isSameVNodeType(n1, n2) { + if ( + process.env.NODE_ENV !== 'production' && + n2.shapeFlag & 6 /* COMPONENT */ && + hmrDirtyComponents.has(n2.type) + ) { + // HMR only: if the component has been hot-updated, force a reload. + return false + } + return n1.type === n2.type && n1.key === n2.key +} +let vnodeArgsTransformer +/** + * Internal API for registering an arguments transform for createVNode + * used for creating stubs in the test-utils + * It is *internal* but needs to be exposed for test-utils to pick up proper + * typings + */ +function transformVNodeArgs(transformer) { + vnodeArgsTransformer = transformer +} +const createVNodeWithArgsTransform = (...args) => { + return _createVNode( + ...(vnodeArgsTransformer + ? vnodeArgsTransformer(args, currentRenderingInstance) + : args) + ) +} +const InternalObjectKey = `__vInternal` +const normalizeKey = ({ key }) => (key != null ? key : null) +const normalizeRef = ({ ref }) => { + return ref != null + ? isArray(ref) + ? ref + : [currentRenderingInstance, ref] + : null +} +const createVNode = + process.env.NODE_ENV !== 'production' + ? createVNodeWithArgsTransform + : _createVNode +function _createVNode( + type, + props = null, + children = null, + patchFlag = 0, + dynamicProps = null, + isBlockNode = false +) { + if (!type || type === NULL_DYNAMIC_COMPONENT) { + if (process.env.NODE_ENV !== 'production' && !type) { + warn(`Invalid vnode type when creating vnode: ${type}.`) + } + type = Comment + } + if (isVNode(type)) { + const cloned = cloneVNode(type, props) + if (children) { + normalizeChildren(cloned, children) + } + return cloned + } + // class component normalization. + if (isFunction(type) && '__vccOpts' in type) { + type = type.__vccOpts + } + // class & style normalization. + if (props) { + // for reactive or proxy objects, we need to clone it to enable mutation. + if (isProxy(props) || InternalObjectKey in props) { + props = extend({}, props) + } + let { class: klass, style } = props + if (klass && !isString(klass)) { + props.class = normalizeClass(klass) + } + if (isObject(style)) { + // reactive state objects need to be cloned since they are likely to be + // mutated + if (isProxy(style) && !isArray(style)) { + style = extend({}, style) + } + props.style = normalizeStyle(style) + } + } + // encode the vnode type information into a bitmap + const shapeFlag = isString(type) + ? 1 /* ELEMENT */ + : isSuspense(type) + ? 128 /* SUSPENSE */ + : isTeleport(type) + ? 64 /* TELEPORT */ + : isObject(type) + ? 4 /* STATEFUL_COMPONENT */ + : isFunction(type) + ? 2 /* FUNCTIONAL_COMPONENT */ + : 0 + if ( + process.env.NODE_ENV !== 'production' && + shapeFlag & 4 /* STATEFUL_COMPONENT */ && + isProxy(type) + ) { + type = toRaw(type) + warn( + `Vue received a Component which was made a reactive object. This can ` + + `lead to unnecessary performance overhead, and should be avoided by ` + + `marking the component with \`markRaw\` or using \`shallowRef\` ` + + `instead of \`ref\`.`, + `\nComponent that was made reactive: `, + type + ) + } + const vnode = { + __v_isVNode: true, + ['__v_skip' /* SKIP */]: true, + type, + props, + key: props && normalizeKey(props), + ref: props && normalizeRef(props), + scopeId: currentScopeId, + children: null, + component: null, + suspense: null, + dirs: null, + transition: null, + el: null, + anchor: null, + target: null, + targetAnchor: null, + staticCount: 0, + shapeFlag, + patchFlag, + dynamicProps, + dynamicChildren: null, + appContext: null + } + // validate key + if (process.env.NODE_ENV !== 'production' && vnode.key !== vnode.key) { + warn(`VNode created with invalid key (NaN). VNode type:`, vnode.type) + } + normalizeChildren(vnode, children) + if ( + shouldTrack$1 > 0 && + // avoid a block node from tracking itself + !isBlockNode && + // has current parent block + currentBlock && + // presence of a patch flag indicates this node needs patching on updates. + // component nodes also should always be patched, because even if the + // component doesn't need to update, it needs to persist the instance on to + // the next vnode so that it can be properly unmounted later. + (patchFlag > 0 || shapeFlag & 6) /* COMPONENT */ && + // the EVENTS flag is only for hydration and if it is the only flag, the + // vnode should not be considered dynamic due to handler caching. + patchFlag !== 32 /* HYDRATE_EVENTS */ + ) { + currentBlock.push(vnode) + } + return vnode +} +function cloneVNode(vnode, extraProps) { + // This is intentionally NOT using spread or extend to avoid the runtime + // key enumeration cost. + const { props, patchFlag } = vnode + const mergedProps = extraProps ? mergeProps(props || {}, extraProps) : props + return { + __v_isVNode: true, + ['__v_skip' /* SKIP */]: true, + type: vnode.type, + props: mergedProps, + key: mergedProps && normalizeKey(mergedProps), + ref: extraProps && extraProps.ref ? normalizeRef(extraProps) : vnode.ref, + scopeId: vnode.scopeId, + children: vnode.children, + target: vnode.target, + targetAnchor: vnode.targetAnchor, + staticCount: vnode.staticCount, + shapeFlag: vnode.shapeFlag, + // if the vnode is cloned with extra props, we can no longer assume its + // existing patch flag to be reliable and need to add the FULL_PROPS flag. + // note: perserve flag for fragments since they use the flag for children + // fast paths only. + patchFlag: + extraProps && vnode.type !== Fragment + ? patchFlag === -1 // hoisted node + ? 16 /* FULL_PROPS */ + : patchFlag | 16 /* FULL_PROPS */ + : patchFlag, + dynamicProps: vnode.dynamicProps, + dynamicChildren: vnode.dynamicChildren, + appContext: vnode.appContext, + dirs: vnode.dirs, + transition: vnode.transition, + // These should technically only be non-null on mounted VNodes. However, + // they *should* be copied for kept-alive vnodes. So we just always copy + // them since them being non-null during a mount doesn't affect the logic as + // they will simply be overwritten. + component: vnode.component, + suspense: vnode.suspense, + el: vnode.el, + anchor: vnode.anchor + } +} +/** + * @private + */ +function createTextVNode(text = ' ', flag = 0) { + return createVNode(Text, null, text, flag) +} +/** + * @private + */ +function createStaticVNode(content, numberOfNodes) { + // A static vnode can contain multiple stringified elements, and the number + // of elements is necessary for hydration. + const vnode = createVNode(Static, null, content) + vnode.staticCount = numberOfNodes + return vnode +} +/** + * @private + */ +function createCommentVNode( + text = '', + // when used as the v-else branch, the comment node must be created as a + // block to ensure correct updates. + asBlock = false +) { + return asBlock + ? (openBlock(), createBlock(Comment, null, text)) + : createVNode(Comment, null, text) +} +function normalizeVNode(child) { + if (child == null || typeof child === 'boolean') { + // empty placeholder + return createVNode(Comment) + } else if (isArray(child)) { + // fragment + return createVNode(Fragment, null, child) + } else if (typeof child === 'object') { + // already vnode, this should be the most common since compiled templates + // always produce all-vnode children arrays + return child.el === null ? child : cloneVNode(child) + } else { + // strings and numbers + return createVNode(Text, null, String(child)) + } +} +// optimized normalization for template-compiled render fns +function cloneIfMounted(child) { + return child.el === null ? child : cloneVNode(child) +} +function normalizeChildren(vnode, children) { + let type = 0 + const { shapeFlag } = vnode + if (children == null) { + children = null + } else if (isArray(children)) { + type = 16 /* ARRAY_CHILDREN */ + } else if (typeof children === 'object') { + if (shapeFlag & 1 /* ELEMENT */ || shapeFlag & 64 /* TELEPORT */) { + // Normalize slot to plain children for plain element and Teleport + const slot = children.default + if (slot) { + // _c marker is added by withCtx() indicating this is a compiled slot + slot._c && setCompiledSlotRendering(1) + normalizeChildren(vnode, slot()) + slot._c && setCompiledSlotRendering(-1) + } + return + } else { + type = 32 /* SLOTS_CHILDREN */ + const slotFlag = children._ + if (!slotFlag && !(InternalObjectKey in children)) { + children._ctx = currentRenderingInstance + } else if (slotFlag === 3 /* FORWARDED */ && currentRenderingInstance) { + // a child component receives forwarded slots from the parent. + // its slot type is determined by its parent's slot type. + if ( + currentRenderingInstance.vnode.patchFlag & 1024 /* DYNAMIC_SLOTS */ + ) { + children._ = 2 /* DYNAMIC */ + vnode.patchFlag |= 1024 /* DYNAMIC_SLOTS */ + } else { + children._ = 1 /* STABLE */ + } + } + } + } else if (isFunction(children)) { + children = { default: children, _ctx: currentRenderingInstance } + type = 32 /* SLOTS_CHILDREN */ + } else { + children = String(children) + // force teleport children to array so it can be moved around + if (shapeFlag & 64 /* TELEPORT */) { + type = 16 /* ARRAY_CHILDREN */ + children = [createTextVNode(children)] + } else { + type = 8 /* TEXT_CHILDREN */ + } + } + vnode.children = children + vnode.shapeFlag |= type +} +function mergeProps(...args) { + const ret = extend({}, args[0]) + for (let i = 1; i < args.length; i++) { + const toMerge = args[i] + for (const key in toMerge) { + if (key === 'class') { + if (ret.class !== toMerge.class) { + ret.class = normalizeClass([ret.class, toMerge.class]) + } + } else if (key === 'style') { + ret.style = normalizeStyle([ret.style, toMerge.style]) + } else if (isOn(key)) { + const existing = ret[key] + const incoming = toMerge[key] + if (existing !== incoming) { + ret[key] = existing ? [].concat(existing, toMerge[key]) : incoming + } + } else { + ret[key] = toMerge[key] + } + } + } + return ret +} + +let devtools +function setDevtoolsHook(hook) { + devtools = hook +} +function devtoolsInitApp(app, version) { + // TODO queue if devtools is undefined + if (!devtools) return + devtools.emit('app:init' /* APP_INIT */, app, version, { + Fragment, + Text, + Comment, + Static + }) +} +function devtoolsUnmountApp(app) { + if (!devtools) return + devtools.emit('app:unmount' /* APP_UNMOUNT */, app) +} +const devtoolsComponentAdded = /*#__PURE__*/ createDevtoolsComponentHook( + 'component:added' /* COMPONENT_ADDED */ +) +const devtoolsComponentUpdated = /*#__PURE__*/ createDevtoolsComponentHook( + 'component:updated' /* COMPONENT_UPDATED */ +) +const devtoolsComponentRemoved = /*#__PURE__*/ createDevtoolsComponentHook( + 'component:removed' /* COMPONENT_REMOVED */ +) +function createDevtoolsComponentHook(hook) { + return component => { + if (!devtools) return + devtools.emit( + hook, + component.appContext.app, + component.uid, + component.parent ? component.parent.uid : undefined + ) + } +} +function devtoolsComponentEmit(component, event, params) { + if (!devtools) return + devtools.emit( + 'component:emit' /* COMPONENT_EMIT */, + component.appContext.app, + component, + event, + params + ) +} + +function emit(instance, event, ...args) { + const props = instance.vnode.props || EMPTY_OBJ + if (process.env.NODE_ENV !== 'production') { + const { + emitsOptions, + propsOptions: [propsOptions] + } = instance + if (emitsOptions) { + if (!(event in emitsOptions)) { + if (!propsOptions || !(`on` + capitalize(event) in propsOptions)) { + warn( + `Component emitted event "${event}" but it is neither declared in ` + + `the emits option nor as an "on${capitalize(event)}" prop.` + ) + } + } else { + const validator = emitsOptions[event] + if (isFunction(validator)) { + const isValid = validator(...args) + if (!isValid) { + warn( + `Invalid event arguments: event validation failed for event "${event}".` + ) + } + } + } + } + } + if (process.env.NODE_ENV !== 'production' || __VUE_PROD_DEVTOOLS__) { + devtoolsComponentEmit(instance, event, args) + } + let handlerName = `on${capitalize(event)}` + let handler = props[handlerName] + // for v-model update:xxx events, also trigger kebab-case equivalent + // for props passed via kebab-case + if (!handler && event.startsWith('update:')) { + handlerName = `on${capitalize(hyphenate(event))}` + handler = props[handlerName] + } + if (!handler) { + handler = props[handlerName + `Once`] + if (!instance.emitted) { + ;(instance.emitted = {})[handlerName] = true + } else if (instance.emitted[handlerName]) { + return + } + } + if (handler) { + callWithAsyncErrorHandling( + handler, + instance, + 6 /* COMPONENT_EVENT_HANDLER */, + args + ) + } +} +function normalizeEmitsOptions(comp, appContext, asMixin = false) { + const appId = appContext.app ? appContext.app._uid : -1 + const cache = comp.__emits || (comp.__emits = {}) + const cached = cache[appId] + if (cached !== undefined) { + return cached + } + const raw = comp.emits + let normalized = {} + // apply mixin/extends props + let hasExtends = false + if (__VUE_OPTIONS_API__ && !isFunction(comp)) { + const extendEmits = raw => { + hasExtends = true + extend(normalized, normalizeEmitsOptions(raw, appContext, true)) + } + if (!asMixin && appContext.mixins.length) { + appContext.mixins.forEach(extendEmits) + } + if (comp.extends) { + extendEmits(comp.extends) + } + if (comp.mixins) { + comp.mixins.forEach(extendEmits) + } + } + if (!raw && !hasExtends) { + return (cache[appId] = null) + } + if (isArray(raw)) { + raw.forEach(key => (normalized[key] = null)) + } else { + extend(normalized, raw) + } + return (cache[appId] = normalized) +} +// Check if an incoming prop key is a declared emit event listener. +// e.g. With `emits: { click: null }`, props named `onClick` and `onclick` are +// both considered matched listeners. +function isEmitListener(options, key) { + if (!options || !isOn(key)) { + return false + } + key = key.replace(/Once$/, '') + return ( + hasOwn(options, key[2].toLowerCase() + key.slice(3)) || + hasOwn(options, key.slice(2)) + ) +} + +function initProps( + instance, + rawProps, + isStateful, // result of bitwise flag comparison + isSSR = false +) { + const props = {} + const attrs = {} + def(attrs, InternalObjectKey, 1) + setFullProps(instance, rawProps, props, attrs) + // validation + if (process.env.NODE_ENV !== 'production') { + validateProps(props, instance) + } + if (isStateful) { + // stateful + instance.props = isSSR ? props : shallowReactive(props) + } else { + if (!instance.type.props) { + // functional w/ optional props, props === attrs + instance.props = attrs + } else { + // functional w/ declared props + instance.props = props + } + } + instance.attrs = attrs +} +function updateProps(instance, rawProps, rawPrevProps, optimized) { + const { + props, + attrs, + vnode: { patchFlag } + } = instance + const rawCurrentProps = toRaw(props) + const [options] = instance.propsOptions + if ( + // always force full diff if hmr is enabled + !(process.env.NODE_ENV !== 'production' && instance.type.__hmrId) && + (optimized || patchFlag > 0) && + !(patchFlag & 16) /* FULL_PROPS */ + ) { + if (patchFlag & 8 /* PROPS */) { + // Compiler-generated props & no keys change, just set the updated + // the props. + const propsToUpdate = instance.vnode.dynamicProps + for (let i = 0; i < propsToUpdate.length; i++) { + const key = propsToUpdate[i] + // PROPS flag guarantees rawProps to be non-null + const value = rawProps[key] + if (options) { + // attr / props separation was done on init and will be consistent + // in this code path, so just check if attrs have it. + if (hasOwn(attrs, key)) { + attrs[key] = value + } else { + const camelizedKey = camelize(key) + props[camelizedKey] = resolvePropValue( + options, + rawCurrentProps, + camelizedKey, + value + ) + } + } else { + attrs[key] = value + } + } + } + } else { + // full props update. + setFullProps(instance, rawProps, props, attrs) + // in case of dynamic props, check if we need to delete keys from + // the props object + let kebabKey + for (const key in rawCurrentProps) { + if ( + !rawProps || + // for camelCase + (!hasOwn(rawProps, key) && + // it's possible the original props was passed in as kebab-case + // and converted to camelCase (#955) + ((kebabKey = hyphenate(key)) === key || !hasOwn(rawProps, kebabKey))) + ) { + if (options) { + if ( + rawPrevProps && + // for camelCase + (rawPrevProps[key] !== undefined || + // for kebab-case + rawPrevProps[kebabKey] !== undefined) + ) { + props[key] = resolvePropValue( + options, + rawProps || EMPTY_OBJ, + key, + undefined + ) + } + } else { + delete props[key] + } + } + } + // in the case of functional component w/o props declaration, props and + // attrs point to the same object so it should already have been updated. + if (attrs !== rawCurrentProps) { + for (const key in attrs) { + if (!rawProps || !hasOwn(rawProps, key)) { + delete attrs[key] + } + } + } + } + // trigger updates for $attrs in case it's used in component slots + trigger(instance, 'set' /* SET */, '$attrs') + if (process.env.NODE_ENV !== 'production' && rawProps) { + validateProps(props, instance) + } +} +function setFullProps(instance, rawProps, props, attrs) { + const [options, needCastKeys] = instance.propsOptions + if (rawProps) { + for (const key in rawProps) { + const value = rawProps[key] + // key, ref are reserved and never passed down + if (isReservedProp(key)) { + continue + } + // prop option names are camelized during normalization, so to support + // kebab -> camel conversion here we need to camelize the key. + let camelKey + if (options && hasOwn(options, (camelKey = camelize(key)))) { + props[camelKey] = value + } else if (!isEmitListener(instance.emitsOptions, key)) { + // Any non-declared (either as a prop or an emitted event) props are put + // into a separate `attrs` object for spreading. Make sure to preserve + // original key casing + attrs[key] = value + } + } + } + if (needCastKeys) { + const rawCurrentProps = toRaw(props) + for (let i = 0; i < needCastKeys.length; i++) { + const key = needCastKeys[i] + props[key] = resolvePropValue( + options, + rawCurrentProps, + key, + rawCurrentProps[key] + ) + } + } +} +function resolvePropValue(options, props, key, value) { + const opt = options[key] + if (opt != null) { + const hasDefault = hasOwn(opt, 'default') + // default values + if (hasDefault && value === undefined) { + const defaultValue = opt.default + value = + opt.type !== Function && isFunction(defaultValue) + ? defaultValue(props) + : defaultValue + } + // boolean casting + if (opt[0 /* shouldCast */]) { + if (!hasOwn(props, key) && !hasDefault) { + value = false + } else if ( + opt[1 /* shouldCastTrue */] && + (value === '' || value === hyphenate(key)) + ) { + value = true + } + } + } + return value +} +function normalizePropsOptions(comp, appContext, asMixin = false) { + const appId = appContext.app ? appContext.app._uid : -1 + const cache = comp.__props || (comp.__props = {}) + const cached = cache[appId] + if (cached) { + return cached + } + const raw = comp.props + const normalized = {} + const needCastKeys = [] + // apply mixin/extends props + let hasExtends = false + if (__VUE_OPTIONS_API__ && !isFunction(comp)) { + const extendProps = raw => { + hasExtends = true + const [props, keys] = normalizePropsOptions(raw, appContext, true) + extend(normalized, props) + if (keys) needCastKeys.push(...keys) + } + if (!asMixin && appContext.mixins.length) { + appContext.mixins.forEach(extendProps) + } + if (comp.extends) { + extendProps(comp.extends) + } + if (comp.mixins) { + comp.mixins.forEach(extendProps) + } + } + if (!raw && !hasExtends) { + return (cache[appId] = EMPTY_ARR) + } + if (isArray(raw)) { + for (let i = 0; i < raw.length; i++) { + if (process.env.NODE_ENV !== 'production' && !isString(raw[i])) { + warn(`props must be strings when using array syntax.`, raw[i]) + } + const normalizedKey = camelize(raw[i]) + if (validatePropName(normalizedKey)) { + normalized[normalizedKey] = EMPTY_OBJ + } + } + } else if (raw) { + if (process.env.NODE_ENV !== 'production' && !isObject(raw)) { + warn(`invalid props options`, raw) + } + for (const key in raw) { + const normalizedKey = camelize(key) + if (validatePropName(normalizedKey)) { + const opt = raw[key] + const prop = (normalized[normalizedKey] = + isArray(opt) || isFunction(opt) ? { type: opt } : opt) + if (prop) { + const booleanIndex = getTypeIndex(Boolean, prop.type) + const stringIndex = getTypeIndex(String, prop.type) + prop[0 /* shouldCast */] = booleanIndex > -1 + prop[1 /* shouldCastTrue */] = + stringIndex < 0 || booleanIndex < stringIndex + // if the prop needs boolean casting or default value + if (booleanIndex > -1 || hasOwn(prop, 'default')) { + needCastKeys.push(normalizedKey) + } + } + } + } + } + return (cache[appId] = [normalized, needCastKeys]) +} +// use function string name to check type constructors +// so that it works across vms / iframes. +function getType(ctor) { + const match = ctor && ctor.toString().match(/^\s*function (\w+)/) + return match ? match[1] : '' +} +function isSameType(a, b) { + return getType(a) === getType(b) +} +function getTypeIndex(type, expectedTypes) { + if (isArray(expectedTypes)) { + for (let i = 0, len = expectedTypes.length; i < len; i++) { + if (isSameType(expectedTypes[i], type)) { + return i + } + } + } else if (isFunction(expectedTypes)) { + return isSameType(expectedTypes, type) ? 0 : -1 + } + return -1 +} +/** + * dev only + */ +function validateProps(props, instance) { + const rawValues = toRaw(props) + const options = instance.propsOptions[0] + for (const key in options) { + let opt = options[key] + if (opt == null) continue + validateProp(key, rawValues[key], opt, !hasOwn(rawValues, key)) + } +} +/** + * dev only + */ +function validatePropName(key) { + if (key[0] !== '$') { + return true + } else if (process.env.NODE_ENV !== 'production') { + warn(`Invalid prop name: "${key}" is a reserved property.`) + } + return false +} +/** + * dev only + */ +function validateProp(name, value, prop, isAbsent) { + const { type, required, validator } = prop + // required! + if (required && isAbsent) { + warn('Missing required prop: "' + name + '"') + return + } + // missing but optional + if (value == null && !prop.required) { + return + } + // type check + if (type != null && type !== true) { + let isValid = false + const types = isArray(type) ? type : [type] + const expectedTypes = [] + // value is valid as long as one of the specified types match + for (let i = 0; i < types.length && !isValid; i++) { + const { valid, expectedType } = assertType(value, types[i]) + expectedTypes.push(expectedType || '') + isValid = valid + } + if (!isValid) { + warn(getInvalidTypeMessage(name, value, expectedTypes)) + return + } + } + // custom validator + if (validator && !validator(value)) { + warn('Invalid prop: custom validator check failed for prop "' + name + '".') + } +} +const isSimpleType = /*#__PURE__*/ makeMap( + 'String,Number,Boolean,Function,Symbol' +) +/** + * dev only + */ +function assertType(value, type) { + let valid + const expectedType = getType(type) + if (isSimpleType(expectedType)) { + const t = typeof value + valid = t === expectedType.toLowerCase() + // for primitive wrapper objects + if (!valid && t === 'object') { + valid = value instanceof type + } + } else if (expectedType === 'Object') { + valid = isObject(value) + } else if (expectedType === 'Array') { + valid = isArray(value) + } else { + valid = value instanceof type + } + return { + valid, + expectedType + } +} +/** + * dev only + */ +function getInvalidTypeMessage(name, value, expectedTypes) { + let message = + `Invalid prop: type check failed for prop "${name}".` + + ` Expected ${expectedTypes.map(capitalize).join(', ')}` + const expectedType = expectedTypes[0] + const receivedType = toRawType(value) + const expectedValue = styleValue(value, expectedType) + const receivedValue = styleValue(value, receivedType) + // check if we need to specify expected value + if ( + expectedTypes.length === 1 && + isExplicable(expectedType) && + !isBoolean(expectedType, receivedType) + ) { + message += ` with value ${expectedValue}` + } + message += `, got ${receivedType} ` + // check if we need to specify received value + if (isExplicable(receivedType)) { + message += `with value ${receivedValue}.` + } + return message +} +/** + * dev only + */ +function styleValue(value, type) { + if (type === 'String') { + return `"${value}"` + } else if (type === 'Number') { + return `${Number(value)}` + } else { + return `${value}` + } +} +/** + * dev only + */ +function isExplicable(type) { + const explicitTypes = ['string', 'number', 'boolean'] + return explicitTypes.some(elem => type.toLowerCase() === elem) +} +/** + * dev only + */ +function isBoolean(...args) { + return args.some(elem => elem.toLowerCase() === 'boolean') +} + +function injectHook(type, hook, target = currentInstance, prepend = false) { + if (target) { + const hooks = target[type] || (target[type] = []) + // cache the error handling wrapper for injected hooks so the same hook + // can be properly deduped by the scheduler. "__weh" stands for "with error + // handling". + const wrappedHook = + hook.__weh || + (hook.__weh = (...args) => { + if (target.isUnmounted) { + return + } + // disable tracking inside all lifecycle hooks + // since they can potentially be called inside effects. + pauseTracking() + // Set currentInstance during hook invocation. + // This assumes the hook does not synchronously trigger other hooks, which + // can only be false when the user does something really funky. + setCurrentInstance(target) + const res = callWithAsyncErrorHandling(hook, target, type, args) + setCurrentInstance(null) + resetTracking() + return res + }) + if (prepend) { + hooks.unshift(wrappedHook) + } else { + hooks.push(wrappedHook) + } + return wrappedHook + } else if (process.env.NODE_ENV !== 'production') { + const apiName = `on${capitalize( + ErrorTypeStrings[type].replace(/ hook$/, '') + )}` + warn( + `${apiName} is called when there is no active component instance to be ` + + `associated with. ` + + `Lifecycle injection APIs can only be used during execution of setup().` + + (` If you are using async setup(), make sure to register lifecycle ` + + `hooks before the first await statement.`) + ) + } +} +const createHook = lifecycle => (hook, target = currentInstance) => + // post-create lifecycle registrations are noops during SSR + !isInSSRComponentSetup && injectHook(lifecycle, hook, target) +const onBeforeMount = createHook('bm' /* BEFORE_MOUNT */) +const onMounted = createHook('m' /* MOUNTED */) +const onBeforeUpdate = createHook('bu' /* BEFORE_UPDATE */) +const onUpdated = createHook('u' /* UPDATED */) +const onBeforeUnmount = createHook('bum' /* BEFORE_UNMOUNT */) +const onUnmounted = createHook('um' /* UNMOUNTED */) +const onRenderTriggered = createHook('rtg' /* RENDER_TRIGGERED */) +const onRenderTracked = createHook('rtc' /* RENDER_TRACKED */) +const onErrorCaptured = (hook, target = currentInstance) => { + injectHook('ec' /* ERROR_CAPTURED */, hook, target) +} + +function useTransitionState() { + const state = { + isMounted: false, + isLeaving: false, + isUnmounting: false, + leavingVNodes: new Map() + } + onMounted(() => { + state.isMounted = true + }) + onBeforeUnmount(() => { + state.isUnmounting = true + }) + return state +} +const TransitionHookValidator = [Function, Array] +const BaseTransitionImpl = { + name: `BaseTransition`, + props: { + mode: String, + appear: Boolean, + persisted: Boolean, + // enter + onBeforeEnter: TransitionHookValidator, + onEnter: TransitionHookValidator, + onAfterEnter: TransitionHookValidator, + onEnterCancelled: TransitionHookValidator, + // leave + onBeforeLeave: TransitionHookValidator, + onLeave: TransitionHookValidator, + onAfterLeave: TransitionHookValidator, + onLeaveCancelled: TransitionHookValidator, + // appear + onBeforeAppear: TransitionHookValidator, + onAppear: TransitionHookValidator, + onAfterAppear: TransitionHookValidator, + onAppearCancelled: TransitionHookValidator + }, + setup(props, { slots }) { + const instance = getCurrentInstance() + const state = useTransitionState() + let prevTransitionKey + return () => { + const children = + slots.default && getTransitionRawChildren(slots.default(), true) + if (!children || !children.length) { + return + } + // warn multiple elements + if (process.env.NODE_ENV !== 'production' && children.length > 1) { + warn( + ' can only be used on a single element or component. Use ' + + ' for lists.' + ) + } + // there's no need to track reactivity for these props so use the raw + // props for a bit better perf + const rawProps = toRaw(props) + const { mode } = rawProps + // check mode + if ( + process.env.NODE_ENV !== 'production' && + mode && + !['in-out', 'out-in', 'default'].includes(mode) + ) { + warn(`invalid mode: ${mode}`) + } + // at this point children has a guaranteed length of 1. + const child = children[0] + if (state.isLeaving) { + return emptyPlaceholder(child) + } + // in the case of , we need to + // compare the type of the kept-alive children. + const innerChild = getKeepAliveChild(child) + if (!innerChild) { + return emptyPlaceholder(child) + } + const enterHooks = (innerChild.transition = resolveTransitionHooks( + innerChild, + rawProps, + state, + instance + )) + const oldChild = instance.subTree + const oldInnerChild = oldChild && getKeepAliveChild(oldChild) + let transitionKeyChanged = false + const { getTransitionKey } = innerChild.type + if (getTransitionKey) { + const key = getTransitionKey() + if (prevTransitionKey === undefined) { + prevTransitionKey = key + } else if (key !== prevTransitionKey) { + prevTransitionKey = key + transitionKeyChanged = true + } + } + // handle mode + if ( + oldInnerChild && + oldInnerChild.type !== Comment && + (!isSameVNodeType(innerChild, oldInnerChild) || transitionKeyChanged) + ) { + const leavingHooks = resolveTransitionHooks( + oldInnerChild, + rawProps, + state, + instance + ) + // update old tree's hooks in case of dynamic transition + setTransitionHooks(oldInnerChild, leavingHooks) + // switching between different views + if (mode === 'out-in') { + state.isLeaving = true + // return placeholder node and queue update when leave finishes + leavingHooks.afterLeave = () => { + state.isLeaving = false + instance.update() + } + return emptyPlaceholder(child) + } else if (mode === 'in-out') { + leavingHooks.delayLeave = (el, earlyRemove, delayedLeave) => { + const leavingVNodesCache = getLeavingNodesForType( + state, + oldInnerChild + ) + leavingVNodesCache[String(oldInnerChild.key)] = oldInnerChild + // early removal callback + el._leaveCb = () => { + earlyRemove() + el._leaveCb = undefined + delete enterHooks.delayedLeave + } + enterHooks.delayedLeave = delayedLeave + } + } + } + return child + } + } +} +// export the public type for h/tsx inference +// also to avoid inline import() in generated d.ts files +const BaseTransition = BaseTransitionImpl +function getLeavingNodesForType(state, vnode) { + const { leavingVNodes } = state + let leavingVNodesCache = leavingVNodes.get(vnode.type) + if (!leavingVNodesCache) { + leavingVNodesCache = Object.create(null) + leavingVNodes.set(vnode.type, leavingVNodesCache) + } + return leavingVNodesCache +} +// The transition hooks are attached to the vnode as vnode.transition +// and will be called at appropriate timing in the renderer. +function resolveTransitionHooks( + vnode, + { + appear, + persisted = false, + onBeforeEnter, + onEnter, + onAfterEnter, + onEnterCancelled, + onBeforeLeave, + onLeave, + onAfterLeave, + onLeaveCancelled, + onBeforeAppear, + onAppear, + onAfterAppear, + onAppearCancelled + }, + state, + instance +) { + const key = String(vnode.key) + const leavingVNodesCache = getLeavingNodesForType(state, vnode) + const callHook = (hook, args) => { + hook && + callWithAsyncErrorHandling(hook, instance, 9 /* TRANSITION_HOOK */, args) + } + const hooks = { + persisted, + beforeEnter(el) { + let hook = onBeforeEnter + if (!state.isMounted) { + if (appear) { + hook = onBeforeAppear || onBeforeEnter + } else { + return + } + } + // for same element (v-show) + if (el._leaveCb) { + el._leaveCb(true /* cancelled */) + } + // for toggled element with same key (v-if) + const leavingVNode = leavingVNodesCache[key] + if ( + leavingVNode && + isSameVNodeType(vnode, leavingVNode) && + leavingVNode.el._leaveCb + ) { + // force early removal (not cancelled) + leavingVNode.el._leaveCb() + } + callHook(hook, [el]) + }, + enter(el) { + let hook = onEnter + let afterHook = onAfterEnter + let cancelHook = onEnterCancelled + if (!state.isMounted) { + if (appear) { + hook = onAppear || onEnter + afterHook = onAfterAppear || onAfterEnter + cancelHook = onAppearCancelled || onEnterCancelled + } else { + return + } + } + let called = false + const done = (el._enterCb = cancelled => { + if (called) return + called = true + if (cancelled) { + callHook(cancelHook, [el]) + } else { + callHook(afterHook, [el]) + } + if (hooks.delayedLeave) { + hooks.delayedLeave() + } + el._enterCb = undefined + }) + if (hook) { + hook(el, done) + if (hook.length <= 1) { + done() + } + } else { + done() + } + }, + leave(el, remove) { + const key = String(vnode.key) + if (el._enterCb) { + el._enterCb(true /* cancelled */) + } + if (state.isUnmounting) { + return remove() + } + callHook(onBeforeLeave, [el]) + let called = false + const done = (el._leaveCb = cancelled => { + if (called) return + called = true + remove() + if (cancelled) { + callHook(onLeaveCancelled, [el]) + } else { + callHook(onAfterLeave, [el]) + } + el._leaveCb = undefined + if (leavingVNodesCache[key] === vnode) { + delete leavingVNodesCache[key] + } + }) + leavingVNodesCache[key] = vnode + if (onLeave) { + onLeave(el, done) + if (onLeave.length <= 1) { + done() + } + } else { + done() + } + } + } + return hooks +} +// the placeholder really only handles one special case: KeepAlive +// in the case of a KeepAlive in a leave phase we need to return a KeepAlive +// placeholder with empty content to avoid the KeepAlive instance from being +// unmounted. +function emptyPlaceholder(vnode) { + if (isKeepAlive(vnode)) { + vnode = cloneVNode(vnode) + vnode.children = null + return vnode + } +} +function getKeepAliveChild(vnode) { + return isKeepAlive(vnode) + ? vnode.children + ? vnode.children[0] + : undefined + : vnode +} +function setTransitionHooks(vnode, hooks) { + if (vnode.shapeFlag & 6 /* COMPONENT */ && vnode.component) { + setTransitionHooks(vnode.component.subTree, hooks) + } else { + vnode.transition = hooks + } +} +function getTransitionRawChildren(children, keepComment = false) { + let ret = [] + let keyedFragmentCount = 0 + for (let i = 0; i < children.length; i++) { + const child = children[i] + // handle fragment children case, e.g. v-for + if (child.type === Fragment) { + if (child.patchFlag & 128 /* KEYED_FRAGMENT */) keyedFragmentCount++ + ret = ret.concat(getTransitionRawChildren(child.children, keepComment)) + } + // comment placeholders should be skipped, e.g. v-if + else if (keepComment || child.type !== Comment) { + ret.push(child) + } + } + // #1126 if a transition children list contains multiple sub fragments, these + // fragments will be merged into a flat children array. Since each v-for + // fragment may contain different static bindings inside, we need to de-top + // these children to force full diffs to ensure correct behavior. + if (keyedFragmentCount > 1) { + for (let i = 0; i < ret.length; i++) { + ret[i].patchFlag = -2 /* BAIL */ + } + } + return ret +} + +const isKeepAlive = vnode => vnode.type.__isKeepAlive +const KeepAliveImpl = { + name: `KeepAlive`, + // Marker for special handling inside the renderer. We are not using a === + // check directly on KeepAlive in the renderer, because importing it directly + // would prevent it from being tree-shaken. + __isKeepAlive: true, + inheritRef: true, + props: { + include: [String, RegExp, Array], + exclude: [String, RegExp, Array], + max: [String, Number] + }, + setup(props, { slots }) { + const cache = new Map() + const keys = new Set() + let current = null + const instance = getCurrentInstance() + const parentSuspense = instance.suspense + // KeepAlive communicates with the instantiated renderer via the + // ctx where the renderer passes in its internals, + // and the KeepAlive instance exposes activate/deactivate implementations. + // The whole point of this is to avoid importing KeepAlive directly in the + // renderer to facilitate tree-shaking. + const sharedContext = instance.ctx + const { + renderer: { + p: patch, + m: move, + um: _unmount, + o: { createElement } + } + } = sharedContext + const storageContainer = createElement('div') + sharedContext.activate = (vnode, container, anchor, isSVG, optimized) => { + const instance = vnode.component + move(vnode, container, anchor, 0 /* ENTER */, parentSuspense) + // in case props have changed + patch( + instance.vnode, + vnode, + container, + anchor, + instance, + parentSuspense, + isSVG, + optimized + ) + queuePostRenderEffect(() => { + instance.isDeactivated = false + if (instance.a) { + invokeArrayFns(instance.a) + } + const vnodeHook = vnode.props && vnode.props.onVnodeMounted + if (vnodeHook) { + invokeVNodeHook(vnodeHook, instance.parent, vnode) + } + }, parentSuspense) + } + sharedContext.deactivate = vnode => { + const instance = vnode.component + move(vnode, storageContainer, null, 1 /* LEAVE */, parentSuspense) + queuePostRenderEffect(() => { + if (instance.da) { + invokeArrayFns(instance.da) + } + const vnodeHook = vnode.props && vnode.props.onVnodeUnmounted + if (vnodeHook) { + invokeVNodeHook(vnodeHook, instance.parent, vnode) + } + instance.isDeactivated = true + }, parentSuspense) + } + function unmount(vnode) { + // reset the shapeFlag so it can be properly unmounted + resetShapeFlag(vnode) + _unmount(vnode, instance, parentSuspense) + } + function pruneCache(filter) { + cache.forEach((vnode, key) => { + const name = getName(vnode.type) + if (name && (!filter || !filter(name))) { + pruneCacheEntry(key) + } + }) + } + function pruneCacheEntry(key) { + const cached = cache.get(key) + if (!current || cached.type !== current.type) { + unmount(cached) + } else if (current) { + // current active instance should no longer be kept-alive. + // we can't unmount it now but it might be later, so reset its flag now. + resetShapeFlag(current) + } + cache.delete(key) + keys.delete(key) + } + watch( + () => [props.include, props.exclude], + ([include, exclude]) => { + include && pruneCache(name => matches(include, name)) + exclude && pruneCache(name => matches(exclude, name)) + } + ) + // cache sub tree in beforeMount/Update (i.e. right after the render) + let pendingCacheKey = null + const cacheSubtree = () => { + // fix #1621, the pendingCacheKey could be 0 + if (pendingCacheKey != null) { + cache.set(pendingCacheKey, instance.subTree) + } + } + onBeforeMount(cacheSubtree) + onBeforeUpdate(cacheSubtree) + onBeforeUnmount(() => { + cache.forEach(cached => { + const { subTree, suspense } = instance + if (cached.type === subTree.type) { + // current instance will be unmounted as part of keep-alive's unmount + resetShapeFlag(subTree) + // but invoke its deactivated hook here + const da = subTree.component.da + da && queuePostRenderEffect(da, suspense) + return + } + unmount(cached) + }) + }) + return () => { + pendingCacheKey = null + if (!slots.default) { + return null + } + const children = slots.default() + let vnode = children[0] + if (children.length > 1) { + if (process.env.NODE_ENV !== 'production') { + warn(`KeepAlive should contain exactly one component child.`) + } + current = null + return children + } else if ( + !isVNode(vnode) || + !(vnode.shapeFlag & 4) /* STATEFUL_COMPONENT */ + ) { + current = null + return vnode + } + const comp = vnode.type + const name = getName(comp) + const { include, exclude, max } = props + if ( + (include && (!name || !matches(include, name))) || + (exclude && name && matches(exclude, name)) + ) { + return (current = vnode) + } + const key = vnode.key == null ? comp : vnode.key + const cachedVNode = cache.get(key) + // clone vnode if it's reused because we are going to mutate it + if (vnode.el) { + vnode = cloneVNode(vnode) + } + // #1513 it's possible for the returned vnode to be cloned due to attr + // fallthrough or scopeId, so the vnode here may not be the final vnode + // that is mounted. Instead of caching it directly, we store the pending + // key and cache `instance.subTree` (the normalized vnode) in + // beforeMount/beforeUpdate hooks. + pendingCacheKey = key + if (cachedVNode) { + // copy over mounted state + vnode.el = cachedVNode.el + vnode.component = cachedVNode.component + if (vnode.transition) { + // recursively update transition hooks on subTree + setTransitionHooks(vnode, vnode.transition) + } + // avoid vnode being mounted as fresh + vnode.shapeFlag |= 512 /* COMPONENT_KEPT_ALIVE */ + // make this key the freshest + keys.delete(key) + keys.add(key) + } else { + keys.add(key) + // prune oldest entry + if (max && keys.size > parseInt(max, 10)) { + pruneCacheEntry(keys.values().next().value) + } + } + // avoid vnode being unmounted + vnode.shapeFlag |= 256 /* COMPONENT_SHOULD_KEEP_ALIVE */ + current = vnode + return vnode + } + } +} +// export the public type for h/tsx inference +// also to avoid inline import() in generated d.ts files +const KeepAlive = KeepAliveImpl +function getName(comp) { + return comp.displayName || comp.name +} +function matches(pattern, name) { + if (isArray(pattern)) { + return pattern.some(p => matches(p, name)) + } else if (isString(pattern)) { + return pattern.split(',').indexOf(name) > -1 + } else if (pattern.test) { + return pattern.test(name) + } + /* istanbul ignore next */ + return false +} +function onActivated(hook, target) { + registerKeepAliveHook(hook, 'a' /* ACTIVATED */, target) +} +function onDeactivated(hook, target) { + registerKeepAliveHook(hook, 'da' /* DEACTIVATED */, target) +} +function registerKeepAliveHook(hook, type, target = currentInstance) { + // cache the deactivate branch check wrapper for injected hooks so the same + // hook can be properly deduped by the scheduler. "__wdc" stands for "with + // deactivation check". + const wrappedHook = + hook.__wdc || + (hook.__wdc = () => { + // only fire the hook if the target instance is NOT in a deactivated branch. + let current = target + while (current) { + if (current.isDeactivated) { + return + } + current = current.parent + } + hook() + }) + injectHook(type, wrappedHook, target) + // In addition to registering it on the target instance, we walk up the parent + // chain and register it on all ancestor instances that are keep-alive roots. + // This avoids the need to walk the entire component tree when invoking these + // hooks, and more importantly, avoids the need to track child components in + // arrays. + if (target) { + let current = target.parent + while (current && current.parent) { + if (isKeepAlive(current.parent.vnode)) { + injectToKeepAliveRoot(wrappedHook, type, target, current) + } + current = current.parent + } + } +} +function injectToKeepAliveRoot(hook, type, target, keepAliveRoot) { + // injectHook wraps the original for error handling, so make sure to remove + // the wrapped version. + const injected = injectHook(type, hook, keepAliveRoot, true /* prepend */) + onUnmounted(() => { + remove(keepAliveRoot[type], injected) + }, target) +} +function resetShapeFlag(vnode) { + let shapeFlag = vnode.shapeFlag + if (shapeFlag & 256 /* COMPONENT_SHOULD_KEEP_ALIVE */) { + shapeFlag -= 256 /* COMPONENT_SHOULD_KEEP_ALIVE */ + } + if (shapeFlag & 512 /* COMPONENT_KEPT_ALIVE */) { + shapeFlag -= 512 /* COMPONENT_KEPT_ALIVE */ + } + vnode.shapeFlag = shapeFlag +} + +const isInternalKey = key => key[0] === '_' || key === '$stable' +const normalizeSlotValue = value => + isArray(value) ? value.map(normalizeVNode) : [normalizeVNode(value)] +const normalizeSlot = (key, rawSlot, ctx) => + withCtx(props => { + if (process.env.NODE_ENV !== 'production' && currentInstance) { + warn( + `Slot "${key}" invoked outside of the render function: ` + + `this will not track dependencies used in the slot. ` + + `Invoke the slot function inside the render function instead.` + ) + } + return normalizeSlotValue(rawSlot(props)) + }, ctx) +const normalizeObjectSlots = (rawSlots, slots) => { + const ctx = rawSlots._ctx + for (const key in rawSlots) { + if (isInternalKey(key)) continue + const value = rawSlots[key] + if (isFunction(value)) { + slots[key] = normalizeSlot(key, value, ctx) + } else if (value != null) { + if (process.env.NODE_ENV !== 'production') { + warn( + `Non-function value encountered for slot "${key}". ` + + `Prefer function slots for better performance.` + ) + } + const normalized = normalizeSlotValue(value) + slots[key] = () => normalized + } + } +} +const normalizeVNodeSlots = (instance, children) => { + if (process.env.NODE_ENV !== 'production' && !isKeepAlive(instance.vnode)) { + warn( + `Non-function value encountered for default slot. ` + + `Prefer function slots for better performance.` + ) + } + const normalized = normalizeSlotValue(children) + instance.slots.default = () => normalized +} +const initSlots = (instance, children) => { + if (instance.vnode.shapeFlag & 32 /* SLOTS_CHILDREN */) { + const type = children._ + if (type) { + instance.slots = children + // make compiler marker non-enumerable + def(children, '_', type) + } else { + normalizeObjectSlots(children, (instance.slots = {})) + } + } else { + instance.slots = {} + if (children) { + normalizeVNodeSlots(instance, children) + } + } + def(instance.slots, InternalObjectKey, 1) +} +const updateSlots = (instance, children) => { + const { vnode, slots } = instance + let needDeletionCheck = true + let deletionComparisonTarget = EMPTY_OBJ + if (vnode.shapeFlag & 32 /* SLOTS_CHILDREN */) { + const type = children._ + if (type) { + // compiled slots. + if (process.env.NODE_ENV !== 'production' && isHmrUpdating) { + // Parent was HMR updated so slot content may have changed. + // force update slots and mark instance for hmr as well + extend(slots, children) + } else if (type === 1 /* STABLE */) { + // compiled AND stable. + // no need to update, and skip stale slots removal. + needDeletionCheck = false + } else { + // compiled but dynamic (v-if/v-for on slots) - update slots, but skip + // normalization. + extend(slots, children) + } + } else { + needDeletionCheck = !children.$stable + normalizeObjectSlots(children, slots) + } + deletionComparisonTarget = children + } else if (children) { + // non slot object children (direct value) passed to a component + normalizeVNodeSlots(instance, children) + deletionComparisonTarget = { default: 1 } + } + // delete stale slots + if (needDeletionCheck) { + for (const key in slots) { + if (!isInternalKey(key) && !(key in deletionComparisonTarget)) { + delete slots[key] + } + } + } +} + +/** +Runtime helper for applying directives to a vnode. Example usage: + +const comp = resolveComponent('comp') +const foo = resolveDirective('foo') +const bar = resolveDirective('bar') + +return withDirectives(h(comp), [ + [foo, this.x], + [bar, this.y] +]) +*/ +const isBuiltInDirective = /*#__PURE__*/ makeMap( + 'bind,cloak,else-if,else,for,html,if,model,on,once,pre,show,slot,text' +) +function validateDirectiveName(name) { + if (isBuiltInDirective(name)) { + warn('Do not use built-in directive ids as custom directive id: ' + name) + } +} +/** + * Adds directives to a VNode. + */ +function withDirectives(vnode, directives) { + const internalInstance = currentRenderingInstance + if (internalInstance === null) { + process.env.NODE_ENV !== 'production' && + warn(`withDirectives can only be used inside render functions.`) + return vnode + } + const instance = internalInstance.proxy + const bindings = vnode.dirs || (vnode.dirs = []) + for (let i = 0; i < directives.length; i++) { + let [dir, value, arg, modifiers = EMPTY_OBJ] = directives[i] + if (isFunction(dir)) { + dir = { + mounted: dir, + updated: dir + } + } + bindings.push({ + dir, + instance, + value, + oldValue: void 0, + arg, + modifiers + }) + } + return vnode +} +function invokeDirectiveHook(vnode, prevVNode, instance, name) { + const bindings = vnode.dirs + const oldBindings = prevVNode && prevVNode.dirs + for (let i = 0; i < bindings.length; i++) { + const binding = bindings[i] + if (oldBindings) { + binding.oldValue = oldBindings[i].value + } + const hook = binding.dir[name] + if (hook) { + callWithAsyncErrorHandling(hook, instance, 8 /* DIRECTIVE_HOOK */, [ + vnode.el, + binding, + vnode, + prevVNode + ]) + } + } +} + +function createAppContext() { + return { + app: null, + config: { + isNativeTag: NO, + performance: false, + globalProperties: {}, + optionMergeStrategies: {}, + isCustomElement: NO, + errorHandler: undefined, + warnHandler: undefined + }, + mixins: [], + components: {}, + directives: {}, + provides: Object.create(null) + } +} +let uid$1 = 0 +function createAppAPI(render, hydrate) { + return function createApp(rootComponent, rootProps = null) { + if (rootProps != null && !isObject(rootProps)) { + process.env.NODE_ENV !== 'production' && + warn(`root props passed to app.mount() must be an object.`) + rootProps = null + } + const context = createAppContext() + const installedPlugins = new Set() + let isMounted = false + const app = (context.app = { + _uid: uid$1++, + _component: rootComponent, + _props: rootProps, + _container: null, + _context: context, + version, + get config() { + return context.config + }, + set config(v) { + if (process.env.NODE_ENV !== 'production') { + warn( + `app.config cannot be replaced. Modify individual options instead.` + ) + } + }, + use(plugin, ...options) { + if (installedPlugins.has(plugin)) { + process.env.NODE_ENV !== 'production' && + warn(`Plugin has already been applied to target app.`) + } else if (plugin && isFunction(plugin.install)) { + installedPlugins.add(plugin) + plugin.install(app, ...options) + } else if (isFunction(plugin)) { + installedPlugins.add(plugin) + plugin(app, ...options) + } else if (process.env.NODE_ENV !== 'production') { + warn( + `A plugin must either be a function or an object with an "install" ` + + `function.` + ) + } + return app + }, + mixin(mixin) { + if (__VUE_OPTIONS_API__) { + if (!context.mixins.includes(mixin)) { + context.mixins.push(mixin) + } else if (process.env.NODE_ENV !== 'production') { + warn( + 'Mixin has already been applied to target app' + + (mixin.name ? `: ${mixin.name}` : '') + ) + } + } else if (process.env.NODE_ENV !== 'production') { + warn('Mixins are only available in builds supporting Options API') + } + return app + }, + component(name, component) { + if (process.env.NODE_ENV !== 'production') { + validateComponentName(name, context.config) + } + if (!component) { + return context.components[name] + } + if (process.env.NODE_ENV !== 'production' && context.components[name]) { + warn(`Component "${name}" has already been registered in target app.`) + } + context.components[name] = component + return app + }, + directive(name, directive) { + if (process.env.NODE_ENV !== 'production') { + validateDirectiveName(name) + } + if (!directive) { + return context.directives[name] + } + if (process.env.NODE_ENV !== 'production' && context.directives[name]) { + warn(`Directive "${name}" has already been registered in target app.`) + } + context.directives[name] = directive + return app + }, + mount(rootContainer, isHydrate) { + if (!isMounted) { + const vnode = createVNode(rootComponent, rootProps) + // store app context on the root VNode. + // this will be set on the root instance on initial mount. + vnode.appContext = context + // HMR root reload + if (process.env.NODE_ENV !== 'production') { + context.reload = () => { + render(cloneVNode(vnode), rootContainer) + } + } + if (isHydrate && hydrate) { + hydrate(vnode, rootContainer) + } else { + render(vnode, rootContainer) + } + isMounted = true + app._container = rootContainer + rootContainer.__vue_app__ = app + if (process.env.NODE_ENV !== 'production' || __VUE_PROD_DEVTOOLS__) { + devtoolsInitApp(app, version) + } + return vnode.component.proxy + } else if (process.env.NODE_ENV !== 'production') { + warn( + `App has already been mounted.\n` + + `If you want to remount the same app, move your app creation logic ` + + `into a factory function and create fresh app instances for each ` + + `mount - e.g. \`const createMyApp = () => createApp(App)\`` + ) + } + }, + unmount() { + if (isMounted) { + render(null, app._container) + if (process.env.NODE_ENV !== 'production' || __VUE_PROD_DEVTOOLS__) { + devtoolsUnmountApp(app) + } + } else if (process.env.NODE_ENV !== 'production') { + warn(`Cannot unmount an app that is not mounted.`) + } + }, + provide(key, value) { + if (process.env.NODE_ENV !== 'production' && key in context.provides) { + warn( + `App already provides property with key "${String(key)}". ` + + `It will be overwritten with the new value.` + ) + } + // TypeScript doesn't allow symbols as index type + // https://github.com/Microsoft/TypeScript/issues/24587 + context.provides[key] = value + return app + } + }) + return app + } +} + +let hasMismatch = false +const isSVGContainer = container => + /svg/.test(container.namespaceURI) && container.tagName !== 'foreignObject' +const isComment = node => node.nodeType === 8 /* COMMENT */ +// Note: hydration is DOM-specific +// But we have to place it in core due to tight coupling with core - splitting +// it out creates a ton of unnecessary complexity. +// Hydration also depends on some renderer internal logic which needs to be +// passed in via arguments. +function createHydrationFunctions(rendererInternals) { + const { + mt: mountComponent, + p: patch, + o: { patchProp, nextSibling, parentNode, remove, insert, createComment } + } = rendererInternals + const hydrate = (vnode, container) => { + if (process.env.NODE_ENV !== 'production' && !container.hasChildNodes()) { + warn( + `Attempting to hydrate existing markup but container is empty. ` + + `Performing full mount instead.` + ) + patch(null, vnode, container) + return + } + hasMismatch = false + hydrateNode(container.firstChild, vnode, null, null) + flushPostFlushCbs() + if (hasMismatch && !false) { + // this error should show up in production + console.error(`Hydration completed but contains mismatches.`) + } + } + const hydrateNode = ( + node, + vnode, + parentComponent, + parentSuspense, + optimized = false + ) => { + const isFragmentStart = isComment(node) && node.data === '[' + const onMismatch = () => + handleMismatch( + node, + vnode, + parentComponent, + parentSuspense, + isFragmentStart + ) + const { type, ref, shapeFlag } = vnode + const domType = node.nodeType + vnode.el = node + let nextNode = null + switch (type) { + case Text: + if (domType !== 3 /* TEXT */) { + nextNode = onMismatch() + } else { + if (node.data !== vnode.children) { + hasMismatch = true + process.env.NODE_ENV !== 'production' && + warn( + `Hydration text mismatch:` + + `\n- Client: ${JSON.stringify(node.data)}` + + `\n- Server: ${JSON.stringify(vnode.children)}` + ) + node.data = vnode.children + } + nextNode = nextSibling(node) + } + break + case Comment: + if (domType !== 8 /* COMMENT */ || isFragmentStart) { + nextNode = onMismatch() + } else { + nextNode = nextSibling(node) + } + break + case Static: + if (domType !== 1 /* ELEMENT */) { + nextNode = onMismatch() + } else { + // determine anchor, adopt content + nextNode = node + // if the static vnode has its content stripped during build, + // adopt it from the server-rendered HTML. + const needToAdoptContent = !vnode.children.length + for (let i = 0; i < vnode.staticCount; i++) { + if (needToAdoptContent) vnode.children += nextNode.outerHTML + if (i === vnode.staticCount - 1) { + vnode.anchor = nextNode + } + nextNode = nextSibling(nextNode) + } + return nextNode + } + break + case Fragment: + if (!isFragmentStart) { + nextNode = onMismatch() + } else { + nextNode = hydrateFragment( + node, + vnode, + parentComponent, + parentSuspense, + optimized + ) + } + break + default: + if (shapeFlag & 1 /* ELEMENT */) { + if ( + domType !== 1 /* ELEMENT */ || + vnode.type !== node.tagName.toLowerCase() + ) { + nextNode = onMismatch() + } else { + nextNode = hydrateElement( + node, + vnode, + parentComponent, + parentSuspense, + optimized + ) + } + } else if (shapeFlag & 6 /* COMPONENT */) { + // when setting up the render effect, if the initial vnode already + // has .el set, the component will perform hydration instead of mount + // on its sub-tree. + const container = parentNode(node) + const hydrateComponent = () => { + mountComponent( + vnode, + container, + null, + parentComponent, + parentSuspense, + isSVGContainer(container), + optimized + ) + } + // async component + const loadAsync = vnode.type.__asyncLoader + if (loadAsync) { + loadAsync().then(hydrateComponent) + } else { + hydrateComponent() + } + // component may be async, so in the case of fragments we cannot rely + // on component's rendered output to determine the end of the fragment + // instead, we do a lookahead to find the end anchor node. + nextNode = isFragmentStart + ? locateClosingAsyncAnchor(node) + : nextSibling(node) + } else if (shapeFlag & 64 /* TELEPORT */) { + if (domType !== 8 /* COMMENT */) { + nextNode = onMismatch() + } else { + nextNode = vnode.type.hydrate( + node, + vnode, + parentComponent, + parentSuspense, + optimized, + rendererInternals, + hydrateChildren + ) + } + } else if (shapeFlag & 128 /* SUSPENSE */) { + nextNode = vnode.type.hydrate( + node, + vnode, + parentComponent, + parentSuspense, + isSVGContainer(parentNode(node)), + optimized, + rendererInternals, + hydrateNode + ) + } else if (process.env.NODE_ENV !== 'production') { + warn('Invalid HostVNode type:', type, `(${typeof type})`) + } + } + if (ref != null && parentComponent) { + setRef(ref, null, parentComponent, parentSuspense, vnode) + } + return nextNode + } + const hydrateElement = ( + el, + vnode, + parentComponent, + parentSuspense, + optimized + ) => { + optimized = optimized || !!vnode.dynamicChildren + const { props, patchFlag, shapeFlag, dirs } = vnode + // skip props & children if this is hoisted static nodes + if (patchFlag !== -1 /* HOISTED */) { + if (dirs) { + invokeDirectiveHook(vnode, null, parentComponent, 'created') + } + // props + if (props) { + if ( + !optimized || + (patchFlag & 16 /* FULL_PROPS */ || + patchFlag & 32) /* HYDRATE_EVENTS */ + ) { + for (const key in props) { + if (!isReservedProp(key) && isOn(key)) { + patchProp(el, key, null, props[key]) + } + } + } else if (props.onClick) { + // Fast path for click listeners (which is most often) to avoid + // iterating through props. + patchProp(el, 'onClick', null, props.onClick) + } + } + // vnode / directive hooks + let vnodeHooks + if ((vnodeHooks = props && props.onVnodeBeforeMount)) { + invokeVNodeHook(vnodeHooks, parentComponent, vnode) + } + if (dirs) { + invokeDirectiveHook(vnode, null, parentComponent, 'beforeMount') + } + if ((vnodeHooks = props && props.onVnodeMounted) || dirs) { + queueEffectWithSuspense(() => { + vnodeHooks && invokeVNodeHook(vnodeHooks, parentComponent, vnode) + dirs && invokeDirectiveHook(vnode, null, parentComponent, 'mounted') + }, parentSuspense) + } + // children + if ( + shapeFlag & 16 /* ARRAY_CHILDREN */ && + // skip if element has innerHTML / textContent + !(props && (props.innerHTML || props.textContent)) + ) { + let next = hydrateChildren( + el.firstChild, + vnode, + el, + parentComponent, + parentSuspense, + optimized + ) + let hasWarned = false + while (next) { + hasMismatch = true + if (process.env.NODE_ENV !== 'production' && !hasWarned) { + warn( + `Hydration children mismatch in <${vnode.type}>: ` + + `server rendered element contains more child nodes than client vdom.` + ) + hasWarned = true + } + // The SSRed DOM contains more nodes than it should. Remove them. + const cur = next + next = next.nextSibling + remove(cur) + } + } else if (shapeFlag & 8 /* TEXT_CHILDREN */) { + if (el.textContent !== vnode.children) { + hasMismatch = true + process.env.NODE_ENV !== 'production' && + warn( + `Hydration text content mismatch in <${vnode.type}>:\n` + + `- Client: ${el.textContent}\n` + + `- Server: ${vnode.children}` + ) + el.textContent = vnode.children + } + } + } + return el.nextSibling + } + const hydrateChildren = ( + node, + vnode, + container, + parentComponent, + parentSuspense, + optimized + ) => { + optimized = optimized || !!vnode.dynamicChildren + const children = vnode.children + const l = children.length + let hasWarned = false + for (let i = 0; i < l; i++) { + const vnode = optimized + ? children[i] + : (children[i] = normalizeVNode(children[i])) + if (node) { + node = hydrateNode( + node, + vnode, + parentComponent, + parentSuspense, + optimized + ) + } else { + hasMismatch = true + if (process.env.NODE_ENV !== 'production' && !hasWarned) { + warn( + `Hydration children mismatch in <${container.tagName.toLowerCase()}>: ` + + `server rendered element contains fewer child nodes than client vdom.` + ) + hasWarned = true + } + // the SSRed DOM didn't contain enough nodes. Mount the missing ones. + patch( + null, + vnode, + container, + null, + parentComponent, + parentSuspense, + isSVGContainer(container) + ) + } + } + return node + } + const hydrateFragment = ( + node, + vnode, + parentComponent, + parentSuspense, + optimized + ) => { + const container = parentNode(node) + const next = hydrateChildren( + nextSibling(node), + vnode, + container, + parentComponent, + parentSuspense, + optimized + ) + if (next && isComment(next) && next.data === ']') { + return nextSibling((vnode.anchor = next)) + } else { + // fragment didn't hydrate successfully, since we didn't get a end anchor + // back. This should have led to node/children mismatch warnings. + hasMismatch = true + // since the anchor is missing, we need to create one and insert it + insert((vnode.anchor = createComment(`]`)), container, next) + return next + } + } + const handleMismatch = ( + node, + vnode, + parentComponent, + parentSuspense, + isFragment + ) => { + hasMismatch = true + process.env.NODE_ENV !== 'production' && + warn( + `Hydration node mismatch:\n- Client vnode:`, + vnode.type, + `\n- Server rendered DOM:`, + node, + node.nodeType === 3 /* TEXT */ + ? `(text)` + : isComment(node) && node.data === '[' + ? `(start of fragment)` + : `` + ) + vnode.el = null + if (isFragment) { + // remove excessive fragment nodes + const end = locateClosingAsyncAnchor(node) + while (true) { + const next = nextSibling(node) + if (next && next !== end) { + remove(next) + } else { + break + } + } + } + const next = nextSibling(node) + const container = parentNode(node) + remove(node) + patch( + null, + vnode, + container, + next, + parentComponent, + parentSuspense, + isSVGContainer(container) + ) + return next + } + const locateClosingAsyncAnchor = node => { + let match = 0 + while (node) { + node = nextSibling(node) + if (node && isComment(node)) { + if (node.data === '[') match++ + if (node.data === ']') { + if (match === 0) { + return nextSibling(node) + } else { + match-- + } + } + } + } + return node + } + return [hydrate, hydrateNode] +} + +let supported +let perf +function startMeasure(instance, type) { + if (instance.appContext.config.performance && isSupported()) { + perf.mark(`vue-${type}-${instance.uid}`) + } +} +function endMeasure(instance, type) { + if (instance.appContext.config.performance && isSupported()) { + const startTag = `vue-${type}-${instance.uid}` + const endTag = startTag + `:end` + perf.mark(endTag) + perf.measure( + `<${formatComponentName(instance, instance.type)}> ${type}`, + startTag, + endTag + ) + perf.clearMarks(startTag) + perf.clearMarks(endTag) + } +} +function isSupported() { + if (supported !== undefined) { + return supported + } + /* eslint-disable no-restricted-globals */ + if (typeof window !== 'undefined' && window.performance) { + supported = true + perf = window.performance + } else { + supported = false + } + /* eslint-enable no-restricted-globals */ + return supported +} + +/** + * This is only called in esm-bundler builds. + * It is called when a renderer is created, in `baseCreateRenderer` so that + * importing runtime-core is side-effects free. + * + * istanbul-ignore-next + */ +function initFeatureFlags() { + let needWarn = false + if (typeof __VUE_OPTIONS_API__ !== 'boolean') { + needWarn = true + getGlobalThis().__VUE_OPTIONS_API__ = true + } + if (typeof __VUE_PROD_DEVTOOLS__ !== 'boolean') { + needWarn = true + getGlobalThis().__VUE_PROD_DEVTOOLS__ = false + } + if (process.env.NODE_ENV !== 'production' && needWarn) { + console.warn( + `You are running the esm-bundler build of Vue. It is recommended to ` + + `configure your bundler to explicitly replace feature flag globals ` + + `with boolean literals to get proper tree-shaking in the final bundle. ` + + `See http://link.vuejs.org/feature-flags for more details.` + ) + } +} + +const prodEffectOptions = { + scheduler: queueJob +} +function createDevEffectOptions(instance) { + return { + scheduler: queueJob, + onTrack: instance.rtc ? e => invokeArrayFns(instance.rtc, e) : void 0, + onTrigger: instance.rtg ? e => invokeArrayFns(instance.rtg, e) : void 0 + } +} +const queuePostRenderEffect = queueEffectWithSuspense +const setRef = (rawRef, oldRawRef, parentComponent, parentSuspense, vnode) => { + let value + if (!vnode) { + value = null + } else { + if (vnode.shapeFlag & 4 /* STATEFUL_COMPONENT */) { + value = vnode.component.proxy + } else { + value = vnode.el + } + } + const [owner, ref] = rawRef + if (process.env.NODE_ENV !== 'production' && !owner) { + warn( + `Missing ref owner context. ref cannot be used on hoisted vnodes. ` + + `A vnode with ref must be created inside the render function.` + ) + return + } + const oldRef = oldRawRef && oldRawRef[1] + const refs = owner.refs === EMPTY_OBJ ? (owner.refs = {}) : owner.refs + const setupState = owner.setupState + // unset old ref + if (oldRef != null && oldRef !== ref) { + if (isString(oldRef)) { + refs[oldRef] = null + if (hasOwn(setupState, oldRef)) { + setupState[oldRef] = null + } + } else if (isRef(oldRef)) { + oldRef.value = null + } + } + if (isString(ref)) { + const doSet = () => { + refs[ref] = value + if (hasOwn(setupState, ref)) { + setupState[ref] = value + } + } + // #1789: for non-null values, set them after render + // null values means this is unmount and it should not overwrite another + // ref with the same key + if (value) { + doSet.id = -1 + queuePostRenderEffect(doSet, parentSuspense) + } else { + doSet() + } + } else if (isRef(ref)) { + const doSet = () => { + ref.value = value + } + if (value) { + doSet.id = -1 + queuePostRenderEffect(doSet, parentSuspense) + } else { + doSet() + } + } else if (isFunction(ref)) { + callWithErrorHandling(ref, parentComponent, 12 /* FUNCTION_REF */, [ + value, + refs + ]) + } else if (process.env.NODE_ENV !== 'production') { + warn('Invalid template ref type:', value, `(${typeof value})`) + } +} +/** + * The createRenderer function accepts two generic arguments: + * HostNode and HostElement, corresponding to Node and Element types in the + * host environment. For example, for runtime-dom, HostNode would be the DOM + * `Node` interface and HostElement would be the DOM `Element` interface. + * + * Custom renderers can pass in the platform specific types like this: + * + * ``` js + * const { render, createApp } = createRenderer({ + * patchProp, + * ...nodeOps + * }) + * ``` + */ +function createRenderer(options) { + return baseCreateRenderer(options) +} +// Separate API for creating hydration-enabled renderer. +// Hydration logic is only used when calling this function, making it +// tree-shakable. +function createHydrationRenderer(options) { + return baseCreateRenderer(options, createHydrationFunctions) +} +// implementation +function baseCreateRenderer(options, createHydrationFns) { + // compile-time feature flags check + { + initFeatureFlags() + } + const { + insert: hostInsert, + remove: hostRemove, + patchProp: hostPatchProp, + forcePatchProp: hostForcePatchProp, + createElement: hostCreateElement, + createText: hostCreateText, + createComment: hostCreateComment, + setText: hostSetText, + setElementText: hostSetElementText, + parentNode: hostParentNode, + nextSibling: hostNextSibling, + setScopeId: hostSetScopeId = NOOP, + cloneNode: hostCloneNode, + insertStaticContent: hostInsertStaticContent + } = options + // Note: functions inside this closure should use `const xxx = () => {}` + // style in order to prevent being inlined by minifiers. + const patch = ( + n1, + n2, + container, + anchor = null, + parentComponent = null, + parentSuspense = null, + isSVG = false, + optimized = false + ) => { + // patching & not same type, unmount old tree + if (n1 && !isSameVNodeType(n1, n2)) { + anchor = getNextHostNode(n1) + unmount(n1, parentComponent, parentSuspense, true) + n1 = null + } + if (n2.patchFlag === -2 /* BAIL */) { + optimized = false + n2.dynamicChildren = null + } + const { type, ref, shapeFlag } = n2 + switch (type) { + case Text: + processText(n1, n2, container, anchor) + break + case Comment: + processCommentNode(n1, n2, container, anchor) + break + case Static: + if (n1 == null) { + mountStaticNode(n2, container, anchor, isSVG) + } else if (process.env.NODE_ENV !== 'production') { + patchStaticNode(n1, n2, container, isSVG) + } + break + case Fragment: + processFragment( + n1, + n2, + container, + anchor, + parentComponent, + parentSuspense, + isSVG, + optimized + ) + break + default: + if (shapeFlag & 1 /* ELEMENT */) { + processElement( + n1, + n2, + container, + anchor, + parentComponent, + parentSuspense, + isSVG, + optimized + ) + } else if (shapeFlag & 6 /* COMPONENT */) { + processComponent( + n1, + n2, + container, + anchor, + parentComponent, + parentSuspense, + isSVG, + optimized + ) + } else if (shapeFlag & 64 /* TELEPORT */) { + type.process( + n1, + n2, + container, + anchor, + parentComponent, + parentSuspense, + isSVG, + optimized, + internals + ) + } else if (shapeFlag & 128 /* SUSPENSE */) { + type.process( + n1, + n2, + container, + anchor, + parentComponent, + parentSuspense, + isSVG, + optimized, + internals + ) + } else if (process.env.NODE_ENV !== 'production') { + warn('Invalid VNode type:', type, `(${typeof type})`) + } + } + // set ref + if (ref != null && parentComponent) { + setRef(ref, n1 && n1.ref, parentComponent, parentSuspense, n2) + } + } + const processText = (n1, n2, container, anchor) => { + if (n1 == null) { + hostInsert((n2.el = hostCreateText(n2.children)), container, anchor) + } else { + const el = (n2.el = n1.el) + if (n2.children !== n1.children) { + hostSetText(el, n2.children) + } + } + } + const processCommentNode = (n1, n2, container, anchor) => { + if (n1 == null) { + hostInsert( + (n2.el = hostCreateComment(n2.children || '')), + container, + anchor + ) + } else { + // there's no support for dynamic comments + n2.el = n1.el + } + } + const mountStaticNode = (n2, container, anchor, isSVG) => { + ;[n2.el, n2.anchor] = hostInsertStaticContent( + n2.children, + container, + anchor, + isSVG + ) + } + /** + * Dev / HMR only + */ + const patchStaticNode = (n1, n2, container, isSVG) => { + // static nodes are only patched during dev for HMR + if (n2.children !== n1.children) { + const anchor = hostNextSibling(n1.anchor) + // remove existing + removeStaticNode(n1) + ;[n2.el, n2.anchor] = hostInsertStaticContent( + n2.children, + container, + anchor, + isSVG + ) + } else { + n2.el = n1.el + n2.anchor = n1.anchor + } + } + /** + * Dev / HMR only + */ + const moveStaticNode = (vnode, container, anchor) => { + let cur = vnode.el + const end = vnode.anchor + while (cur && cur !== end) { + const next = hostNextSibling(cur) + hostInsert(cur, container, anchor) + cur = next + } + hostInsert(end, container, anchor) + } + /** + * Dev / HMR only + */ + const removeStaticNode = vnode => { + let cur = vnode.el + while (cur && cur !== vnode.anchor) { + const next = hostNextSibling(cur) + hostRemove(cur) + cur = next + } + hostRemove(vnode.anchor) + } + const processElement = ( + n1, + n2, + container, + anchor, + parentComponent, + parentSuspense, + isSVG, + optimized + ) => { + isSVG = isSVG || n2.type === 'svg' + if (n1 == null) { + mountElement( + n2, + container, + anchor, + parentComponent, + parentSuspense, + isSVG, + optimized + ) + } else { + patchElement(n1, n2, parentComponent, parentSuspense, isSVG, optimized) + } + } + const mountElement = ( + vnode, + container, + anchor, + parentComponent, + parentSuspense, + isSVG, + optimized + ) => { + let el + let vnodeHook + const { + type, + props, + shapeFlag, + transition, + scopeId, + patchFlag, + dirs + } = vnode + if ( + !(process.env.NODE_ENV !== 'production') && + vnode.el && + hostCloneNode !== undefined && + patchFlag === -1 /* HOISTED */ + ) { + // If a vnode has non-null el, it means it's being reused. + // Only static vnodes can be reused, so its mounted DOM nodes should be + // exactly the same, and we can simply do a clone here. + // only do this in production since cloned trees cannot be HMR updated. + el = vnode.el = hostCloneNode(vnode.el) + } else { + el = vnode.el = hostCreateElement(vnode.type, isSVG, props && props.is) + // mount children first, since some props may rely on child content + // being already rendered, e.g. `