diff --git a/.gitignore b/.gitignore index 0a663edeb54caf4c87bce21c0ed3840b92c7c48b..6dcaa2b2bcf4440185ab29f45211fe5cadc8fa16 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 0000000000000000000000000000000000000000..f4552b86f583e46389dd8a148be86fab91fd4c8d --- /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,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); +} +.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 0000000000000000000000000000000000000000..4805521ed2bac3dabce1008a723a1eaa47a4fd7d --- /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('') == 0) { + match = html.match(endTag) + if (match) { + html = html.substring(match[0].length) + match[0].replace(endTag, parseEndTag) + chars = false + } + } else if (html.indexOf('<') == 0) { + match = html.match(startTag) + if (match) { + html = html.substring(match[0].length) + match[0].replace(startTag, parseStartTag) + chars = false + } + } + if (chars) { + index = html.indexOf('<') + var text2 = index < 0 ? html : html.substring(0, index) + html = index < 0 ? '' : html.substring(index) + if (handler.chars) { + handler.chars(text2) + } + } + } else { + html = html.replace( + new RegExp('([\\s\\S]*?)' + stack.last() + '[^>]*>'), + 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 += `${tag}>` + } + }, + 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 0000000000000000000000000000000000000000..23332189513fc171e74aa64cfbdcb0abde9a7540 --- /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. `` + if (shapeFlag & 8 /* TEXT_CHILDREN */) { + hostSetElementText(el, vnode.children) + } else if (shapeFlag & 16 /* ARRAY_CHILDREN */) { + mountChildren( + vnode.children, + el, + null, + parentComponent, + parentSuspense, + isSVG && type !== 'foreignObject', + optimized || !!vnode.dynamicChildren + ) + } + if (dirs) { + invokeDirectiveHook(vnode, null, parentComponent, 'created') + } + // props + if (props) { + for (const key in props) { + if (!isReservedProp(key)) { + hostPatchProp( + el, + key, + null, + props[key], + isSVG, + vnode.children, + parentComponent, + parentSuspense, + unmountChildren + ) + } + } + if ((vnodeHook = props.onVnodeBeforeMount)) { + invokeVNodeHook(vnodeHook, parentComponent, vnode) + } + } + // scopeId + setScopeId(el, scopeId, vnode, parentComponent) + // if (scopeId) { + // hostSetScopeId(el, scopeId) + // } + // if (parentComponent) { + // const treeOwnerId = parentComponent.type.__scopeId + // // vnode's own scopeId and the current patched component's scopeId is + // // different - this is a slot content node. + // if (treeOwnerId && treeOwnerId !== scopeId) { + // hostSetScopeId(el, treeOwnerId + '-s') + // } + // const parentScopeId = + // vnode === parentComponent.subTree && parentComponent.vnode.scopeId + // if (parentScopeId) { + // hostSetScopeId(el, parentScopeId) + // if (parentComponent.parent) { + // const treeOwnerId = parentComponent.parent.type.__scopeId + // // vnode's own scopeId and the current patched component's scopeId is + // // different - this is a slot content node. + // if (treeOwnerId && treeOwnerId !== parentScopeId) { + // hostSetScopeId(el, treeOwnerId + '-s') + // } + // } + // } + // } + } + if (process.env.NODE_ENV !== 'production' || __VUE_PROD_DEVTOOLS__) { + Object.defineProperty(el, '__vnode', { + value: vnode, + enumerable: false + }) + Object.defineProperty(el, '__vueParentComponent', { + value: parentComponent, + enumerable: false + }) + } + if (dirs) { + invokeDirectiveHook(vnode, null, parentComponent, 'beforeMount') + } + // #1583 For inside suspense + suspense not resolved case, enter hook should call when suspense resolved + // #1689 For inside suspense + suspense resolved case, just call it + const needCallTransitionHooks = + (!parentSuspense || (parentSuspense && parentSuspense.isResolved)) && + transition && + !transition.persisted + if (needCallTransitionHooks) { + transition.beforeEnter(el) + } + hostInsert(el, container, anchor) + if ( + (vnodeHook = props && props.onVnodeMounted) || + needCallTransitionHooks || + dirs + ) { + queuePostRenderEffect(() => { + vnodeHook && invokeVNodeHook(vnodeHook, parentComponent, vnode) + needCallTransitionHooks && transition.enter(el) + dirs && invokeDirectiveHook(vnode, null, parentComponent, 'mounted') + }, parentSuspense) + } + } + const setScopeId = (el, scopeId, vnode, parentComponent) => { + if (scopeId) { + hostSetScopeId(el, scopeId) + } + if (parentComponent) { + const treeOwnerId = parentComponent.type.__scopeId + // vnode's own scopeId and the current patched component's scopeId is + // different - this is a slot content node. + if (treeOwnerId && treeOwnerId !== scopeId) { + hostSetScopeId(el, treeOwnerId + '-s') + } + if (vnode === parentComponent.subTree) { + setScopeId( + el, + parentComponent.vnode.scopeId, + parentComponent.vnode, + parentComponent.parent + ) + } + } + } + const mountChildren = ( + children, + container, + anchor, + parentComponent, + parentSuspense, + isSVG, + optimized, + start = 0 + ) => { + for (let i = start; i < children.length; i++) { + const child = (children[i] = optimized + ? cloneIfMounted(children[i]) + : normalizeVNode(children[i])) + patch( + null, + child, + container, + anchor, + parentComponent, + parentSuspense, + isSVG, + optimized + ) + } + } + const patchElement = ( + n1, + n2, + parentComponent, + parentSuspense, + isSVG, + optimized + ) => { + const el = (n2.el = n1.el) + let { patchFlag, dynamicChildren, dirs } = n2 + // #1426 take the old vnode's patch flag into account since user may clone a + // compiler-generated vnode, which de-opts to FULL_PROPS + patchFlag |= n1.patchFlag & 16 /* FULL_PROPS */ + const oldProps = n1.props || EMPTY_OBJ + const newProps = n2.props || EMPTY_OBJ + let vnodeHook + if ((vnodeHook = newProps.onVnodeBeforeUpdate)) { + invokeVNodeHook(vnodeHook, parentComponent, n2, n1) + } + if (dirs) { + invokeDirectiveHook(n2, n1, parentComponent, 'beforeUpdate') + } + if (process.env.NODE_ENV !== 'production' && isHmrUpdating) { + // HMR updated, force full diff + patchFlag = 0 + optimized = false + dynamicChildren = null + } + if (patchFlag > 0) { + // the presence of a patchFlag means this element's render code was + // generated by the compiler and can take the fast path. + // in this path old node and new node are guaranteed to have the same shape + // (i.e. at the exact same position in the source template) + if (patchFlag & 16 /* FULL_PROPS */) { + // element props contain dynamic keys, full diff needed + patchProps( + el, + n2, + oldProps, + newProps, + parentComponent, + parentSuspense, + isSVG + ) + } else { + // class + // this flag is matched when the element has dynamic class bindings. + if (patchFlag & 2 /* CLASS */) { + if (oldProps.class !== newProps.class) { + hostPatchProp(el, 'class', null, newProps.class, isSVG) + } + } + // style + // this flag is matched when the element has dynamic style bindings + if (patchFlag & 4 /* STYLE */) { + hostPatchProp(el, 'style', oldProps.style, newProps.style, isSVG) + } + // props + // This flag is matched when the element has dynamic prop/attr bindings + // other than class and style. The keys of dynamic prop/attrs are saved for + // faster iteration. + // Note dynamic keys like :[foo]="bar" will cause this optimization to + // bail out and go through a full diff because we need to unset the old key + if (patchFlag & 8 /* PROPS */) { + // if the flag is present then dynamicProps must be non-null + const propsToUpdate = n2.dynamicProps + for (let i = 0; i < propsToUpdate.length; i++) { + const key = propsToUpdate[i] + const prev = oldProps[key] + const next = newProps[key] + if ( + next !== prev || + (hostForcePatchProp && hostForcePatchProp(el, key)) + ) { + hostPatchProp( + el, + key, + prev, + next, + isSVG, + n1.children, + parentComponent, + parentSuspense, + unmountChildren + ) + } + } + } + } + // text + // This flag is matched when the element has only dynamic text children. + if (patchFlag & 1 /* TEXT */) { + if (n1.children !== n2.children) { + hostSetElementText(el, n2.children) + } + } + } else if (!optimized && dynamicChildren == null) { + // unoptimized, full diff + patchProps( + el, + n2, + oldProps, + newProps, + parentComponent, + parentSuspense, + isSVG + ) + } + const areChildrenSVG = isSVG && n2.type !== 'foreignObject' + if (dynamicChildren) { + patchBlockChildren( + n1.dynamicChildren, + dynamicChildren, + el, + parentComponent, + parentSuspense, + areChildrenSVG + ) + if ( + process.env.NODE_ENV !== 'production' && + parentComponent && + parentComponent.type.__hmrId + ) { + traverseStaticChildren(n1, n2) + } + } else if (!optimized) { + // full diff + patchChildren( + n1, + n2, + el, + null, + parentComponent, + parentSuspense, + areChildrenSVG + ) + } + if ((vnodeHook = newProps.onVnodeUpdated) || dirs) { + queuePostRenderEffect(() => { + vnodeHook && invokeVNodeHook(vnodeHook, parentComponent, n2, n1) + dirs && invokeDirectiveHook(n2, n1, parentComponent, 'updated') + }, parentSuspense) + } + } + // The fast path for blocks. + const patchBlockChildren = ( + oldChildren, + newChildren, + fallbackContainer, + parentComponent, + parentSuspense, + isSVG + ) => { + for (let i = 0; i < newChildren.length; i++) { + const oldVNode = oldChildren[i] + const newVNode = newChildren[i] + // Determine the container (parent element) for the patch. + const container = + // - In the case of a Fragment, we need to provide the actual parent + // of the Fragment itself so it can move its children. + oldVNode.type === Fragment || + // - In the case of different nodes, there is going to be a replacement + // which also requires the correct parent container + !isSameVNodeType(oldVNode, newVNode) || + // - In the case of a component, it could contain anything. + oldVNode.shapeFlag & 6 /* COMPONENT */ || + oldVNode.shapeFlag & 64 /* TELEPORT */ + ? hostParentNode(oldVNode.el) + : // In other cases, the parent container is not actually used so we + // just pass the block element here to avoid a DOM parentNode call. + fallbackContainer + patch( + oldVNode, + newVNode, + container, + null, + parentComponent, + parentSuspense, + isSVG, + true + ) + } + } + const patchProps = ( + el, + vnode, + oldProps, + newProps, + parentComponent, + parentSuspense, + isSVG + ) => { + if (oldProps !== newProps) { + for (const key in newProps) { + if (isReservedProp(key)) continue + const next = newProps[key] + const prev = oldProps[key] + if ( + next !== prev || + (hostForcePatchProp && hostForcePatchProp(el, key)) + ) { + hostPatchProp( + el, + key, + prev, + next, + isSVG, + vnode.children, + parentComponent, + parentSuspense, + unmountChildren + ) + } + } + if (oldProps !== EMPTY_OBJ) { + for (const key in oldProps) { + if (!isReservedProp(key) && !(key in newProps)) { + hostPatchProp( + el, + key, + oldProps[key], + null, + isSVG, + vnode.children, + parentComponent, + parentSuspense, + unmountChildren + ) + } + } + } + } + } + const processFragment = ( + n1, + n2, + container, + anchor, + parentComponent, + parentSuspense, + isSVG, + optimized + ) => { + const fragmentStartAnchor = (n2.el = n1 ? n1.el : hostCreateText('')) + const fragmentEndAnchor = (n2.anchor = n1 ? n1.anchor : hostCreateText('')) + let { patchFlag, dynamicChildren } = n2 + if (patchFlag > 0) { + optimized = true + } + if (process.env.NODE_ENV !== 'production' && isHmrUpdating) { + // HMR updated, force full diff + patchFlag = 0 + optimized = false + dynamicChildren = null + } + if (n1 == null) { + hostInsert(fragmentStartAnchor, container, anchor) + hostInsert(fragmentEndAnchor, container, anchor) + // a fragment can only have array children + // since they are either generated by the compiler, or implicitly created + // from arrays. + mountChildren( + n2.children, + container, + fragmentEndAnchor, + parentComponent, + parentSuspense, + isSVG, + optimized + ) + } else { + if ( + patchFlag > 0 && + patchFlag & 64 /* STABLE_FRAGMENT */ && + dynamicChildren + ) { + // a stable fragment (template root or ) doesn't need to + // patch children order, but it may contain dynamicChildren. + patchBlockChildren( + n1.dynamicChildren, + dynamicChildren, + container, + parentComponent, + parentSuspense, + isSVG + ) + if ( + process.env.NODE_ENV !== 'production' && + parentComponent && + parentComponent.type.__hmrId + ) { + traverseStaticChildren(n1, n2) + } + } else { + // keyed / unkeyed, or manual fragments. + // for keyed & unkeyed, since they are compiler generated from v-for, + // each child is guaranteed to be a block so the fragment will never + // have dynamicChildren. + patchChildren( + n1, + n2, + container, + fragmentEndAnchor, + parentComponent, + parentSuspense, + isSVG, + optimized + ) + } + } + } + const processComponent = ( + n1, + n2, + container, + anchor, + parentComponent, + parentSuspense, + isSVG, + optimized + ) => { + if (n1 == null) { + if (n2.shapeFlag & 512 /* COMPONENT_KEPT_ALIVE */) { + parentComponent.ctx.activate(n2, container, anchor, isSVG, optimized) + } else { + mountComponent( + n2, + container, + anchor, + parentComponent, + parentSuspense, + isSVG, + optimized + ) + } + } else { + updateComponent(n1, n2, optimized) + } + } + const mountComponent = ( + initialVNode, + container, + anchor, + parentComponent, + parentSuspense, + isSVG, + optimized + ) => { + const instance = (initialVNode.component = createComponentInstance( + initialVNode, + parentComponent, + parentSuspense + )) + if (process.env.NODE_ENV !== 'production' && instance.type.__hmrId) { + registerHMR(instance) + } + if (process.env.NODE_ENV !== 'production') { + pushWarningContext(initialVNode) + startMeasure(instance, `mount`) + } + // inject renderer internals for keepAlive + if (isKeepAlive(initialVNode)) { + instance.ctx.renderer = internals + } + // resolve props and slots for setup context + if (process.env.NODE_ENV !== 'production') { + startMeasure(instance, `init`) + } + setupComponent(instance) + if (process.env.NODE_ENV !== 'production') { + endMeasure(instance, `init`) + } + // setup() is async. This component relies on async logic to be resolved + // before proceeding + if (instance.asyncDep) { + if (!parentSuspense) { + if (process.env.NODE_ENV !== 'production') + warn('async setup() is used without a suspense boundary!') + return + } + parentSuspense.registerDep(instance, setupRenderEffect) + // Give it a placeholder if this is not hydration + if (!initialVNode.el) { + const placeholder = (instance.subTree = createVNode(Comment)) + processCommentNode(null, placeholder, container, anchor) + } + return + } + setupRenderEffect( + instance, + initialVNode, + container, + anchor, + parentSuspense, + isSVG, + optimized + ) + if (process.env.NODE_ENV !== 'production') { + popWarningContext() + endMeasure(instance, `mount`) + } + } + const updateComponent = (n1, n2, optimized) => { + const instance = (n2.component = n1.component) + if (shouldUpdateComponent(n1, n2, optimized)) { + if (instance.asyncDep && !instance.asyncResolved) { + // async & still pending - just update props and slots + // since the component's reactive effect for render isn't set-up yet + if (process.env.NODE_ENV !== 'production') { + pushWarningContext(n2) + } + updateComponentPreRender(instance, n2, optimized) + if (process.env.NODE_ENV !== 'production') { + popWarningContext() + } + return + } else { + // normal update + instance.next = n2 + // in case the child component is also queued, remove it to avoid + // double updating the same child component in the same flush. + invalidateJob(instance.update) + // instance.update is the reactive effect runner. + instance.update() + } + } else { + // no update needed. just copy over properties + n2.component = n1.component + n2.el = n1.el + instance.vnode = n2 + } + } + const setupRenderEffect = ( + instance, + initialVNode, + container, + anchor, + parentSuspense, + isSVG, + optimized + ) => { + // create reactive effect for rendering + instance.update = effect(function componentEffect() { + if (!instance.isMounted) { + let vnodeHook + const { el, props } = initialVNode + const { bm, m, parent } = instance + // beforeMount hook + if (bm) { + invokeArrayFns(bm) + } + // onVnodeBeforeMount + if ((vnodeHook = props && props.onVnodeBeforeMount)) { + invokeVNodeHook(vnodeHook, parent, initialVNode) + } + // render + if (process.env.NODE_ENV !== 'production') { + startMeasure(instance, `render`) + } + const subTree = (instance.subTree = renderComponentRoot(instance)) + if (process.env.NODE_ENV !== 'production') { + endMeasure(instance, `render`) + } + if (el && hydrateNode) { + if (process.env.NODE_ENV !== 'production') { + startMeasure(instance, `hydrate`) + } + // vnode has adopted host node - perform hydration instead of mount. + hydrateNode(initialVNode.el, subTree, instance, parentSuspense) + if (process.env.NODE_ENV !== 'production') { + endMeasure(instance, `hydrate`) + } + } else { + if (process.env.NODE_ENV !== 'production') { + startMeasure(instance, `patch`) + } + patch( + null, + subTree, + container, + anchor, + instance, + parentSuspense, + isSVG + ) + if (process.env.NODE_ENV !== 'production') { + endMeasure(instance, `patch`) + } + initialVNode.el = subTree.el + } + // mounted hook + if (m) { + queuePostRenderEffect(m, parentSuspense) + } + // onVnodeMounted + if ((vnodeHook = props && props.onVnodeMounted)) { + queuePostRenderEffect(() => { + invokeVNodeHook(vnodeHook, parent, initialVNode) + }, parentSuspense) + } + // activated hook for keep-alive roots. + // #1742 activated hook must be accessed after first render + // since the hook may be injected by a child keep-alive + const { a } = instance + if ( + a && + initialVNode.shapeFlag & 256 /* COMPONENT_SHOULD_KEEP_ALIVE */ + ) { + queuePostRenderEffect(a, parentSuspense) + } + instance.isMounted = true + } else { + // updateComponent + // This is triggered by mutation of component's own state (next: null) + // OR parent calling processComponent (next: VNode) + let { next, bu, u, parent, vnode } = instance + let originNext = next + let vnodeHook + if (process.env.NODE_ENV !== 'production') { + pushWarningContext(next || instance.vnode) + } + if (next) { + updateComponentPreRender(instance, next, optimized) + } else { + next = vnode + } + next.el = vnode.el + // beforeUpdate hook + if (bu) { + invokeArrayFns(bu) + } + // onVnodeBeforeUpdate + if ((vnodeHook = next.props && next.props.onVnodeBeforeUpdate)) { + invokeVNodeHook(vnodeHook, parent, next, vnode) + } + // render + if (process.env.NODE_ENV !== 'production') { + startMeasure(instance, `render`) + } + const nextTree = renderComponentRoot(instance) + if (process.env.NODE_ENV !== 'production') { + endMeasure(instance, `render`) + } + const prevTree = instance.subTree + instance.subTree = nextTree + // reset refs + // only needed if previous patch had refs + if (instance.refs !== EMPTY_OBJ) { + instance.refs = {} + } + if (process.env.NODE_ENV !== 'production') { + startMeasure(instance, `patch`) + } + patch( + prevTree, + nextTree, + // parent may have changed if it's in a teleport + hostParentNode(prevTree.el), + // anchor may have changed if it's in a fragment + getNextHostNode(prevTree), + instance, + parentSuspense, + isSVG + ) + if (process.env.NODE_ENV !== 'production') { + endMeasure(instance, `patch`) + } + next.el = nextTree.el + if (originNext === null) { + // self-triggered update. In case of HOC, update parent component + // vnode el. HOC is indicated by parent instance's subTree pointing + // to child component's vnode + updateHOCHostEl(instance, nextTree.el) + } + // updated hook + if (u) { + queuePostRenderEffect(u, parentSuspense) + } + // onVnodeUpdated + if ((vnodeHook = next.props && next.props.onVnodeUpdated)) { + queuePostRenderEffect(() => { + invokeVNodeHook(vnodeHook, parent, next, vnode) + }, parentSuspense) + } + if (process.env.NODE_ENV !== 'production' || __VUE_PROD_DEVTOOLS__) { + devtoolsComponentUpdated(instance) + } + if (process.env.NODE_ENV !== 'production') { + popWarningContext() + } + } + }, process.env.NODE_ENV !== 'production' + ? createDevEffectOptions(instance) + : prodEffectOptions) + instance.update.allowRecurse = true + } + const updateComponentPreRender = (instance, nextVNode, optimized) => { + nextVNode.component = instance + const prevProps = instance.vnode.props + instance.vnode = nextVNode + instance.next = null + updateProps(instance, nextVNode.props, prevProps, optimized) + updateSlots(instance, nextVNode.children) + // props update may have triggered pre-flush watchers. + // flush them before the render update. + flushPreFlushCbs(undefined, instance.update) + } + const patchChildren = ( + n1, + n2, + container, + anchor, + parentComponent, + parentSuspense, + isSVG, + optimized = false + ) => { + const c1 = n1 && n1.children + const prevShapeFlag = n1 ? n1.shapeFlag : 0 + const c2 = n2.children + const { patchFlag, shapeFlag } = n2 + // fast path + if (patchFlag > 0) { + if (patchFlag & 128 /* KEYED_FRAGMENT */) { + // this could be either fully-keyed or mixed (some keyed some not) + // presence of patchFlag means children are guaranteed to be arrays + patchKeyedChildren( + c1, + c2, + container, + anchor, + parentComponent, + parentSuspense, + isSVG, + optimized + ) + return + } else if (patchFlag & 256 /* UNKEYED_FRAGMENT */) { + // unkeyed + patchUnkeyedChildren( + c1, + c2, + container, + anchor, + parentComponent, + parentSuspense, + isSVG, + optimized + ) + return + } + } + // children has 3 possibilities: text, array or no children. + if (shapeFlag & 8 /* TEXT_CHILDREN */) { + // text children fast path + if (prevShapeFlag & 16 /* ARRAY_CHILDREN */) { + unmountChildren(c1, parentComponent, parentSuspense) + } + if (c2 !== c1) { + hostSetElementText(container, c2) + } + } else { + if (prevShapeFlag & 16 /* ARRAY_CHILDREN */) { + // prev children was array + if (shapeFlag & 16 /* ARRAY_CHILDREN */) { + // two arrays, cannot assume anything, do full diff + patchKeyedChildren( + c1, + c2, + container, + anchor, + parentComponent, + parentSuspense, + isSVG, + optimized + ) + } else { + // no new children, just unmount old + unmountChildren(c1, parentComponent, parentSuspense, true) + } + } else { + // prev children was text OR null + // new children is array OR null + if (prevShapeFlag & 8 /* TEXT_CHILDREN */) { + hostSetElementText(container, '') + } + // mount new if array + if (shapeFlag & 16 /* ARRAY_CHILDREN */) { + mountChildren( + c2, + container, + anchor, + parentComponent, + parentSuspense, + isSVG, + optimized + ) + } + } + } + } + const patchUnkeyedChildren = ( + c1, + c2, + container, + anchor, + parentComponent, + parentSuspense, + isSVG, + optimized + ) => { + c1 = c1 || EMPTY_ARR + c2 = c2 || EMPTY_ARR + const oldLength = c1.length + const newLength = c2.length + const commonLength = Math.min(oldLength, newLength) + let i + for (i = 0; i < commonLength; i++) { + const nextChild = (c2[i] = optimized + ? cloneIfMounted(c2[i]) + : normalizeVNode(c2[i])) + patch( + c1[i], + nextChild, + container, + null, + parentComponent, + parentSuspense, + isSVG, + optimized + ) + } + if (oldLength > newLength) { + // remove old + unmountChildren(c1, parentComponent, parentSuspense, true, commonLength) + } else { + // mount new + mountChildren( + c2, + container, + anchor, + parentComponent, + parentSuspense, + isSVG, + optimized, + commonLength + ) + } + } + // can be all-keyed or mixed + const patchKeyedChildren = ( + c1, + c2, + container, + parentAnchor, + parentComponent, + parentSuspense, + isSVG, + optimized + ) => { + let i = 0 + const l2 = c2.length + let e1 = c1.length - 1 // prev ending index + let e2 = l2 - 1 // next ending index + // 1. sync from start + // (a b) c + // (a b) d e + while (i <= e1 && i <= e2) { + const n1 = c1[i] + const n2 = (c2[i] = optimized + ? cloneIfMounted(c2[i]) + : normalizeVNode(c2[i])) + if (isSameVNodeType(n1, n2)) { + patch( + n1, + n2, + container, + null, + parentComponent, + parentSuspense, + isSVG, + optimized + ) + } else { + break + } + i++ + } + // 2. sync from end + // a (b c) + // d e (b c) + while (i <= e1 && i <= e2) { + const n1 = c1[e1] + const n2 = (c2[e2] = optimized + ? cloneIfMounted(c2[e2]) + : normalizeVNode(c2[e2])) + if (isSameVNodeType(n1, n2)) { + patch( + n1, + n2, + container, + null, + parentComponent, + parentSuspense, + isSVG, + optimized + ) + } else { + break + } + e1-- + e2-- + } + // 3. common sequence + mount + // (a b) + // (a b) c + // i = 2, e1 = 1, e2 = 2 + // (a b) + // c (a b) + // i = 0, e1 = -1, e2 = 0 + if (i > e1) { + if (i <= e2) { + const nextPos = e2 + 1 + const anchor = nextPos < l2 ? c2[nextPos].el : parentAnchor + while (i <= e2) { + patch( + null, + (c2[i] = optimized ? cloneIfMounted(c2[i]) : normalizeVNode(c2[i])), + container, + anchor, + parentComponent, + parentSuspense, + isSVG + ) + i++ + } + } + } + // 4. common sequence + unmount + // (a b) c + // (a b) + // i = 2, e1 = 2, e2 = 1 + // a (b c) + // (b c) + // i = 0, e1 = 0, e2 = -1 + else if (i > e2) { + while (i <= e1) { + unmount(c1[i], parentComponent, parentSuspense, true) + i++ + } + } + // 5. unknown sequence + // [i ... e1 + 1]: a b [c d e] f g + // [i ... e2 + 1]: a b [e d c h] f g + // i = 2, e1 = 4, e2 = 5 + else { + const s1 = i // prev starting index + const s2 = i // next starting index + // 5.1 build key:index map for newChildren + const keyToNewIndexMap = new Map() + for (i = s2; i <= e2; i++) { + const nextChild = (c2[i] = optimized + ? cloneIfMounted(c2[i]) + : normalizeVNode(c2[i])) + if (nextChild.key != null) { + if ( + process.env.NODE_ENV !== 'production' && + keyToNewIndexMap.has(nextChild.key) + ) { + warn( + `Duplicate keys found during update:`, + JSON.stringify(nextChild.key), + `Make sure keys are unique.` + ) + } + keyToNewIndexMap.set(nextChild.key, i) + } + } + // 5.2 loop through old children left to be patched and try to patch + // matching nodes & remove nodes that are no longer present + let j + let patched = 0 + const toBePatched = e2 - s2 + 1 + let moved = false + // used to track whether any node has moved + let maxNewIndexSoFar = 0 + // works as Map + // Note that oldIndex is offset by +1 + // and oldIndex = 0 is a special value indicating the new node has + // no corresponding old node. + // used for determining longest stable subsequence + const newIndexToOldIndexMap = new Array(toBePatched) + for (i = 0; i < toBePatched; i++) newIndexToOldIndexMap[i] = 0 + for (i = s1; i <= e1; i++) { + const prevChild = c1[i] + if (patched >= toBePatched) { + // all new children have been patched so this can only be a removal + unmount(prevChild, parentComponent, parentSuspense, true) + continue + } + let newIndex + if (prevChild.key != null) { + newIndex = keyToNewIndexMap.get(prevChild.key) + } else { + // key-less node, try to locate a key-less node of the same type + for (j = s2; j <= e2; j++) { + if ( + newIndexToOldIndexMap[j - s2] === 0 && + isSameVNodeType(prevChild, c2[j]) + ) { + newIndex = j + break + } + } + } + if (newIndex === undefined) { + unmount(prevChild, parentComponent, parentSuspense, true) + } else { + newIndexToOldIndexMap[newIndex - s2] = i + 1 + if (newIndex >= maxNewIndexSoFar) { + maxNewIndexSoFar = newIndex + } else { + moved = true + } + patch( + prevChild, + c2[newIndex], + container, + null, + parentComponent, + parentSuspense, + isSVG, + optimized + ) + patched++ + } + } + // 5.3 move and mount + // generate longest stable subsequence only when nodes have moved + const increasingNewIndexSequence = moved + ? getSequence(newIndexToOldIndexMap) + : EMPTY_ARR + j = increasingNewIndexSequence.length - 1 + // looping backwards so that we can use last patched node as anchor + for (i = toBePatched - 1; i >= 0; i--) { + const nextIndex = s2 + i + const nextChild = c2[nextIndex] + const anchor = nextIndex + 1 < l2 ? c2[nextIndex + 1].el : parentAnchor + if (newIndexToOldIndexMap[i] === 0) { + // mount new + patch( + null, + nextChild, + container, + anchor, + parentComponent, + parentSuspense, + isSVG + ) + } else if (moved) { + // move if: + // There is no stable subsequence (e.g. a reverse) + // OR current node is not among the stable sequence + if (j < 0 || i !== increasingNewIndexSequence[j]) { + move(nextChild, container, anchor, 2 /* REORDER */) + } else { + j-- + } + } + } + } + } + const move = (vnode, container, anchor, moveType, parentSuspense = null) => { + const { el, type, transition, children, shapeFlag } = vnode + if (shapeFlag & 6 /* COMPONENT */) { + move(vnode.component.subTree, container, anchor, moveType) + return + } + if (shapeFlag & 128 /* SUSPENSE */) { + vnode.suspense.move(container, anchor, moveType) + return + } + if (shapeFlag & 64 /* TELEPORT */) { + type.move(vnode, container, anchor, internals) + return + } + if (type === Fragment) { + hostInsert(el, container, anchor) + for (let i = 0; i < children.length; i++) { + move(children[i], container, anchor, moveType) + } + hostInsert(vnode.anchor, container, anchor) + return + } + // static node move can only happen when force updating HMR + if (process.env.NODE_ENV !== 'production' && type === Static) { + moveStaticNode(vnode, container, anchor) + return + } + // single nodes + const needTransition = + moveType !== 2 /* REORDER */ && shapeFlag & 1 /* ELEMENT */ && transition + if (needTransition) { + if (moveType === 0 /* ENTER */) { + transition.beforeEnter(el) + hostInsert(el, container, anchor) + queuePostRenderEffect(() => transition.enter(el), parentSuspense) + } else { + const { leave, delayLeave, afterLeave } = transition + const remove = () => hostInsert(el, container, anchor) + const performLeave = () => { + leave(el, () => { + remove() + afterLeave && afterLeave() + }) + } + if (delayLeave) { + delayLeave(el, remove, performLeave) + } else { + performLeave() + } + } + } else { + hostInsert(el, container, anchor) + } + } + const unmount = ( + vnode, + parentComponent, + parentSuspense, + doRemove = false + ) => { + const { + type, + props, + ref, + children, + dynamicChildren, + shapeFlag, + patchFlag, + dirs + } = vnode + // unset ref + if (ref != null && parentComponent) { + setRef(ref, null, parentComponent, parentSuspense, null) + } + if (shapeFlag & 256 /* COMPONENT_SHOULD_KEEP_ALIVE */) { + parentComponent.ctx.deactivate(vnode) + return + } + const shouldInvokeDirs = shapeFlag & 1 /* ELEMENT */ && dirs + let vnodeHook + if ((vnodeHook = props && props.onVnodeBeforeUnmount)) { + invokeVNodeHook(vnodeHook, parentComponent, vnode) + } + if (shapeFlag & 6 /* COMPONENT */) { + unmountComponent(vnode.component, parentSuspense, doRemove) + } else { + if (shapeFlag & 128 /* SUSPENSE */) { + vnode.suspense.unmount(parentSuspense, doRemove) + return + } + if (shouldInvokeDirs) { + invokeDirectiveHook(vnode, null, parentComponent, 'beforeUnmount') + } + if ( + dynamicChildren && + // #1153: fast path should not be taken for non-stable (v-for) fragments + (type !== Fragment || + (patchFlag > 0 && patchFlag & 64) /* STABLE_FRAGMENT */) + ) { + // fast path for block nodes: only need to unmount dynamic children. + unmountChildren(dynamicChildren, parentComponent, parentSuspense) + } else if (shapeFlag & 16 /* ARRAY_CHILDREN */) { + unmountChildren(children, parentComponent, parentSuspense) + } + // an unmounted teleport should always remove its children + if (shapeFlag & 64 /* TELEPORT */) { + vnode.type.remove(vnode, internals) + } + if (doRemove) { + remove(vnode) + } + } + if ((vnodeHook = props && props.onVnodeUnmounted) || shouldInvokeDirs) { + queuePostRenderEffect(() => { + vnodeHook && invokeVNodeHook(vnodeHook, parentComponent, vnode) + shouldInvokeDirs && + invokeDirectiveHook(vnode, null, parentComponent, 'unmounted') + }, parentSuspense) + } + } + const remove = vnode => { + const { type, el, anchor, transition } = vnode + if (type === Fragment) { + removeFragment(el, anchor) + return + } + if (process.env.NODE_ENV !== 'production' && type === Static) { + removeStaticNode(vnode) + return + } + const performRemove = () => { + hostRemove(el) + if (transition && !transition.persisted && transition.afterLeave) { + transition.afterLeave() + } + } + if ( + vnode.shapeFlag & 1 /* ELEMENT */ && + transition && + !transition.persisted + ) { + const { leave, delayLeave } = transition + const performLeave = () => leave(el, performRemove) + if (delayLeave) { + delayLeave(vnode.el, performRemove, performLeave) + } else { + performLeave() + } + } else { + performRemove() + } + } + const removeFragment = (cur, end) => { + // For fragments, directly remove all contained DOM nodes. + // (fragment child nodes cannot have transition) + let next + while (cur !== end) { + next = hostNextSibling(cur) + hostRemove(cur) + cur = next + } + hostRemove(end) + } + const unmountComponent = (instance, parentSuspense, doRemove) => { + if (process.env.NODE_ENV !== 'production' && instance.type.__hmrId) { + unregisterHMR(instance) + } + const { bum, effects, update, subTree, um } = instance + // beforeUnmount hook + if (bum) { + invokeArrayFns(bum) + } + if (effects) { + for (let i = 0; i < effects.length; i++) { + stop(effects[i]) + } + } + // update may be null if a component is unmounted before its async + // setup has resolved. + if (update) { + stop(update) + unmount(subTree, instance, parentSuspense, doRemove) + } + // unmounted hook + if (um) { + queuePostRenderEffect(um, parentSuspense) + } + queuePostRenderEffect(() => { + instance.isUnmounted = true + }, parentSuspense) + // A component with async dep inside a pending suspense is unmounted before + // its async dep resolves. This should remove the dep from the suspense, and + // cause the suspense to resolve immediately if that was the last dep. + if ( + parentSuspense && + !parentSuspense.isResolved && + !parentSuspense.isUnmounted && + instance.asyncDep && + !instance.asyncResolved + ) { + parentSuspense.deps-- + if (parentSuspense.deps === 0) { + parentSuspense.resolve() + } + } + if (process.env.NODE_ENV !== 'production' || __VUE_PROD_DEVTOOLS__) { + devtoolsComponentRemoved(instance) + } + } + const unmountChildren = ( + children, + parentComponent, + parentSuspense, + doRemove = false, + start = 0 + ) => { + for (let i = start; i < children.length; i++) { + unmount(children[i], parentComponent, parentSuspense, doRemove) + } + } + const getNextHostNode = vnode => { + if (vnode.shapeFlag & 6 /* COMPONENT */) { + return getNextHostNode(vnode.component.subTree) + } + if (vnode.shapeFlag & 128 /* SUSPENSE */) { + return vnode.suspense.next() + } + return hostNextSibling(vnode.anchor || vnode.el) + } + /** + * #1156 + * When a component is HMR-enabled, we need to make sure that all static nodes + * inside a block also inherit the DOM element from the previous tree so that + * HMR updates (which are full updates) can retrieve the element for patching. + * + * Dev only. + */ + const traverseStaticChildren = (n1, n2) => { + const ch1 = n1.children + const ch2 = n2.children + if (isArray(ch1) && isArray(ch2)) { + for (let i = 0; i < ch1.length; i++) { + // this is only called in the optimized path so array children are + // guaranteed to be vnodes + const c1 = ch1[i] + const c2 = (ch2[i] = cloneIfMounted(ch2[i])) + if (c2.shapeFlag & 1 /* ELEMENT */ && !c2.dynamicChildren) { + if (c2.patchFlag <= 0 || c2.patchFlag === 32 /* HYDRATE_EVENTS */) { + c2.el = c1.el + } + traverseStaticChildren(c1, c2) + } + } + } + } + const render = (vnode, container) => { + if (vnode == null) { + if (container._vnode) { + unmount(container._vnode, null, null, true) + } + } else { + patch(container._vnode || null, vnode, container) + } + flushPostFlushCbs() + container._vnode = vnode + } + const internals = { + p: patch, + um: unmount, + m: move, + r: remove, + mt: mountComponent, + mc: mountChildren, + pc: patchChildren, + pbc: patchBlockChildren, + n: getNextHostNode, + o: options + } + let hydrate + let hydrateNode + if (createHydrationFns) { + ;[hydrate, hydrateNode] = createHydrationFns(internals) + } + return { + render, + hydrate, + createApp: createAppAPI(render, hydrate) + } +} +function invokeVNodeHook(hook, instance, vnode, prevVNode = null) { + callWithAsyncErrorHandling(hook, instance, 7 /* VNODE_HOOK */, [ + vnode, + prevVNode + ]) +} +// https://en.wikipedia.org/wiki/Longest_increasing_subsequence +function getSequence(arr) { + const p = arr.slice() + const result = [0] + let i, j, u, v, c + const len = arr.length + for (i = 0; i < len; i++) { + const arrI = arr[i] + if (arrI !== 0) { + j = result[result.length - 1] + if (arr[j] < arrI) { + p[i] = j + result.push(i) + continue + } + u = 0 + v = result.length - 1 + while (u < v) { + c = ((u + v) / 2) | 0 + if (arr[result[c]] < arrI) { + u = c + 1 + } else { + v = c + } + } + if (arrI < arr[result[u]]) { + if (u > 0) { + p[i] = result[u - 1] + } + result[u] = i + } + } + } + u = result.length + v = result[u - 1] + while (u-- > 0) { + result[u] = v + v = p[v] + } + return result +} + +// Simple effect. +function watchEffect(effect, options) { + return doWatch(effect, null, options) +} +// initial value for watchers to trigger on undefined initial values +const INITIAL_WATCHER_VALUE = {} +// implementation +function watch(source, cb, options) { + if (process.env.NODE_ENV !== 'production' && !isFunction(cb)) { + warn( + `\`watch(fn, options?)\` signature has been moved to a separate API. ` + + `Use \`watchEffect(fn, options?)\` instead. \`watch\` now only ` + + `supports \`watch(source, cb, options?) signature.` + ) + } + return doWatch(source, cb, options) +} +function doWatch( + source, + cb, + { immediate, deep, flush, onTrack, onTrigger } = EMPTY_OBJ, + instance = currentInstance +) { + if (process.env.NODE_ENV !== 'production' && !cb) { + if (immediate !== undefined) { + warn( + `watch() "immediate" option is only respected when using the ` + + `watch(source, callback, options?) signature.` + ) + } + if (deep !== undefined) { + warn( + `watch() "deep" option is only respected when using the ` + + `watch(source, callback, options?) signature.` + ) + } + } + const warnInvalidSource = s => { + warn( + `Invalid watch source: `, + s, + `A watch source can only be a getter/effect function, a ref, ` + + `a reactive object, or an array of these types.` + ) + } + let getter + const isRefSource = isRef(source) + if (isRefSource) { + getter = () => source.value + } else if (isReactive(source)) { + getter = () => source + deep = true + } else if (isArray(source)) { + getter = () => + source.map(s => { + if (isRef(s)) { + return s.value + } else if (isReactive(s)) { + return traverse(s) + } else if (isFunction(s)) { + return callWithErrorHandling(s, instance, 2 /* WATCH_GETTER */) + } else { + process.env.NODE_ENV !== 'production' && warnInvalidSource(s) + } + }) + } else if (isFunction(source)) { + if (cb) { + // getter with cb + getter = () => + callWithErrorHandling(source, instance, 2 /* WATCH_GETTER */) + } else { + // no cb -> simple effect + getter = () => { + if (instance && instance.isUnmounted) { + return + } + if (cleanup) { + cleanup() + } + return callWithErrorHandling(source, instance, 3 /* WATCH_CALLBACK */, [ + onInvalidate + ]) + } + } + } else { + getter = NOOP + process.env.NODE_ENV !== 'production' && warnInvalidSource(source) + } + if (cb && deep) { + const baseGetter = getter + getter = () => traverse(baseGetter()) + } + let cleanup + const onInvalidate = fn => { + cleanup = runner.options.onStop = () => { + callWithErrorHandling(fn, instance, 4 /* WATCH_CLEANUP */) + } + } + let oldValue = isArray(source) ? [] : INITIAL_WATCHER_VALUE + const job = () => { + if (!runner.active) { + return + } + if (cb) { + // watch(source, cb) + const newValue = runner() + if (deep || isRefSource || hasChanged(newValue, oldValue)) { + // cleanup before running cb again + if (cleanup) { + cleanup() + } + callWithAsyncErrorHandling(cb, instance, 3 /* WATCH_CALLBACK */, [ + newValue, + // pass undefined as the old value when it's changed for the first time + oldValue === INITIAL_WATCHER_VALUE ? undefined : oldValue, + onInvalidate + ]) + oldValue = newValue + } + } else { + // watchEffect + runner() + } + } + // important: mark the job as a watcher callback so that scheduler knows it + // it is allowed to self-trigger (#1727) + job.allowRecurse = !!cb + let scheduler + if (flush === 'sync') { + scheduler = job + } else if (flush === 'pre') { + // ensure it's queued before component updates (which have positive ids) + job.id = -1 + scheduler = () => { + if (!instance || instance.isMounted) { + queuePreFlushCb(job) + } else { + // with 'pre' option, the first call must happen before + // the component is mounted so it is called synchronously. + job() + } + } + } else { + scheduler = () => queuePostRenderEffect(job, instance && instance.suspense) + } + const runner = effect(getter, { + lazy: true, + onTrack, + onTrigger, + scheduler + }) + recordInstanceBoundEffect(runner) + // initial run + if (cb) { + if (immediate) { + job() + } else { + oldValue = runner() + } + } else { + runner() + } + return () => { + stop(runner) + if (instance) { + remove(instance.effects, runner) + } + } +} +// this.$watch +function instanceWatch(source, cb, options) { + const publicThis = this.proxy + const getter = isString(source) + ? () => publicThis[source] + : source.bind(publicThis) + return doWatch(getter, cb.bind(publicThis), options, this) +} +function traverse(value, seen = new Set()) { + if (!isObject(value) || seen.has(value)) { + return value + } + seen.add(value) + if (isRef(value)) { + traverse(value.value, seen) + } else if (isArray(value)) { + for (let i = 0; i < value.length; i++) { + traverse(value[i], seen) + } + } else if (value instanceof Map) { + value.forEach((v, key) => { + // to register mutation dep for existing keys + traverse(value.get(key), seen) + }) + } else if (value instanceof Set) { + value.forEach(v => { + traverse(v, seen) + }) + } else { + for (const key in value) { + traverse(value[key], seen) + } + } + return value +} + +function provide(key, value) { + if (!currentInstance) { + if (process.env.NODE_ENV !== 'production') { + warn(`provide() can only be used inside setup().`) + } + } else { + let provides = currentInstance.provides + // by default an instance inherits its parent's provides object + // but when it needs to provide values of its own, it creates its + // own provides object using parent provides object as prototype. + // this way in `inject` we can simply look up injections from direct + // parent and let the prototype chain do the work. + const parentProvides = + currentInstance.parent && currentInstance.parent.provides + if (parentProvides === provides) { + provides = currentInstance.provides = Object.create(parentProvides) + } + // TS doesn't allow symbol as index type + provides[key] = value + } +} +function inject(key, defaultValue) { + // fallback to `currentRenderingInstance` so that this can be called in + // a functional component + const instance = currentInstance || currentRenderingInstance + if (instance) { + const provides = instance.provides + if (key in provides) { + // TS doesn't allow symbol as index type + return provides[key] + } else if (arguments.length > 1) { + return defaultValue + } else if (process.env.NODE_ENV !== 'production') { + warn(`injection "${String(key)}" not found.`) + } + } else if (process.env.NODE_ENV !== 'production') { + warn(`inject() can only be used inside setup() or functional components.`) + } +} + +function createDuplicateChecker() { + const cache = Object.create(null) + return (type, key) => { + if (cache[key]) { + warn(`${type} property "${key}" is already defined in ${cache[key]}.`) + } else { + cache[key] = type + } + } +} +let isInBeforeCreate = false +function applyOptions( + instance, + options, + deferredData = [], + deferredWatch = [], + asMixin = false +) { + const { + // composition + mixins, + extends: extendsOptions, + // state + data: dataOptions, + computed: computedOptions, + methods, + watch: watchOptions, + provide: provideOptions, + inject: injectOptions, + // assets + components, + directives, + // lifecycle + beforeMount, + mounted, + beforeUpdate, + updated, + activated, + deactivated, + beforeUnmount, + unmounted, + render, + renderTracked, + renderTriggered, + errorCaptured + } = options + const publicThis = instance.proxy + const ctx = instance.ctx + const globalMixins = instance.appContext.mixins + if (asMixin && render && instance.render === NOOP) { + instance.render = render + } + // applyOptions is called non-as-mixin once per instance + if (!asMixin) { + isInBeforeCreate = true + callSyncHook('beforeCreate', options, publicThis, globalMixins) + isInBeforeCreate = false + // global mixins are applied first + applyMixins(instance, globalMixins, deferredData, deferredWatch) + } + // extending a base component... + if (extendsOptions) { + applyOptions(instance, extendsOptions, deferredData, deferredWatch, true) + } + // local mixins + if (mixins) { + applyMixins(instance, mixins, deferredData, deferredWatch) + } + const checkDuplicateProperties = + process.env.NODE_ENV !== 'production' ? createDuplicateChecker() : null + if (process.env.NODE_ENV !== 'production') { + const [propsOptions] = instance.propsOptions + if (propsOptions) { + for (const key in propsOptions) { + checkDuplicateProperties('Props' /* PROPS */, key) + } + } + } + // options initialization order (to be consistent with Vue 2): + // - props (already done outside of this function) + // - inject + // - methods + // - data (deferred since it relies on `this` access) + // - computed + // - watch (deferred since it relies on `this` access) + if (injectOptions) { + if (isArray(injectOptions)) { + for (let i = 0; i < injectOptions.length; i++) { + const key = injectOptions[i] + ctx[key] = inject(key) + if (process.env.NODE_ENV !== 'production') { + checkDuplicateProperties('Inject' /* INJECT */, key) + } + } + } else { + for (const key in injectOptions) { + const opt = injectOptions[key] + if (isObject(opt)) { + ctx[key] = inject(opt.from, opt.default) + } else { + ctx[key] = inject(opt) + } + if (process.env.NODE_ENV !== 'production') { + checkDuplicateProperties('Inject' /* INJECT */, key) + } + } + } + } + if (methods) { + for (const key in methods) { + const methodHandler = methods[key] + if (isFunction(methodHandler)) { + ctx[key] = methodHandler.bind(publicThis) + if (process.env.NODE_ENV !== 'production') { + checkDuplicateProperties('Methods' /* METHODS */, key) + } + } else if (process.env.NODE_ENV !== 'production') { + warn( + `Method "${key}" has type "${typeof methodHandler}" in the component definition. ` + + `Did you reference the function correctly?` + ) + } + } + } + if (!asMixin) { + if (deferredData.length) { + deferredData.forEach(dataFn => resolveData(instance, dataFn, publicThis)) + } + if (dataOptions) { + resolveData(instance, dataOptions, publicThis) + } + if (process.env.NODE_ENV !== 'production') { + const rawData = toRaw(instance.data) + for (const key in rawData) { + checkDuplicateProperties('Data' /* DATA */, key) + // expose data on ctx during dev + if (key[0] !== '$' && key[0] !== '_') { + Object.defineProperty(ctx, key, { + configurable: true, + enumerable: true, + get: () => rawData[key], + set: NOOP + }) + } + } + } + } else if (dataOptions) { + deferredData.push(dataOptions) + } + if (computedOptions) { + for (const key in computedOptions) { + const opt = computedOptions[key] + const get = isFunction(opt) + ? opt.bind(publicThis, publicThis) + : isFunction(opt.get) + ? opt.get.bind(publicThis, publicThis) + : NOOP + if (process.env.NODE_ENV !== 'production' && get === NOOP) { + warn(`Computed property "${key}" has no getter.`) + } + const set = + !isFunction(opt) && isFunction(opt.set) + ? opt.set.bind(publicThis) + : process.env.NODE_ENV !== 'production' + ? () => { + warn( + `Write operation failed: computed property "${key}" is readonly.` + ) + } + : NOOP + const c = computed$1({ + get, + set + }) + Object.defineProperty(ctx, key, { + enumerable: true, + configurable: true, + get: () => c.value, + set: v => (c.value = v) + }) + if (process.env.NODE_ENV !== 'production') { + checkDuplicateProperties('Computed' /* COMPUTED */, key) + } + } + } + if (watchOptions) { + deferredWatch.push(watchOptions) + } + if (!asMixin && deferredWatch.length) { + deferredWatch.forEach(watchOptions => { + for (const key in watchOptions) { + createWatcher(watchOptions[key], ctx, publicThis, key) + } + }) + } + if (provideOptions) { + const provides = isFunction(provideOptions) + ? provideOptions.call(publicThis) + : provideOptions + for (const key in provides) { + provide(key, provides[key]) + } + } + // asset options. + // To reduce memory usage, only components with mixins or extends will have + // resolved asset registry attached to instance. + if (asMixin) { + if (components) { + extend( + instance.components || + (instance.components = extend({}, instance.type.components)), + components + ) + } + if (directives) { + extend( + instance.directives || + (instance.directives = extend({}, instance.type.directives)), + directives + ) + } + } + // lifecycle options + if (!asMixin) { + callSyncHook('created', options, publicThis, globalMixins) + } + if (beforeMount) { + onBeforeMount(beforeMount.bind(publicThis)) + } + if (mounted) { + onMounted(mounted.bind(publicThis)) + } + if (beforeUpdate) { + onBeforeUpdate(beforeUpdate.bind(publicThis)) + } + if (updated) { + onUpdated(updated.bind(publicThis)) + } + if (activated) { + onActivated(activated.bind(publicThis)) + } + if (deactivated) { + onDeactivated(deactivated.bind(publicThis)) + } + if (errorCaptured) { + onErrorCaptured(errorCaptured.bind(publicThis)) + } + if (renderTracked) { + onRenderTracked(renderTracked.bind(publicThis)) + } + if (renderTriggered) { + onRenderTriggered(renderTriggered.bind(publicThis)) + } + if (beforeUnmount) { + onBeforeUnmount(beforeUnmount.bind(publicThis)) + } + if (unmounted) { + onUnmounted(unmounted.bind(publicThis)) + } +} +function callSyncHook(name, options, ctx, globalMixins) { + callHookFromMixins(name, globalMixins, ctx) + const { extends: base, mixins } = options + if (base) { + callHookFromExtends(name, base, ctx) + } + if (mixins) { + callHookFromMixins(name, mixins, ctx) + } + const selfHook = options[name] + if (selfHook) { + selfHook.call(ctx) + } +} +function callHookFromExtends(name, base, ctx) { + if (base.extends) { + callHookFromExtends(name, base.extends, ctx) + } + const baseHook = base[name] + if (baseHook) { + baseHook.call(ctx) + } +} +function callHookFromMixins(name, mixins, ctx) { + for (let i = 0; i < mixins.length; i++) { + const chainedMixins = mixins[i].mixins + if (chainedMixins) { + callHookFromMixins(name, chainedMixins, ctx) + } + const fn = mixins[i][name] + if (fn) { + fn.call(ctx) + } + } +} +function applyMixins(instance, mixins, deferredData, deferredWatch) { + for (let i = 0; i < mixins.length; i++) { + applyOptions(instance, mixins[i], deferredData, deferredWatch, true) + } +} +function resolveData(instance, dataFn, publicThis) { + if (process.env.NODE_ENV !== 'production' && !isFunction(dataFn)) { + warn( + `The data option must be a function. ` + + `Plain object usage is no longer supported.` + ) + } + const data = dataFn.call(publicThis, publicThis) + if (process.env.NODE_ENV !== 'production' && isPromise(data)) { + warn( + `data() returned a Promise - note data() cannot be async; If you ` + + `intend to perform data fetching before component renders, use ` + + `async setup() + .` + ) + } + if (!isObject(data)) { + process.env.NODE_ENV !== 'production' && + warn(`data() should return an object.`) + } else if (instance.data === EMPTY_OBJ) { + instance.data = reactive(data) + } else { + // existing data: this is a mixin or extends. + extend(instance.data, data) + } +} +function createWatcher(raw, ctx, publicThis, key) { + const getter = () => publicThis[key] + if (isString(raw)) { + const handler = ctx[raw] + if (isFunction(handler)) { + watch(getter, handler) + } else if (process.env.NODE_ENV !== 'production') { + warn(`Invalid watch handler specified by key "${raw}"`, handler) + } + } else if (isFunction(raw)) { + watch(getter, raw.bind(publicThis)) + } else if (isObject(raw)) { + if (isArray(raw)) { + raw.forEach(r => createWatcher(r, ctx, publicThis, key)) + } else { + const handler = isFunction(raw.handler) + ? raw.handler.bind(publicThis) + : ctx[raw.handler] + if (isFunction(handler)) { + watch(getter, handler, raw) + } else if (process.env.NODE_ENV !== 'production') { + warn(`Invalid watch handler specified by key "${raw.handler}"`, handler) + } + } + } else if (process.env.NODE_ENV !== 'production') { + warn(`Invalid watch option: "${key}"`) + } +} +function resolveMergedOptions(instance) { + const raw = instance.type + const { __merged, mixins, extends: extendsOptions } = raw + if (__merged) return __merged + const globalMixins = instance.appContext.mixins + if (!globalMixins.length && !mixins && !extendsOptions) return raw + const options = {} + globalMixins.forEach(m => mergeOptions(options, m, instance)) + mergeOptions(options, raw, instance) + return (raw.__merged = options) +} +function mergeOptions(to, from, instance) { + const strats = instance.appContext.config.optionMergeStrategies + const { mixins, extends: extendsOptions } = from + extendsOptions && mergeOptions(to, extendsOptions, instance) + mixins && mixins.forEach(m => mergeOptions(to, m, instance)) + for (const key in from) { + if (strats && hasOwn(strats, key)) { + to[key] = strats[key](to[key], from[key], instance.proxy, key) + } else { + to[key] = from[key] + } + } +} + +const publicPropertiesMap = extend(Object.create(null), { + $: i => i, + $el: i => i.vnode.el, + $data: i => i.data, + $props: i => + process.env.NODE_ENV !== 'production' ? shallowReadonly(i.props) : i.props, + $attrs: i => + process.env.NODE_ENV !== 'production' ? shallowReadonly(i.attrs) : i.attrs, + $slots: i => + process.env.NODE_ENV !== 'production' ? shallowReadonly(i.slots) : i.slots, + $refs: i => + process.env.NODE_ENV !== 'production' ? shallowReadonly(i.refs) : i.refs, + $parent: i => i.parent && i.parent.proxy, + $root: i => i.root && i.root.proxy, + $emit: i => i.emit, + $options: i => (__VUE_OPTIONS_API__ ? resolveMergedOptions(i) : i.type), + $forceUpdate: i => () => queueJob(i.update), + $nextTick: () => nextTick, + $watch: i => (__VUE_OPTIONS_API__ ? instanceWatch.bind(i) : NOOP) +}) +const PublicInstanceProxyHandlers = { + get({ _: instance }, key) { + const { + ctx, + setupState, + data, + props, + accessCache, + type, + appContext + } = instance + // let @vue/reactivity know it should never observe Vue public instances. + if (key === '__v_skip' /* SKIP */) { + return true + } + // data / props / ctx + // This getter gets called for every property access on the render context + // during render and is a major hotspot. The most expensive part of this + // is the multiple hasOwn() calls. It's much faster to do a simple property + // access on a plain object, so we use an accessCache object (with null + // prototype) to memoize what access type a key corresponds to. + let normalizedProps + if (key[0] !== '$') { + const n = accessCache[key] + if (n !== undefined) { + switch (n) { + case 0 /* SETUP */: + return setupState[key] + case 1 /* DATA */: + return data[key] + case 3 /* CONTEXT */: + return ctx[key] + case 2 /* PROPS */: + return props[key] + // default: just fallthrough + } + } else if (setupState !== EMPTY_OBJ && hasOwn(setupState, key)) { + accessCache[key] = 0 /* SETUP */ + return setupState[key] + } else if (data !== EMPTY_OBJ && hasOwn(data, key)) { + accessCache[key] = 1 /* DATA */ + return data[key] + } else if ( + // only cache other properties when instance has declared (thus stable) + // props + (normalizedProps = instance.propsOptions[0]) && + hasOwn(normalizedProps, key) + ) { + accessCache[key] = 2 /* PROPS */ + return props[key] + } else if (ctx !== EMPTY_OBJ && hasOwn(ctx, key)) { + accessCache[key] = 3 /* CONTEXT */ + return ctx[key] + } else if (!__VUE_OPTIONS_API__ || !isInBeforeCreate) { + accessCache[key] = 4 /* OTHER */ + } + } + const publicGetter = publicPropertiesMap[key] + let cssModule, globalProperties + // public $xxx properties + if (publicGetter) { + if (key === '$attrs') { + track(instance, 'get' /* GET */, key) + process.env.NODE_ENV !== 'production' && markAttrsAccessed() + } + return publicGetter(instance) + } else if ( + // css module (injected by vue-loader) + (cssModule = type.__cssModules) && + (cssModule = cssModule[key]) + ) { + return cssModule + } else if (ctx !== EMPTY_OBJ && hasOwn(ctx, key)) { + // user may set custom properties to `this` that start with `$` + accessCache[key] = 3 /* CONTEXT */ + return ctx[key] + } else if ( + // global properties + ((globalProperties = appContext.config.globalProperties), + hasOwn(globalProperties, key)) + ) { + return globalProperties[key] + } else if ( + process.env.NODE_ENV !== 'production' && + currentRenderingInstance && + (!isString(key) || + // #1091 avoid internal isRef/isVNode checks on component instance leading + // to infinite warning loop + key.indexOf('__v') !== 0) + ) { + if ( + data !== EMPTY_OBJ && + (key[0] === '$' || key[0] === '_') && + hasOwn(data, key) + ) { + warn( + `Property ${JSON.stringify( + key + )} must be accessed via $data because it starts with a reserved ` + + `character ("$" or "_") and is not proxied on the render context.` + ) + } else { + warn( + `Property ${JSON.stringify(key)} was accessed during render ` + + `but is not defined on instance.` + ) + } + } + }, + set({ _: instance }, key, value) { + const { data, setupState, ctx } = instance + if (setupState !== EMPTY_OBJ && hasOwn(setupState, key)) { + setupState[key] = value + } else if (data !== EMPTY_OBJ && hasOwn(data, key)) { + data[key] = value + } else if (key in instance.props) { + process.env.NODE_ENV !== 'production' && + warn( + `Attempting to mutate prop "${key}". Props are readonly.`, + instance + ) + return false + } + if (key[0] === '$' && key.slice(1) in instance) { + process.env.NODE_ENV !== 'production' && + warn( + `Attempting to mutate public property "${key}". ` + + `Properties starting with $ are reserved and readonly.`, + instance + ) + return false + } else { + if ( + process.env.NODE_ENV !== 'production' && + key in instance.appContext.config.globalProperties + ) { + Object.defineProperty(ctx, key, { + enumerable: true, + configurable: true, + value + }) + } else { + ctx[key] = value + } + } + return true + }, + has( + { + _: { data, setupState, accessCache, ctx, appContext, propsOptions } + }, + key + ) { + let normalizedProps + return ( + accessCache[key] !== undefined || + (data !== EMPTY_OBJ && hasOwn(data, key)) || + (setupState !== EMPTY_OBJ && hasOwn(setupState, key)) || + ((normalizedProps = propsOptions[0]) && hasOwn(normalizedProps, key)) || + hasOwn(ctx, key) || + hasOwn(publicPropertiesMap, key) || + hasOwn(appContext.config.globalProperties, key) + ) + } +} +if (process.env.NODE_ENV !== 'production' && !false) { + PublicInstanceProxyHandlers.ownKeys = target => { + warn( + `Avoid app logic that relies on enumerating keys on a component instance. ` + + `The keys will be empty in production mode to avoid performance overhead.` + ) + return Reflect.ownKeys(target) + } +} +const RuntimeCompiledPublicInstanceProxyHandlers = extend( + {}, + PublicInstanceProxyHandlers, + { + get(target, key) { + // fast path for unscopables when using `with` block + if (key === Symbol.unscopables) { + return + } + return PublicInstanceProxyHandlers.get(target, key, target) + }, + has(_, key) { + const has = key[0] !== '_' && !isGloballyWhitelisted(key) + if ( + process.env.NODE_ENV !== 'production' && + !has && + PublicInstanceProxyHandlers.has(_, key) + ) { + warn( + `Property ${JSON.stringify( + key + )} should not start with _ which is a reserved prefix for Vue internals.` + ) + } + return has + } + } +) +// In dev mode, the proxy target exposes the same properties as seen on `this` +// for easier console inspection. In prod mode it will be an empty object so +// these properties definitions can be skipped. +function createRenderContext(instance) { + const target = {} + // expose internal instance for proxy handlers + Object.defineProperty(target, `_`, { + configurable: true, + enumerable: false, + get: () => instance + }) + // expose public properties + Object.keys(publicPropertiesMap).forEach(key => { + Object.defineProperty(target, key, { + configurable: true, + enumerable: false, + get: () => publicPropertiesMap[key](instance), + // intercepted by the proxy so no need for implementation, + // but needed to prevent set errors + set: NOOP + }) + }) + // expose global properties + const { globalProperties } = instance.appContext.config + Object.keys(globalProperties).forEach(key => { + Object.defineProperty(target, key, { + configurable: true, + enumerable: false, + get: () => globalProperties[key], + set: NOOP + }) + }) + return target +} +// dev only +function exposePropsOnRenderContext(instance) { + const { + ctx, + propsOptions: [propsOptions] + } = instance + if (propsOptions) { + Object.keys(propsOptions).forEach(key => { + Object.defineProperty(ctx, key, { + enumerable: true, + configurable: true, + get: () => instance.props[key], + set: NOOP + }) + }) + } +} +// dev only +function exposeSetupStateOnRenderContext(instance) { + const { ctx, setupState } = instance + Object.keys(toRaw(setupState)).forEach(key => { + if (key[0] === '$' || key[0] === '_') { + warn( + `setup() return property ${JSON.stringify( + key + )} should not start with "$" or "_" ` + + `which are reserved prefixes for Vue internals.` + ) + return + } + Object.defineProperty(ctx, key, { + enumerable: true, + configurable: true, + get: () => setupState[key], + set: NOOP + }) + }) +} + +const emptyAppContext = createAppContext() +let uid$2 = 0 +function createComponentInstance(vnode, parent, suspense) { + const type = vnode.type + // inherit parent app context - or - if root, adopt from root vnode + const appContext = + (parent ? parent.appContext : vnode.appContext) || emptyAppContext + const instance = { + uid: uid$2++, + vnode, + type, + parent, + appContext, + root: null, + next: null, + subTree: null, + update: null, + render: null, + proxy: null, + withProxy: null, + effects: null, + provides: parent ? parent.provides : Object.create(appContext.provides), + accessCache: null, + renderCache: [], + // local resovled assets + components: null, + directives: null, + // resolved props and emits options + propsOptions: normalizePropsOptions(type, appContext), + emitsOptions: normalizeEmitsOptions(type, appContext), + // emit + emit: null, + emitted: null, + // state + ctx: EMPTY_OBJ, + data: EMPTY_OBJ, + props: EMPTY_OBJ, + attrs: EMPTY_OBJ, + slots: EMPTY_OBJ, + refs: EMPTY_OBJ, + setupState: EMPTY_OBJ, + setupContext: null, + // suspense related + suspense, + asyncDep: null, + asyncResolved: false, + // lifecycle hooks + // not using enums here because it results in computed properties + isMounted: false, + isUnmounted: false, + isDeactivated: false, + bc: null, + c: null, + bm: null, + m: null, + bu: null, + u: null, + um: null, + bum: null, + da: null, + a: null, + rtg: null, + rtc: null, + ec: null + } + if (process.env.NODE_ENV !== 'production') { + instance.ctx = createRenderContext(instance) + } else { + instance.ctx = { _: instance } + } + instance.root = parent ? parent.root : instance + instance.emit = emit.bind(null, instance) + if (process.env.NODE_ENV !== 'production' || __VUE_PROD_DEVTOOLS__) { + devtoolsComponentAdded(instance) + } + return instance +} +let currentInstance = null +const getCurrentInstance = () => currentInstance || currentRenderingInstance +const setCurrentInstance = instance => { + currentInstance = instance +} +const isBuiltInTag = /*#__PURE__*/ makeMap('slot,component') +function validateComponentName(name, config) { + const appIsNativeTag = config.isNativeTag || NO + if (isBuiltInTag(name) || appIsNativeTag(name)) { + warn( + 'Do not use built-in or reserved HTML elements as component id: ' + name + ) + } +} +let isInSSRComponentSetup = false +function setupComponent(instance, isSSR = false) { + isInSSRComponentSetup = isSSR + const { props, children, shapeFlag } = instance.vnode + const isStateful = shapeFlag & 4 /* STATEFUL_COMPONENT */ + initProps(instance, props, isStateful, isSSR) + initSlots(instance, children) + const setupResult = isStateful + ? setupStatefulComponent(instance, isSSR) + : undefined + isInSSRComponentSetup = false + return setupResult +} +function setupStatefulComponent(instance, isSSR) { + const Component = instance.type + if (process.env.NODE_ENV !== 'production') { + if (Component.name) { + validateComponentName(Component.name, instance.appContext.config) + } + if (Component.components) { + const names = Object.keys(Component.components) + for (let i = 0; i < names.length; i++) { + validateComponentName(names[i], instance.appContext.config) + } + } + if (Component.directives) { + const names = Object.keys(Component.directives) + for (let i = 0; i < names.length; i++) { + validateDirectiveName(names[i]) + } + } + } + // 0. create render proxy property access cache + instance.accessCache = {} + // 1. create public instance / render proxy + // also mark it raw so it's never observed + instance.proxy = new Proxy(instance.ctx, PublicInstanceProxyHandlers) + if (process.env.NODE_ENV !== 'production') { + exposePropsOnRenderContext(instance) + } + // 2. call setup() + const { setup } = Component + if (setup) { + const setupContext = (instance.setupContext = + setup.length > 1 ? createSetupContext(instance) : null) + currentInstance = instance + pauseTracking() + const setupResult = callWithErrorHandling( + setup, + instance, + 0 /* SETUP_FUNCTION */, + [ + process.env.NODE_ENV !== 'production' + ? shallowReadonly(instance.props) + : instance.props, + setupContext + ] + ) + resetTracking() + currentInstance = null + if (isPromise(setupResult)) { + if (isSSR) { + // return the promise so server-renderer can wait on it + return setupResult.then(resolvedResult => { + handleSetupResult(instance, resolvedResult) + }) + } else { + // async setup returned Promise. + // bail here and wait for re-entry. + instance.asyncDep = setupResult + } + } else { + handleSetupResult(instance, setupResult) + } + } else { + finishComponentSetup(instance) + } +} +function handleSetupResult(instance, setupResult, isSSR) { + if (isFunction(setupResult)) { + // setup returned an inline render function + instance.render = setupResult + } else if (isObject(setupResult)) { + if (process.env.NODE_ENV !== 'production' && isVNode(setupResult)) { + warn( + `setup() should not return VNodes directly - ` + + `return a render function instead.` + ) + } + // setup returned bindings. + // assuming a render function compiled from template is present. + if (process.env.NODE_ENV !== 'production' || __VUE_PROD_DEVTOOLS__) { + instance.devtoolsRawSetupState = setupResult + } + instance.setupState = proxyRefs(setupResult) + if (process.env.NODE_ENV !== 'production') { + exposeSetupStateOnRenderContext(instance) + } + } else if ( + process.env.NODE_ENV !== 'production' && + setupResult !== undefined + ) { + warn( + `setup() should return an object. Received: ${ + setupResult === null ? 'null' : typeof setupResult + }` + ) + } + finishComponentSetup(instance) +} +let compile +/** + * For runtime-dom to register the compiler. + * Note the exported method uses any to avoid d.ts relying on the compiler types. + */ +function registerRuntimeCompiler(_compile) { + compile = _compile +} +function finishComponentSetup(instance, isSSR) { + const Component = instance.type + // template / render function normalization + if (!instance.render) { + // could be set from setup() + if (compile && Component.template && !Component.render) { + if (process.env.NODE_ENV !== 'production') { + startMeasure(instance, `compile`) + } + Component.render = compile(Component.template, { + isCustomElement: instance.appContext.config.isCustomElement, + delimiters: Component.delimiters + }) + if (process.env.NODE_ENV !== 'production') { + endMeasure(instance, `compile`) + } + } + instance.render = Component.render || NOOP + // for runtime-compiled render functions using `with` blocks, the render + // proxy used needs a different `has` handler which is more performant and + // also only allows a whitelist of globals to fallthrough. + if (instance.render._rc) { + instance.withProxy = new Proxy( + instance.ctx, + RuntimeCompiledPublicInstanceProxyHandlers + ) + } + } + // support for 2.x options + if (__VUE_OPTIONS_API__) { + currentInstance = instance + applyOptions(instance, Component) + currentInstance = null + } + // warn missing template/render + if ( + process.env.NODE_ENV !== 'production' && + !Component.render && + instance.render === NOOP + ) { + /* istanbul ignore if */ + if (!compile && Component.template) { + warn( + `Component provided template option but ` + + `runtime compilation is not supported in this build of Vue.` + + ` Configure your bundler to alias "vue" to "vue/dist/vue.esm-bundler.js".` /* should not happen */ + ) + } else { + warn(`Component is missing template or render function.`) + } + } +} +const attrHandlers = { + get: (target, key) => { + if (process.env.NODE_ENV !== 'production') { + markAttrsAccessed() + } + return target[key] + }, + set: () => { + warn(`setupContext.attrs is readonly.`) + return false + }, + deleteProperty: () => { + warn(`setupContext.attrs is readonly.`) + return false + } +} +function createSetupContext(instance) { + if (process.env.NODE_ENV !== 'production') { + // We use getters in dev in case libs like test-utils overwrite instance + // properties (overwrites should not be done in prod) + return Object.freeze({ + get attrs() { + return new Proxy(instance.attrs, attrHandlers) + }, + get slots() { + return shallowReadonly(instance.slots) + }, + get emit() { + return (event, ...args) => instance.emit(event, ...args) + } + }) + } else { + return { + attrs: instance.attrs, + slots: instance.slots, + emit: instance.emit + } + } +} +// record effects created during a component's setup() so that they can be +// stopped when the component unmounts +function recordInstanceBoundEffect(effect) { + if (currentInstance) { + ;(currentInstance.effects || (currentInstance.effects = [])).push(effect) + } +} +const classifyRE = /(?:^|[-_])(\w)/g +const classify = str => + str.replace(classifyRE, c => c.toUpperCase()).replace(/[-_]/g, '') +/* istanbul ignore next */ +function formatComponentName(instance, Component, isRoot = false) { + let name = isFunction(Component) + ? Component.displayName || Component.name + : Component.name + if (!name && Component.__file) { + const match = Component.__file.match(/([^/\\]+)\.vue$/) + if (match) { + name = match[1] + } + } + if (!name && instance && instance.parent) { + // try to infer the name based on reverse resolution + const inferFromRegistry = registry => { + for (const key in registry) { + if (registry[key] === Component) { + return key + } + } + } + name = + inferFromRegistry( + instance.components || instance.parent.type.components + ) || inferFromRegistry(instance.appContext.components) + } + return name ? classify(name) : isRoot ? `App` : `Anonymous` +} + +function computed$1(getterOrOptions) { + const c = computed(getterOrOptions) + recordInstanceBoundEffect(c.effect) + return c +} + +// implementation, close to no-op +function defineComponent(options) { + return isFunction(options) ? { setup: options, name: options.name } : options +} + +function defineAsyncComponent(source) { + if (isFunction(source)) { + source = { loader: source } + } + const { + loader, + loadingComponent: loadingComponent, + errorComponent: errorComponent, + delay = 200, + timeout, // undefined = never times out + suspensible = true, + onError: userOnError + } = source + let pendingRequest = null + let resolvedComp + let retries = 0 + const retry = () => { + retries++ + pendingRequest = null + return load() + } + const load = () => { + let thisRequest + return ( + pendingRequest || + (thisRequest = pendingRequest = loader() + .catch(err => { + err = err instanceof Error ? err : new Error(String(err)) + if (userOnError) { + return new Promise((resolve, reject) => { + const userRetry = () => resolve(retry()) + const userFail = () => reject(err) + userOnError(err, userRetry, userFail, retries + 1) + }) + } else { + throw err + } + }) + .then(comp => { + if (thisRequest !== pendingRequest && pendingRequest) { + return pendingRequest + } + if (process.env.NODE_ENV !== 'production' && !comp) { + warn( + `Async component loader resolved to undefined. ` + + `If you are using retry(), make sure to return its return value.` + ) + } + // interop module default + if ( + comp && + (comp.__esModule || comp[Symbol.toStringTag] === 'Module') + ) { + comp = comp.default + } + if ( + process.env.NODE_ENV !== 'production' && + comp && + !isObject(comp) && + !isFunction(comp) + ) { + throw new Error(`Invalid async component load result: ${comp}`) + } + resolvedComp = comp + return comp + })) + ) + } + return defineComponent({ + __asyncLoader: load, + name: 'AsyncComponentWrapper', + setup() { + const instance = currentInstance + // already resolved + if (resolvedComp) { + return () => createInnerComp(resolvedComp, instance) + } + const onError = err => { + pendingRequest = null + handleError(err, instance, 13 /* ASYNC_COMPONENT_LOADER */) + } + // suspense-controlled or SSR. + if ((suspensible && instance.suspense) || false) { + return load() + .then(comp => { + return () => createInnerComp(comp, instance) + }) + .catch(err => { + onError(err) + return () => + errorComponent + ? createVNode(errorComponent, { + error: err + }) + : null + }) + } + const loaded = ref(false) + const error = ref() + const delayed = ref(!!delay) + if (delay) { + setTimeout(() => { + delayed.value = false + }, delay) + } + if (timeout != null) { + setTimeout(() => { + if (!loaded.value) { + const err = new Error( + `Async component timed out after ${timeout}ms.` + ) + onError(err) + error.value = err + } + }, timeout) + } + load() + .then(() => { + loaded.value = true + }) + .catch(err => { + onError(err) + error.value = err + }) + return () => { + if (loaded.value && resolvedComp) { + return createInnerComp(resolvedComp, instance) + } else if (error.value && errorComponent) { + return createVNode(errorComponent, { + error: error.value + }) + } else if (loadingComponent && !delayed.value) { + return createVNode(loadingComponent) + } + } + } + }) +} +function createInnerComp(comp, { vnode: { props, children } }) { + return createVNode(comp, props, children) +} + +// Actual implementation +function h(type, propsOrChildren, children) { + const l = arguments.length + if (l === 2) { + if (isObject(propsOrChildren) && !isArray(propsOrChildren)) { + // single vnode without props + if (isVNode(propsOrChildren)) { + return createVNode(type, null, [propsOrChildren]) + } + // props without children + return createVNode(type, propsOrChildren) + } else { + // omit props + return createVNode(type, null, propsOrChildren) + } + } else { + if (l > 3) { + children = Array.prototype.slice.call(arguments, 2) + } else if (l === 3 && isVNode(children)) { + children = [children] + } + return createVNode(type, propsOrChildren, children) + } +} + +const ssrContextKey = Symbol( + process.env.NODE_ENV !== 'production' ? `ssrContext` : `` +) +const useSSRContext = () => { + { + const ctx = inject(ssrContextKey) + if (!ctx) { + warn( + `Server rendering context not provided. Make sure to only call ` + + `useSsrContext() conditionally in the server build.` + ) + } + return ctx + } +} + +/** + * Actual implementation + */ +function renderList(source, renderItem) { + let ret + if (isArray(source) || isString(source)) { + ret = new Array(source.length) + for (let i = 0, l = source.length; i < l; i++) { + ret[i] = renderItem(source[i], i) + } + } else if (typeof source === 'number') { + ret = new Array(source) + for (let i = 0; i < source; i++) { + ret[i] = renderItem(i + 1, i) + } + } else if (isObject(source)) { + if (source[Symbol.iterator]) { + ret = Array.from(source, renderItem) + } else { + const keys = Object.keys(source) + ret = new Array(keys.length) + for (let i = 0, l = keys.length; i < l; i++) { + const key = keys[i] + ret[i] = renderItem(source[key], key, i) + } + } + } else { + ret = [] + } + return ret +} + +/** + * For prefixing keys in v-on="obj" with "on" + * @private + */ +function toHandlers(obj) { + const ret = {} + if (process.env.NODE_ENV !== 'production' && !isObject(obj)) { + warn(`v-on with no argument expects an object value.`) + return ret + } + for (const key in obj) { + ret[`on${capitalize(key)}`] = obj[key] + } + return ret +} + +/** + * Compiler runtime helper for creating dynamic slots object + * @private + */ +function createSlots(slots, dynamicSlots) { + for (let i = 0; i < dynamicSlots.length; i++) { + const slot = dynamicSlots[i] + // array of dynamic slot generated by + if (isArray(slot)) { + for (let j = 0; j < slot.length; j++) { + slots[slot[j].name] = slot[j].fn + } + } else if (slot) { + // conditional single slot generated by + slots[slot.name] = slot.fn + } + } + return slots +} + +// Core API ------------------------------------------------------------------ +const version = '3.0.0-rc.10' +/** + * SSR utils for \@vue/server-renderer. Only exposed in cjs builds. + * @internal + */ +const ssrUtils = null + +const svgNS = 'http://www.w3.org/2000/svg' +const doc = typeof document !== 'undefined' ? document : null +let tempContainer +let tempSVGContainer +const nodeOps = { + insert: (child, parent, anchor) => { + parent.insertBefore(child, anchor || null) + }, + remove: child => { + const parent = child.parentNode + if (parent) { + parent.removeChild(child) + } + }, + createElement: (tag, isSVG, is) => + isSVG + ? doc.createElementNS(svgNS, tag) + : doc.createElement(tag, is ? { is } : undefined), + createText: text => doc.createTextNode(text), + createComment: text => doc.createComment(text), + setText: (node, text) => { + node.nodeValue = text + }, + setElementText: (el, text) => { + el.textContent = text + }, + parentNode: node => node.parentNode, + nextSibling: node => node.nextSibling, + querySelector: selector => doc.querySelector(selector), + setScopeId(el, id) { + el.setAttribute(id, '') + }, + cloneNode(el) { + return el.cloneNode(true) + }, + // __UNSAFE__ + // Reason: innerHTML. + // Static content here can only come from compiled templates. + // As long as the user only uses trusted templates, this is safe. + insertStaticContent(content, parent, anchor, isSVG) { + const temp = isSVG + ? tempSVGContainer || + (tempSVGContainer = doc.createElementNS(svgNS, 'svg')) + : tempContainer || (tempContainer = doc.createElement('div')) + temp.innerHTML = content + const first = temp.firstChild + let node = first + let last = node + while (node) { + last = node + nodeOps.insert(node, parent, anchor) + node = temp.firstChild + } + return [first, last] + } +} + +// compiler should normalize class + :class bindings on the same element +// into a single binding ['staticClass', dynamic] +function patchClass(el, value, isSVG) { + if (value == null) { + value = '' + } + if (isSVG) { + el.setAttribute('class', value) + } else { + // directly setting className should be faster than setAttribute in theory + // if this is an element during a transition, take the temporary transition + // classes into account. + const transitionClasses = el._vtc + if (transitionClasses) { + value = (value + ? [value, ...transitionClasses] + : [...transitionClasses] + ).join(' ') + } + el.className = value + } +} + +function patchStyle(el, prev, next) { + const style = el.style + if (!next) { + el.removeAttribute('style') + } else if (isString(next)) { + if (prev !== next) { + style.cssText = next + } + } else { + for (const key in next) { + setStyle(style, key, next[key]) + } + if (prev && !isString(prev)) { + for (const key in prev) { + if (next[key] == null) { + setStyle(style, key, '') + } + } + } + } +} +const importantRE = /\s*!important$/ +function setStyle(style, name, val) { + if (isArray(val)) { + val.forEach(v => setStyle(style, name, v)) + } else { + if (name.startsWith('--')) { + // custom property definition + style.setProperty(name, val) + } else { + const prefixed = autoPrefix(style, name) + if (importantRE.test(val)) { + // !important + style.setProperty( + hyphenate(prefixed), + val.replace(importantRE, ''), + 'important' + ) + } else { + style[prefixed] = val + } + } + } +} +const prefixes = ['Webkit', 'Moz', 'ms'] +const prefixCache = {} +function autoPrefix(style, rawName) { + const cached = prefixCache[rawName] + if (cached) { + return cached + } + let name = camelize(rawName) + if (name !== 'filter' && name in style) { + return (prefixCache[rawName] = name) + } + name = capitalize(name) + for (let i = 0; i < prefixes.length; i++) { + const prefixed = prefixes[i] + name + if (prefixed in style) { + return (prefixCache[rawName] = prefixed) + } + } + return rawName +} + +const xlinkNS = 'http://www.w3.org/1999/xlink' +function patchAttr(el, key, value, isSVG) { + if (isSVG && key.startsWith('xlink:')) { + if (value == null) { + el.removeAttributeNS(xlinkNS, key.slice(6, key.length)) + } else { + el.setAttributeNS(xlinkNS, key, value) + } + } else { + // note we are only checking boolean attributes that don't have a + // corresponding dom prop of the same name here. + const isBoolean = isSpecialBooleanAttr(key) + if (value == null || (isBoolean && value === false)) { + el.removeAttribute(key) + } else { + el.setAttribute(key, isBoolean ? '' : value) + } + } +} + +// __UNSAFE__ +// functions. The user is responsible for using them with only trusted content. +function patchDOMProp( + el, + key, + value, + // the following args are passed only due to potential innerHTML/textContent + // overriding existing VNodes, in which case the old tree must be properly + // unmounted. + prevChildren, + parentComponent, + parentSuspense, + unmountChildren +) { + if (key === 'innerHTML' || key === 'textContent') { + if (prevChildren) { + unmountChildren(prevChildren, parentComponent, parentSuspense) + } + el[key] = value == null ? '' : value + return + } + if (key === 'value' && el.tagName !== 'PROGRESS') { + // store value as _value as well since + // non-string values will be stringified. + el._value = value + const newValue = value == null ? '' : value + if (el.value !== newValue) { + el.value = newValue + } + return + } + if (value === '' && typeof el[key] === 'boolean') { + // e.g. compiles to { multiple: '' } + el[key] = true + } else if (value == null && typeof el[key] === 'string') { + // e.g. + el[key] = '' + el.removeAttribute(key) + } else { + // some properties perform value validation and throw + try { + el[key] = value + } catch (e) { + if (process.env.NODE_ENV !== 'production') { + warn( + `Failed setting prop "${key}" on <${el.tagName.toLowerCase()}>: ` + + `value ${value} is invalid.`, + e + ) + } + } + } +} + +// Async edge case fix requires storing an event listener's attach timestamp. +let _getNow = Date.now +// Determine what event timestamp the browser is using. Annoyingly, the +// timestamp can either be hi-res (relative to page load) or low-res +// (relative to UNIX epoch), so in order to compare time we have to use the +// same timestamp type when saving the flush timestamp. +if ( + typeof document !== 'undefined' && + _getNow() > document.createEvent('Event').timeStamp +) { + // if the low-res timestamp which is bigger than the event timestamp + // (which is evaluated AFTER) it means the event is using a hi-res timestamp, + // and we need to use the hi-res version for event listeners as well. + _getNow = () => performance.now() +} +// To avoid the overhead of repeatedly calling performance.now(), we cache +// and use the same timestamp for all event listeners attached in the same tick. +let cachedNow = 0 +const p = Promise.resolve() +const reset = () => { + cachedNow = 0 +} +const getNow = () => cachedNow || (p.then(reset), (cachedNow = _getNow())) +function addEventListener(el, event, handler, options) { + el.addEventListener(event, handler, options) +} +function removeEventListener(el, event, handler, options) { + el.removeEventListener(event, handler, options) +} +function patchEvent(el, rawName, prevValue, nextValue, instance = null) { + // vei = vue event invokers + const invokers = el._vei || (el._vei = {}) + const existingInvoker = invokers[rawName] + if (nextValue && existingInvoker) { + // patch + existingInvoker.value = nextValue + } else { + const [name, options] = parseName(rawName) + if (nextValue) { + // add + const invoker = (invokers[rawName] = createInvoker(nextValue, instance)) + addEventListener(el, name, invoker, options) + } else if (existingInvoker) { + // remove + removeEventListener(el, name, existingInvoker, options) + invokers[rawName] = undefined + } + } +} +const optionsModifierRE = /(?:Once|Passive|Capture)$/ +function parseName(name) { + let options + if (optionsModifierRE.test(name)) { + options = {} + let m + while ((m = name.match(optionsModifierRE))) { + name = name.slice(0, name.length - m[0].length) + options[m[0].toLowerCase()] = true + } + } + return [name.slice(2).toLowerCase(), options] +} +function createInvoker(initialValue, instance) { + const invoker = e => { + // async edge case #6566: inner click event triggers patch, event handler + // attached to outer element during patch, and triggered again. This + // happens because browsers fire microtask ticks between event propagation. + // the solution is simple: we save the timestamp when a handler is attached, + // and the handler would only fire if the event passed to it was fired + // AFTER it was attached. + const timeStamp = e.timeStamp || _getNow() + if (timeStamp >= invoker.attached - 1) { + callWithAsyncErrorHandling( + patchStopImmediatePropagation(e, invoker.value), + instance, + 5 /* NATIVE_EVENT_HANDLER */, + [e] + ) + } + } + invoker.value = initialValue + invoker.attached = getNow() + return invoker +} +function patchStopImmediatePropagation(e, value) { + if (isArray(value)) { + const originalStop = e.stopImmediatePropagation + e.stopImmediatePropagation = () => { + originalStop.call(e) + e._stopped = true + } + return value.map(fn => e => !e._stopped && fn(e)) + } else { + return value + } +} + +const nativeOnRE = /^on[a-z]/ +const forcePatchProp = (_, key) => key === 'value' +const patchProp = ( + el, + key, + prevValue, + nextValue, + isSVG = false, + prevChildren, + parentComponent, + parentSuspense, + unmountChildren +) => { + switch (key) { + // special + case 'class': + patchClass(el, nextValue, isSVG) + break + case 'style': + patchStyle(el, prevValue, nextValue) + break + default: + if (isOn(key)) { + // ignore v-model listeners + if (!isModelListener(key)) { + patchEvent(el, key, prevValue, nextValue, parentComponent) + } + } else if (shouldSetAsProp(el, key, nextValue, isSVG)) { + patchDOMProp( + el, + key, + nextValue, + prevChildren, + parentComponent, + parentSuspense, + unmountChildren + ) + } else { + // special case for with + // :true-value & :false-value + // store value as dom properties since non-string values will be + // stringified. + if (key === 'true-value') { + el._trueValue = nextValue + } else if (key === 'false-value') { + el._falseValue = nextValue + } + patchAttr(el, key, nextValue, isSVG) + } + break + } +} +function shouldSetAsProp(el, key, value, isSVG) { + if (isSVG) { + // most keys must be set as attribute on svg elements to work + // ...except innerHTML + if (key === 'innerHTML') { + return true + } + // or native onclick with function values + if (key in el && nativeOnRE.test(key) && isFunction(value)) { + return true + } + return false + } + // spellcheck and draggable are numerated attrs, however their + // corresponding DOM properties are actually booleans - this leads to + // setting it with a string "false" value leading it to be coerced to + // `true`, so we need to always treat them as attributes. + // Note that `contentEditable` doesn't have this problem: its DOM + // property is also enumerated string values. + if (key === 'spellcheck' || key === 'draggable') { + return false + } + // #1787 form as an attribute must be a string, while it accepts an Element as + // a prop + if (key === 'form' && typeof value === 'string') { + return false + } + // #1526 must be set as attribute + if (key === 'list' && el.tagName === 'INPUT') { + return false + } + // native onclick with string value, must be set as attribute + if (nativeOnRE.test(key) && isString(value)) { + return false + } + return key in el +} + +function useCssModule(name = '$style') { + /* istanbul ignore else */ + { + const instance = getCurrentInstance() + if (!instance) { + process.env.NODE_ENV !== 'production' && + warn(`useCssModule must be called inside setup()`) + return EMPTY_OBJ + } + const modules = instance.type.__cssModules + if (!modules) { + process.env.NODE_ENV !== 'production' && + warn(`Current instance does not have CSS modules injected.`) + return EMPTY_OBJ + } + const mod = modules[name] + if (!mod) { + process.env.NODE_ENV !== 'production' && + warn(`Current instance does not have CSS module named "${name}".`) + return EMPTY_OBJ + } + return mod + } +} + +function useCssVars(getter, scoped = false) { + const instance = getCurrentInstance() + /* istanbul ignore next */ + if (!instance) { + process.env.NODE_ENV !== 'production' && + warn(`useCssVars is called without current active component instance.`) + return + } + const prefix = + scoped && instance.type.__scopeId + ? `${instance.type.__scopeId.replace(/^data-v-/, '')}-` + : `` + onMounted(() => { + watchEffect(() => { + setVarsOnVNode(instance.subTree, getter(instance.proxy), prefix) + }) + }) +} +function setVarsOnVNode(vnode, vars, prefix) { + if (vnode.shapeFlag & 128 /* SUSPENSE */) { + const { isResolved, isHydrating, fallbackTree, subTree } = vnode.suspense + if (isResolved || isHydrating) { + vnode = subTree + } else { + vnode.suspense.effects.push(() => { + setVarsOnVNode(subTree, vars, prefix) + }) + vnode = fallbackTree + } + } + // drill down HOCs until it's a non-component vnode + while (vnode.component) { + vnode = vnode.component.subTree + } + if (vnode.shapeFlag & 1 /* ELEMENT */ && vnode.el) { + const style = vnode.el.style + for (const key in vars) { + style.setProperty(`--${prefix}${key}`, unref(vars[key])) + } + } else if (vnode.type === Fragment) { + vnode.children.forEach(c => setVarsOnVNode(c, vars, prefix)) + } +} + +const TRANSITION = 'transition' +const ANIMATION = 'animation' +// DOM Transition is a higher-order-component based on the platform-agnostic +// base Transition component, with DOM-specific logic. +const Transition = (props, { slots }) => + h(BaseTransition, resolveTransitionProps(props), slots) +Transition.displayName = 'Transition' +const DOMTransitionPropsValidators = { + name: String, + type: String, + css: { + type: Boolean, + default: true + }, + duration: [String, Number, Object], + enterFromClass: String, + enterActiveClass: String, + enterToClass: String, + appearFromClass: String, + appearActiveClass: String, + appearToClass: String, + leaveFromClass: String, + leaveActiveClass: String, + leaveToClass: String +} +const TransitionPropsValidators = (Transition.props = /*#__PURE__*/ extend( + {}, + BaseTransition.props, + DOMTransitionPropsValidators +)) +function resolveTransitionProps(rawProps) { + let { + name = 'v', + type, + css = true, + duration, + enterFromClass = `${name}-enter-from`, + enterActiveClass = `${name}-enter-active`, + enterToClass = `${name}-enter-to`, + appearFromClass = enterFromClass, + appearActiveClass = enterActiveClass, + appearToClass = enterToClass, + leaveFromClass = `${name}-leave-from`, + leaveActiveClass = `${name}-leave-active`, + leaveToClass = `${name}-leave-to` + } = rawProps + const baseProps = {} + for (const key in rawProps) { + if (!(key in DOMTransitionPropsValidators)) { + baseProps[key] = rawProps[key] + } + } + if (!css) { + return baseProps + } + const durations = normalizeDuration(duration) + const enterDuration = durations && durations[0] + const leaveDuration = durations && durations[1] + const { + onBeforeEnter, + onEnter, + onEnterCancelled, + onLeave, + onLeaveCancelled, + onBeforeAppear = onBeforeEnter, + onAppear = onEnter, + onAppearCancelled = onEnterCancelled + } = baseProps + const finishEnter = (el, isAppear, done) => { + removeTransitionClass(el, isAppear ? appearToClass : enterToClass) + removeTransitionClass(el, isAppear ? appearActiveClass : enterActiveClass) + done && done() + } + const finishLeave = (el, done) => { + removeTransitionClass(el, leaveToClass) + removeTransitionClass(el, leaveActiveClass) + done && done() + } + const makeEnterHook = isAppear => { + return (el, done) => { + const hook = isAppear ? onAppear : onEnter + const resolve = () => finishEnter(el, isAppear, done) + hook && hook(el, resolve) + nextFrame(() => { + removeTransitionClass(el, isAppear ? appearFromClass : enterFromClass) + addTransitionClass(el, isAppear ? appearToClass : enterToClass) + if (!(hook && hook.length > 1)) { + if (enterDuration) { + setTimeout(resolve, enterDuration) + } else { + whenTransitionEnds(el, type, resolve) + } + } + }) + } + } + return extend(baseProps, { + onBeforeEnter(el) { + onBeforeEnter && onBeforeEnter(el) + addTransitionClass(el, enterActiveClass) + addTransitionClass(el, enterFromClass) + }, + onBeforeAppear(el) { + onBeforeAppear && onBeforeAppear(el) + addTransitionClass(el, appearActiveClass) + addTransitionClass(el, appearFromClass) + }, + onEnter: makeEnterHook(false), + onAppear: makeEnterHook(true), + onLeave(el, done) { + const resolve = () => finishLeave(el, done) + addTransitionClass(el, leaveActiveClass) + addTransitionClass(el, leaveFromClass) + nextFrame(() => { + removeTransitionClass(el, leaveFromClass) + addTransitionClass(el, leaveToClass) + if (!(onLeave && onLeave.length > 1)) { + if (leaveDuration) { + setTimeout(resolve, leaveDuration) + } else { + whenTransitionEnds(el, type, resolve) + } + } + }) + onLeave && onLeave(el, resolve) + }, + onEnterCancelled(el) { + finishEnter(el, false) + onEnterCancelled && onEnterCancelled(el) + }, + onAppearCancelled(el) { + finishEnter(el, true) + onAppearCancelled && onAppearCancelled(el) + }, + onLeaveCancelled(el) { + finishLeave(el) + onLeaveCancelled && onLeaveCancelled(el) + } + }) +} +function normalizeDuration(duration) { + if (duration == null) { + return null + } else if (isObject(duration)) { + return [NumberOf(duration.enter), NumberOf(duration.leave)] + } else { + const n = NumberOf(duration) + return [n, n] + } +} +function NumberOf(val) { + const res = toNumber(val) + if (process.env.NODE_ENV !== 'production') validateDuration(res) + return res +} +function validateDuration(val) { + if (typeof val !== 'number') { + warn( + ` explicit duration is not a valid number - ` + + `got ${JSON.stringify(val)}.` + ) + } else if (isNaN(val)) { + warn( + ` explicit duration is NaN - ` + + 'the duration expression might be incorrect.' + ) + } +} +function addTransitionClass(el, cls) { + cls.split(/\s+/).forEach(c => c && el.classList.add(c)) + ;(el._vtc || (el._vtc = new Set())).add(cls) +} +function removeTransitionClass(el, cls) { + cls.split(/\s+/).forEach(c => c && el.classList.remove(c)) + const { _vtc } = el + if (_vtc) { + _vtc.delete(cls) + if (!_vtc.size) { + el._vtc = undefined + } + } +} +function nextFrame(cb) { + requestAnimationFrame(() => { + requestAnimationFrame(cb) + }) +} +function whenTransitionEnds(el, expectedType, cb) { + const { type, timeout, propCount } = getTransitionInfo(el, expectedType) + if (!type) { + return cb() + } + const endEvent = type + 'end' + let ended = 0 + const end = () => { + el.removeEventListener(endEvent, onEnd) + cb() + } + const onEnd = e => { + if (e.target === el) { + if (++ended >= propCount) { + end() + } + } + } + setTimeout(() => { + if (ended < propCount) { + end() + } + }, timeout + 1) + el.addEventListener(endEvent, onEnd) +} +function getTransitionInfo(el, expectedType) { + const styles = window.getComputedStyle(el) + // JSDOM may return undefined for transition properties + const getStyleProperties = key => (styles[key] || '').split(', ') + const transitionDelays = getStyleProperties(TRANSITION + 'Delay') + const transitionDurations = getStyleProperties(TRANSITION + 'Duration') + const transitionTimeout = getTimeout(transitionDelays, transitionDurations) + const animationDelays = getStyleProperties(ANIMATION + 'Delay') + const animationDurations = getStyleProperties(ANIMATION + 'Duration') + const animationTimeout = getTimeout(animationDelays, animationDurations) + let type = null + let timeout = 0 + let propCount = 0 + /* istanbul ignore if */ + if (expectedType === TRANSITION) { + if (transitionTimeout > 0) { + type = TRANSITION + timeout = transitionTimeout + propCount = transitionDurations.length + } + } else if (expectedType === ANIMATION) { + if (animationTimeout > 0) { + type = ANIMATION + timeout = animationTimeout + propCount = animationDurations.length + } + } else { + timeout = Math.max(transitionTimeout, animationTimeout) + type = + timeout > 0 + ? transitionTimeout > animationTimeout + ? TRANSITION + : ANIMATION + : null + propCount = type + ? type === TRANSITION + ? transitionDurations.length + : animationDurations.length + : 0 + } + const hasTransform = + type === TRANSITION && + /\b(transform|all)(,|$)/.test(styles[TRANSITION + 'Property']) + return { + type, + timeout, + propCount, + hasTransform + } +} +function getTimeout(delays, durations) { + while (delays.length < durations.length) { + delays = delays.concat(delays) + } + return Math.max(...durations.map((d, i) => toMs(d) + toMs(delays[i]))) +} +// Old versions of Chromium (below 61.0.3163.100) formats floating pointer +// numbers in a locale-dependent way, using a comma instead of a dot. +// If comma is not replaced with a dot, the input will be rounded down +// (i.e. acting as a floor function) causing unexpected behaviors +function toMs(s) { + return Number(s.slice(0, -1).replace(',', '.')) * 1000 +} + +const positionMap = new WeakMap() +const newPositionMap = new WeakMap() +const TransitionGroupImpl = { + name: 'TransitionGroup', + props: /*#__PURE__*/ extend({}, TransitionPropsValidators, { + tag: String, + moveClass: String + }), + setup(props, { slots }) { + const instance = getCurrentInstance() + const state = useTransitionState() + let prevChildren + let children + onUpdated(() => { + // children is guaranteed to exist after initial render + if (!prevChildren.length) { + return + } + const moveClass = props.moveClass || `${props.name || 'v'}-move` + if (!hasCSSTransform(prevChildren[0].el, instance.vnode.el, moveClass)) { + return + } + // we divide the work into three loops to avoid mixing DOM reads and writes + // in each iteration - which helps prevent layout thrashing. + prevChildren.forEach(callPendingCbs) + prevChildren.forEach(recordPosition) + const movedChildren = prevChildren.filter(applyTranslation) + // force reflow to put everything in position + forceReflow() + movedChildren.forEach(c => { + const el = c.el + const style = el.style + addTransitionClass(el, moveClass) + style.transform = style.webkitTransform = style.transitionDuration = '' + const cb = (el._moveCb = e => { + if (e && e.target !== el) { + return + } + if (!e || /transform$/.test(e.propertyName)) { + el.removeEventListener('transitionend', cb) + el._moveCb = null + removeTransitionClass(el, moveClass) + } + }) + el.addEventListener('transitionend', cb) + }) + }) + return () => { + const rawProps = toRaw(props) + const cssTransitionProps = resolveTransitionProps(rawProps) + const tag = rawProps.tag || Fragment + prevChildren = children + children = slots.default ? getTransitionRawChildren(slots.default()) : [] + for (let i = 0; i < children.length; i++) { + const child = children[i] + if (child.key != null) { + setTransitionHooks( + child, + resolveTransitionHooks(child, cssTransitionProps, state, instance) + ) + } else if (process.env.NODE_ENV !== 'production') { + warn(` children must be keyed.`) + } + } + if (prevChildren) { + for (let i = 0; i < prevChildren.length; i++) { + const child = prevChildren[i] + setTransitionHooks( + child, + resolveTransitionHooks(child, cssTransitionProps, state, instance) + ) + positionMap.set(child, child.el.getBoundingClientRect()) + } + } + return createVNode(tag, null, children) + } + } +} +const TransitionGroup = TransitionGroupImpl +function callPendingCbs(c) { + const el = c.el + if (el._moveCb) { + el._moveCb() + } + if (el._enterCb) { + el._enterCb() + } +} +function recordPosition(c) { + newPositionMap.set(c, c.el.getBoundingClientRect()) +} +function applyTranslation(c) { + const oldPos = positionMap.get(c) + const newPos = newPositionMap.get(c) + const dx = oldPos.left - newPos.left + const dy = oldPos.top - newPos.top + if (dx || dy) { + const s = c.el.style + s.transform = s.webkitTransform = `translate(${dx}px,${dy}px)` + s.transitionDuration = '0s' + return c + } +} +// this is put in a dedicated function to avoid the line from being treeshaken +function forceReflow() { + return document.body.offsetHeight +} +function hasCSSTransform(el, root, moveClass) { + // Detect whether an element with the move class applied has + // CSS transitions. Since the element may be inside an entering + // transition at this very moment, we make a clone of it and remove + // all other transition classes applied to ensure only the move class + // is applied. + const clone = el.cloneNode() + if (el._vtc) { + el._vtc.forEach(cls => { + cls.split(/\s+/).forEach(c => c && clone.classList.remove(c)) + }) + } + moveClass.split(/\s+/).forEach(c => c && clone.classList.add(c)) + clone.style.display = 'none' + const container = root.nodeType === 1 ? root : root.parentNode + container.appendChild(clone) + const { hasTransform } = getTransitionInfo(clone) + container.removeChild(clone) + return hasTransform +} + +const getModelAssigner = vnode => { + const fn = vnode.props['onUpdate:modelValue'] + return isArray(fn) ? value => invokeArrayFns(fn, value) : fn +} +function onCompositionStart(e) { + e.target.composing = true +} +function onCompositionEnd(e) { + const target = e.target + if (target.composing) { + target.composing = false + trigger$1(target, 'input') + } +} +function trigger$1(el, type) { + const e = document.createEvent('HTMLEvents') + e.initEvent(type, true, true) + el.dispatchEvent(e) +} +// We are exporting the v-model runtime directly as vnode hooks so that it can +// be tree-shaken in case v-model is never used. +const vModelText = { + created( + el, + { + value, + modifiers: { lazy, trim, number } + }, + vnode + ) { + el.value = value == null ? '' : value + el._assign = getModelAssigner(vnode) + const castToNumber = number || el.type === 'number' + addEventListener(el, lazy ? 'change' : 'input', e => { + if (e.target.composing) return + let domValue = el.value + if (trim) { + domValue = domValue.trim() + } else if (castToNumber) { + domValue = toNumber(domValue) + } + el._assign(domValue) + }) + if (trim) { + addEventListener(el, 'change', () => { + el.value = el.value.trim() + }) + } + if (!lazy) { + addEventListener(el, 'compositionstart', onCompositionStart) + addEventListener(el, 'compositionend', onCompositionEnd) + // Safari < 10.2 & UIWebView doesn't fire compositionend when + // switching focus before confirming composition choice + // this also fixes the issue where some browsers e.g. iOS Chrome + // fires "change" instead of "input" on autocomplete. + addEventListener(el, 'change', onCompositionEnd) + } + }, + beforeUpdate( + el, + { + value, + modifiers: { trim, number } + }, + vnode + ) { + el._assign = getModelAssigner(vnode) + if (document.activeElement === el) { + if (trim && el.value.trim() === value) { + return + } + if ((number || el.type === 'number') && toNumber(el.value) === value) { + return + } + } + const newValue = value == null ? '' : value + if (el.value !== newValue) { + el.value = newValue + } + } +} +const vModelCheckbox = { + created(el, binding, vnode) { + setChecked(el, binding, vnode) + el._assign = getModelAssigner(vnode) + addEventListener(el, 'change', () => { + const modelValue = el._modelValue + const elementValue = getValue(el) + const checked = el.checked + const assign = el._assign + if (isArray(modelValue)) { + const index = looseIndexOf(modelValue, elementValue) + const found = index !== -1 + if (checked && !found) { + assign(modelValue.concat(elementValue)) + } else if (!checked && found) { + const filtered = [...modelValue] + filtered.splice(index, 1) + assign(filtered) + } + } else { + assign(getCheckboxValue(el, checked)) + } + }) + }, + beforeUpdate(el, binding, vnode) { + el._assign = getModelAssigner(vnode) + setChecked(el, binding, vnode) + } +} +function setChecked(el, { value, oldValue }, vnode) { + el._modelValue = value + if (isArray(value)) { + el.checked = looseIndexOf(value, vnode.props.value) > -1 + } else if (value !== oldValue) { + el.checked = looseEqual(value, getCheckboxValue(el, true)) + } +} +const vModelRadio = { + created(el, { value }, vnode) { + el.checked = looseEqual(value, vnode.props.value) + el._assign = getModelAssigner(vnode) + addEventListener(el, 'change', () => { + el._assign(getValue(el)) + }) + }, + beforeUpdate(el, { value, oldValue }, vnode) { + el._assign = getModelAssigner(vnode) + if (value !== oldValue) { + el.checked = looseEqual(value, vnode.props.value) + } + } +} +const vModelSelect = { + created(el, binding, vnode) { + addEventListener(el, 'change', () => { + const selectedVal = Array.prototype.filter + .call(el.options, o => o.selected) + .map(getValue) + el._assign(el.multiple ? selectedVal : selectedVal[0]) + }) + el._assign = getModelAssigner(vnode) + }, + // set value in mounted & updated because relies on its children + // s. + mounted(el, { value }) { + setSelected(el, value) + }, + beforeUpdate(el, _binding, vnode) { + el._assign = getModelAssigner(vnode) + }, + updated(el, { value }) { + setSelected(el, value) + } +} +function setSelected(el, value) { + const isMultiple = el.multiple + if (isMultiple && !isArray(value)) { + process.env.NODE_ENV !== 'production' && + warn( + ` expects an Array value for its binding, ` + + `but got ${Object.prototype.toString.call(value).slice(8, -1)}.` + ) + return + } + for (let i = 0, l = el.options.length; i < l; i++) { + const option = el.options[i] + const optionValue = getValue(option) + if (isMultiple) { + option.selected = looseIndexOf(value, optionValue) > -1 + } else { + if (looseEqual(getValue(option), value)) { + el.selectedIndex = i + return + } + } + } + if (!isMultiple) { + el.selectedIndex = -1 + } +} +// retrieve raw value set via :value bindings +function getValue(el) { + return '_value' in el ? el._value : el.value +} +// retrieve raw value for true-value and false-value set via :true-value or :false-value bindings +function getCheckboxValue(el, checked) { + const key = checked ? '_trueValue' : '_falseValue' + return key in el ? el[key] : checked +} +const vModelDynamic = { + created(el, binding, vnode) { + callModelHook(el, binding, vnode, null, 'created') + }, + mounted(el, binding, vnode) { + callModelHook(el, binding, vnode, null, 'mounted') + }, + beforeUpdate(el, binding, vnode, prevVNode) { + callModelHook(el, binding, vnode, prevVNode, 'beforeUpdate') + }, + updated(el, binding, vnode, prevVNode) { + callModelHook(el, binding, vnode, prevVNode, 'updated') + } +} +function callModelHook(el, binding, vnode, prevVNode, hook) { + let modelToUse + switch (el.tagName) { + case 'SELECT': + modelToUse = vModelSelect + break + case 'TEXTAREA': + modelToUse = vModelText + break + default: + switch (vnode.props && vnode.props.type) { + case 'checkbox': + modelToUse = vModelCheckbox + break + case 'radio': + modelToUse = vModelRadio + break + default: + modelToUse = vModelText + } + } + const fn = modelToUse[hook] + fn && fn(el, binding, vnode, prevVNode) +} + +const systemModifiers = ['ctrl', 'shift', 'alt', 'meta'] +const modifierGuards = { + stop: e => e.stopPropagation(), + prevent: e => e.preventDefault(), + self: e => e.target !== e.currentTarget, + ctrl: e => !e.ctrlKey, + shift: e => !e.shiftKey, + alt: e => !e.altKey, + meta: e => !e.metaKey, + left: e => 'button' in e && e.button !== 0, + middle: e => 'button' in e && e.button !== 1, + right: e => 'button' in e && e.button !== 2, + exact: (e, modifiers) => + systemModifiers.some(m => e[`${m}Key`] && !modifiers.includes(m)) +} +/** + * @private + */ +const withModifiers = (fn, modifiers) => { + return (event, ...args) => { + for (let i = 0; i < modifiers.length; i++) { + const guard = modifierGuards[modifiers[i]] + if (guard && guard(event, modifiers)) return + } + return fn(event, ...args) + } +} +// Kept for 2.x compat. +// Note: IE11 compat for `spacebar` and `del` is removed for now. +const keyNames = { + esc: 'escape', + space: ' ', + up: 'arrow-up', + left: 'arrow-left', + right: 'arrow-right', + down: 'arrow-down', + delete: 'backspace' +} +/** + * @private + */ +const withKeys = (fn, modifiers) => { + return event => { + if (!('key' in event)) return + const eventKey = hyphenate(event.key) + if ( + // None of the provided key modifiers match the current event key + !modifiers.some(k => k === eventKey || keyNames[k] === eventKey) + ) { + return + } + return fn(event) + } +} + +const vShow = { + beforeMount(el, { value }, { transition }) { + el._vod = el.style.display === 'none' ? '' : el.style.display + if (transition && value) { + transition.beforeEnter(el) + } else { + setDisplay(el, value) + } + }, + mounted(el, { value }, { transition }) { + if (transition && value) { + transition.enter(el) + } + }, + updated(el, { value, oldValue }, { transition }) { + if (!value === !oldValue) return + if (transition) { + if (value) { + transition.beforeEnter(el) + setDisplay(el, true) + transition.enter(el) + } else { + transition.leave(el, () => { + setDisplay(el, false) + }) + } + } else { + setDisplay(el, value) + } + }, + beforeUnmount(el, { value }) { + setDisplay(el, value) + } +} +function setDisplay(el, value) { + el.style.display = value ? el._vod : 'none' +} + +const rendererOptions = extend({ patchProp, forcePatchProp }, nodeOps) +// lazy create the renderer - this makes core renderer logic tree-shakable +// in case the user only imports reactivity utilities from Vue. +let renderer +let enabledHydration = false +function ensureRenderer() { + return renderer || (renderer = createRenderer(rendererOptions)) +} +function ensureHydrationRenderer() { + renderer = enabledHydration + ? renderer + : createHydrationRenderer(rendererOptions) + enabledHydration = true + return renderer +} +// use explicit type casts here to avoid import() calls in rolled-up d.ts +const render = (...args) => { + ensureRenderer().render(...args) +} +const hydrate = (...args) => { + ensureHydrationRenderer().hydrate(...args) +} +const createApp = (...args) => { + const app = ensureRenderer().createApp(...args) + if (process.env.NODE_ENV !== 'production') { + injectNativeTagCheck(app) + } + const { mount } = app + app.mount = containerOrSelector => { + const container = normalizeContainer(containerOrSelector) + if (!container) return + const component = app._component + if (!isFunction(component) && !component.render && !component.template) { + component.template = container.innerHTML + } + // clear content before mounting + container.innerHTML = '' + const proxy = mount(container) + container.removeAttribute('v-cloak') + container.setAttribute('data-v-app', '') + return proxy + } + return app +} +const createSSRApp = (...args) => { + const app = ensureHydrationRenderer().createApp(...args) + if (process.env.NODE_ENV !== 'production') { + injectNativeTagCheck(app) + } + const { mount } = app + app.mount = containerOrSelector => { + const container = normalizeContainer(containerOrSelector) + if (container) { + return mount(container, true) + } + } + return app +} +function injectNativeTagCheck(app) { + // Inject `isNativeTag` + // this is used for component name validation (dev only) + Object.defineProperty(app.config, 'isNativeTag', { + value: tag => isHTMLTag(tag) || isSVGTag(tag), + writable: false + }) +} +function normalizeContainer(container) { + if (isString(container)) { + const res = document.querySelector(container) + if (process.env.NODE_ENV !== 'production' && !res) { + warn(`Failed to mount app: mount target selector returned null.`) + } + return res + } + return container +} + +function initDev() { + const target = getGlobalThis() + target.__VUE__ = true + setDevtoolsHook(target.__VUE_DEVTOOLS_GLOBAL_HOOK__) + { + console.info( + `You are running a development build of Vue.\n` + + `Make sure to use the production build (*.prod.js) when deploying for production.` + ) + } +} + +// This entry exports the runtime only, and is built as +process.env.NODE_ENV !== 'production' && initDev() +const compile$1 = () => { + if (process.env.NODE_ENV !== 'production') { + warn( + `Runtime compilation is not supported in this build of Vue.` + + ` Configure your bundler to alias "vue" to "vue/dist/vue.esm-bundler.js".` /* should not happen */ + ) + } +} + +// @ts-ignore +const createHook$1 = lifecycle => (hook, target) => + // post-create lifecycle registrations are noops during SSR + !isInSSRComponentSetup && injectHook(lifecycle, hook, target) +const onShow = /*#__PURE__*/ createHook$1('onShow' /* ON_SHOW */) +const onHide = /*#__PURE__*/ createHook$1('onHide' /* ON_HIDE */) +const onLaunch = /*#__PURE__*/ createHook$1('onLaunch' /* ON_LAUCH */) +const onError = /*#__PURE__*/ createHook$1('onError' /* ON_ERROR */) +const onThemeChange = /*#__PURE__*/ createHook$1( + 'onThemeChange' /* ON_THEME_CHANGE */ +) +const onPageNotFound = /*#__PURE__*/ createHook$1( + 'onPageNotFound' /* ON_PAGE_NOT_FOUND */ +) +const onUnhandledRejection = /*#__PURE__*/ createHook$1( + 'onUnhandledRejection' /* ON_UNHANDLE_REJECTION */ +) +const onLoad = /*#__PURE__*/ createHook$1('onLoad' /* ON_LOAD */) +const onReady = /*#__PURE__*/ createHook$1('onReady' /* ON_READY */) +const onUnload = /*#__PURE__*/ createHook$1('onUnload' /* ON_UNLOAD */) +const onResize = /*#__PURE__*/ createHook$1('onResize' /* ON_RESIZE */) +const onBackPress = /*#__PURE__*/ createHook$1( + 'onBackPress' /* ON_BACK_PRESS */ +) +const onPageScroll = /*#__PURE__*/ createHook$1( + 'onPageScroll' /* ON_PAGE_SCROLL */ +) +const onTabItemTap = /*#__PURE__*/ createHook$1( + 'onTabItemTap' /* ON_TAB_ITEM_TAP */ +) +const onReachBottom = /*#__PURE__*/ createHook$1( + 'onReachBottom' /* ON_REACH_BOTTOM */ +) +const onPullDownRefresh = /*#__PURE__*/ createHook$1( + 'onPullDownRefresh' /* ON_PULL_DOWN_REFRESH */ +) +const onShareTimeline = /*#__PURE__*/ createHook$1( + 'onShareTimeline' /* ON_SHARE_TIMELINE */ +) +const onAddToFavorites = /*#__PURE__*/ createHook$1( + 'onAddToFavorites' /* ON_ADD_TO_FAVORITES */ +) +const onShareAppMessage = /*#__PURE__*/ createHook$1( + 'onShareAppMessage' /* ON_SHARE_APP_MESSAGE */ +) +const onNavigationBarButtonTap = /*#__PURE__*/ createHook$1( + 'onNavigationBarButtonTap' /* ON_NAVIGATION_BAR_BUTTON_TAP */ +) +const onNavigationBarSearchInputChanged = /*#__PURE__*/ createHook$1( + 'onNavigationBarSearchInputChanged' /* ON_NAVIGATION_BAR_SEARCH_INPUT_CHANGED */ +) +const onNavigationBarSearchInputClicked = /*#__PURE__*/ createHook$1( + 'onNavigationBarSearchInputClicked' /* ON_NAVIGATION_BAR_SEARCH_INPUT_CLICKED */ +) +const onNavigationBarSearchInputConfirmed = /*#__PURE__*/ createHook$1( + 'onNavigationBarSearchInputConfirmed' /* ON_NAVIGATION_BAR_SEARCH_INPUT_CONFIRMED */ +) +const onNavigationBarSearchInputFocusChanged = /*#__PURE__*/ createHook$1( + 'onNavigationBarSearchInputFocusChanged' /* ON_NAVIGATION_BAR_SEARCH_INPUT_FOCUS_CHANGED */ +) + +export { + BaseTransition, + Comment, + Fragment, + KeepAlive, + Static, + Suspense, + Teleport, + Text, + Transition, + TransitionGroup, + callWithAsyncErrorHandling, + callWithErrorHandling, + cloneVNode, + compile$1 as compile, + computed$1 as computed, + createApp, + createBlock, + createCommentVNode, + createHook$1 as createHook, + createHydrationRenderer, + createRenderer, + createSSRApp, + createSlots, + createStaticVNode, + createTextVNode, + createVNode, + customRef, + defineAsyncComponent, + defineComponent, + devtools, + getCurrentInstance, + getTransitionRawChildren, + h, + handleError, + hydrate, + inject, + injectHook, + isInSSRComponentSetup, + isProxy, + isReactive, + isReadonly, + isRef, + isVNode, + markRaw, + mergeProps, + nextTick, + onActivated, + onAddToFavorites, + onBackPress, + onBeforeMount, + onBeforeUnmount, + onBeforeUpdate, + onDeactivated, + onError, + onErrorCaptured, + onHide, + onLaunch, + onLoad, + onMounted, + onNavigationBarButtonTap, + onNavigationBarSearchInputChanged, + onNavigationBarSearchInputClicked, + onNavigationBarSearchInputConfirmed, + onNavigationBarSearchInputFocusChanged, + onPageNotFound, + onPageScroll, + onPullDownRefresh, + onReachBottom, + onReady, + onRenderTracked, + onRenderTriggered, + onResize, + onShareAppMessage, + onShareTimeline, + onShow, + onTabItemTap, + onThemeChange, + onUnhandledRejection, + onUnload, + onUnmounted, + onUpdated, + openBlock, + popScopeId, + provide, + proxyRefs, + pushScopeId, + queuePostFlushCb, + reactive, + readonly, + ref, + registerRuntimeCompiler, + render, + renderList, + renderSlot, + resolveComponent, + resolveDirective, + resolveDynamicComponent, + resolveTransitionHooks, + setBlockTracking, + setDevtoolsHook, + setTransitionHooks, + shallowReactive, + shallowReadonly, + shallowRef, + ssrContextKey, + ssrUtils, + toHandlers, + toRaw, + toRef, + toRefs, + transformVNodeArgs, + triggerRef, + unref, + useCssModule, + useCssVars, + useSSRContext, + useTransitionState, + vModelCheckbox, + vModelDynamic, + vModelRadio, + vModelSelect, + vModelText, + vShow, + version, + warn, + watch, + watchEffect, + withCtx, + withDirectives, + withKeys, + withModifiers, + withScopeId +} diff --git a/packages/uni-h5-vue/lib/vue.runtime.esm.js b/packages/uni-h5-vue/lib/vue.runtime.esm.js index 7eca3d64c1e157123b424b58ed797ce6bf7532fd..ab08e586fea1e53f6cec6520fc033d49273ffd02 100644 --- a/packages/uni-h5-vue/lib/vue.runtime.esm.js +++ b/packages/uni-h5-vue/lib/vue.runtime.esm.js @@ -338,8 +338,6 @@ const mutableHandlers = { } const readonlyHandlers = { get: readonlyGet, - has, - ownKeys, set(target, key) { if (process.env.NODE_ENV !== 'production') { console.warn( @@ -1453,11 +1451,11 @@ function markAttrsAccessed() { function renderComponentRoot(instance) { const { type: Component, - parent, vnode, proxy, withProxy, props, + propsOptions: [propsOptions], slots, attrs, emit, @@ -1531,11 +1529,15 @@ function renderComponentRoot(instance) { const { shapeFlag } = root if (keys.length) { if (shapeFlag & 1 /* ELEMENT */ || shapeFlag & 6 /* COMPONENT */) { - if (shapeFlag & 1 /* ELEMENT */ && keys.some(isModelListener)) { - // #1643, #1543 - // component v-model listeners should only fallthrough for component - // HOCs - fallthroughAttrs = filterModelListeners(fallthroughAttrs) + 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 ( @@ -1580,21 +1582,6 @@ function renderComponentRoot(instance) { } } } - // inherit scopeId - const scopeId = vnode.scopeId - // vite#536: if subtree root is created from parent slot if would already - // have the correct scopeId, in this case adding the scopeId will cause - // it to be removed if the original slot vnode is reused. - const needScopeId = scopeId && root.scopeId !== scopeId - const treeOwnerId = parent && parent.type.__scopeId - const slotScopeId = - treeOwnerId && treeOwnerId !== scopeId ? treeOwnerId + '-s' : null - if (needScopeId || slotScopeId) { - const extras = {} - if (needScopeId) extras[scopeId] = '' - if (slotScopeId) extras[slotScopeId] = '' - root = cloneVNode(root, extras) - } // inherit directives if (vnode.dirs) { if (process.env.NODE_ENV !== 'production' && !isElementRoot(root)) { @@ -1668,10 +1655,10 @@ const getFunctionalFallthrough = attrs => { } return res } -const filterModelListeners = attrs => { +const filterModelListeners = (attrs, props) => { const res = {} for (const key in attrs) { - if (!isModelListener(key)) { + if (!isModelListener(key) || !(key.slice(9) in props)) { res[key] = attrs[key] } } @@ -2237,6 +2224,7 @@ function queueEffectWithSuspense(fn, suspense) { } let isRenderingCompiledSlot = 0 +const setCompiledSlotRendering = n => (isRenderingCompiledSlot += n) /** * Compiler runtime helper for rendering `` * @private @@ -2280,7 +2268,7 @@ function renderSlot( */ function withCtx(fn, ctx = currentRenderingInstance) { if (!ctx) return fn - return function renderFnWithContext() { + 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 ``. @@ -2289,13 +2277,15 @@ function withCtx(fn, ctx = currentRenderingInstance) { } const owner = currentRenderingInstance setCurrentRenderingInstance(ctx) - const res = fn.apply(null, arguments) + const res = fn(...args) setCurrentRenderingInstance(owner) if (!isRenderingCompiledSlot) { closeBlock() } return res } + renderFnWithContext._c = true + return renderFnWithContext } // SFC scoped style ID management. @@ -2354,7 +2344,11 @@ const resolveTarget = (props, select) => { return target } } else { - if (process.env.NODE_ENV !== 'production' && !targetSelector) { + if ( + process.env.NODE_ENV !== 'production' && + !targetSelector && + !isTeleportDisabled(props) + ) { warn(`Invalid Teleport target: ${targetSelector}`) } return targetSelector @@ -2397,7 +2391,7 @@ const TeleportImpl = { const targetAnchor = (n2.targetAnchor = createText('')) if (target) { insert(targetAnchor, target) - } else if (process.env.NODE_ENV !== 'production') { + } else if (process.env.NODE_ENV !== 'production' && !disabled) { warn('Invalid Teleport target on mount:', target, `(${typeof target})`) } const mount = (container, anchor) => { @@ -2743,7 +2737,7 @@ function createBlock(type, props, children, patchFlag, dynamicProps) { closeBlock() // a block is always going to be patched, so track it as a child of its // parent block - if (currentBlock) { + if (shouldTrack$1 > 0 && currentBlock) { currentBlock.push(vnode) } return vnode @@ -3011,12 +3005,15 @@ function normalizeChildren(vnode, children) { } else if (isArray(children)) { type = 16 /* ARRAY_CHILDREN */ } else if (typeof children === 'object') { - // Normalize slot to plain children - if ( - (shapeFlag & 1 /* ELEMENT */ || shapeFlag & 64) /* TELEPORT */ && - children.default - ) { - normalizeChildren(vnode, children.default()) + 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 */ @@ -3129,10 +3126,12 @@ function devtoolsComponentEmit(component, event, params) { function emit(instance, event, ...args) { const props = instance.vnode.props || EMPTY_OBJ if (process.env.NODE_ENV !== 'production') { - const options = normalizeEmitsOptions(instance.type) - if (options) { - if (!(event in options)) { - const propsOptions = normalizePropsOptions(instance.type)[0] + 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 ` + @@ -3140,7 +3139,7 @@ function emit(instance, event, ...args) { ) } } else { - const validator = options[event] + const validator = emitsOptions[event] if (isFunction(validator)) { const isValid = validator(...args) if (!isValid) { @@ -3180,46 +3179,53 @@ function emit(instance, event, ...args) { ) } } -function normalizeEmitsOptions(comp) { - if (hasOwn(comp, '__emits')) { - return comp.__emits +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)) { - if (comp.extends) { + const extendEmits = raw => { hasExtends = true - extend(normalized, normalizeEmitsOptions(comp.extends)) + extend(normalized, normalizeEmitsOptions(raw, appContext, true)) + } + if (!asMixin && appContext.mixins.length) { + appContext.mixins.forEach(extendEmits) + } + if (comp.extends) { + extendEmits(comp.extends) } if (comp.mixins) { - hasExtends = true - comp.mixins.forEach(m => extend(normalized, normalizeEmitsOptions(m))) + comp.mixins.forEach(extendEmits) } } if (!raw && !hasExtends) { - return (comp.__emits = undefined) + return (cache[appId] = null) } if (isArray(raw)) { raw.forEach(key => (normalized[key] = null)) } else { extend(normalized, raw) } - return (comp.__emits = normalized) + 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(comp, key) { - let emits - if (!isOn(key) || !(emits = normalizeEmitsOptions(comp))) { +function isEmitListener(options, key) { + if (!options || !isOn(key)) { return false } key = key.replace(/Once$/, '') return ( - hasOwn(emits, key[2].toLowerCase() + key.slice(3)) || - hasOwn(emits, key.slice(2)) + hasOwn(options, key[2].toLowerCase() + key.slice(3)) || + hasOwn(options, key.slice(2)) ) } @@ -3235,7 +3241,7 @@ function initProps( setFullProps(instance, rawProps, props, attrs) // validation if (process.env.NODE_ENV !== 'production') { - validateProps(props, instance.type) + validateProps(props, instance) } if (isStateful) { // stateful @@ -3258,7 +3264,7 @@ function updateProps(instance, rawProps, rawPrevProps, optimized) { vnode: { patchFlag } } = instance const rawCurrentProps = toRaw(props) - const [options] = normalizePropsOptions(instance.type) + const [options] = instance.propsOptions if ( // always force full diff if hmr is enabled !(process.env.NODE_ENV !== 'production' && instance.type.__hmrId) && @@ -3340,11 +3346,11 @@ function updateProps(instance, rawProps, rawPrevProps, optimized) { // 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.type) + validateProps(props, instance) } } function setFullProps(instance, rawProps, props, attrs) { - const [options, needCastKeys] = normalizePropsOptions(instance.type) + const [options, needCastKeys] = instance.propsOptions if (rawProps) { for (const key in rawProps) { const value = rawProps[key] @@ -3357,7 +3363,7 @@ function setFullProps(instance, rawProps, props, attrs) { let camelKey if (options && hasOwn(options, (camelKey = camelize(key)))) { props[camelKey] = value - } else if (!isEmitListener(instance.type, key)) { + } 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 @@ -3404,9 +3410,12 @@ function resolvePropValue(options, props, key, value) { } return value } -function normalizePropsOptions(comp) { - if (comp.__props) { - return comp.__props +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 = {} @@ -3415,21 +3424,23 @@ function normalizePropsOptions(comp) { let hasExtends = false if (__VUE_OPTIONS_API__ && !isFunction(comp)) { const extendProps = raw => { - const [props, keys] = normalizePropsOptions(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) { - hasExtends = true extendProps(comp.extends) } if (comp.mixins) { - hasExtends = true comp.mixins.forEach(extendProps) } } if (!raw && !hasExtends) { - return (comp.__props = EMPTY_ARR) + return (cache[appId] = EMPTY_ARR) } if (isArray(raw)) { for (let i = 0; i < raw.length; i++) { @@ -3465,9 +3476,7 @@ function normalizePropsOptions(comp) { } } } - const normalizedEntry = [normalized, needCastKeys] - comp.__props = normalizedEntry - return normalizedEntry + return (cache[appId] = [normalized, needCastKeys]) } // use function string name to check type constructors // so that it works across vms / iframes. @@ -3493,9 +3502,9 @@ function getTypeIndex(type, expectedTypes) { /** * dev only */ -function validateProps(props, comp) { +function validateProps(props, instance) { const rawValues = toRaw(props) - const options = normalizePropsOptions(comp)[0] + const options = instance.propsOptions[0] for (const key in options) { let opt = options[key] if (opt == null) continue @@ -4483,6 +4492,7 @@ function createAppContext() { provides: Object.create(null) } } +let uid$1 = 0 function createAppAPI(render, hydrate) { return function createApp(rootComponent, rootProps = null) { if (rootProps != null && !isObject(rootProps)) { @@ -4494,6 +4504,7 @@ function createAppAPI(render, hydrate) { const installedPlugins = new Set() let isMounted = false const app = (context.app = { + _uid: uid$1++, _component: rootComponent, _props: rootProps, _container: null, @@ -5513,15 +5524,41 @@ function baseCreateRenderer(options, createHydrationFns) { } } // scopeId - if (scopeId) { - hostSetScopeId(el, scopeId) - } - const treeOwnerId = parentComponent && parentComponent.type.__scopeId - // vnode's own scopeId and the current patched component's scopeId is - // different - this is a slot content node. - if (treeOwnerId && treeOwnerId !== scopeId) { - hostSetScopeId(el, treeOwnerId + '-s') - } + setScopeId(el, scopeId, vnode, parentComponent) + // if (scopeId) { + // hostSetScopeId(el, scopeId) + // } + // if (parentComponent) { + // const treeOwnerId = parentComponent.type.__scopeId + // // vnode's own scopeId and the current patched component's scopeId is + // // different - this is a slot content node. + // if (treeOwnerId && treeOwnerId !== scopeId) { + // hostSetScopeId(el, treeOwnerId + '-s') + // } + // const parentScopeId = + // vnode === parentComponent.subTree && parentComponent.vnode.scopeId + // if (parentScopeId) { + // hostSetScopeId(el, parentScopeId) + // if (parentComponent.parent) { + // const treeOwnerId = parentComponent.parent.type.__scopeId + // // vnode's own scopeId and the current patched component's scopeId is + // // different - this is a slot content node. + // if (treeOwnerId && treeOwnerId !== parentScopeId) { + // hostSetScopeId(el, treeOwnerId + '-s') + // } + // } + // } + // } + } + if (process.env.NODE_ENV !== 'production' || __VUE_PROD_DEVTOOLS__) { + Object.defineProperty(el, '__vnode', { + value: vnode, + enumerable: false + }) + Object.defineProperty(el, '__vueParentComponent', { + value: parentComponent, + enumerable: false + }) } if (dirs) { invokeDirectiveHook(vnode, null, parentComponent, 'beforeMount') @@ -5548,6 +5585,27 @@ function baseCreateRenderer(options, createHydrationFns) { }, parentSuspense) } } + const setScopeId = (el, scopeId, vnode, parentComponent) => { + if (scopeId) { + hostSetScopeId(el, scopeId) + } + if (parentComponent) { + const treeOwnerId = parentComponent.type.__scopeId + // vnode's own scopeId and the current patched component's scopeId is + // different - this is a slot content node. + if (treeOwnerId && treeOwnerId !== scopeId) { + hostSetScopeId(el, treeOwnerId + '-s') + } + if (vnode === parentComponent.subTree) { + setScopeId( + el, + parentComponent.vnode.scopeId, + parentComponent.vnode, + parentComponent.parent + ) + } + } + } const mountChildren = ( children, container, @@ -6713,7 +6771,7 @@ function baseCreateRenderer(options, createHydrationFns) { if (process.env.NODE_ENV !== 'production' && instance.type.__hmrId) { unregisterHMR(instance) } - const { bum, effects, update, subTree, um, da, isDeactivated } = instance + const { bum, effects, update, subTree, um } = instance // beforeUnmount hook if (bum) { invokeArrayFns(bum) @@ -6733,14 +6791,6 @@ function baseCreateRenderer(options, createHydrationFns) { if (um) { queuePostRenderEffect(um, parentSuspense) } - // deactivated hook - if ( - da && - !isDeactivated && - instance.vnode.shapeFlag & 256 /* COMPONENT_SHOULD_KEEP_ALIVE */ - ) { - queuePostRenderEffect(da, parentSuspense) - } queuePostRenderEffect(() => { instance.isUnmounted = true }, parentSuspense) @@ -7207,7 +7257,7 @@ function applyOptions( const checkDuplicateProperties = process.env.NODE_ENV !== 'production' ? createDuplicateChecker() : null if (process.env.NODE_ENV !== 'production') { - const propsOptions = normalizePropsOptions(options)[0] + const [propsOptions] = instance.propsOptions if (propsOptions) { for (const key in propsOptions) { checkDuplicateProperties('Props' /* PROPS */, key) @@ -7497,17 +7547,18 @@ function resolveMergedOptions(instance) { if (!globalMixins.length && !mixins && !extendsOptions) return raw const options = {} globalMixins.forEach(m => mergeOptions(options, m, instance)) - extendsOptions && mergeOptions(options, extendsOptions, instance) - mixins && mixins.forEach(m => mergeOptions(options, m, instance)) mergeOptions(options, raw, instance) return (raw.__merged = options) } function mergeOptions(to, from, instance) { const strats = instance.appContext.config.optionMergeStrategies + const { mixins, extends: extendsOptions } = from + extendsOptions && mergeOptions(to, extendsOptions, instance) + mixins && mixins.forEach(m => mergeOptions(to, m, instance)) for (const key in from) { if (strats && hasOwn(strats, key)) { to[key] = strats[key](to[key], from[key], instance.proxy, key) - } else if (!hasOwn(to, key)) { + } else { to[key] = from[key] } } @@ -7578,7 +7629,7 @@ const PublicInstanceProxyHandlers = { } else if ( // only cache other properties when instance has declared (thus stable) // props - (normalizedProps = normalizePropsOptions(type)[0]) && + (normalizedProps = instance.propsOptions[0]) && hasOwn(normalizedProps, key) ) { accessCache[key] = 2 /* PROPS */ @@ -7623,12 +7674,16 @@ const PublicInstanceProxyHandlers = { // to infinite warning loop key.indexOf('__v') !== 0) ) { - if (data !== EMPTY_OBJ && key[0] === '$' && hasOwn(data, key)) { + if ( + data !== EMPTY_OBJ && + (key[0] === '$' || key[0] === '_') && + hasOwn(data, key) + ) { warn( `Property ${JSON.stringify( key )} must be accessed via $data because it starts with a reserved ` + - `character and is not proxied on the render context.` + `character ("$" or "_") and is not proxied on the render context.` ) } else { warn( @@ -7678,7 +7733,7 @@ const PublicInstanceProxyHandlers = { }, has( { - _: { data, setupState, accessCache, ctx, type, appContext } + _: { data, setupState, accessCache, ctx, appContext, propsOptions } }, key ) { @@ -7687,8 +7742,7 @@ const PublicInstanceProxyHandlers = { accessCache[key] !== undefined || (data !== EMPTY_OBJ && hasOwn(data, key)) || (setupState !== EMPTY_OBJ && hasOwn(setupState, key)) || - ((normalizedProps = normalizePropsOptions(type)[0]) && - hasOwn(normalizedProps, key)) || + ((normalizedProps = propsOptions[0]) && hasOwn(normalizedProps, key)) || hasOwn(ctx, key) || hasOwn(publicPropertiesMap, key) || hasOwn(appContext.config.globalProperties, key) @@ -7768,8 +7822,10 @@ function createRenderContext(instance) { } // dev only function exposePropsOnRenderContext(instance) { - const { ctx, type } = instance - const propsOptions = normalizePropsOptions(type)[0] + const { + ctx, + propsOptions: [propsOptions] + } = instance if (propsOptions) { Object.keys(propsOptions).forEach(key => { Object.defineProperty(ctx, key, { @@ -7785,6 +7841,15 @@ function exposePropsOnRenderContext(instance) { function exposeSetupStateOnRenderContext(instance) { const { ctx, setupState } = instance Object.keys(toRaw(setupState)).forEach(key => { + if (key[0] === '$' || key[0] === '_') { + warn( + `setup() return property ${JSON.stringify( + key + )} should not start with "$" or "_" ` + + `which are reserved prefixes for Vue internals.` + ) + return + } Object.defineProperty(ctx, key, { enumerable: true, configurable: true, @@ -7795,14 +7860,14 @@ function exposeSetupStateOnRenderContext(instance) { } const emptyAppContext = createAppContext() -let uid$1 = 0 +let uid$2 = 0 function createComponentInstance(vnode, parent, suspense) { const type = vnode.type // inherit parent app context - or - if root, adopt from root vnode const appContext = (parent ? parent.appContext : vnode.appContext) || emptyAppContext const instance = { - uid: uid$1++, + uid: uid$2++, vnode, type, parent, @@ -7821,6 +7886,12 @@ function createComponentInstance(vnode, parent, suspense) { // local resovled assets components: null, directives: null, + // resolved props and emits options + propsOptions: normalizePropsOptions(type, appContext), + emitsOptions: normalizeEmitsOptions(type, appContext), + // emit + emit: null, + emitted: null, // state ctx: EMPTY_OBJ, data: EMPTY_OBJ, @@ -7851,9 +7922,7 @@ function createComponentInstance(vnode, parent, suspense) { a: null, rtg: null, rtc: null, - ec: null, - emit: null, - emitted: null + ec: null } if (process.env.NODE_ENV !== 'production') { instance.ctx = createRenderContext(instance) @@ -8391,7 +8460,7 @@ function createSlots(slots, dynamicSlots) { } // Core API ------------------------------------------------------------------ -const version = '3.0.0-rc.9' +const version = '3.0.0-rc.10' /** * SSR utils for \@vue/server-renderer. Only exposed in cjs builds. * @internal diff --git a/packages/uni-h5/dist/uni-h5.css b/packages/uni-h5/dist/uni-h5.css new file mode 100644 index 0000000000000000000000000000000000000000..09a9593b61f835415dbc9e0940a4107fc9ce1448 --- /dev/null +++ b/packages/uni-h5/dist/uni-h5.css @@ -0,0 +1,822 @@ + +uni-tabbar{ + display:block; + box-sizing:border-box; + position:fixed; + left:0; + bottom:0; + width:100%; + z-index:998; +} +uni-tabbar .uni-tabbar{ + display:flex; + position:fixed; + left:0; + bottom:0; + width:100%; + z-index:998; + box-sizing:border-box; + padding-bottom:0; + padding-bottom:constant(safe-area-inset-bottom); + padding-bottom:env(safe-area-inset-bottom); +} +uni-tabbar .uni-tabbar ~ .uni-placeholder{ + width:100%; + height:50px; + margin-bottom:0; + margin-bottom:constant(safe-area-inset-bottom); + margin-bottom:env(safe-area-inset-bottom); +} +uni-tabbar .uni-tabbar *{ + box-sizing:border-box; +} +uni-tabbar .uni-tabbar__item{ + display:flex; + justify-content:center; + align-items:center; + flex-direction:column; + flex:1; + font-size:0; + text-align:center; + -webkit-tap-highlight-color:rgba(0, 0, 0, 0); +} +uni-tabbar .uni-tabbar__bd{ + position:relative; + height:50px; + display:flex; + flex-direction:column; + align-items:center; + justify-content:center; + cursor:pointer; +} +uni-tabbar .uni-tabbar__icon{ + position:relative; + display:inline-block; + margin-top:5px; + width:24px; + height:24px; +} +uni-tabbar .uni-tabbar__icon.uni-tabbar__icon__diff{ + margin-top:0px; + width:34px; + height:34px; +} +uni-tabbar .uni-tabbar__icon img{ + width:100%; + height:100%; +} +uni-tabbar .uni-tabbar__label{ + position:relative; + text-align:center; + font-size:10px; + line-height:1.8; +} +uni-tabbar .uni-tabbar-border{ + position:absolute; + left:0; + top:0; + width:100%; + height:1px; + transform:scaleY(0.5); +} +uni-tabbar .uni-tabbar__reddot{ + position:absolute; + top:0; + right:0; + width:12px; + height:12px; + border-radius:50%; + background-color:#f43530; + color:#ffffff; + transform:translate(40%, -20%); +} +uni-tabbar .uni-tabbar__badge{ + width:auto; + height:16px; + line-height:16px; + border-radius:16px; + min-width:16px; + padding:0 2px; + font-size:12px; + text-align:center; + white-space:nowrap; +} + +uni-toast{ + position:fixed; + top:0; + right:0; + bottom:0; + left:0; + z-index:999; + display:block; + box-sizing:border-box; + pointer-events:none; +} +uni-toast .uni-sample-toast{ + position:fixed; + z-index:999; + top:50%; + left:50%; + transform:translate(-50%, -50%); + text-align:center; + max-width:80%; +} +uni-toast .uni-simple-toast__text{ + display:inline-block; + vertical-align:middle; + color:#ffffff; + background-color:rgba(17, 17, 17, 0.7); + padding:10px 20px; + border-radius:5px; + font-size:13px; + text-align:center; + max-width:100%; + word-break:break-all; + white-space:normal; +} +uni-toast .uni-mask{ + pointer-events:auto; +} +uni-toast .uni-toast{ + position:fixed; + z-index:999; + width:8em; + top:50%; + left:50%; + transform:translate(-50%, -50%); + background:rgba(17, 17, 17, 0.7); + text-align:center; + border-radius:5px; + color:#ffffff; +} +uni-toast .uni-toast *{ + box-sizing:border-box; +} +uni-toast .uni-toast__icon{ + margin:20px 0 0; + width:38px; + height:38px; + vertical-align:baseline; +} +uni-toast .uni-icon_toast{ + margin:15px 0 0; +} +uni-toast .uni-icon_toast.uni-icon-success-no-circle:before{ + color:#ffffff; + font-size:55px; +} +uni-toast .uni-icon_toast.uni-loading{ + margin:20px 0 0; + width:38px; + height:38px; + vertical-align:baseline; +} +uni-toast .uni-toast__content{ + margin:0 0 15px; +} + +uni-modal{ + position:fixed; + top:0; + right:0; + bottom:0; + left:0; + z-index:999; + display:block; + box-sizing:border-box; +} +uni-modal .uni-modal{ + position:fixed; + z-index:999; + width:80%; + max-width:300px; + top:50%; + left:50%; + transform:translate(-50%, -50%); + background-color:#ffffff; + text-align:center; + border-radius:3px; + overflow:hidden; +} +uni-modal .uni-modal *{ + box-sizing:border-box; +} +uni-modal .uni-modal__hd{ + padding:1em 1.6em 0.3em; +} +uni-modal .uni-modal__title{ + font-weight:400; + font-size:18px; + word-wrap:break-word; + word-break:break-all; + white-space:pre-wrap; + overflow:hidden; + text-overflow:ellipsis; + display:-webkit-box; + -webkit-line-clamp:2; + -webkit-box-orient:vertical; +} +uni-modal .uni-modal__bd{ + padding:1.3em 1.6em 1.3em; + min-height:40px; + font-size:15px; + line-height:1.4; + word-wrap:break-word; + word-break:break-all; + white-space:pre-wrap; + color:#999999; + max-height:400px; + overflow-y:auto; +} +uni-modal .uni-modal__ft{ + position:relative; + line-height:48px; + font-size:18px; + display:flex; +} +uni-modal .uni-modal__ft:after{ + content:" "; + position:absolute; + left:0; + top:0; + right:0; + height:1px; + border-top:1px solid #d5d5d6; + color:#d5d5d6; + transform-origin:0 0; + transform:scaleY(0.5); +} +uni-modal .uni-modal__btn{ + display:block; + flex:1; + color:#3cc51f; + text-decoration:none; + -webkit-tap-highlight-color:rgba(0, 0, 0, 0); + position:relative; +} +uni-modal .uni-modal__btn:active{ + background-color:#eeeeee; +} +uni-modal .uni-modal__btn:after{ + content:" "; + position:absolute; + left:0; + top:0; + width:1px; + bottom:0; + border-left:1px solid #d5d5d6; + color:#d5d5d6; + transform-origin:0 0; + transform:scaleX(0.5); +} +uni-modal .uni-modal__btn:first-child:after{ + display:none; +} +uni-modal .uni-modal__btn_default{ + color:#353535; +} +uni-modal .uni-modal__btn_primary{ + color:#007aff; +} + +uni-actionsheet{ + display:block; + box-sizing:border-box; +} +uni-actionsheet .uni-actionsheet{ + position:fixed; + left:0; + bottom:0; + transform:translate(0, 100%); + backface-visibility:hidden; + z-index:999; + width:100%; + background-color:#efeff4; + visibility:hidden; + transition:transform 0.3s, visibility 0.3s; +} +uni-actionsheet .uni-actionsheet.uni-actionsheet_toggle{ + visibility:visible; + transform:translate(0, 0); +} +uni-actionsheet .uni-actionsheet *{ + box-sizing:border-box; +} +uni-actionsheet .uni-actionsheet__menu{ + background-color:#fcfcfd; +} +uni-actionsheet .uni-actionsheet__action{ + margin-top:6px; + background-color:#fcfcfd; +} +uni-actionsheet .uni-actionsheet__cell , + uni-actionsheet .uni-actionsheet__title{ + position:relative; + padding:10px 0; + text-align:center; + font-size:18px; +} +uni-actionsheet .uni-actionsheet__cell:before{ + content:" "; + position:absolute; + left:0; + top:0; + right:0; + height:1px; + border-top:1px solid #e5e5e5; + color:#e5e5e5; + transform-origin:0 0; + transform:scaleY(0.5); +} +uni-actionsheet .uni-actionsheet__cell:active{ + background-color:#ececec; +} +uni-actionsheet .uni-actionsheet__cell:first-child:before{ + display:none; +} +*{ + margin:0; + -webkit-tap-highlight-color:transparent; +} +@font-face{ + font-weight:normal; + font-style:normal; + font-family:"uni"; + src:url('data:application/octet-stream;base64,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') format('truetype'); +} +@font-face{ + font-weight:normal; + font-style:normal; + font-family:"unibtn"; + src:url('data:application/octet-stream;base64,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') format('truetype') +} +html, +body{ + -webkit-user-select:none; + user-select:none; + width:100%; + height:100%; +} +body{ + overflow-x:hidden; +} +[class^="uni-icon-"], +[class*=" uni-icon-"]{ + display:inline-block; + vertical-align:middle; + font:normal normal normal 14px/1 "uni"; + font-size:inherit; + text-rendering:auto; + -webkit-font-smoothing:antialiased; +} +[class^="uni-btn-icon"], +[class*=" uni-btn-icon"]{ + display:inline-block; + font:normal normal normal 14px/1 "unibtn"; + font-size:inherit; + text-rendering:auto; + -webkit-font-smoothing:antialiased; +} +[class^="uni-btn-icon"]:before, +[class*=" uni-btn-icon"]:before{ + margin:0; + box-sizing:border-box; +} +.uni-icon-success-no-circle:before{ + content:"\EA08"; +} +.uni-loading, +uni-button[loading]:before{ + background:transparent url("data:image/svg+xml;base64, PHN2ZyB4bWxucz0iaHR0cDovL3d3dy53My5vcmcvMjAwMC9zdmciIHdpZHRoPSIxMjAiIGhlaWdodD0iMTIwIiB2aWV3Qm94PSIwIDAgMTAwIDEwMCI+PHBhdGggZmlsbD0ibm9uZSIgZD0iTTAgMGgxMDB2MTAwSDB6Ii8+PHJlY3Qgd2lkdGg9IjciIGhlaWdodD0iMjAiIHg9IjQ2LjUiIHk9IjQwIiBmaWxsPSIjRTlFOUU5IiByeD0iNSIgcnk9IjUiIHRyYW5zZm9ybT0idHJhbnNsYXRlKDAgLTMwKSIvPjxyZWN0IHdpZHRoPSI3IiBoZWlnaHQ9IjIwIiB4PSI0Ni41IiB5PSI0MCIgZmlsbD0iIzk4OTY5NyIgcng9IjUiIHJ5PSI1IiB0cmFuc2Zvcm09InJvdGF0ZSgzMCAxMDUuOTggNjUpIi8+PHJlY3Qgd2lkdGg9IjciIGhlaWdodD0iMjAiIHg9IjQ2LjUiIHk9IjQwIiBmaWxsPSIjOUI5OTlBIiByeD0iNSIgcnk9IjUiIHRyYW5zZm9ybT0icm90YXRlKDYwIDc1Ljk4IDY1KSIvPjxyZWN0IHdpZHRoPSI3IiBoZWlnaHQ9IjIwIiB4PSI0Ni41IiB5PSI0MCIgZmlsbD0iI0EzQTFBMiIgcng9IjUiIHJ5PSI1IiB0cmFuc2Zvcm09InJvdGF0ZSg5MCA2NSA2NSkiLz48cmVjdCB3aWR0aD0iNyIgaGVpZ2h0PSIyMCIgeD0iNDYuNSIgeT0iNDAiIGZpbGw9IiNBQkE5QUEiIHJ4PSI1IiByeT0iNSIgdHJhbnNmb3JtPSJyb3RhdGUoMTIwIDU4LjY2IDY1KSIvPjxyZWN0IHdpZHRoPSI3IiBoZWlnaHQ9IjIwIiB4PSI0Ni41IiB5PSI0MCIgZmlsbD0iI0IyQjJCMiIgcng9IjUiIHJ5PSI1IiB0cmFuc2Zvcm09InJvdGF0ZSgxNTAgNTQuMDIgNjUpIi8+PHJlY3Qgd2lkdGg9IjciIGhlaWdodD0iMjAiIHg9IjQ2LjUiIHk9IjQwIiBmaWxsPSIjQkFCOEI5IiByeD0iNSIgcnk9IjUiIHRyYW5zZm9ybT0icm90YXRlKDE4MCA1MCA2NSkiLz48cmVjdCB3aWR0aD0iNyIgaGVpZ2h0PSIyMCIgeD0iNDYuNSIgeT0iNDAiIGZpbGw9IiNDMkMwQzEiIHJ4PSI1IiByeT0iNSIgdHJhbnNmb3JtPSJyb3RhdGUoLTE1MCA0NS45OCA2NSkiLz48cmVjdCB3aWR0aD0iNyIgaGVpZ2h0PSIyMCIgeD0iNDYuNSIgeT0iNDAiIGZpbGw9IiNDQkNCQ0IiIHJ4PSI1IiByeT0iNSIgdHJhbnNmb3JtPSJyb3RhdGUoLTEyMCA0MS4zNCA2NSkiLz48cmVjdCB3aWR0aD0iNyIgaGVpZ2h0PSIyMCIgeD0iNDYuNSIgeT0iNDAiIGZpbGw9IiNEMkQyRDIiIHJ4PSI1IiByeT0iNSIgdHJhbnNmb3JtPSJyb3RhdGUoLTkwIDM1IDY1KSIvPjxyZWN0IHdpZHRoPSI3IiBoZWlnaHQ9IjIwIiB4PSI0Ni41IiB5PSI0MCIgZmlsbD0iI0RBREFEQSIgcng9IjUiIHJ5PSI1IiB0cmFuc2Zvcm09InJvdGF0ZSgtNjAgMjQuMDIgNjUpIi8+PHJlY3Qgd2lkdGg9IjciIGhlaWdodD0iMjAiIHg9IjQ2LjUiIHk9IjQwIiBmaWxsPSIjRTJFMkUyIiByeD0iNSIgcnk9IjUiIHRyYW5zZm9ybT0icm90YXRlKC0zMCAtNS45OCA2NSkiLz48L3N2Zz4=") no-repeat; +} +.uni-loading{ + width:20px; + height:20px; + display:inline-block; + vertical-align:middle; + animation:uni-loading 1s steps(12, end) infinite; + background-size:100%; +} +@keyframes uni-loading{ +0%{ + transform:rotate3d(0, 0, 1, 0deg); +} +100%{ + transform:rotate3d(0, 0, 1, 360deg); +} +} +.uni-mask{ + position:fixed; + z-index:999; + top:0; + right:0; + left:0; + bottom:0; + background:rgba(0, 0, 0, 0.6); +} +.uni-fade-enter-active, +.uni-fade-leave-active{ + transition-duration:0.25s; + transition-property:opacity; + transition-timing-function:ease; +} +.uni-fade-enter, +.uni-fade-leave-active{ + opacity:0 +} +[nvue] uni-view, +[nvue] uni-swiper-item, +[nvue] uni-scroll-view{ + display:flex; + flex-shrink:0; + flex-grow:0; + flex-basis:auto; + align-items:stretch; + align-content:flex-start; +} +[nvue-dir-row] uni-view, +[nvue-dir-row] uni-swiper-item{ + flex-direction:row; +} +[nvue-dir-column] uni-view, +[nvue-dir-column] uni-swiper-item{ + flex-direction:column; +} +[nvue-dir-row-reverse] uni-view, +[nvue-dir-row-reverse] uni-swiper-item{ + flex-direction:row-reverse; +} +[nvue-dir-column-reverse] uni-view, +[nvue-dir-column-reverse] uni-swiper-item{ + flex-direction:column-reverse; +} +[nvue] uni-view, +[nvue] uni-image, +[nvue] uni-input, +[nvue] uni-scroll-view, +[nvue] uni-swiper, +[nvue] uni-swiper-item, +[nvue] uni-text, +[nvue] uni-textarea, +[nvue] uni-video{ + position:relative; + border:0px solid #000000; + box-sizing:border-box; +} +[nvue] uni-swiper-item{ + position:absolute; +} +uni-app{ + display:block; + box-sizing:border-box; + width:100%; + height:100%; +} + +uni-page-head{ + display:block; + box-sizing:border-box; +} +uni-page-head .uni-page-head{ + position:fixed; + left:0; + top:0; + width:100%; + height:44px; + height:calc(44px + constant(safe-area-inset-top)); + height:calc(44px + env(safe-area-inset-top)); + padding:7px 3px; + padding-top:calc(7px + constant(safe-area-inset-top)); + padding-top:calc(7px + env(safe-area-inset-top)); + display:flex; + overflow:hidden; + justify-content:space-between; + box-sizing:border-box; + z-index:998; + color:#fff; + background-color:#000; + transition-property:all; +} +uni-page-head .uni-page-head-titlePenetrate, +uni-page-head .uni-page-head-titlePenetrate .uni-page-head-bd, +uni-page-head .uni-page-head-titlePenetrate .uni-page-head-bd *{ + pointer-events:none; +} +uni-page-head .uni-page-head-titlePenetrate *{ + pointer-events:auto; +} +uni-page-head .uni-page-head.uni-page-head-transparent .uni-page-head-ft > div{ + justify-content:center; +} +uni-page-head .uni-page-head ~ .uni-placeholder{ + width:100%; + height:44px; + height:calc(44px + constant(safe-area-inset-top)); + height:calc(44px + env(safe-area-inset-top)); +} +uni-page-head .uni-placeholder-titlePenetrate{ + pointer-events:none; +} +uni-page-head .uni-page-head *{ + box-sizing:border-box; +} +uni-page-head .uni-page-head-hd{ + display:flex; + align-items:center; + font-size:16px; +} +uni-page-head .uni-page-head-bd{ + position:absolute; + left:70px; + right:70px; + min-width:0; + user-select:auto; +} +.uni-page-head-btn{ + position:relative; + width:auto; + margin:0 2px; + word-break:keep-all; + white-space:pre; + cursor:pointer; +} +.uni-page-head-transparent .uni-page-head-btn{ + display:flex; + align-items:center; + width:32px; + height:32px; + border-radius:50%; + background-color:rgba(0, 0, 0, 0.5); +} +uni-page-head .uni-btn-icon{ + overflow:hidden; + min-width:1em; +} +.uni-page-head-btn-red-dot::after{ + content:attr(badge-text); + position:absolute; + right:0; + top:0; + background-color:red; + color:white; + width:18px; + height:18px; + line-height:18px; + border-radius:18px; + overflow:hidden; + transform:scale(0.5) translate(40%, -40%); + transform-origin:100% 0; +} +.uni-page-head-btn-red-dot[badge-text]::after{ + font-size:12px; + width:auto; + min-width:18px; + max-width:42px; + text-align:center; + padding:0 3px; + transform:scale(0.7) translate(40%, -40%); +} +.uni-page-head-btn-select > .uni-btn-icon::after{ + display:inline-block; + font-family:'unibtn'; + content:'\e601'; + margin-left:2px; + transform:rotate(-90deg) scale(0.8); +} +.uni-page-head-search{ + position:relative; + display:flex; + flex:1; + margin:0 2px; + line-height:30px; + font-size:15px; +} +.uni-page-head-search-input{ + width:100%; + height:100%; + padding-left:34px; + text-align:left; +} +.uni-page-head-search-placeholder{ + position:absolute; + max-width:100%; + height:100%; + padding-left:34px; + overflow:hidden; + word-break:keep-all; + white-space:pre; +} +.uni-page-head-search-placeholder-right{ + right:0; +} +.uni-page-head-search-placeholder-center{ + left:50%; + transform:translateX(-50%); +} +.uni-page-head-search-placeholder::before{ + position:absolute; + top:0; + left:2px; + width:30px; + content:'\ea0e'; + display:block; + font-size:20px; + font-family:'uni'; + text-align:center; +} +uni-page-head .uni-page-head-ft{ + display:flex; + align-items:center; + flex-direction:row-reverse; + font-size:13px; +} +uni-page-head .uni-page-head__title{ + font-weight:bold; + font-size:16px; + line-height:30px; + text-align:center; + overflow:hidden; + white-space:nowrap; + text-overflow:ellipsis; +} +uni-page-head .uni-page-head__title .uni-loading{ + width:16px; + height:16px; + margin-top:-3px; +} +uni-page-head .uni-page-head__title .uni-page-head__title_image{ + width:auto; + height:26px; + vertical-align:middle; +} +uni-page-head .uni-page-head-shadow{ + overflow:visible; +} +uni-page-head .uni-page-head-shadow::after{ + content:''; + position:absolute; + left:0; + right:0; + top:100%; + height:5px; + background-size:100% 100%; +} +uni-page-head .uni-page-head-shadow-grey::after{ + background-image:url('https://cdn.dcloud.net.cn/img/shadow-grey.png'); +} +uni-page-head .uni-page-head-shadow-blue::after{ + background-image:url('https://cdn.dcloud.net.cn/img/shadow-blue.png'); +} +uni-page-head .uni-page-head-shadow-green::after{ + background-image:url('https://cdn.dcloud.net.cn/img/shadow-green.png'); +} +uni-page-head .uni-page-head-shadow-orange::after{ + background-image:url('https://cdn.dcloud.net.cn/img/shadow-orange.png'); +} +uni-page-head .uni-page-head-shadow-red::after{ + background-image:url('https://cdn.dcloud.net.cn/img/shadow-red.png'); +} +uni-page-head .uni-page-head-shadow-yellow::after{ + background-image:url('https://cdn.dcloud.net.cn/img/shadow-yellow.png'); +} + +uni-page-wrapper{ + display:block; + height:100%; + position:relative; +} +uni-page-head[uni-page-head-type="default"] ~ uni-page-wrapper{ + height:calc(100% - 44px); + height:calc(100% - 44px - constant(safe-area-inset-top)); + height:calc(100% - 44px - env(safe-area-inset-top)); +} +.uni-app--showtabbar uni-page-wrapper{ + display:block; + height:calc(100% - 50px); + height:calc(100% - 50px - constant(safe-area-inset-bottom)); + height:calc(100% - 50px - env(safe-area-inset-bottom)); +} +.uni-app--showtabbar uni-page-wrapper::after{ + content:""; + display:block; + width:100%; + height:50px; + height:calc(50px + constant(safe-area-inset-bottom)); + height:calc(50px + env(safe-area-inset-bottom)); +} +.uni-app--showtabbar uni-page-head[uni-page-head-type="default"] ~ uni-page-wrapper{ + height:calc(100% - 44px - 50px); + height:calc(100% - 44px - constant(safe-area-inset-top) - 50px - constant(safe-area-inset-bottom)); + height:calc(100% - 44px - env(safe-area-inset-top) - 50px - env(safe-area-inset-bottom)); +} +uni-page-body{ + display:block; + box-sizing:border-box; + width:100%; +} + +uni-page-refresh{ + position:absolute; + top:0; + width:100%; + height:40px; + display:block; + box-sizing:border-box; +} +uni-page-refresh .uni-page-refresh{ + position:absolute; + top:-45px; + left:50%; + transform:translate3d(-50%, 0, 0); + width:40px; + height:40px; + justify-content:center; + align-items:center; + background:#fff; + border-radius:50%; + box-shadow:0 1px 6px rgba(0, 0, 0, .117647), 0 1px 4px rgba(0, 0, 0, .117647); + display:none; + z-index:997; +} +uni-page-refresh .uni-page-refresh-inner{ + display:flex; + align-items:center; + justify-content:center; + line-height:0; + width:40px; + height:40px; + border-radius:50%; +} +uni-page-refresh.uni-page-refresh--pulling .uni-page-refresh, + uni-page-refresh.uni-page-refresh--aborting .uni-page-refresh, + uni-page-refresh.uni-page-refresh--reached .uni-page-refresh, + uni-page-refresh.uni-page-refresh--refreshing .uni-page-refresh, + uni-page-refresh.uni-page-refresh--restoring .uni-page-refresh{ + display:flex; +} +uni-page-refresh.uni-page-refresh--pulling .uni-page-refresh__spinner, + uni-page-refresh.uni-page-refresh--aborting .uni-page-refresh__spinner, + uni-page-refresh.uni-page-refresh--reached .uni-page-refresh__spinner, + uni-page-refresh.uni-page-refresh--refreshing .uni-page-refresh__icon, + uni-page-refresh.uni-page-refresh--restoring .uni-page-refresh__icon{ + display:none; +} +uni-page-refresh.uni-page-refresh--refreshing .uni-page-refresh__spinner{ + transform-origin:center center; + animation:uni-page-refresh-rotate 2s linear infinite; +} +uni-page-refresh.uni-page-refresh--refreshing .uni-page-refresh__path{ + stroke-dasharray:1, 200; + stroke-dashoffset:0; + stroke-linecap:round; + animation:uni-page-refresh-dash 1.5s ease-in-out infinite, uni-page-refresh-colorful 6s ease-in-out infinite; +} +@keyframes uni-page-refresh-rotate{ +100%{ + -webkit-transform:rotate(360deg); + transform:rotate(360deg); +} +} +@keyframes uni-page-refresh-dash{ +0%{ + stroke-dasharray:1, 200; + stroke-dashoffset:0; +} +50%{ + stroke-dasharray:89, 200; + stroke-dashoffset:-35px; +} +100%{ + stroke-dasharray:89, 200; + stroke-dashoffset:-124px; +} +} + +uni-page{ + display:block; + width:100%; + height:100%; +} + +.uni-async-error{ + position:absolute; + left:0; + right:0; + top:0; + bottom:0; + color:#999; + padding:100px 0; + text-align:center; +} + +.uni-async-loading{ + box-sizing:border-box; + width:100%; + padding:50px; + text-align:center; +} +.uni-async-loading .uni-loading{ + width:30px; + height:30px; +} diff --git a/packages/uni-h5/dist/uni-h5.esm.js b/packages/uni-h5/dist/uni-h5.esm.js new file mode 100644 index 0000000000000000000000000000000000000000..be87714a8f0a96478876fe35e171296203f18d64 --- /dev/null +++ b/packages/uni-h5/dist/uni-h5.esm.js @@ -0,0 +1,3532 @@ +import { + isFunction, + extend, + isPlainObject, + isPromise, + isArray, + hasOwn +} from '@vue/shared' +import { + injectHook, + openBlock, + createBlock, + createVNode, + Fragment, + renderList, + toDisplayString, + createCommentVNode, + createTextVNode, + Transition, + withCtx, + withModifiers, + withDirectives, + vShow, + resolveComponent, + KeepAlive, + resolveDynamicComponent, + mergeProps, + renderSlot +} from 'vue' +import { + isCustomElement, + TABBAR_HEIGHT, + COMPONENT_NAME_PREFIX, + NAVBAR_HEIGHT +} from '@dcloudio/uni-shared' +import { passiveOptions, Input } from '@dcloudio/uni-components' +export * from '@dcloudio/uni-components' +import { + createWebHistory, + createWebHashHistory, + createRouter +} from 'vue-router' +function applyOptions(options, instance2, publicThis) { + Object.keys(options).forEach(name => { + if (name.indexOf('on') === 0) { + const hook = options[name] + if (isFunction(hook)) { + injectHook(name, hook.bind(publicThis), instance2) + } + } + }) +} +function set(target, key, val) { + return (target[key] = val) +} +function hasHook(name) { + const hooks = this.$[name] + if (hooks && hooks.length) { + return true + } + return false +} +function callHook(name, args) { + const hooks = this.$[name] + let ret + if (hooks) { + for (let i = 0; i < hooks.length; i++) { + ret = hooks[i](args) + } + } + return ret +} +function errorHandler(err, instance2, info) { + if (!instance2) { + throw err + } + const appInstance = instance2.$.appContext.$appInstance + if (!appInstance) { + throw err + } + appInstance.$callHook('onError', err, info) +} +function initApp(app) { + const appConfig2 = app._context.config + if (isFunction(app._component.onError)) { + appConfig2.errorHandler = errorHandler + } + appConfig2.isCustomElement = isCustomElement + const globalProperties = appConfig2.globalProperties + globalProperties.$hasHook = hasHook + globalProperties.$callHook = callHook + { + globalProperties.$set = set + globalProperties.$applyOptions = applyOptions + } +} +function initBridge(namespace) { + const { on, off, emit } = { + on(event, callback) { + console.log(event, callback) + }, + off(event, callback) { + console.log(event, callback) + }, + emit(event, ...args) { + console.log(event, args) + } + } + return { + on, + off, + emit, + subscribe(event, callback) { + return on(`${namespace}.${event}`, callback) + }, + unsubscribe(event, callback) { + return off(`${namespace}.${event}`, callback) + }, + subscribeHandler(event, args, pageId) { + if (process.env.NODE_ENV !== 'production') { + console.log( + `[${namespace}][subscribeHandler][${Date.now()}]:${event}, ${JSON.stringify( + args + )}, ${pageId}` + ) + } + return emit(`${namespace}.${event}`, args, pageId) + } + } +} +const ViewJSBridge = initBridge('view') +const LONGPRESS_TIMEOUT = 350 +const LONGPRESS_THRESHOLD = 10 +let longPressTimer = 0 +function clearLongPressTimer() { + if (longPressTimer) { + clearTimeout(longPressTimer) + longPressTimer = 0 + } +} +let startPageX = 0 +let startPageY = 0 +function touchstart(evt) { + clearLongPressTimer() + if (evt.touches.length !== 1) { + return + } + const { pageX, pageY } = evt.touches[0] + startPageX = pageX + startPageY = pageY + longPressTimer = setTimeout(function() { + const customEvent = new CustomEvent('longpress', { + bubbles: true, + cancelable: true, + target: evt.target, + currentTarget: evt.currentTarget + }) + customEvent.touches = evt.touches + customEvent.changedTouches = evt.changedTouches + evt.target.dispatchEvent(customEvent) + }, LONGPRESS_TIMEOUT) +} +function touchmove(evt) { + if (!longPressTimer) { + return + } + if (evt.touches.length !== 1) { + return clearLongPressTimer() + } + const { pageX, pageY } = evt.touches[0] + if ( + Math.abs(pageX - startPageX) > LONGPRESS_THRESHOLD || + Math.abs(pageY - startPageY) > LONGPRESS_THRESHOLD + ) { + return clearLongPressTimer() + } +} +function initLongPress() { + window.addEventListener('touchstart', touchstart, passiveOptions) + window.addEventListener('touchmove', touchmove, passiveOptions) + window.addEventListener('touchend', clearLongPressTimer, passiveOptions) + window.addEventListener('touchcancel', clearLongPressTimer, passiveOptions) +} +var attrs = ['top', 'left', 'right', 'bottom'] +var inited +var elementComputedStyle = {} +var support +function getSupport() { + if (!('CSS' in window) || typeof CSS.supports != 'function') { + support = '' + } else if (CSS.supports('top: env(safe-area-inset-top)')) { + support = 'env' + } else if (CSS.supports('top: constant(safe-area-inset-top)')) { + support = 'constant' + } else { + support = '' + } + return support +} +function init() { + support = typeof support === 'string' ? support : getSupport() + if (!support) { + attrs.forEach(function(attr) { + elementComputedStyle[attr] = 0 + }) + return + } + function setStyle(el, style) { + var elStyle = el.style + Object.keys(style).forEach(function(key) { + var val = style[key] + elStyle[key] = val + }) + } + var cbs = [] + function parentReady(callback) { + if (callback) { + cbs.push(callback) + } else { + cbs.forEach(function(cb) { + cb() + }) + } + } + var passiveEvents = false + try { + var opts = Object.defineProperty({}, 'passive', { + get: function() { + passiveEvents = { passive: true } + } + }) + window.addEventListener('test', null, opts) + } catch (e) {} + function addChild(parent, attr) { + var a1 = document.createElement('div') + var a2 = document.createElement('div') + var a1Children = document.createElement('div') + var a2Children = document.createElement('div') + var W = 100 + var MAX = 1e4 + var aStyle = { + position: 'absolute', + width: W + 'px', + height: '200px', + boxSizing: 'border-box', + overflow: 'hidden', + paddingBottom: support + '(safe-area-inset-' + attr + ')' + } + setStyle(a1, aStyle) + setStyle(a2, aStyle) + setStyle(a1Children, { + transition: '0s', + animation: 'none', + width: '400px', + height: '400px' + }) + setStyle(a2Children, { + transition: '0s', + animation: 'none', + width: '250%', + height: '250%' + }) + a1.appendChild(a1Children) + a2.appendChild(a2Children) + parent.appendChild(a1) + parent.appendChild(a2) + parentReady(function() { + a1.scrollTop = a2.scrollTop = MAX + var a1LastScrollTop = a1.scrollTop + var a2LastScrollTop = a2.scrollTop + function onScroll() { + if ( + this.scrollTop === (this === a1 ? a1LastScrollTop : a2LastScrollTop) + ) { + return + } + a1.scrollTop = a2.scrollTop = MAX + a1LastScrollTop = a1.scrollTop + a2LastScrollTop = a2.scrollTop + attrChange(attr) + } + a1.addEventListener('scroll', onScroll, passiveEvents) + a2.addEventListener('scroll', onScroll, passiveEvents) + }) + var computedStyle = getComputedStyle(a1) + Object.defineProperty(elementComputedStyle, attr, { + configurable: true, + get: function() { + return parseFloat(computedStyle.paddingBottom) + } + }) + } + var parentDiv = document.createElement('div') + setStyle(parentDiv, { + position: 'absolute', + left: '0', + top: '0', + width: '0', + height: '0', + zIndex: '-1', + overflow: 'hidden', + visibility: 'hidden' + }) + attrs.forEach(function(key) { + addChild(parentDiv, key) + }) + document.body.appendChild(parentDiv) + parentReady() + inited = true +} +function getAttr(attr) { + if (!inited) { + init() + } + return elementComputedStyle[attr] +} +var changeAttrs = [] +function attrChange(attr) { + if (!changeAttrs.length) { + setTimeout(function() { + var style = {} + changeAttrs.forEach(function(attr2) { + style[attr2] = elementComputedStyle[attr2] + }) + changeAttrs.length = 0 + callbacks.forEach(function(callback) { + callback(style) + }) + }, 0) + } + changeAttrs.push(attr) +} +var callbacks = [] +function onChange(callback) { + if (!getSupport()) { + return + } + if (!inited) { + init() + } + if (typeof callback === 'function') { + callbacks.push(callback) + } +} +function offChange(callback) { + var index2 = callbacks.indexOf(callback) + if (index2 >= 0) { + callbacks.splice(index2, 1) + } +} +var safeAreaInsets = { + get support() { + return (typeof support === 'string' ? support : getSupport()).length != 0 + }, + get top() { + return getAttr('top') + }, + get left() { + return getAttr('left') + }, + get right() { + return getAttr('right') + }, + get bottom() { + return getAttr('bottom') + }, + onChange, + offChange +} +var out = safeAreaInsets +function getWindowOffset() { + if (uni.canIUse('css.var')) { + const style = document.documentElement.style + const top = parseInt(style.getPropertyValue('--window-top')) + const bottom = parseInt(style.getPropertyValue('--window-bottom')) + const left = parseInt(style.getPropertyValue('--window-left')) + const right = parseInt(style.getPropertyValue('--window-right')) + return { + top: top ? top + out.top : 0, + bottom: bottom ? bottom + out.bottom : 0, + left: left ? left + out.left : 0, + right: right ? right + out.right : 0 + } + } + return { + top: 0, + bottom: 0, + left: 0, + right: 0 + } +} +function findUniTarget($event, $el) { + let target = $event.target + for (; target && target !== $el; target = target.parentNode) { + if (target.tagName && target.tagName.indexOf('UNI-') === 0) { + break + } + } + return target +} +function normalizeDataset(dataset = {}) { + const result = JSON.parse(JSON.stringify(dataset)) + return result +} +function normalizeEvent(name, $event, detail = {}, target, currentTarget) { + if ($event._processed) { + $event.type = detail.type || name + return $event + } + if (isClickEvent($event, name)) { + const { top } = getWindowOffset() + detail = { + x: $event.x, + y: $event.y - top + } + normalizeClickEvent($event) + } + const ret = { + _processed: true, + type: detail.type || name, + timeStamp: $event.timeStamp || 0, + detail, + target: normalizeTarget(target, detail), + currentTarget: normalizeTarget(currentTarget), + touches: normalizeTouchList($event.touches), + changedTouches: normalizeTouchList($event.changedTouches), + preventDefault() {}, + stopPropagation() {} + } + return ret +} +function normalizeClickEvent($event) { + $event.touches = $event.changedTouches = [ + { + force: 1, + identifier: 0, + clientX: $event.clientX, + clientY: $event.clientY, + pageX: $event.pageX, + pageY: $event.pageY + } + ] +} +function isClickEvent(val, name) { + return name === 'click' +} +function normalizeTarget(target, detail) { + if (!target) { + target = {} + } + const res = { + id: target.id, + offsetLeft: target.offsetLeft, + offsetTop: target.offsetTop, + dataset: normalizeDataset(target.dataset) + } + if (detail) { + extend(res, detail) + } + return res +} +function normalizeTouchList(touches) { + if (touches && touches instanceof TouchList) { + const res = [] + const { top } = getWindowOffset() + for (let i = 0; i < touches.length; i++) { + const touch = touches[i] + res.push({ + identifier: touch.identifier, + pageX: touch.pageX, + pageY: touch.pageY - top, + clientX: touch.clientX, + clientY: touch.clientY - top, + force: touch.force || 0 + }) + } + return res + } + return [] +} +function $trigger(name, $event, detail) { + const target = this.$el + this.$emit(name, normalizeEvent(name, $event, detail, target, target)) +} +function $handleEvent($event) { + if ($event instanceof Event) { + const target = findUniTarget($event, this.$el) + return normalizeEvent( + $event.type, + $event, + {}, + target || $event.target, + $event.currentTarget + ) + } + return $event +} +function $getRealPath(v) { + return v +} +var instance = /* @__PURE__ */ Object.freeze({ + __proto__: null, + $trigger, + $handleEvent, + $getRealPath +}) +const CLASS_RE = /^\s+|\s+$/g +const WXS_CLASS_RE = /\s+/ +function getWxsClsArr(clsArr, classList, isAdd) { + const wxsClsArr = [] + let checkClassList = function(cls) { + if (isAdd) { + checkClassList = function(cls2) { + return !classList.contains(cls2) + } + } else { + checkClassList = function(cls2) { + return classList.contains(cls2) + } + } + return checkClassList(cls) + } + clsArr.forEach(cls => { + cls = cls.replace(CLASS_RE, '') + checkClassList(cls) && wxsClsArr.push(cls) + }) + return wxsClsArr +} +function parseStyleText(cssText) { + const res = {} + const listDelimiter = /;(?![^(]*\))/g + const propertyDelimiter = /:(.+)/ + cssText.split(listDelimiter).forEach(function(item) { + if (item) { + const tmp = item.split(propertyDelimiter) + tmp.length > 1 && (res[tmp[0].trim()] = tmp[1].trim()) + } + }) + return res +} +class ComponentDescriptor { + constructor(vm) { + this.$vm = vm + this.$el = vm.$el + } + selectComponent(selector) { + if (!this.$el || !selector) { + return + } + const el = this.$el.querySelector(selector) + return el && el.__vue__ && createComponentDescriptor(el.__vue__, false) + } + selectAllComponents(selector) { + if (!this.$el || !selector) { + return [] + } + const descriptors = [] + const els = this.$el.querySelectorAll(selector) + for (let i = 0; i < els.length; i++) { + const el = els[i] + el.__vue__ && + descriptors.push(createComponentDescriptor(el.__vue__, false)) + } + return descriptors + } + setStyle(style) { + if (!this.$el || !style) { + return this + } + if (typeof style === 'string') { + style = parseStyleText(style) + } + if (isPlainObject(style)) { + this.$el.__wxsStyle = style + this.$vm.$forceUpdate() + } + return this + } + addClass(...clsArr) { + if (!this.$el || !clsArr.length) { + return this + } + const wxsClsArr = getWxsClsArr(clsArr, this.$el.classList, true) + if (wxsClsArr.length) { + const wxsClass = this.$el.__wxsAddClass || '' + this.$el.__wxsAddClass = + wxsClass + (wxsClass ? ' ' : '') + wxsClsArr.join(' ') + this.$vm.$forceUpdate() + } + return this + } + removeClass(...clsArr) { + if (!this.$el || !clsArr.length) { + return this + } + const classList = this.$el.classList + const addWxsClsArr = this.$el.__wxsAddClass + ? this.$el.__wxsAddClass.split(WXS_CLASS_RE) + : [] + const wxsClsArr = getWxsClsArr(clsArr, classList, false) + if (wxsClsArr.length) { + const removeWxsClsArr = [] + wxsClsArr.forEach(cls => { + const clsIndex = addWxsClsArr.findIndex(oldCls => oldCls === cls) + if (clsIndex !== -1) { + addWxsClsArr.splice(clsIndex, 1) + } + removeWxsClsArr.push(cls) + }) + this.$el.__wxsRemoveClass = removeWxsClsArr + this.$el.__wxsAddClass = addWxsClsArr.join(' ') + this.$vm.$forceUpdate() + } + return this + } + hasClass(cls) { + return this.$el && this.$el.classList.contains(cls) + } + getComputedStyle() { + if (this.$el) { + return window.getComputedStyle(this.$el) + } + return {} + } + getDataset() { + return this.$el && this.$el.dataset + } + callMethod(funcName, args = {}) { + const func = this.$vm[funcName] + if (isFunction(func)) { + func(JSON.parse(JSON.stringify(args))) + } else if (this.$vm._$id) { + UniViewJSBridge.publishHandler('onWxsInvokeCallMethod', { + cid: this.$vm._$id, + method: funcName, + args + }) + } + } + requestAnimationFrame(callback) { + return window.requestAnimationFrame(callback), this + } + getState() { + return this.$el && (this.$el.__wxsState || (this.$el.__wxsState = {})) + } + triggerEvent(eventName, detail = {}) { + return this.$vm.$emit(eventName, detail), this + } +} +function createComponentDescriptor(vm, isOwnerInstance = true) { + if ( + isOwnerInstance && + vm && + vm.$options.name && + vm.$options.name.indexOf('VUni') === 0 + ) { + vm = vm.$parent + } + if (vm && vm.$el) { + if (!vm.$el.__wxsComponentDescriptor) { + vm.$el.__wxsComponentDescriptor = new ComponentDescriptor(vm) + } + return vm.$el.__wxsComponentDescriptor + } +} +function getComponentDescriptor(instance2, isOwnerInstance) { + return createComponentDescriptor(instance2 || this, isOwnerInstance) +} +function handleWxsEvent($event) { + if (!($event instanceof Event)) { + return $event + } + const currentTarget = $event.currentTarget + const instance2 = + currentTarget && + currentTarget.__vue__ && + getComponentDescriptor.call(this, currentTarget.__vue__, false) + const $origEvent = $event + $event = normalizeEvent( + $origEvent.type, + $origEvent, + {}, + findUniTarget($origEvent, this.$el) || $origEvent.target, + $origEvent.currentTarget + ) + $event.instance = instance2 + $event.preventDefault = function() { + return $origEvent.preventDefault() + } + $event.stopPropagation = function() { + return $origEvent.stopPropagation() + } +} +function initAppConfig(appConfig) { + const globalProperties = appConfig.globalProperties + extend(globalProperties, instance) + if (__UNI_WXS_API__) { + globalProperties.getComponentDescriptor = getComponentDescriptor + Object.defineProperty(globalProperties, '$ownerInstance', { + get() { + return this.$getComponentDescriptor(this) + } + }) + globalProperties.$handleWxsEvent = handleWxsEvent + } +} +function initView(app) { + initLongPress() + initAppConfig(app._context.config) +} +const ServiceJSBridge = initBridge('service') +function querySelector(vm, selector) { + const el = vm.$el.querySelector(selector) + return el && el.__vue__ +} +function querySelectorAll(vm, selector) { + const nodeList = vm.$el.querySelectorAll(selector) + if (nodeList) { + return [...nodeList].map(node => node.__vue__).filter(Boolean) + } + return [] +} +function createSelectorQuery() { + return uni.createSelectorQuery().in(this) +} +function createIntersectionObserver(options) { + return uni.createIntersectionObserver(this, options) +} +function selectComponent(selector) { + return querySelector(this, selector) +} +function selectAllComponents(selector) { + return querySelectorAll(this, selector) +} +var wxInstance = /* @__PURE__ */ Object.freeze({ + __proto__: null, + createSelectorQuery, + createIntersectionObserver, + selectComponent, + selectAllComponents +}) +function initAppConfig$1(appConfig) { + const globalProperties = appConfig.globalProperties + if (__UNI_WX_API__) { + extend(globalProperties, wxInstance) + } +} +function initService(app) { + initAppConfig$1(app._context.config) +} +var UniServiceJSBridge$1 = extend(ServiceJSBridge, { + publishHandler(event, args, pageId) { + window.UniViewJSBridge.subscribeHandler(event, args, pageId) + } +}) +var UniViewJSBridge$1 = extend(ViewJSBridge, { + publishHandler(event, args, pageId) { + window.UniServiceJSBridge.subscribeHandler(event, args, pageId) + } +}) +function initBridge$1() { + window.UniServiceJSBridge = UniServiceJSBridge$1 + window.UniViewJSBridge = UniViewJSBridge$1 +} +function initRouter(app) { + const history = + __UNI_ROUTER_MODE__ === 'history' + ? createWebHistory() + : createWebHashHistory() + app.use( + createRouter({ + history, + strict: !!__uniConfig.router.strict, + routes: __uniRoutes, + scrollBehavior(to, from, savedPosition) { + if (savedPosition) { + return savedPosition + } + } + }) + ) +} +var script = { + name: 'TabBar', + props: { + position: { + default: 'bottom', + validator(value) { + return ['bottom', 'top'].indexOf(value) !== -1 + } + }, + color: { + type: String, + default: '#999' + }, + selectedColor: { + type: String, + default: '#007aff' + }, + backgroundColor: { + type: String, + default: '#f7f7fa' + }, + borderStyle: { + default: 'black', + validator(value) { + return ['black', 'white'].indexOf(value) !== -1 + } + }, + list: { + type: Array, + default: function() { + return [] + } + } + }, + computed: { + borderColor() { + return this.borderStyle === 'white' + ? 'rgba(255, 255, 255, 0.33)' + : 'rgba(0, 0, 0, 0.33)' + } + }, + watch: { + $route(to, from) { + if (to.meta.isTabBar) { + this.__path__ = to.path + } + } + }, + beforeCreate() { + this.__path__ = this.$route.path + }, + methods: { + _getRealPath(filePath) { + if (filePath.indexOf('/') !== 0) { + filePath = '/' + filePath + } + return this.$getRealPath(filePath) + }, + _switchTab({ text, pagePath }, index2) { + let url = '/' + pagePath + if (url === __uniRoutes[0].alias) { + url = '/' + } + const detail = { + index: index2, + text, + pagePath + } + if (this.$route.path !== url) { + this.__path__ = this.$route.path + uni.switchTab({ + from: 'tabBar', + url, + detail + }) + } else { + UniServiceJSBridge.emit('onTabItemTap', detail) + } + } + } +} +const _hoisted_1 = { class: 'uni-tabbar__bd' } +const _hoisted_2 = /* @__PURE__ */ createVNode( + 'div', + { class: 'uni-placeholder' }, + null, + -1 +) +function render(_ctx, _cache, $props, $setup, $data, $options) { + return ( + openBlock(), + createBlock('uni-tabbar', null, [ + createVNode( + 'div', + { + style: { backgroundColor: _ctx.backgroundColor }, + class: 'uni-tabbar' + }, + [ + createVNode( + 'div', + { + style: { backgroundColor: _ctx.borderColor }, + class: 'uni-tabbar-border' + }, + null, + 4 + ), + (openBlock(true), + createBlock( + Fragment, + null, + renderList(_ctx.list, (item, index2) => { + return ( + openBlock(), + createBlock( + 'div', + { + key: item.pagePath, + class: 'uni-tabbar__item', + onClick: $event => _ctx._switchTab(item, index2) + }, + [ + createVNode('div', _hoisted_1, [ + item.iconPath + ? (openBlock(), + createBlock( + 'div', + { + key: 0, + class: [ + { 'uni-tabbar__icon__diff': !item.text }, + 'uni-tabbar__icon' + ] + }, + [ + createVNode( + 'img', + { + src: _ctx._getRealPath( + _ctx.$route.meta.pagePath === item.pagePath + ? item.selectedIconPath + : item.iconPath + ) + }, + null, + 8, + ['src'] + ), + item.redDot + ? (openBlock(), + createBlock( + 'div', + { + key: 0, + class: [ + { 'uni-tabbar__badge': !!item.badge }, + 'uni-tabbar__reddot' + ] + }, + toDisplayString(item.badge), + 3 + )) + : createCommentVNode('v-if', true) + ], + 2 + )) + : createCommentVNode('v-if', true), + item.text + ? (openBlock(), + createBlock( + 'div', + { + key: 1, + style: { + color: + _ctx.$route.meta.pagePath === item.pagePath + ? _ctx.selectedColor + : _ctx.color, + fontSize: item.iconPath ? '10px' : '14px' + }, + class: 'uni-tabbar__label' + }, + [ + createTextVNode( + toDisplayString(item.text) + ' ', + 1 + ), + item.redDot && !item.iconPath + ? (openBlock(), + createBlock( + 'div', + { + key: 0, + class: [ + { 'uni-tabbar__badge': !!item.badge }, + 'uni-tabbar__reddot' + ] + }, + toDisplayString(item.badge), + 3 + )) + : createCommentVNode('v-if', true) + ], + 4 + )) + : createCommentVNode('v-if', true) + ]) + ], + 8, + ['onClick'] + ) + ) + }), + 128 + )) + ], + 4 + ), + _hoisted_2 + ]) + ) +} +script.render = render +script.__file = 'packages/uni-h5/src/framework/components/app/tabBar.vue' +var Transtion = { + methods: { + beforeTransition() {}, + afterTransition() {} + } +} +var script$1 = { + name: 'Toast', + mixins: [Transtion], + props: { + title: { + type: String, + default: '' + }, + icon: { + default: 'success', + validator(value) { + return ['success', 'loading', 'none'].indexOf(value) !== -1 + } + }, + image: { + type: String, + default: '' + }, + duration: { + type: Number, + default: 1500 + }, + mask: { + type: Boolean, + default: false + }, + visible: { + type: Boolean, + default: false + } + }, + computed: { + iconClass() { + if (this.icon === 'success') { + return 'uni-icon-success-no-circle' + } + if (this.icon === 'loading') { + return 'uni-loading' + } + return '' + } + }, + beforeUpdate() { + if (this.visible) { + this.timeoutId && clearTimeout(this.timeoutId) + this.timeoutId = setTimeout(() => { + UniServiceJSBridge.emit('onHideToast') + }, this.duration) + } + } +} +const _hoisted_1$1 = { + key: 1, + class: 'uni-sample-toast' +} +const _hoisted_2$1 = { class: 'uni-simple-toast__text' } +const _hoisted_3 = { + key: 2, + class: 'uni-toast' +} +const _hoisted_4 = { class: 'uni-toast__content' } +function render$1(_ctx, _cache, $props, $setup, $data, $options) { + return ( + openBlock(), + createBlock( + Transition, + { name: 'uni-fade' }, + { + default: withCtx(() => [ + _ctx.visible + ? (openBlock(), + createBlock( + 'uni-toast', + { + key: 0, + 'data-duration': _ctx.duration + }, + [ + _ctx.mask + ? (openBlock(), + createBlock( + 'div', + { + key: 0, + class: 'uni-mask', + style: { background: 'transparent' }, + onTouchmovePassive: + _cache[1] || + (_cache[1] = withModifiers(() => {}, ['prevent'])) + }, + null, + 32 + )) + : createCommentVNode('v-if', true), + !_ctx.image && !_ctx.iconClass + ? (openBlock(), + createBlock('div', _hoisted_1$1, [ + createVNode( + 'p', + _hoisted_2$1, + toDisplayString(_ctx.title), + 1 + ) + ])) + : (openBlock(), + createBlock('div', _hoisted_3, [ + _ctx.image + ? (openBlock(), + createBlock( + 'img', + { + key: 0, + src: _ctx.image, + class: 'uni-toast__icon' + }, + null, + 8, + ['src'] + )) + : (openBlock(), + createBlock( + 'i', + { + key: 1, + class: [_ctx.iconClass, 'uni-icon_toast'] + }, + null, + 2 + )), + createVNode( + 'p', + _hoisted_4, + toDisplayString(_ctx.title), + 1 + ) + ])) + ], + 8, + ['data-duration'] + )) + : createCommentVNode('v-if', true) + ]), + _: 1 + } + ) + ) +} +script$1.render = render$1 +script$1.__file = 'packages/uni-h5/src/framework/components/app/popup/toast.vue' +var script$2 = { + name: 'Modal', + mixins: [Transtion], + props: { + title: { + type: String, + default: '' + }, + content: { + type: String, + default: '' + }, + showCancel: { + type: Boolean, + default: true + }, + cancelText: { + type: String, + default: '取消' + }, + cancelColor: { + type: String, + default: '#000000' + }, + confirmText: { + type: String, + default: '确定' + }, + confirmColor: { + type: String, + default: '#007aff' + }, + visible: { + type: Boolean, + default: false + } + }, + methods: { + _close(type) { + this.$emit('close', type) + } + } +} +const _hoisted_1$2 = /* @__PURE__ */ createVNode( + 'div', + { class: 'uni-mask' }, + null, + -1 +) +const _hoisted_2$2 = { class: 'uni-modal' } +const _hoisted_3$1 = { + key: 0, + class: 'uni-modal__hd' +} +const _hoisted_4$1 = { class: 'uni-modal__ft' } +function render$2(_ctx, _cache, $props, $setup, $data, $options) { + return ( + openBlock(), + createBlock( + Transition, + { name: 'uni-fade' }, + { + default: withCtx(() => [ + withDirectives( + createVNode( + 'uni-modal', + { + onTouchmovePassive: + _cache[4] || + (_cache[4] = withModifiers(() => {}, ['prevent'])) + }, + [ + _hoisted_1$2, + createVNode('div', _hoisted_2$2, [ + _ctx.title + ? (openBlock(), + createBlock('div', _hoisted_3$1, [ + createVNode( + 'strong', + { + class: 'uni-modal__title', + textContent: _ctx.title + }, + null, + 8, + ['textContent'] + ) + ])) + : createCommentVNode('v-if', true), + createVNode( + 'div', + { + class: 'uni-modal__bd', + onTouchmovePassive: + _cache[1] || + (_cache[1] = withModifiers(() => {}, ['stop'])), + textContent: _ctx.content + }, + null, + 40, + ['textContent'] + ), + createVNode('div', _hoisted_4$1, [ + _ctx.showCancel + ? (openBlock(), + createBlock( + 'div', + { + key: 0, + style: { color: _ctx.cancelColor }, + class: 'uni-modal__btn uni-modal__btn_default', + onClick: + _cache[2] || + (_cache[2] = $event => _ctx._close('cancel')) + }, + toDisplayString(_ctx.cancelText), + 5 + )) + : createCommentVNode('v-if', true), + createVNode( + 'div', + { + style: { color: _ctx.confirmColor }, + class: 'uni-modal__btn uni-modal__btn_primary', + onClick: + _cache[3] || + (_cache[3] = $event => _ctx._close('confirm')) + }, + toDisplayString(_ctx.confirmText), + 5 + ) + ]) + ]) + ], + 544 + ), + [[vShow, _ctx.visible]] + ) + ]), + _: 1 + } + ) + ) +} +script$2.render = render$2 +script$2.__file = 'packages/uni-h5/src/framework/components/app/popup/modal.vue' +var script$3 = { + name: 'ActionSheet', + props: { + title: { + type: String, + default: '' + }, + itemList: { + type: Array, + default() { + return [] + } + }, + itemColor: { + type: String, + default: '#000000' + }, + visible: { + type: Boolean, + default: false + } + }, + methods: { + _close(tapIndex) { + this.$emit('close', tapIndex) + } + } +} +const _hoisted_1$3 = { class: 'uni-actionsheet__menu' } +const _hoisted_2$3 = { + key: 0, + class: 'uni-actionsheet__title' +} +const _hoisted_3$2 = { class: 'uni-actionsheet__action' } +function render$3(_ctx, _cache, $props, $setup, $data, $options) { + return ( + openBlock(), + createBlock( + 'uni-actionsheet', + { + onTouchmovePassive: + _cache[3] || (_cache[3] = withModifiers(() => {}, ['prevent'])) + }, + [ + createVNode( + Transition, + { name: 'uni-fade' }, + { + default: withCtx(() => [ + withDirectives( + createVNode( + 'div', + { + class: 'uni-mask', + onClick: + _cache[1] || (_cache[1] = $event => _ctx._close(-1)) + }, + null, + 512 + ), + [[vShow, _ctx.visible]] + ) + ]), + _: 1 + } + ), + createVNode( + 'div', + { + class: [ + { 'uni-actionsheet_toggle': _ctx.visible }, + 'uni-actionsheet' + ] + }, + [ + createVNode('div', _hoisted_1$3, [ + _ctx.title + ? (openBlock(), + createBlock( + 'div', + _hoisted_2$3, + toDisplayString(_ctx.title), + 1 + )) + : createCommentVNode('v-if', true), + (openBlock(true), + createBlock( + Fragment, + null, + renderList(_ctx.itemList, (itemTitle, index2) => { + return ( + openBlock(), + createBlock( + 'div', + { + key: index2, + style: { color: _ctx.itemColor }, + class: 'uni-actionsheet__cell', + onClick: $event => _ctx._close(index2) + }, + toDisplayString(itemTitle), + 13, + ['onClick'] + ) + ) + }), + 128 + )) + ]), + createVNode('div', _hoisted_3$2, [ + createVNode( + 'div', + { + style: { color: _ctx.itemColor }, + class: 'uni-actionsheet__cell', + onClick: _cache[2] || (_cache[2] = $event => _ctx._close(-1)) + }, + ' 取消 ', + 4 + ) + ]) + ], + 2 + ) + ], + 32 + ) + ) +} +script$3.render = render$3 +script$3.__file = + 'packages/uni-h5/src/framework/components/app/popup/actionSheet.vue' +var Components = { + Toast: script$1, + Modal: script$2, + ActionSheet: script$3 +} +var components = { + TabBar: script, + ...Components +} +var ActionSheet = { + data() { + return { + showActionSheet: { + visible: false + } + } + }, + created() { + UniServiceJSBridge.on('onShowActionSheet', (args, callback) => { + this.showActionSheet = args + this.onActionSheetCloseCallback = callback + }) + UniServiceJSBridge.on('onHidePopup', args => { + this.showActionSheet.visible = false + }) + }, + methods: { + _onActionSheetClose(type) { + this.showActionSheet.visible = false + isFunction(this.onActionSheetCloseCallback) && + this.onActionSheetCloseCallback(type) + } + } +} +var Modal = { + data() { + return { + showModal: { + visible: false + } + } + }, + created() { + UniServiceJSBridge.on('onShowModal', (args, callback) => { + this.showModal = args + this.onModalCloseCallback = callback + }) + UniServiceJSBridge.on('onHidePopup', args => { + this.showModal.visible = false + }) + }, + methods: { + _onModalClose(type) { + this.showModal.visible = false + isFunction(this.onModalCloseCallback) && this.onModalCloseCallback(type) + } + } +} +var Toast = { + data() { + return { + showToast: { + visible: false + } + } + }, + created() { + let showType = '' + const createOnShow = type => { + return args => { + showType = type + setTimeout(() => { + this.showToast = args + }, 10) + } + } + UniServiceJSBridge.on('onShowToast', createOnShow('onShowToast')) + UniServiceJSBridge.on('onShowLoading', createOnShow('onShowLoading')) + const createOnHide = type => { + return () => { + if (!showType) { + return + } + let warnMsg = '' + if (type === 'onHideToast' && showType !== 'onShowToast') { + warnMsg = '请注意 showToast 与 hideToast 必须配对使用' + } else if (type === 'onHideLoading' && showType !== 'onShowLoading') { + warnMsg = '请注意 showLoading 与 hideLoading 必须配对使用' + } + if (warnMsg) { + return console.warn(warnMsg) + } + showType = '' + setTimeout(() => { + this.showToast.visible = false + }, 10) + } + } + UniServiceJSBridge.on('onHidePopup', createOnHide('onHidePopup')) + UniServiceJSBridge.on('onHideToast', createOnHide('onHideToast')) + UniServiceJSBridge.on('onHideLoading', createOnHide('onHideLoading')) + } +} +var mixins = [ActionSheet, Modal, Toast, Transtion] +var chars = 'ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/' +var lookup = new Uint8Array(256) +for (var i = 0; i < chars.length; i++) { + lookup[chars.charCodeAt(i)] = i +} +var encode = function(arraybuffer) { + var bytes = new Uint8Array(arraybuffer), + i, + len = bytes.length, + base64 = '' + for (i = 0; i < len; i += 3) { + base64 += chars[bytes[i] >> 2] + base64 += chars[((bytes[i] & 3) << 4) | (bytes[i + 1] >> 4)] + base64 += chars[((bytes[i + 1] & 15) << 2) | (bytes[i + 2] >> 6)] + base64 += chars[bytes[i + 2] & 63] + } + if (len % 3 === 2) { + base64 = base64.substring(0, base64.length - 1) + '=' + } else if (len % 3 === 1) { + base64 = base64.substring(0, base64.length - 2) + '==' + } + return base64 +} +var decode = function(base64) { + var bufferLength = base64.length * 0.75, + len = base64.length, + i, + p = 0, + encoded1, + encoded2, + encoded3, + encoded4 + if (base64[base64.length - 1] === '=') { + bufferLength-- + if (base64[base64.length - 2] === '=') { + bufferLength-- + } + } + var arraybuffer = new ArrayBuffer(bufferLength), + bytes = new Uint8Array(arraybuffer) + for (i = 0; i < len; i += 4) { + encoded1 = lookup[base64.charCodeAt(i)] + encoded2 = lookup[base64.charCodeAt(i + 1)] + encoded3 = lookup[base64.charCodeAt(i + 2)] + encoded4 = lookup[base64.charCodeAt(i + 3)] + bytes[p++] = (encoded1 << 2) | (encoded2 >> 4) + bytes[p++] = ((encoded2 & 15) << 4) | (encoded3 >> 2) + bytes[p++] = ((encoded3 & 3) << 6) | (encoded4 & 63) + } + return arraybuffer +} +function createApi(fn, validate) { + if (process.env.NODE_ENV !== 'production' && validate); + return fn +} +const Base64ToArrayBufferProtocol = [ + { + name: 'base64', + type: String, + required: true + } +] +const ArrayBufferToBase64Protocol = [ + { + name: 'arrayBuffer', + type: [ArrayBuffer, Uint8Array], + required: true + } +] +const base64ToArrayBuffer = /* @__PURE__ */ createApi(base642 => { + return decode(base642) +}, Base64ToArrayBufferProtocol) +const arrayBufferToBase64 = /* @__PURE__ */ createApi(arrayBuffer => { + return encode(arrayBuffer) +}, ArrayBufferToBase64Protocol) +const Upx2pxProtocol = [ + { + name: 'upx', + type: [Number, String], + required: true + } +] +const EPS = 1e-4 +const BASE_DEVICE_WIDTH = 750 +let isIOS = false +let deviceWidth = 0 +let deviceDPR = 0 +function checkDeviceWidth() { + const { platform, pixelRatio, windowWidth } = __GLOBAL__.getSystemInfoSync() + deviceWidth = windowWidth + deviceDPR = pixelRatio + isIOS = platform === 'ios' +} +const upx2px = /* @__PURE__ */ createApi((number, newDeviceWidth) => { + if (deviceWidth === 0) { + checkDeviceWidth() + } + number = Number(number) + if (number === 0) { + return 0 + } + let result = (number / BASE_DEVICE_WIDTH) * (newDeviceWidth || deviceWidth) + if (result < 0) { + result = -result + } + result = Math.floor(result + EPS) + if (result === 0) { + if (deviceDPR === 1 || !isIOS) { + result = 1 + } else { + result = 0.5 + } + } + return number < 0 ? -result : result +}, Upx2pxProtocol) +var HOOKS +;(function(HOOKS2) { + HOOKS2['INVOKE'] = 'invoke' + HOOKS2['SUCCESS'] = 'success' + HOOKS2['FAIL'] = 'fail' + HOOKS2['COMPLETE'] = 'complete' + HOOKS2['RETURN_VALUE'] = 'returnValue' +})(HOOKS || (HOOKS = {})) +const globalInterceptors = {} +const scopedInterceptors = {} +const AddInterceptorProtocol = [ + { + name: 'method', + type: [String, Object], + required: true + } +] +const RemoveInterceptorProtocol = AddInterceptorProtocol +function mergeInterceptorHook(interceptors, interceptor3) { + Object.keys(interceptor3).forEach(hook => { + if (isFunction(interceptor3[hook])) { + interceptors[hook] = mergeHook(interceptors[hook], interceptor3[hook]) + } + }) +} +function removeInterceptorHook(interceptors, interceptor3) { + if (!interceptors || !interceptor3) { + return + } + Object.keys(interceptor3).forEach(hook => { + if (isFunction(interceptor3[hook])) { + removeHook(interceptors[hook], interceptor3[hook]) + } + }) +} +function mergeHook(parentVal, childVal) { + const res = childVal + ? parentVal + ? parentVal.concat(childVal) + : isArray(childVal) + ? childVal + : [childVal] + : parentVal + return res ? dedupeHooks(res) : res +} +function dedupeHooks(hooks) { + const res = [] + for (let i = 0; i < hooks.length; i++) { + if (res.indexOf(hooks[i]) === -1) { + res.push(hooks[i]) + } + } + return res +} +function removeHook(hooks, hook) { + if (!hooks) { + return + } + const index2 = hooks.indexOf(hook) + if (index2 !== -1) { + hooks.splice(index2, 1) + } +} +const addInterceptor = /* @__PURE__ */ createApi((method, interceptor3) => { + if (typeof method === 'string' && isPlainObject(interceptor3)) { + mergeInterceptorHook( + scopedInterceptors[method] || (scopedInterceptors[method] = {}), + interceptor3 + ) + } else if (isPlainObject(method)) { + mergeInterceptorHook(globalInterceptors, method) + } +}, AddInterceptorProtocol) +const removeInterceptor = /* @__PURE__ */ createApi((method, interceptor3) => { + if (typeof method === 'string') { + if (isPlainObject(interceptor3)) { + removeInterceptorHook(scopedInterceptors[method], interceptor3) + } else { + delete scopedInterceptors[method] + } + } else if (isPlainObject(method)) { + removeInterceptorHook(globalInterceptors, method) + } +}, RemoveInterceptorProtocol) +const promiseInterceptor = { + returnValue(res) { + if (!isPromise(res)) { + return res + } + return res + .then(res2 => { + return res2[1] + }) + .catch(res2 => { + return res2[0] + }) + } +} +const createIntersectionObserver$1 = /* @__PURE__ */ createApi(() => {}) +const createSelectorQuery$1 = /* @__PURE__ */ createApi(() => {}) +const CanIUseProtocol = [ + { + name: 'schema', + type: String, + required: true + } +] +const MakePhoneCallProtocol = { + phoneNumber: { + type: String, + required: true, + validator(phoneNumber) { + if (!phoneNumber) { + return 'makePhoneCall:fail parameter error: parameter.phoneNumber should not be empty String;' + } + } + } +} +const OpenDocumentProtocol = { + filePath: { + type: String, + required: true + }, + fileType: { + type: String + } +} +function cssSupports(css) { + return window.CSS && window.CSS.supports && window.CSS.supports(css) +} +const SCHEMA_CSS = { + 'css.var': cssSupports('--a:0'), + 'css.env': cssSupports('top:env(a)'), + 'css.constant': cssSupports('top:constant(a)') +} +const canIUse = /* @__PURE__ */ createApi(schema => { + if (hasOwn(SCHEMA_CSS, schema)) { + return SCHEMA_CSS[schema] + } + return true +}, CanIUseProtocol) +const makePhoneCall = /* @__PURE__ */ createApi(({ phoneNumber }) => { + window.location.href = `tel:${phoneNumber}` + return { + errMsg: 'makePhoneCall:ok' + } +}, MakePhoneCallProtocol) +const ua = navigator.userAgent +const isAndroid = /android/i.test(ua) +const isIOS$1 = /iphone|ipad|ipod/i.test(ua) +const getSystemInfoSync = /* @__PURE__ */ createApi(() => { + var screen = window.screen + var pixelRatio = window.devicePixelRatio + const screenFix = + /^Apple/.test(navigator.vendor) && typeof window.orientation === 'number' + const landscape = screenFix && Math.abs(window.orientation) === 90 + var screenWidth = screenFix + ? Math[landscape ? 'max' : 'min'](screen.width, screen.height) + : screen.width + var screenHeight = screenFix + ? Math[landscape ? 'min' : 'max'](screen.height, screen.width) + : screen.height + var windowWidth = + Math.min( + window.innerWidth, + document.documentElement.clientWidth, + screenWidth + ) || screenWidth + var windowHeight = window.innerHeight + var language = navigator.language + var statusBarHeight = out.top + var osname + var osversion + var model + if (isIOS$1) { + osname = 'iOS' + const osversionFind = ua.match(/OS\s([\w_]+)\slike/) + if (osversionFind) { + osversion = osversionFind[1].replace(/_/g, '.') + } + const modelFind = ua.match(/\(([a-zA-Z]+);/) + if (modelFind) { + model = modelFind[1] + } + } else if (isAndroid) { + osname = 'Android' + const osversionFind = ua.match(/Android[\s/]([\w\.]+)[;\s]/) + if (osversionFind) { + osversion = osversionFind[1] + } + const infoFind = ua.match(/\((.+?)\)/) + const infos = infoFind ? infoFind[1].split(';') : ua.split(' ') + const otherInfo = [ + /\bAndroid\b/i, + /\bLinux\b/i, + /\bU\b/i, + /^\s?[a-z][a-z]$/i, + /^\s?[a-z][a-z]-[a-z][a-z]$/i, + /\bwv\b/i, + /\/[\d\.,]+$/, + /^\s?[\d\.,]+$/, + /\bBrowser\b/i, + /\bMobile\b/i + ] + for (let i = 0; i < infos.length; i++) { + const info = infos[i] + if (info.indexOf('Build') > 0) { + model = info.split('Build')[0].trim() + break + } + let other + for (let o = 0; o < otherInfo.length; o++) { + if (otherInfo[o].test(info)) { + other = true + break + } + } + if (!other) { + model = info.trim() + break + } + } + } else { + osname = 'Other' + osversion = '0' + } + var system = `${osname} ${osversion}` + var platform = osname.toLocaleLowerCase() + var safeArea = { + left: out.left, + right: windowWidth - out.right, + top: out.top, + bottom: windowHeight - out.bottom, + width: windowWidth - out.left - out.right, + height: windowHeight - out.top - out.bottom + } + const { top: windowTop, bottom: windowBottom } = getWindowOffset() + windowHeight -= windowTop + windowHeight -= windowBottom + return { + windowTop, + windowBottom, + windowWidth, + windowHeight, + pixelRatio, + screenWidth, + screenHeight, + language, + statusBarHeight, + system, + platform, + model, + safeArea, + safeAreaInsets: { + top: out.top, + right: out.right, + bottom: out.bottom, + left: out.left + } + } +}) +const getSystemInfo = /* @__PURE__ */ createApi(() => { + return getSystemInfoSync() +}) +const openDocument = /* @__PURE__ */ createApi(option => { + window.open(option.filePath) + return true +}, OpenDocumentProtocol) +const navigateBack = /* @__PURE__ */ createApi(() => {}) +const navigateTo = /* @__PURE__ */ createApi(() => {}) +const redirectTo = /* @__PURE__ */ createApi(() => {}) +const reLaunch = /* @__PURE__ */ createApi(() => {}) +const switchTab = /* @__PURE__ */ createApi(() => {}) +var api = /* @__PURE__ */ Object.freeze({ + __proto__: null, + upx2px, + addInterceptor, + removeInterceptor, + promiseInterceptor, + arrayBufferToBase64, + base64ToArrayBuffer, + createSelectorQuery: createSelectorQuery$1, + createIntersectionObserver: createIntersectionObserver$1, + canIUse, + makePhoneCall, + getSystemInfo, + getSystemInfoSync, + openDocument, + navigateBack, + navigateTo, + redirectTo, + reLaunch, + switchTab +}) +var script$4 = { + name: 'App', + components, + mixins, + props: { + keepAliveInclude: { + type: Array, + default: function() { + return [] + } + } + }, + data() { + return { + transitionName: 'fade', + hideTabBar: false, + tabBar: __uniConfig.tabBar || {}, + sysComponents: this.$sysComponents + } + }, + computed: { + key() { + return ( + this.$route.meta.name + + '-' + + this.$route.params.__id__ + + '-' + + (__uniConfig.reLaunch || 1) + ) + }, + hasTabBar() { + return ( + __uniConfig.tabBar && + __uniConfig.tabBar.list && + __uniConfig.tabBar.list.length + ) + }, + showTabBar() { + return this.$route.meta.isTabBar && !this.hideTabBar + } + }, + watch: { + $route(newRoute, oldRoute) { + UniServiceJSBridge.emit('onHidePopup') + }, + hideTabBar(newVal, oldVal) { + if (canIUse('css.var')) { + const windowBottomValue = !newVal ? TABBAR_HEIGHT : 0 + const envMethod = canIUse('css.env') + ? 'env' + : canIUse('css.constant') + ? 'constant' + : '' + const windowBottom = + windowBottomValue && envMethod + ? `calc(${windowBottomValue}px + ${envMethod}(safe-area-inset-bottom))` + : `${windowBottomValue}px` + document.documentElement.style.setProperty( + '--window-bottom', + windowBottom + ) + console.debug( + `uni.${ + windowBottom ? 'showTabBar' : 'hideTabBar' + }:--window-bottom=${windowBottom}` + ) + } + window.dispatchEvent(new CustomEvent('resize')) + } + }, + created() { + if (canIUse('css.var')) { + document.documentElement.style.setProperty('--status-bar-height', '0px') + } + }, + mounted() { + window.addEventListener('message', function(evt) { + if ( + isPlainObject(evt.data) && + evt.data.type === 'WEB_INVOKE_APPSERVICE' + ) { + UniServiceJSBridge.emit( + 'onWebInvokeAppService', + evt.data.data, + evt.data.pageId + ) + } + }) + document.addEventListener('visibilitychange', function() { + if (document.visibilityState === 'visible') { + UniServiceJSBridge.emit('onAppEnterForeground') + } else { + UniServiceJSBridge.emit('onAppEnterBackground') + } + }) + } +} +function render$4(_ctx, _cache, $props, $setup, $data, $options) { + const _component_router_view = resolveComponent('router-view') + const _component_tab_bar = resolveComponent('tab-bar') + const _component_toast = resolveComponent('toast') + const _component_action_sheet = resolveComponent('action-sheet') + const _component_modal = resolveComponent('modal') + return ( + openBlock(), + createBlock( + 'uni-app', + { + class: { 'uni-app--showtabbar': _ctx.showTabBar } + }, + [ + createCommentVNode(' '), + createCommentVNode(' TODO '), + createVNode( + _component_router_view, + { key: _ctx.key }, + { + default: withCtx(({ Component }) => [ + (openBlock(), + createBlock( + KeepAlive, + { include: _ctx.keepAliveInclude }, + [ + (openBlock(), createBlock(resolveDynamicComponent(Component))) + ], + 1032, + ['include'] + )) + ]), + _: 1 + } + ), + createCommentVNode(' '), + _ctx.hasTabBar + ? withDirectives( + createVNode( + _component_tab_bar, + mergeProps({ key: 0 }, _ctx.tabBar), + null, + 16 + ), + [[vShow, _ctx.showTabBar]] + ) + : createCommentVNode('v-if', true), + _ctx.$options.components.Toast + ? createVNode( + _component_toast, + mergeProps({ key: 1 }, _ctx.showToast), + null, + 16 + ) + : createCommentVNode('v-if', true), + _ctx.$options.components.ActionSheet + ? createVNode( + _component_action_sheet, + mergeProps({ key: 2 }, _ctx.showActionSheet, { + onClose: _ctx._onActionSheetClose + }), + null, + 16, + ['onClose'] + ) + : createCommentVNode('v-if', true), + _ctx.$options.components.Modal + ? createVNode( + _component_modal, + mergeProps({ key: 3 }, _ctx.showModal, { + onClose: _ctx._onModalClose + }), + null, + 16, + ['onClose'] + ) + : createCommentVNode('v-if', true), + _ctx.sysComponents && _ctx.sysComponents.length + ? (openBlock(true), + createBlock( + Fragment, + { key: 4 }, + renderList(_ctx.sysComponents, (item, index2) => { + return ( + openBlock(), + createBlock(resolveDynamicComponent(item), { key: index2 }) + ) + }), + 128 + )) + : createCommentVNode('v-if', true) + ], + 2 + ) + ) +} +script$4.render = render$4 +script$4.__file = 'packages/uni-h5/src/framework/components/app/index.vue' +function initSystemComponents(app2) { + script$4.name = COMPONENT_NAME_PREFIX + script$4.name + app2.component(script$4.name, script$4) +} +var index = { + install(app) { + initBridge$1() + initApp(app) + initView(app) + initService(app) + initSystemComponents(app) + initRouter(app) + } +} +const uni$1 = api +let appVm +function getApp() { + return appVm +} +function getCurrentPages$1() { + return [] +} +function mergeTitleNView(navigationBar, titleNView) { + if (isPlainObject(titleNView)) { + if (hasOwn(titleNView, 'backgroundColor')) { + navigationBar.backgroundColor = titleNView.backgroundColor + } + if (hasOwn(titleNView, 'buttons')) { + navigationBar.buttons = titleNView.buttons + } + if (hasOwn(titleNView, 'titleColor')) { + navigationBar.textColor = titleNView.titleColor + } + if (hasOwn(titleNView, 'titleText')) { + navigationBar.titleText = titleNView.titleText + } + if (hasOwn(titleNView, 'titleSize')) { + navigationBar.titleSize = titleNView.titleSize + } + if (hasOwn(titleNView, 'type')) { + navigationBar.type = titleNView.type + } + if ( + hasOwn(titleNView, 'searchInput') && + typeof titleNView.searchInput === 'object' + ) { + navigationBar.searchInput = Object.assign( + { + autoFocus: false, + align: 'center', + color: '#000000', + backgroundColor: 'rgba(255,255,255,0.5)', + borderRadius: '0px', + placeholder: '', + placeholderColor: '#CCCCCC', + disabled: false + }, + titleNView.searchInput + ) + } + } + return navigationBar +} +function appendCss(css, cssId, replace = false) { + let style = document.getElementById(cssId) + if (style && replace) { + style.parentNode.removeChild(style) + style = null + } + if (!style) { + style = document.createElement('style') + style.type = 'text/css' + cssId && (style.id = cssId) + document.getElementsByTagName('head')[0].appendChild(style) + } + style.appendChild(document.createTextNode(css)) +} +function hexToRgba(hex) { + let r + let g + let b + hex = hex.replace('#', '') + if (hex.length === 6) { + r = hex.substring(0, 2) + g = hex.substring(2, 4) + b = hex.substring(4, 6) + } else if (hex.length === 3) { + r = hex.substring(0, 1) + g = hex.substring(1, 2) + b = hex.substring(2, 3) + } else { + return false + } + if (r.length === 1) { + r += r + } + if (g.length === 1) { + g += g + } + if (b.length === 1) { + b += b + } + r = parseInt(r, 16) + g = parseInt(g, 16) + b = parseInt(b, 16) + return { + r, + g, + b + } +} +var transparent = { + mounted() { + if (this.type === 'transparent') { + const transparentElemStyle = this.$el.querySelector( + '.uni-page-head-transparent' + ).style + const titleElem = this.$el.querySelector('.uni-page-head__title') + const iconElems = this.$el.querySelectorAll('.uni-btn-icon') + const iconElemsStyles = [] + const textColor = this.textColor + for (let i = 0; i < iconElems.length; i++) { + iconElemsStyles.push(iconElems[i].style) + } + const borderRadiusElems = this.$el.querySelectorAll('.uni-page-head-btn') + const oldColors = [] + const borderRadiusElemsStyles = [] + for (let i = 0; i < borderRadiusElems.length; i++) { + const borderRadiusElem = borderRadiusElems[i] + oldColors.push(getComputedStyle(borderRadiusElem).backgroundColor) + borderRadiusElemsStyles.push(borderRadiusElem.style) + } + this._A = 0 + UniViewJSBridge.on('onPageScroll', ({ scrollTop }) => { + const alpha = Math.min(scrollTop / this.offset, 1) + if (alpha === 1 && this._A === 1) { + return + } + if (alpha > 0.5 && this._A <= 0.5) { + iconElemsStyles.forEach(function(iconElemStyle) { + iconElemStyle.color = textColor + }) + } else if (alpha <= 0.5 && this._A > 0.5) { + iconElemsStyles.forEach(function(iconElemStyle) { + iconElemStyle.color = '#fff' + }) + } + this._A = alpha + if (titleElem) { + titleElem.style.opacity = alpha + } + transparentElemStyle.backgroundColor = `rgba(${this._R},${this._G},${ + this._B + },${alpha})` + borderRadiusElemsStyles.forEach(function( + borderRadiusElemStyle, + index2 + ) { + const oldColor = oldColors[index2] + let rgba = oldColor.match(/[\d+\.]+/g) + rgba[3] = (1 - alpha) * (rgba.length === 4 ? rgba[3] : 1) + borderRadiusElemStyle.backgroundColor = `rgba(${rgba})` + }) + }) + } else if (this.type === 'float') { + const iconElems = this.$el.querySelectorAll('.uni-btn-icon') + const iconElemsStyles = [] + for (let i = 0; i < iconElems.length; i++) { + iconElemsStyles.push(iconElems[i].style) + } + const borderRadiusElems = this.$el.querySelectorAll('.uni-page-head-btn') + const oldColors = [] + const borderRadiusElemsStyles = [] + for (let i = 0; i < borderRadiusElems.length; i++) { + const borderRadiusElem = borderRadiusElems[i] + oldColors.push(getComputedStyle(borderRadiusElem).backgroundColor) + borderRadiusElemsStyles.push(borderRadiusElem.style) + } + } + }, + computed: { + color() { + return this.type === 'transparent' ? '#fff' : this.textColor + }, + offset() { + return parseInt(this.coverage) + }, + bgColor() { + if (this.type === 'transparent') { + const { r, g, b } = hexToRgba(this.backgroundColor) + this._R = r + this._G = g + this._B = b + return `rgba(${r},${g},${b},0)` + } + return this.backgroundColor + } + } +} +const FONTS = { + forward: '', + back: '', + share: '', + favorite: '', + home: '', + menu: '', + close: '' +} +var script$5 = { + name: 'PageHead', + mixins: [transparent], + components: { + VUniInput: Input + }, + props: { + backButton: { + type: Boolean, + default: true + }, + backgroundColor: { + type: String, + default() { + return this.type === 'transparent' ? '#000' : '#F8F8F8' + } + }, + textColor: { + type: String, + default: '#fff' + }, + titleText: { + type: String, + default: '' + }, + duration: { + type: String, + default: '0' + }, + timingFunc: { + type: String, + default: '' + }, + loading: { + type: Boolean, + default: false + }, + titleSize: { + type: String, + default: '16px' + }, + type: { + default: 'default', + validator(value) { + return ['default', 'transparent', 'float'].indexOf(value) !== -1 + } + }, + coverage: { + type: String, + default: '132px' + }, + buttons: { + type: Array, + default() { + return [] + } + }, + searchInput: { + type: [Object, Boolean], + default() { + return false + } + }, + titleImage: { + type: String, + default: '' + }, + titlePenetrate: { + type: Boolean, + default: false + }, + shadow: { + type: Object, + default() { + return {} + } + } + }, + data() { + return { + focus: false, + text: '', + composing: false + } + }, + computed: { + btns() { + const btns = [] + const fonts = {} + if (this.buttons.length) { + this.buttons.forEach(button => { + const btn = Object.assign({}, button) + if (btn.fontSrc && !btn.fontFamily) { + const fontSrc = (btn.fontSrc = this.$getRealPath(btn.fontSrc)) + let fontFamily + if (fontSrc in fonts) { + fontFamily = fonts[fontSrc] + } else { + fontFamily = `font${Date.now()}` + fonts[fontSrc] = fontFamily + const cssText = `@font-face{font-family: "${fontFamily}";src: url("${fontSrc}") format("truetype")}` + appendCss(cssText, 'uni-btn-font-' + fontFamily) + } + btn.fontFamily = fontFamily + } + btn.color = + this.type === 'transparent' ? '#fff' : btn.color || this.textColor + let fontSize = + btn.fontSize || + (this.type === 'transparent' || /\\u/.test(btn.text) + ? '22px' + : '27px') + if (/\d$/.test(fontSize)) { + fontSize += 'px' + } + btn.fontSize = fontSize + btn.fontWeight = btn.fontWeight || 'normal' + btns.push(btn) + }) + } + return btns + }, + leftBtns() { + return this.btns.filter(btn => btn.float === 'left') + }, + rightBtns() { + return this.btns.filter(btn => btn.float !== 'left') + }, + headClass() { + const shadowColorType = this.shadow.colorType + const data = { + 'uni-page-head-transparent': this.type === 'transparent', + 'uni-page-head-titlePenetrate': this.titlePenetrate, + 'uni-page-head-shadow': shadowColorType + } + if (shadowColorType) { + data[`uni-page-head-shadow-${shadowColorType}`] = shadowColorType + } + return data + } + }, + mounted() { + if (this.searchInput) { + const input = this.$refs.input + input.$watch('composing', val => { + this.composing = val + }) + if (this.searchInput.disabled) { + input.$el.addEventListener('click', () => { + UniServiceJSBridge.emit('onNavigationBarSearchInputClicked', '') + }) + } else { + input.$refs.input.addEventListener('keyup', event => { + if (event.key.toUpperCase() === 'ENTER') { + UniServiceJSBridge.emit('onNavigationBarSearchInputConfirmed', { + text: this.text + }) + } + }) + input.$refs.input.addEventListener('focus', () => { + UniServiceJSBridge.emit('onNavigationBarSearchInputFocusChanged', { + focus: true + }) + }) + input.$refs.input.addEventListener('blur', () => { + UniServiceJSBridge.emit('onNavigationBarSearchInputFocusChanged', { + focus: false + }) + }) + } + } + }, + methods: { + _back() { + if (getCurrentPages().length === 1) { + uni.reLaunch({ + url: '/' + }) + } else { + uni.navigateBack({ + from: 'backbutton' + }) + } + }, + _onBtnClick(index2) { + UniServiceJSBridge.emit( + 'onNavigationBarButtonTap', + Object.assign({}, this.btns[index2], { + index: index2 + }) + ) + }, + _formatBtnFontText(btn) { + if (btn.fontSrc && btn.fontFamily) { + return btn.text.replace('\\u', '') + } else if (FONTS[btn.type]) { + return FONTS[btn.type] + } + return btn.text || '' + }, + _formatBtnStyle(btn) { + const style = { + color: btn.color, + fontSize: btn.fontSize, + fontWeight: btn.fontWeight + } + if (btn.fontFamily) { + style.fontFamily = btn.fontFamily + } + return style + }, + _focus() { + this.focus = true + }, + _blur() { + this.focus = false + }, + _input(text) { + UniServiceJSBridge.emit('onNavigationBarSearchInputChanged', { + text + }) + } + } +} +const _hoisted_1$4 = { class: 'uni-page-head-hd' } +const _hoisted_2$4 = { + key: 0, + class: 'uni-page-head-bd' +} +const _hoisted_3$3 = { + key: 0, + class: 'uni-loading' +} +const _hoisted_4$2 = { class: 'uni-page-head-ft' } +function render$5(_ctx, _cache, $props, $setup, $data, $options) { + const _component_VUniInput = resolveComponent('VUniInput') + return ( + openBlock(), + createBlock( + 'uni-page-head', + { 'uni-page-head-type': _ctx.type }, + [ + createVNode( + 'div', + { + style: { + transitionDuration: _ctx.duration, + transitionTimingFunction: _ctx.timingFunc, + backgroundColor: _ctx.bgColor, + color: _ctx.textColor + }, + class: [_ctx.headClass, 'uni-page-head'] + }, + [ + createVNode('div', _hoisted_1$4, [ + withDirectives( + createVNode( + 'div', + { + class: 'uni-page-head-btn', + onClick: + _cache[1] || + (_cache[1] = (...args) => _ctx._back(...args)) + }, + [ + createVNode( + 'i', + { + style: { color: _ctx.color, fontSize: '27px' }, + class: 'uni-btn-icon' + }, + '', + 4 + ) + ], + 512 + ), + [[vShow, _ctx.backButton]] + ), + (openBlock(true), + createBlock( + Fragment, + null, + renderList(_ctx.leftBtns, (btn, index2) => { + return ( + openBlock(), + createBlock( + 'div', + { + key: index2, + style: { + backgroundColor: + _ctx.type === 'transparent' + ? btn.background + : 'transparent', + width: btn.width + }, + 'badge-text': btn.badgeText, + class: [ + { + 'uni-page-head-btn-red-dot': + btn.redDot || btn.badgeText, + 'uni-page-head-btn-select': btn.select + }, + 'uni-page-head-btn' + ] + }, + [ + createVNode( + 'i', + { + style: _ctx._formatBtnStyle(btn), + class: 'uni-btn-icon', + onClick: $event => _ctx._onBtnClick(index2), + innerHTML: _ctx._formatBtnFontText(btn) + }, + null, + 12, + ['onClick', 'innerHTML'] + ) + ], + 14, + ['badge-text'] + ) + ) + }), + 128 + )) + ]), + !_ctx.searchInput + ? (openBlock(), + createBlock('div', _hoisted_2$4, [ + createVNode( + 'div', + { + style: { + fontSize: _ctx.titleSize, + opacity: _ctx.type === 'transparent' ? 0 : 1 + }, + class: 'uni-page-head__title' + }, + [ + _ctx.loading + ? (openBlock(), createBlock('i', _hoisted_3$3)) + : createCommentVNode('v-if', true), + _ctx.titleImage !== '' + ? (openBlock(), + createBlock( + 'img', + { + key: 1, + src: _ctx.titleImage, + class: 'uni-page-head__title_image' + }, + null, + 8, + ['src'] + )) + : (openBlock(), + createBlock( + Fragment, + { key: 2 }, + [ + createTextVNode( + toDisplayString(_ctx.titleText), + 1 + ) + ], + 64 + )) + ], + 4 + ) + ])) + : createCommentVNode('v-if', true), + _ctx.searchInput + ? (openBlock(), + createBlock( + 'div', + { + key: 1, + style: { + 'border-radius': _ctx.searchInput.borderRadius, + 'background-color': _ctx.searchInput.backgroundColor + }, + class: 'uni-page-head-search' + }, + [ + createVNode( + 'div', + { + style: { color: _ctx.searchInput.placeholderColor }, + class: [ + [ + `uni-page-head-search-placeholder-${ + _ctx.focus || _ctx.text + ? 'left' + : _ctx.searchInput.align + }` + ], + 'uni-page-head-search-placeholder' + ], + textContent: + _ctx.text || _ctx.composing + ? '' + : _ctx.searchInput.placeholder + }, + null, + 14, + ['textContent'] + ), + createVNode( + _component_VUniInput, + { + ref: 'input', + modelValue: _ctx.text, + 'onUpdate:modelValue': + _cache[2] || + (_cache[2] = $event => (_ctx.text = $event)), + focus: _ctx.searchInput.autoFocus, + disabled: _ctx.searchInput.disabled, + style: { color: _ctx.searchInput.color }, + 'placeholder-style': `color:${ + _ctx.searchInput.placeholderColor + }`, + class: 'uni-page-head-search-input', + 'confirm-type': 'search', + onFocus: _ctx._focus, + onBlur: _ctx._blur, + 'onUpdate:value': _ctx._input + }, + null, + 8, + [ + 'modelValue', + 'focus', + 'disabled', + 'style', + 'placeholder-style', + 'onFocus', + 'onBlur', + 'onUpdate:value' + ] + ) + ], + 4 + )) + : createCommentVNode('v-if', true), + createVNode('div', _hoisted_4$2, [ + (openBlock(true), + createBlock( + Fragment, + null, + renderList(_ctx.rightBtns, (btn, index2) => { + return ( + openBlock(), + createBlock( + 'div', + { + key: index2, + style: { + backgroundColor: + _ctx.type === 'transparent' + ? btn.background + : 'transparent', + width: btn.width + }, + 'badge-text': btn.badgeText, + class: [ + { + 'uni-page-head-btn-red-dot': + btn.redDot || btn.badgeText, + 'uni-page-head-btn-select': btn.select + }, + 'uni-page-head-btn' + ] + }, + [ + createVNode( + 'i', + { + style: _ctx._formatBtnStyle(btn), + class: 'uni-btn-icon', + onClick: $event => _ctx._onBtnClick(index2), + innerHTML: _ctx._formatBtnFontText(btn) + }, + null, + 12, + ['onClick', 'innerHTML'] + ) + ], + 14, + ['badge-text'] + ) + ) + }), + 128 + )) + ]) + ], + 6 + ), + _ctx.type !== 'transparent' && _ctx.type !== 'float' + ? (openBlock(), + createBlock( + 'div', + { + key: 0, + class: [ + { 'uni-placeholder-titlePenetrate': _ctx.titlePenetrate }, + 'uni-placeholder' + ] + }, + null, + 2 + )) + : createCommentVNode('v-if', true) + ], + 8, + ['uni-page-head-type'] + ) + ) +} +script$5.render = render$5 +script$5.__file = 'packages/uni-h5/src/framework/components/page/pageHead.vue' +var script$6 = { + name: 'PageBody' +} +function render$6(_ctx, _cache, $props, $setup, $data, $options) { + return ( + openBlock(), + createBlock('uni-page-wrapper', null, [ + createVNode('uni-page-body', null, [renderSlot(_ctx.$slots, 'default')]) + ]) + ) +} +script$6.render = render$6 +script$6.__file = 'packages/uni-h5/src/framework/components/page/pageBody.vue' +var script$7 = { + name: 'PageRefresh', + props: { + color: { + type: String, + default: '#2BD009' + }, + offset: { + type: Number, + default: 0 + } + } +} +const _hoisted_1$5 = { class: 'uni-page-refresh-inner' } +const _hoisted_2$5 = /* @__PURE__ */ createVNode( + 'path', + { + d: + 'M17.65 6.35C16.2 4.9 14.21 4 12 4c-4.42 0-7.99 3.58-7.99 8s3.57 8 7.99 8c3.73 0 6.84-2.55 7.73-6h-2.08c-.82 2.33-3.04 4-5.65 4-3.31 0-6-2.69-6-6s2.69-6 6-6c1.66 0 3.14.69 4.22 1.78L13 11h7V4l-2.35 2.35z' + }, + null, + -1 +) +const _hoisted_3$4 = /* @__PURE__ */ createVNode( + 'path', + { + d: 'M0 0h24v24H0z', + fill: 'none' + }, + null, + -1 +) +const _hoisted_4$3 = { + class: 'uni-page-refresh__spinner', + width: '24', + height: '24', + viewBox: '25 25 50 50' +} +function render$7(_ctx, _cache, $props, $setup, $data, $options) { + return ( + openBlock(), + createBlock('uni-page-refresh', null, [ + createVNode( + 'div', + { + style: { 'margin-top': _ctx.offset + 'px' }, + class: 'uni-page-refresh' + }, + [ + createVNode('div', _hoisted_1$5, [ + (openBlock(), + createBlock( + 'svg', + { + fill: _ctx.color, + class: 'uni-page-refresh__icon', + width: '24', + height: '24', + viewBox: '0 0 24 24' + }, + [_hoisted_2$5, _hoisted_3$4], + 8, + ['fill'] + )), + (openBlock(), + createBlock('svg', _hoisted_4$3, [ + createVNode( + 'circle', + { + stroke: _ctx.color, + class: 'uni-page-refresh__path', + cx: '50', + cy: '50', + r: '20', + fill: 'none', + 'stroke-width': '4', + 'stroke-miterlimit': '10' + }, + null, + 8, + ['stroke'] + ) + ])) + ]) + ], + 4 + ) + ]) + ) +} +script$7.render = render$7 +script$7.__file = + 'packages/uni-h5/src/framework/components/page/pageRefresh.vue' +function processDeltaY(evt, identifier, startY) { + const touch = Array.prototype.slice + .call(evt.changedTouches) + .filter(touch2 => touch2.identifier === identifier)[0] + if (!touch) { + return false + } + evt.deltaY = touch.pageY - startY + return true +} +const PULLING = 'pulling' +const REACHED = 'reached' +const ABORTING = 'aborting' +const REFRESHING = 'refreshing' +const RESTORING = 'restoring' +var pullToRefresh = { + mounted() { + if (this.enablePullDownRefresh) { + this.refreshContainerElem = this.$refs.refresh.$el + this.refreshControllerElem = this.refreshContainerElem.querySelector( + '.uni-page-refresh' + ) + this.refreshInnerElemStyle = this.refreshControllerElem.querySelector( + '.uni-page-refresh-inner' + ).style + UniServiceJSBridge.on( + this.$route.params.__id__ + '.startPullDownRefresh', + () => { + if (!this.state) { + this.state = REFRESHING + this._addClass() + setTimeout(() => { + this._refreshing() + }, 50) + } + } + ) + UniServiceJSBridge.on( + this.$route.params.__id__ + '.stopPullDownRefresh', + () => { + if (this.state === REFRESHING) { + this._removeClass() + this.state = RESTORING + this._addClass() + this._restoring(() => { + this._removeClass() + this.state = this.distance = this.offset = null + }) + } + } + ) + } + }, + methods: { + _touchstart(evt) { + const touch = evt.changedTouches[0] + this.touchId = touch.identifier + this.startY = touch.pageY + if ([ABORTING, REFRESHING, RESTORING].indexOf(this.state) >= 0) { + this.canRefresh = false + } else { + this.canRefresh = true + } + }, + _touchmove(evt) { + if (!this.canRefresh) { + return + } + if (!processDeltaY(evt, this.touchId, this.startY)) { + return + } + let { deltaY } = evt + if ( + (document.documentElement.scrollTop || document.body.scrollTop) !== 0 + ) { + this.touchId = null + return + } + if (deltaY < 0 && !this.state) { + return + } + evt.preventDefault() + if (this.distance == null) { + this.offset = deltaY + this.state = PULLING + this._addClass() + } + deltaY = deltaY - this.offset + if (deltaY < 0) { + deltaY = 0 + } + this.distance = deltaY + const reached = + deltaY >= this.refreshOptions.range && this.state !== REACHED + const pulling = + deltaY < this.refreshOptions.range && this.state !== PULLING + if (reached || pulling) { + this._removeClass() + this.state = this.state === REACHED ? PULLING : REACHED + this._addClass() + } + this._pulling(deltaY) + }, + _touchend(evt) { + if (!processDeltaY(evt, this.touchId, this.startY)) { + return + } + if (this.state === null) { + return + } + if (this.state === PULLING) { + this._removeClass() + this.state = ABORTING + this._addClass() + this._aborting(() => { + this._removeClass() + this.state = this.distance = this.offset = null + }) + } else if (this.state === REACHED) { + this._removeClass() + this.state = REFRESHING + this._addClass() + this._refreshing() + } + }, + _toggleClass(type) { + if (!this.state) { + return + } + const elem = this.refreshContainerElem + if (elem) { + elem.classList[type]('uni-page-refresh--' + this.state) + } + }, + _addClass() { + this._toggleClass('add') + }, + _removeClass() { + this._toggleClass('remove') + }, + _pulling(deltaY) { + const elem = this.refreshControllerElem + if (!elem) { + return + } + const style = elem.style + let rotate = deltaY / this.refreshOptions.range + if (rotate > 1) { + rotate = 1 + } else { + rotate = rotate * rotate * rotate + } + const y = Math.round( + deltaY / (this.refreshOptions.range / this.refreshOptions.height) + ) + const transform = y ? 'translate3d(-50%, ' + y + 'px, 0)' : 0 + style.webkitTransform = transform + style.clip = 'rect(' + (45 - y) + 'px,45px,45px,-5px)' + this.refreshInnerElemStyle.webkitTransform = + 'rotate(' + 360 * rotate + 'deg)' + }, + _aborting(callback) { + const elem = this.refreshControllerElem + if (!elem) { + return + } + const style = elem.style + if (style.webkitTransform) { + style.webkitTransition = '-webkit-transform 0.3s' + style.webkitTransform = 'translate3d(-50%, 0, 0)' + const abortTransitionEnd = function() { + timeout && clearTimeout(timeout) + elem.removeEventListener('webkitTransitionEnd', abortTransitionEnd) + style.webkitTransition = '' + callback() + } + elem.addEventListener('webkitTransitionEnd', abortTransitionEnd) + const timeout = setTimeout(abortTransitionEnd, 350) + } else { + callback() + } + }, + _refreshing() { + const elem = this.refreshControllerElem + if (!elem) { + return + } + const style = elem.style + style.webkitTransition = '-webkit-transform 0.2s' + style.webkitTransform = + 'translate3d(-50%, ' + this.refreshOptions.height + 'px, 0)' + UniServiceJSBridge.emit( + 'onPullDownRefresh', + {}, + this.$route.params.__id__ + ) + }, + _restoring(callback) { + const elem = this.refreshControllerElem + if (!elem) { + return + } + const style = elem.style + style.webkitTransition = '-webkit-transform 0.3s' + style.webkitTransform += ' scale(0.01)' + const restoreTransitionEnd = function() { + timeout && clearTimeout(timeout) + elem.removeEventListener('webkitTransitionEnd', restoreTransitionEnd) + style.webkitTransition = '' + style.webkitTransform = 'translate3d(-50%, 0, 0)' + callback() + } + elem.addEventListener('webkitTransitionEnd', restoreTransitionEnd) + const timeout = setTimeout(restoreTransitionEnd, 350) + } + } +} +var script$8 = { + name: 'Page', + mpType: 'page', + components: { + PageHead: script$5, + PageBody: script$6, + PageRefresh: script$7 + }, + mixins: [pullToRefresh], + props: { + isQuit: { + type: Boolean, + default: false + }, + isEntry: { + type: Boolean, + default: false + }, + isTabBar: { + type: Boolean, + default: false + }, + tabBarIndex: { + type: Number, + default: -1 + }, + navigationBarBackgroundColor: { + type: String, + default: '#000' + }, + navigationBarTextStyle: { + default: 'white', + validator(value) { + return ['white', 'black'].indexOf(value) !== -1 + } + }, + navigationBarTitleText: { + type: String, + default: '' + }, + navigationStyle: { + default: 'default', + validator(value) { + return ['default', 'custom'].indexOf(value) !== -1 + } + }, + backgroundColor: { + type: String, + default: '#ffffff' + }, + backgroundTextStyle: { + default: 'dark', + validator(value) { + return ['dark', 'light'].indexOf(value) !== -1 + } + }, + backgroundColorTop: { + type: String, + default: '#fff' + }, + backgroundColorBottom: { + type: String, + default: '#fff' + }, + enablePullDownRefresh: { + type: Boolean, + default: false + }, + onReachBottomDistance: { + type: Number, + default: 50 + }, + disableScroll: { + type: Boolean, + default: false + }, + titleNView: { + type: [Boolean, Object, String], + default: '' + }, + pullToRefresh: { + type: Object, + default() { + return {} + } + }, + titleImage: { + type: String, + default: '' + }, + transparentTitle: { + type: String, + default: '' + }, + titlePenetrate: { + type: String, + default: 'NO' + }, + navigationBarShadow: { + type: Object, + default() { + return {} + } + } + }, + data() { + const titleNViewTypeList = { + none: 'default', + auto: 'transparent', + always: 'float' + } + let titleNView = this.titleNView + if ( + titleNView === false || + titleNView === 'false' || + (this.navigationStyle === 'custom' && !isPlainObject(titleNView)) || + (this.transparentTitle === 'always' && !isPlainObject(titleNView)) + ) { + titleNView = { + type: 'none' + } + } else { + titleNView = Object.assign( + {}, + { + type: this.navigationStyle === 'custom' ? 'none' : 'default' + }, + this.transparentTitle in titleNViewTypeList + ? { + type: titleNViewTypeList[this.transparentTitle] + } + : null, + typeof titleNView === 'object' + ? titleNView + : typeof titleNView === 'boolean' + ? { + type: titleNView ? 'default' : 'none' + } + : null + ) + } + const yesNoParseList = { + YES: true, + NO: false + } + const navigationBar = mergeTitleNView( + { + loading: false, + backButton: !this.isQuit && !this.$route.meta.isQuit, + backgroundColor: this.navigationBarBackgroundColor, + textColor: this.navigationBarTextStyle === 'black' ? '#000' : '#fff', + titleText: this.navigationBarTitleText, + titleImage: this.titleImage, + duration: '0', + timingFunc: '', + titlePenetrate: yesNoParseList[this.titlePenetrate] + }, + titleNView + ) + navigationBar.shadow = this.navigationBarShadow + const refreshOptions = Object.assign( + { + support: true, + color: '#2BD009', + style: 'circle', + height: 70, + range: 150, + offset: 0 + }, + this.pullToRefresh + ) + let offset = uni.upx2px(refreshOptions.offset) + if (titleNView.type !== 'none' && titleNView.type !== 'transparent') { + offset += NAVBAR_HEIGHT + out.top + } + refreshOptions.offset = offset + refreshOptions.height = uni.upx2px(refreshOptions.height) + refreshOptions.range = uni.upx2px(refreshOptions.range) + return { + navigationBar, + refreshOptions + } + }, + created() { + const navigationBar = this.navigationBar + document.title = navigationBar.titleText + UniServiceJSBridge.emit('onNavigationBarChange', navigationBar) + } +} +function render$8(_ctx, _cache, $props, $setup, $data, $options) { + const _component_page_head = resolveComponent('page-head') + const _component_page_refresh = resolveComponent('page-refresh') + const _component_page_body = resolveComponent('page-body') + return ( + openBlock(), + createBlock( + 'uni-page', + { + 'data-page': _ctx.$route.meta.pagePath + }, + [ + _ctx.navigationBar.type !== 'none' + ? createVNode( + _component_page_head, + mergeProps({ key: 0 }, _ctx.navigationBar), + null, + 16 + ) + : createCommentVNode('v-if', true), + _ctx.enablePullDownRefresh + ? createVNode( + _component_page_refresh, + { + key: 1, + ref: 'refresh', + color: _ctx.refreshOptions.color, + offset: _ctx.refreshOptions.offset + }, + null, + 8, + ['color', 'offset'] + ) + : createCommentVNode('v-if', true), + _ctx.enablePullDownRefresh + ? createVNode( + _component_page_body, + { + key: 2, + onTouchstartPassive: _ctx._touchstart, + onTouchmovePassive: _ctx._touchmove, + onTouchendPassive: _ctx._touchend, + onTouchcancelPassive: _ctx._touchend + }, + { + default: withCtx(() => [renderSlot(_ctx.$slots, 'page')]), + _: 3 + }, + 8, + [ + 'onTouchstartPassive', + 'onTouchmovePassive', + 'onTouchendPassive', + 'onTouchcancelPassive' + ] + ) + : createVNode( + _component_page_body, + { key: 3 }, + { + default: withCtx(() => [renderSlot(_ctx.$slots, 'page')]), + _: 3 + } + ) + ], + 8, + ['data-page'] + ) + ) +} +script$8.render = render$8 +script$8.__file = 'packages/uni-h5/src/framework/components/page/index.vue' +var script$9 = { + name: 'AsyncError', + methods: { + _onClick() { + window.location.reload() + } + } +} +function render$9(_ctx, _cache, $props, $setup, $data, $options) { + return ( + openBlock(), + createBlock( + 'div', + { + class: 'uni-async-error', + onClick: _cache[1] || (_cache[1] = (...args) => _ctx._onClick(...args)) + }, + ' 连接服务器超时,点击屏幕重试 ' + ) + ) +} +script$9.render = render$9 +script$9.__file = + 'packages/uni-h5/src/framework/components/async-error/index.vue' +var script$a = { + name: 'AsyncLoading' +} +const _hoisted_1$6 = { class: 'uni-async-loading' } +const _hoisted_2$6 = /* @__PURE__ */ createVNode( + 'i', + { class: 'uni-loading' }, + null, + -1 +) +function render$a(_ctx, _cache, $props, $setup, $data, $options) { + return openBlock(), createBlock('div', _hoisted_1$6, [_hoisted_2$6]) +} +script$a.render = render$a +script$a.__file = + 'packages/uni-h5/src/framework/components/async-loading/index.vue' +export { + script$9 as AsyncErrorComponent, + script$a as AsyncLoadingComponent, + script$8 as PageComponent, + addInterceptor, + arrayBufferToBase64, + base64ToArrayBuffer, + canIUse, + createIntersectionObserver$1 as createIntersectionObserver, + createSelectorQuery$1 as createSelectorQuery, + getApp, + getCurrentPages$1 as getCurrentPages, + getSystemInfo, + getSystemInfoSync, + makePhoneCall, + navigateBack, + navigateTo, + openDocument, + index as plugin, + promiseInterceptor, + reLaunch, + redirectTo, + removeInterceptor, + switchTab, + uni$1 as uni, + upx2px +} diff --git a/packages/uni-mp-alipay/dist/uni.api.esm.js b/packages/uni-mp-alipay/dist/uni.api.esm.js new file mode 100644 index 0000000000000000000000000000000000000000..da93bbae7558ede8ddabceac930760da681da9ab --- /dev/null +++ b/packages/uni-mp-alipay/dist/uni.api.esm.js @@ -0,0 +1,1064 @@ +import { + isArray, + isPromise, + isFunction, + isPlainObject, + hasOwn, + isString +} from '@vue/shared' + +function createApi(fn, validate) { + if (process.env.NODE_ENV !== 'production' && validate); + return fn +} + +const Upx2pxProtocol = [ + { + name: 'upx', + type: [Number, String], + required: true + } +] + +const EPS = 1e-4 +const BASE_DEVICE_WIDTH = 750 +let isIOS = false +let deviceWidth = 0 +let deviceDPR = 0 +function checkDeviceWidth() { + const { platform, pixelRatio, windowWidth } = my.getSystemInfoSync() + deviceWidth = windowWidth + deviceDPR = pixelRatio + isIOS = platform === 'ios' +} +const upx2px = createApi((number, newDeviceWidth) => { + if (deviceWidth === 0) { + checkDeviceWidth() + } + number = Number(number) + if (number === 0) { + return 0 + } + let result = (number / BASE_DEVICE_WIDTH) * (newDeviceWidth || deviceWidth) + if (result < 0) { + result = -result + } + result = Math.floor(result + EPS) + if (result === 0) { + if (deviceDPR === 1 || !isIOS) { + result = 1 + } else { + result = 0.5 + } + } + return number < 0 ? -result : result +}, Upx2pxProtocol) + +var HOOKS +;(function(HOOKS) { + HOOKS['INVOKE'] = 'invoke' + HOOKS['SUCCESS'] = 'success' + HOOKS['FAIL'] = 'fail' + HOOKS['COMPLETE'] = 'complete' + HOOKS['RETURN_VALUE'] = 'returnValue' +})(HOOKS || (HOOKS = {})) +const globalInterceptors = {} +const scopedInterceptors = {} +function wrapperHook(hook) { + return function(data) { + return hook(data) || data + } +} +function queue(hooks, data) { + let promise = false + for (let i = 0; i < hooks.length; i++) { + const hook = hooks[i] + if (promise) { + promise = Promise.resolve(wrapperHook(hook)) + } else { + const res = hook(data) + if (isPromise(res)) { + promise = Promise.resolve(res) + } + if (res === false) { + return { + then() {}, + catch() {} + } + } + } + } + return ( + promise || { + then(callback) { + return callback(data) + }, + catch() {} + } + ) +} +function wrapperOptions(interceptors, options = {}) { + ;[HOOKS.SUCCESS, HOOKS.FAIL, HOOKS.COMPLETE].forEach(name => { + const hooks = interceptors[name] + if (!isArray(hooks)) { + return + } + const oldCallback = options[name] + options[name] = function callbackInterceptor(res) { + queue(hooks, res).then(res => { + return (isFunction(oldCallback) && oldCallback(res)) || res + }) + } + }) + return options +} +function wrapperReturnValue(method, returnValue) { + const returnValueHooks = [] + if (isArray(globalInterceptors.returnValue)) { + returnValueHooks.push(...globalInterceptors.returnValue) + } + const interceptor = scopedInterceptors[method] + if (interceptor && isArray(interceptor.returnValue)) { + returnValueHooks.push(...interceptor.returnValue) + } + returnValueHooks.forEach(hook => { + returnValue = hook(returnValue) || returnValue + }) + return returnValue +} +function getApiInterceptorHooks(method) { + const interceptor = Object.create(null) + Object.keys(globalInterceptors).forEach(hook => { + if (hook !== 'returnValue') { + interceptor[hook] = globalInterceptors[hook].slice() + } + }) + const scopedInterceptor = scopedInterceptors[method] + if (scopedInterceptor) { + Object.keys(scopedInterceptor).forEach(hook => { + if (hook !== 'returnValue') { + interceptor[hook] = (interceptor[hook] || []).concat( + scopedInterceptor[hook] + ) + } + }) + } + return interceptor +} +function invokeApi(method, api, options, ...params) { + const interceptor = getApiInterceptorHooks(method) + if (interceptor && Object.keys(interceptor).length) { + if (isArray(interceptor.invoke)) { + const res = queue(interceptor.invoke, options) + return res.then(options => { + return api(wrapperOptions(interceptor, options), ...params) + }) + } else { + return api(wrapperOptions(interceptor, options), ...params) + } + } + return api(options, ...params) +} + +const AddInterceptorProtocol = [ + { + name: 'method', + type: [String, Object], + required: true + } +] +const RemoveInterceptorProtocol = AddInterceptorProtocol + +function mergeInterceptorHook(interceptors, interceptor) { + Object.keys(interceptor).forEach(hook => { + if (isFunction(interceptor[hook])) { + interceptors[hook] = mergeHook(interceptors[hook], interceptor[hook]) + } + }) +} +function removeInterceptorHook(interceptors, interceptor) { + if (!interceptors || !interceptor) { + return + } + Object.keys(interceptor).forEach(hook => { + if (isFunction(interceptor[hook])) { + removeHook(interceptors[hook], interceptor[hook]) + } + }) +} +function mergeHook(parentVal, childVal) { + const res = childVal + ? parentVal + ? parentVal.concat(childVal) + : isArray(childVal) + ? childVal + : [childVal] + : parentVal + return res ? dedupeHooks(res) : res +} +function dedupeHooks(hooks) { + const res = [] + for (let i = 0; i < hooks.length; i++) { + if (res.indexOf(hooks[i]) === -1) { + res.push(hooks[i]) + } + } + return res +} +function removeHook(hooks, hook) { + if (!hooks) { + return + } + const index = hooks.indexOf(hook) + if (index !== -1) { + hooks.splice(index, 1) + } +} +const addInterceptor = createApi((method, interceptor) => { + if (typeof method === 'string' && isPlainObject(interceptor)) { + mergeInterceptorHook( + scopedInterceptors[method] || (scopedInterceptors[method] = {}), + interceptor + ) + } else if (isPlainObject(method)) { + mergeInterceptorHook(globalInterceptors, method) + } +}, AddInterceptorProtocol) +const removeInterceptor = createApi((method, interceptor) => { + if (typeof method === 'string') { + if (isPlainObject(interceptor)) { + removeInterceptorHook(scopedInterceptors[method], interceptor) + } else { + delete scopedInterceptors[method] + } + } else if (isPlainObject(method)) { + removeInterceptorHook(globalInterceptors, method) + } +}, RemoveInterceptorProtocol) + +const SYNC_API_RE = /^\$|sendNativeEvent|restoreGlobal|getCurrentSubNVue|getMenuButtonBoundingClientRect|^report|interceptors|Interceptor$|getSubNVueById|requireNativePlugin|upx2px|hideKeyboard|canIUse|^create|Sync$|Manager$|base64ToArrayBuffer|arrayBufferToBase64/ +const CONTEXT_API_RE = /^create|Manager$/ +// Context例外情况 +const CONTEXT_API_RE_EXC = ['createBLEConnection'] +// 同步例外情况 +const ASYNC_API = ['createBLEConnection'] +const CALLBACK_API_RE = /^on|^off/ +function isContextApi(name) { + return CONTEXT_API_RE.test(name) && CONTEXT_API_RE_EXC.indexOf(name) === -1 +} +function isSyncApi(name) { + return SYNC_API_RE.test(name) && ASYNC_API.indexOf(name) === -1 +} +function isCallbackApi(name) { + return CALLBACK_API_RE.test(name) && name !== 'onPush' +} +function handlePromise(promise) { + if (!__UNI_PROMISE_API__) { + return promise + } + return promise + .then(data => { + return [null, data] + }) + .catch(err => [err]) +} +function shouldPromise(name) { + if (isContextApi(name) || isSyncApi(name) || isCallbackApi(name)) { + return false + } + return true +} +/* eslint-disable no-extend-native */ +if (!Promise.prototype.finally) { + Promise.prototype.finally = function(onfinally) { + const promise = this.constructor + return this.then( + value => promise.resolve(onfinally && onfinally()).then(() => value), + reason => + promise.resolve(onfinally && onfinally()).then(() => { + throw reason + }) + ) + } +} +function promisify(name, api) { + if (!shouldPromise(name)) { + return api + } + if (!isFunction(api)) { + return api + } + return function promiseApi(options = {}, ...params) { + if ( + isFunction(options.success) || + isFunction(options.fail) || + isFunction(options.complete) + ) { + return wrapperReturnValue(name, invokeApi(name, api, options, ...params)) + } + return wrapperReturnValue( + name, + handlePromise( + new Promise((resolve, reject) => { + invokeApi( + name, + api, + Object.assign({}, options, { + success: resolve, + fail: reject + }), + ...params + ) + }) + ) + ) + } +} + +const CALLBACKS = ['success', 'fail', 'cancel', 'complete'] +function initWrapper(protocols) { + function processCallback(methodName, method, returnValue) { + return function(res) { + return method(processReturnValue(methodName, res, returnValue)) + } + } + function processArgs( + methodName, + fromArgs, + argsOption = {}, + returnValue = {}, + keepFromArgs = false + ) { + if (isPlainObject(fromArgs)) { + // 一般 api 的参数解析 + const toArgs = keepFromArgs === true ? fromArgs : {} // returnValue 为 false 时,说明是格式化返回值,直接在返回值对象上修改赋值 + if (isFunction(argsOption)) { + argsOption = argsOption(fromArgs, toArgs) || {} + } + for (const key in fromArgs) { + if (hasOwn(argsOption, key)) { + let keyOption = argsOption[key] + if (isFunction(keyOption)) { + keyOption = keyOption(fromArgs[key], fromArgs, toArgs) + } + if (!keyOption) { + // 不支持的参数 + console.warn(`支付宝小程序 ${methodName} 暂不支持 ${key}`) + } else if (isString(keyOption)) { + // 重写参数 key + toArgs[keyOption] = fromArgs[key] + } else if (isPlainObject(keyOption)) { + // {name:newName,value:value}可重新指定参数 key:value + toArgs[keyOption.name ? keyOption.name : key] = keyOption.value + } + } else if (CALLBACKS.indexOf(key) !== -1) { + const callback = fromArgs[key] + if (isFunction(callback)) { + toArgs[key] = processCallback(methodName, callback, returnValue) + } + } else { + if (!keepFromArgs && !hasOwn(toArgs, key)) { + toArgs[key] = fromArgs[key] + } + } + } + return toArgs + } else if (isFunction(fromArgs)) { + fromArgs = processCallback(methodName, fromArgs, returnValue) + } + return fromArgs + } + function processReturnValue( + methodName, + res, + returnValue, + keepReturnValue = false + ) { + if (isFunction(protocols.returnValue)) { + // 处理通用 returnValue + res = protocols.returnValue(methodName, res) + } + return processArgs(methodName, res, returnValue, {}, keepReturnValue) + } + return function wrapper(methodName, method) { + if (!hasOwn(protocols, methodName)) { + return method + } + const protocol = protocols[methodName] + if (!protocol) { + // 暂不支持的 api + return function() { + console.error(`支付宝小程序 暂不支持${methodName}`) + } + } + return function(arg1, arg2) { + // 目前 api 最多两个参数 + let options = protocol + if (isFunction(protocol)) { + options = protocol(arg1) + } + arg1 = processArgs(methodName, arg1, options.args, options.returnValue) + const args = [arg1] + if (typeof arg2 !== 'undefined') { + args.push(arg2) + } + const returnValue = my[options.name || methodName].apply(my, args) + if (isSyncApi(methodName)) { + // 同步 api + return processReturnValue( + methodName, + returnValue, + options.returnValue, + isContextApi(methodName) + ) + } + return returnValue + } + } +} + +const baseApis = { upx2px, addInterceptor, removeInterceptor } +function initUni(api, protocols) { + const wrapper = initWrapper(protocols) + const UniProxyHandlers = { + get(target, key) { + if (hasOwn(target, key)) { + return target[key] + } + if (hasOwn(api, key)) { + return promisify(key, api[key]) + } + if (hasOwn(baseApis, key)) { + return promisify(key, baseApis[key]) + } + // event-api + // provider-api? + return promisify(key, wrapper(key, my[key])) + } + } + return new Proxy({}, UniProxyHandlers) +} + +function initGetProvider(providers) { + return function getProvider({ service, success, fail, complete }) { + let res + if (providers[service]) { + res = { + errMsg: 'getProvider:ok', + service, + provider: providers[service] + } + isFunction(success) && success(res) + } else { + res = { + errMsg: 'getProvider:fail:服务[' + service + ']不存在' + } + isFunction(fail) && fail(res) + } + isFunction(complete) && complete(res) + } +} + +function addSafeAreaInsets(fromRes, toRes) { + if (fromRes.safeArea) { + const safeArea = fromRes.safeArea + toRes.safeAreaInsets = { + top: safeArea.top, + left: safeArea.left, + right: fromRes.windowWidth - safeArea.right, + bottom: fromRes.windowHeight - safeArea.bottom + } + } +} +const redirectTo = {} + +const getProvider = initGetProvider({ + oauth: ['alipay'], + share: ['alipay'], + payment: ['alipay'], + push: ['alipay'] +}) +function setStorageSync(key, data) { + return my.setStorageSync({ + key, + data + }) +} +function getStorageSync(key) { + const result = my.getStorageSync({ + key + }) + // 支付宝平台会返回一个 success 值,但是目前测试的结果这个始终是 true。当没有存储数据的时候,其它平台会返回空字符串。 + return result.data !== null ? result.data : '' +} +function removeStorageSync(key) { + return my.removeStorageSync({ + key + }) +} +function startGyroscope(args) { + if (hasOwn(args, 'interval')) { + console.warn('支付宝小程序 startGyroscope暂不支持interval') + } + args.success && + args.success({ + errMsg: 'startGyroscope:ok' + }) + args.complete && + args.complete({ + errMsg: 'startGyroscope:ok' + }) +} +function createExecCallback(execCallback) { + return function wrapperExecCallback(res) { + this.actions.forEach((action, index) => { + ;(action._$callbacks || []).forEach(callback => { + callback(res[index]) + }) + }) + if (isFunction(execCallback)) { + execCallback(res) + } + } +} +function addCallback(callback) { + if (isFunction(callback)) { + const action = this.actions[this.actions.length - 1] + if (action) { + ;(action._$callbacks || (action._$callbacks = [])).push(callback) + } + } +} +function createSelectorQuery() { + const query = my.createSelectorQuery() + const oldExec = query.exec + const oldScrollOffset = query.scrollOffset + const oldBoundingClientRect = query.boundingClientRect + query.exec = function exec(callback) { + return oldExec.call(this, createExecCallback(callback).bind(this)) + } + query.scrollOffset = function scrollOffset(callback) { + const ret = oldScrollOffset.call(this) + addCallback.call(this, callback) + return ret + } + query.boundingClientRect = function boundingClientRect(callback) { + const ret = oldBoundingClientRect.call(this) + addCallback.call(this, callback) + return ret + } + if (!query.fields) { + query.fields = function({ rect, size, scrollOffset }, callback) { + if (rect || size) { + this.boundingClientRect() + } + if (scrollOffset) { + this.scrollOffset() + } + addCallback.call(this, callback) + return this + } + } + if (!query.in) { + query.in = function() { + return this + } + } + return query +} +function createIntersectionObserver(component, options) { + if (options && options.observeAll) { + options.selectAll = options.observeAll + delete options.observeAll + } + return my.createIntersectionObserver(options) +} + +var shims = /*#__PURE__*/ Object.freeze({ + __proto__: null, + getProvider: getProvider, + setStorageSync: setStorageSync, + getStorageSync: getStorageSync, + removeStorageSync: removeStorageSync, + startGyroscope: startGyroscope, + createSelectorQuery: createSelectorQuery, + createIntersectionObserver: createIntersectionObserver +}) + +function handleNetworkInfo(fromRes, toRes) { + const nextworkType = fromRes.networkType + switch (nextworkType) { + case 'NOTREACHABLE': + toRes.networkType = 'none' + break + case 'WWAN': + // TODO ? + toRes.networkType = '3g' + break + default: + toRes.networkType = fromRes.networkType.toLowerCase() + break + } +} +function handleSystemInfo(fromRes, toRes) { + addSafeAreaInsets(fromRes, toRes) + let platform = fromRes.platform ? fromRes.platform.toLowerCase() : 'devtools' + if (!~['android', 'ios'].indexOf(platform)) { + platform = 'devtools' + } + toRes.platform = platform +} +function returnValue(methodName, res) { + // 通用 returnValue 解析 + if (res.error || res.errorMessage) { + res.errMsg = `${methodName}:fail ${res.errorMessage || res.error}` + delete res.error + delete res.errorMessage + } else { + res.errMsg = `${methodName}:ok` + } + return res +} +const request = { + name: my.canIUse('request') ? 'request' : 'httpRequest', + args(fromArgs) { + const method = fromArgs.method || 'GET' + if (!fromArgs.header) { + // 默认增加 header 参数,方便格式化 content-type + fromArgs.header = {} + } + const headers = { + 'content-type': 'application/json' + } + Object.keys(fromArgs.header).forEach(key => { + headers[key.toLocaleLowerCase()] = fromArgs.header[key] + }) + return { + header() { + return { + name: 'headers', + value: headers + } + }, + data(data) { + // 钉钉小程序在content-type为application/json时需上传字符串形式data,使用my.dd在真机运行钉钉小程序时不能正确判断 + if ( + my.canIUse('saveFileToDingTalk') && + method.toUpperCase() === 'POST' && + headers['content-type'].indexOf('application/json') === 0 && + isPlainObject(data) + ) { + return { + name: 'data', + value: JSON.stringify(data) + } + } + return { + name: 'data', + value: data + } + }, + method: 'method', + responseType: false + } + }, + returnValue: { + status: 'statusCode', + headers: 'header' + } +} +const setNavigationBarColor = { + name: 'setNavigationBar', + args: { + frontColor: false, + animation: false + } +} +const setNavigationBarTitle = { + name: 'setNavigationBar' +} +function showModal({ showCancel = true } = {}) { + if (showCancel) { + return { + name: 'confirm', + args: { + cancelColor: false, + confirmColor: false, + cancelText: 'cancelButtonText', + confirmText: 'confirmButtonText' + }, + returnValue(fromRes, toRes) { + toRes.confirm = fromRes.confirm + toRes.cancel = !fromRes.confirm + } + } + } + return { + name: 'alert', + args: { + confirmColor: false, + confirmText: 'buttonText' + }, + returnValue(fromRes, toRes) { + toRes.confirm = true + toRes.cancel = false + } + } +} +function showToast({ icon = 'success' } = {}) { + const args = { + title: 'content', + icon: 'type', + duration: false, + image: false, + mask: false + } + if (icon === 'loading') { + return { + name: 'showLoading', + args + } + } + return { + name: 'showToast', + args + } +} +const showActionSheet = { + name: 'showActionSheet', + args: { + itemList: 'items', + itemColor: false + }, + returnValue: { + index: 'tapIndex' + } +} +const showLoading = { + args: { + title: 'content', + mask: false + } +} +const uploadFile = { + args: { + name: 'fileName' + } + // 从测试结果看,是有返回对象的,文档上没有说明。 +} +const downloadFile = { + returnValue: { + apFilePath: 'tempFilePath' + } +} +const getFileInfo = { + args: { + filePath: 'apFilePath' + } +} +const compressImage = { + args(fromArgs, toArgs) { + toArgs.compressLevel = 4 + if (fromArgs && fromArgs.quality) { + toArgs.compressLevel = Math.floor(fromArgs.quality / 26) + } + if (fromArgs.src) { + toArgs.apFilePaths = [fromArgs.src] + } + }, + returnValue(fromRes, toRes) { + const apFilePaths = fromRes.apFilePaths + if (apFilePaths && apFilePaths.length) { + toRes.tempFilePath = apFilePaths[0] + } + } +} +const chooseVideo = { + // 支付宝小程序文档中未找到(仅在getSetting处提及),但实际可用 + returnValue: { + apFilePath: 'tempFilePath' + } +} +const connectSocket = { + args: { + method: false, + protocols: false + } + // TODO 有没有返回值还需要测试下 +} +const chooseImage = { + returnValue: { + apFilePaths: 'tempFilePaths' + } +} +const previewImage = { + args(fromArgs, toArgs) { + // 支付宝小程序的 current 是索引值,而非图片地址。 + const currentIndex = Number(fromArgs.current) + if (isNaN(currentIndex)) { + if (fromArgs.current && isArray(fromArgs.urls)) { + const index = fromArgs.urls.indexOf(fromArgs.current) + toArgs.current = ~index ? index : 0 + } + } else { + toArgs.current = currentIndex + } + return { + indicator: false, + loop: false + } + } +} +const saveFile = { + args: { + tempFilePath: 'apFilePath' + }, + returnValue: { + apFilePath: 'savedFilePath' + } +} +const getSavedFileInfo = { + args: { + filePath: 'apFilePath' + } +} +const getSavedFileList = { + returnValue(fromRes, toRes) { + toRes.fileList = fromRes.fileList.map(file => { + return { + filePath: file.apFilePath, + createTime: file.createTime, + size: file.size + } + }) + } +} +const removeSavedFile = { + args: { + filePath: 'apFilePath' + } +} +const getLocation = { + args: { + type: false, + altitude: false + } +} +const openLocation = { + args: { + // TODO address 参数在阿里上是必传的 + } +} +const getNetworkType = { + returnValue: handleNetworkInfo +} +const onNetworkStatusChange = { + returnValue: handleNetworkInfo +} +const stopAccelerometer = { + name: 'offAccelerometerChange' +} +const stopCompass = { + name: 'offCompassChange' +} +const scanCode = { + name: 'scan', + args: { + onlyFromCamera: 'hideAlbum' + }, + returnValue: { + code: 'result' + } +} +const setClipboardData = { + name: 'setClipboard', + args: { + data: 'text' + } +} +const getClipboardData = { + name: 'getClipboard', + returnValue: { + text: 'data' + } +} +const pageScrollTo = { + args: { + duration: false + } +} +const login = { + name: 'getAuthCode', + returnValue: { + authCode: 'code' + } +} +const getUserInfo = { + name: my.canIUse('getOpenUserInfo') ? 'getOpenUserInfo' : 'getAuthUserInfo', + returnValue(fromRes, toRes) { + if (my.canIUse('getOpenUserInfo')) { + let response + try { + response = JSON.parse(fromRes.response).response + } catch (e) {} + if (response) { + toRes.userInfo = response + toRes.userInfo.avatarUrl = response.avatar + delete response.avatar + } + } else { + toRes.userInfo = { + openId: '', + nickName: fromRes.nickName, + avatarUrl: fromRes.avatar + } + } + } +} +const requestPayment = { + name: 'tradePay', + args: { + orderInfo: 'tradeNO' + } +} +const getBLEDeviceServices = { + returnValue(fromRes, toRes) { + toRes.services = fromRes.services.map(item => { + return { + uuid: item.serviceId, + isPrimary: item.isPrimary + } + }) + } +} +const createBLEConnection = { + name: 'connectBLEDevice', + args: { + timeout: false + } +} +const closeBLEConnection = { + name: 'disconnectBLEDevice' +} +const onBLEConnectionStateChange = { + name: 'onBLEConnectionStateChanged' +} +const makePhoneCall = { + args: { + phoneNumber: 'number' + } +} +const stopGyroscope = { + name: 'offGyroscopeChange' +} +const getSystemInfo = { + returnValue: handleSystemInfo +} +const getSystemInfoSync = { + returnValue: handleSystemInfo +} +// 文档没提到,但是实测可用。 +const canvasToTempFilePath = { + returnValue(fromRes, toRes) { + // 真机的情况下会有 tempFilePath 这个值,因此需要主动修改。 + toRes.tempFilePath = fromRes.apFilePath + } +} +const setScreenBrightness = { + args: { + value: 'brightness' + } +} +const getScreenBrightness = { + returnValue: { + brightness: 'value' + } +} +const showShareMenu = { + name: 'showSharePanel' +} +const hideHomeButton = { + name: 'hideBackHome' +} +const saveImageToPhotosAlbum = { + name: 'saveImage', + args: { + filePath: 'url' + } +} +const saveVideoToPhotosAlbum = { + args: { + filePath: 'src' + } +} +const chooseAddress = { + name: 'getAddress', + returnValue(fromRes, toRes) { + const info = fromRes.result || {} + toRes.userName = info.fullname + toRes.countyName = info.country + toRes.provinceName = info.prov + toRes.cityName = info.city + toRes.detailInfo = info.address + toRes.telNumber = info.mobilePhone + toRes.errMsg = toRes.errMsg + ' ' + fromRes.resultStatus + } +} + +var protocols = /*#__PURE__*/ Object.freeze({ + __proto__: null, + returnValue: returnValue, + request: request, + setNavigationBarColor: setNavigationBarColor, + setNavigationBarTitle: setNavigationBarTitle, + showModal: showModal, + showToast: showToast, + showActionSheet: showActionSheet, + showLoading: showLoading, + uploadFile: uploadFile, + downloadFile: downloadFile, + getFileInfo: getFileInfo, + compressImage: compressImage, + chooseVideo: chooseVideo, + connectSocket: connectSocket, + chooseImage: chooseImage, + previewImage: previewImage, + saveFile: saveFile, + getSavedFileInfo: getSavedFileInfo, + getSavedFileList: getSavedFileList, + removeSavedFile: removeSavedFile, + getLocation: getLocation, + openLocation: openLocation, + getNetworkType: getNetworkType, + onNetworkStatusChange: onNetworkStatusChange, + stopAccelerometer: stopAccelerometer, + stopCompass: stopCompass, + scanCode: scanCode, + setClipboardData: setClipboardData, + getClipboardData: getClipboardData, + pageScrollTo: pageScrollTo, + login: login, + getUserInfo: getUserInfo, + requestPayment: requestPayment, + getBLEDeviceServices: getBLEDeviceServices, + createBLEConnection: createBLEConnection, + closeBLEConnection: closeBLEConnection, + onBLEConnectionStateChange: onBLEConnectionStateChange, + makePhoneCall: makePhoneCall, + stopGyroscope: stopGyroscope, + getSystemInfo: getSystemInfo, + getSystemInfoSync: getSystemInfoSync, + canvasToTempFilePath: canvasToTempFilePath, + setScreenBrightness: setScreenBrightness, + getScreenBrightness: getScreenBrightness, + showShareMenu: showShareMenu, + hideHomeButton: hideHomeButton, + saveImageToPhotosAlbum: saveImageToPhotosAlbum, + saveVideoToPhotosAlbum: saveVideoToPhotosAlbum, + chooseAddress: chooseAddress, + redirectTo: redirectTo +}) + +var index = initUni(shims, protocols) + +export default index diff --git a/packages/uni-mp-alipay/dist/uni.mp.esm.js b/packages/uni-mp-alipay/dist/uni.mp.esm.js new file mode 100644 index 0000000000000000000000000000000000000000..1b354c96109bd4613c50e1e9e41a8d3d83b48de1 --- /dev/null +++ b/packages/uni-mp-alipay/dist/uni.mp.esm.js @@ -0,0 +1,1110 @@ +import { + capitalize, + hasOwn, + isArray, + toNumber, + isPlainObject, + isObject, + isFunction, + extend, + NOOP, + EMPTY_OBJ, + camelize +} from '@vue/shared' +import { stringifyQuery } from '@dcloudio/uni-shared' + +function setModel(target, key, value, modifiers) { + if (isArray(modifiers)) { + if (modifiers.indexOf('trim') !== -1) { + value = value.trim() + } + if (modifiers.indexOf('number') !== -1) { + value = toNumber(value) + } + } + if (!target) { + target = this + } + target[key] = value +} +function setSync(target, key, value) { + if (!target) { + target = this + } + target[key] = value +} +function getOrig(data) { + if (isPlainObject(data)) { + return data.$orig || data + } + return data +} +function map(val, iteratee) { + let ret, i, l, keys, key + if (isArray(val)) { + ret = new Array(val.length) + for (i = 0, l = val.length; i < l; i++) { + ret[i] = iteratee(val[i], i) + } + return ret + } else if (isObject(val)) { + keys = Object.keys(val) + ret = Object.create(null) + for (i = 0, l = keys.length; i < l; i++) { + key = keys[i] + ret[key] = iteratee(val[key], key, i) + } + return ret + } + return [] +} +const MP_METHODS = [ + 'createSelectorQuery', + 'createIntersectionObserver', + 'selectAllComponents', + 'selectComponent' +] +function createEmitFn(oldEmit, ctx) { + return function emit(event, ...args) { + if (ctx.$scope && event) { + ctx.$scope.triggerEvent(event, { __args__: args }) + } + { + const vnode = this.$.vnode + const props = vnode && vnode.props + if (props && props[`on${capitalize(event)}`]) { + return + } + } + return oldEmit.apply(this, [event, ...args]) + } +} +function initBaseInstance(instance, options) { + const ctx = instance.ctx + // mp + ctx.mpType = options.mpType // @deprecated + ctx.$mpType = options.mpType + ctx.$scope = options.mpInstance + // TODO @deprecated + ctx.$mp = {} + if (__VUE_OPTIONS_API__) { + ctx._self = {} + } + // $vm + ctx.$scope.$vm = instance.proxy + // slots + { + Object.defineProperty(instance, 'slots', { + get() { + return this.$scope && this.$scope.props.$slots + } + }) + } + // $emit + instance.emit = createEmitFn(instance.emit, ctx) +} +function initComponentInstance(instance, options) { + initBaseInstance(instance, options) + const ctx = instance.ctx + MP_METHODS.forEach(method => { + ctx[method] = function(...args) { + const mpInstance = ctx.$scope + if (mpInstance && mpInstance[method]) { + return mpInstance[method].apply(mpInstance, args) + } + { + return my[method] && my[method].apply(my, args) + } + } + }) + // TODO other + ctx.__set_model = setModel + ctx.__set_sync = setSync + ctx.__get_orig = getOrig + // TODO + // ctx.__get_style = getStyle + ctx.__map = map +} +function initMocks(instance, mpInstance, mocks) { + const ctx = instance.ctx + mocks.forEach(mock => { + if (hasOwn(mpInstance, mock)) { + ctx[mock] = mpInstance[mock] + } + }) +} + +const PAGE_HOOKS = [ + 'onLoad', + 'onShow', + // 'onReady', // lifetimes.ready + 'onHide', + 'onUnload', + 'onResize', + // 'onPageScroll', // 影响性能,开发者手动注册 + 'onTabItemTap', + 'onReachBottom', + 'onPullDownRefresh', + // 'onShareTimeline', // 右上角菜单,开发者手动注册 + 'onAddToFavorites' + // 'onShareAppMessage' // 右上角菜单,开发者手动注册 +] +function findHooks(vueOptions, hooks = new Set()) { + if (vueOptions) { + Object.keys(vueOptions).forEach(name => { + if (name.indexOf('on') === 0 && isFunction(vueOptions[name])) { + hooks.add(name) + } + }) + if (__VUE_OPTIONS_API__) { + const { extends: extendsOptions, mixins } = vueOptions + if (mixins) { + mixins.forEach(mixin => findHooks(mixin, hooks)) + } + if (extendsOptions) { + findHooks(extendsOptions, hooks) + } + } + } + return hooks +} +function initHook(mpOptions, hook, excludes) { + if (excludes.indexOf(hook) === -1 && !hasOwn(mpOptions, hook)) { + mpOptions[hook] = function(args) { + return this.$vm && this.$vm.$callHook(hook, args) + } + } +} +const EXCLUDE_HOOKS = ['onReady'] +function initHooks(mpOptions, hooks, excludes = EXCLUDE_HOOKS) { + hooks.forEach(hook => initHook(mpOptions, hook, excludes)) +} +function initUnknownHooks(mpOptions, vueOptions, excludes = EXCLUDE_HOOKS) { + findHooks(vueOptions).forEach(hook => initHook(mpOptions, hook, excludes)) +} + +const HOOKS = [ + 'onShow', + 'onHide', + 'onError', + 'onThemeChange', + 'onPageNotFound', + 'onUnhandledRejection' +] +function parseApp(instance, parseAppOptions) { + const internalInstance = instance.$ + const appOptions = { + globalData: (instance.$options && instance.$options.globalData) || {}, + $vm: instance, + onLaunch(options) { + const ctx = internalInstance.ctx + if (this.$vm && ctx.$scope) { + // 已经初始化过了,主要是为了百度,百度 onShow 在 onLaunch 之前 + return + } + initBaseInstance(internalInstance, { + mpType: 'app', + mpInstance: this, + slots: [] + }) + ctx.globalData = this.globalData + instance.$callHook('onLaunch', options) + } + } + const vueOptions = instance.$.type + initHooks(appOptions, HOOKS) + initUnknownHooks(appOptions, vueOptions) + if (__VUE_OPTIONS_API__) { + const methods = vueOptions.methods + methods && extend(appOptions, methods) + } + if (parseAppOptions) { + parseAppOptions.parse(appOptions) + } + return appOptions +} +function initCreateApp(parseAppOptions) { + return function createApp(vm) { + return App(parseApp(vm, parseAppOptions)) + } +} + +function initVueIds(vueIds, mpInstance) { + if (!vueIds) { + return + } + const ids = vueIds.split(',') + const len = ids.length + if (len === 1) { + mpInstance._$vueId = ids[0] + } else if (len === 2) { + mpInstance._$vueId = ids[0] + mpInstance._$vuePid = ids[1] + } +} +function initWxsCallMethods(methods, wxsCallMethods) { + if (!isArray(wxsCallMethods)) { + return + } + wxsCallMethods.forEach(callMethod => { + methods[callMethod] = function(args) { + return this.$vm[callMethod](args) + } + }) +} +function findVmByVueId(instance, vuePid) { + // TODO vue3 中 没有 $children + const $children = instance.$children + // 优先查找直属(反向查找:https://github.com/dcloudio/uni-app/issues/1200) + for (let i = $children.length - 1; i >= 0; i--) { + const childVm = $children[i] + if (childVm.$scope._$vueId === vuePid) { + return childVm + } + } + // 反向递归查找 + let parentVm + for (let i = $children.length - 1; i >= 0; i--) { + parentVm = findVmByVueId($children[i], vuePid) + if (parentVm) { + return parentVm + } + } +} + +const PROP_TYPES = [String, Number, Boolean, Object, Array, null] +function parsePropType(key, type, defaultValue) { + // [String]=>String + if (isArray(type) && type.length === 1) { + return type[0] + } + return type +} +function initDefaultProps(isBehavior = false) { + const properties = {} + if (!isBehavior) { + properties.vueId = { + type: String, + value: '' + } + // 小程序不能直接定义 $slots 的 props,所以通过 vueSlots 转换到 $slots + properties.vueSlots = { + type: null, + value: [], + observer: function(newVal) { + const $slots = Object.create(null) + newVal.forEach(slotName => { + $slots[slotName] = true + }) + this.setData({ + $slots + }) + } + } + } + return properties +} +function createProperty(key, prop) { + { + return prop + } +} +function initProps(mpComponentOptions, rawProps, isBehavior = false) { + const properties = initDefaultProps(isBehavior) + if (isArray(rawProps)) { + rawProps.forEach(key => { + properties[key] = createProperty(key, { + type: null + }) + }) + } else if (isPlainObject(rawProps)) { + Object.keys(rawProps).forEach(key => { + const opts = rawProps[key] + if (isPlainObject(opts)) { + // title:{type:String,default:''} + let value = opts.default + if (isFunction(value)) { + value = value() + } + const type = opts.type + opts.type = parsePropType(key, type) + properties[key] = createProperty(key, { + type: PROP_TYPES.indexOf(type) !== -1 ? type : null, + value + }) + } else { + // content:String + const type = parsePropType(key, opts) + properties[key] = createProperty(key, { + type: PROP_TYPES.indexOf(type) !== -1 ? type : null + }) + } + }) + } + mpComponentOptions.properties = properties +} + +function initData(vueOptions) { + let data = vueOptions.data || {} + if (typeof data === 'function') { + try { + const appConfig = getApp().$vm.$.appContext.config + data = data.call(appConfig.globalProperties) + } catch (e) { + if (process.env.VUE_APP_DEBUG) { + console.warn( + '根据 Vue 的 data 函数初始化小程序 data 失败,请尽量确保 data 函数中不访问 vm 对象,否则可能影响首次数据渲染速度。', + data, + e + ) + } + } + } else { + try { + // 对 data 格式化 + data = JSON.parse(JSON.stringify(data)) + } catch (e) {} + } + if (!isPlainObject(data)) { + data = {} + } + return data +} +function initBehaviors(vueOptions, initBehavior) { + const vueBehaviors = vueOptions.behaviors + const vueExtends = vueOptions.extends + const vueMixins = vueOptions.mixins + let vueProps = vueOptions.props + if (!vueProps) { + vueOptions.props = vueProps = [] + } + const behaviors = [] + if (isArray(vueBehaviors)) { + vueBehaviors.forEach(behavior => { + behaviors.push(behavior.replace('uni://', `${__PLATFORM_PREFIX__}://`)) + if (behavior === 'uni://form-field') { + if (isArray(vueProps)) { + vueProps.push('name') + vueProps.push('value') + } else { + vueProps.name = { + type: String, + default: '' + } + vueProps.value = { + type: [String, Number, Boolean, Array, Object, Date], + default: '' + } + } + } + }) + } + if (isPlainObject(vueExtends) && vueExtends.props) { + const behavior = {} + initProps(behavior, vueExtends.props, true) + behaviors.push(initBehavior(behavior)) + } + if (isArray(vueMixins)) { + vueMixins.forEach(vueMixin => { + if (isPlainObject(vueMixin) && vueMixin.props) { + const behavior = {} + initProps(behavior, vueMixin.props, true) + behaviors.push(initBehavior(behavior)) + } + }) + } + return behaviors +} + +function getValue(obj, path) { + const parts = path.split('.') + let key = parts[0] + if (key.indexOf('__$n') === 0) { + //number index + key = parseInt(key.replace('__$n', '')) + } + if (parts.length === 1) { + return obj[key] + } + return getValue(obj[key], parts.slice(1).join('.')) +} +function getExtraValue(instance, dataPathsArray) { + let context = instance + dataPathsArray.forEach(dataPathArray => { + const dataPath = dataPathArray[0] + const value = dataPathArray[2] + if (dataPath || typeof value !== 'undefined') { + // ['','',index,'disable'] + const propPath = dataPathArray[1] + const valuePath = dataPathArray[3] + let vFor + if (Number.isInteger(dataPath)) { + vFor = dataPath + } else if (!dataPath) { + vFor = context + } else if (typeof dataPath === 'string' && dataPath) { + if (dataPath.indexOf('#s#') === 0) { + vFor = dataPath.substr(3) + } else { + vFor = getValue(context, dataPath) + } + } + if (Number.isInteger(vFor)) { + context = value + } else if (!propPath) { + context = vFor[value] + } else { + if (isArray(vFor)) { + context = vFor.find(vForItem => { + return getValue(vForItem, propPath) === value + }) + } else if (isPlainObject(vFor)) { + context = Object.keys(vFor).find(vForKey => { + return getValue(vFor[vForKey], propPath) === value + }) + } else { + console.error('v-for 暂不支持循环数据:', vFor) + } + } + if (valuePath) { + context = getValue(context, valuePath) + } + } + }) + return context +} +function processEventExtra(instance, extra, event) { + const extraObj = {} + if (isArray(extra) && extra.length) { + /** + *[ + * ['data.items', 'data.id', item.data.id], + * ['metas', 'id', meta.id] + *], + *[ + * ['data.items', 'data.id', item.data.id], + * ['metas', 'id', meta.id] + *], + *'test' + */ + extra.forEach((dataPath, index) => { + if (typeof dataPath === 'string') { + if (!dataPath) { + // model,prop.sync + extraObj['$' + index] = instance + } else { + if (dataPath === '$event') { + // $event + extraObj['$' + index] = event + } else if (dataPath === 'arguments') { + if (event.detail && event.detail.__args__) { + extraObj['$' + index] = event.detail.__args__ + } else { + extraObj['$' + index] = [event] + } + } else if (dataPath.indexOf('$event.') === 0) { + // $event.target.value + extraObj['$' + index] = getValue( + event, + dataPath.replace('$event.', '') + ) + } else { + extraObj['$' + index] = getValue(instance, dataPath) + } + } + } else { + extraObj['$' + index] = getExtraValue(instance, dataPath) + } + }) + } + return extraObj +} +function getObjByArray(arr) { + const obj = {} + for (let i = 1; i < arr.length; i++) { + const element = arr[i] + obj[element[0]] = element[1] + } + return obj +} +function processEventArgs( + instance, + event, + args = [], + extra = [], + isCustom, + methodName +) { + let isCustomMPEvent = false // wxcomponent 组件,传递原始 event 对象 + if (isCustom) { + // 自定义事件 + isCustomMPEvent = + event.currentTarget && + event.currentTarget.dataset && + event.currentTarget.dataset.comType === 'wx' + if (!args.length) { + // 无参数,直接传入 event 或 detail 数组 + if (isCustomMPEvent) { + return [event] + } + return event.detail.__args__ || event.detail + } + } + const extraObj = processEventExtra(instance, extra, event) + const ret = [] + args.forEach(arg => { + if (arg === '$event') { + if (methodName === '__set_model' && !isCustom) { + // input v-model value + ret.push(event.target.value) + } else { + if (isCustom && !isCustomMPEvent) { + ret.push(event.detail.__args__[0]) + } else { + // wxcomponent 组件或内置组件 + ret.push(event) + } + } + } else { + if (isArray(arg) && arg[0] === 'o') { + ret.push(getObjByArray(arg)) + } else if (typeof arg === 'string' && hasOwn(extraObj, arg)) { + ret.push(extraObj[arg]) + } else { + ret.push(arg) + } + } + }) + return ret +} +function wrapper(event) { + event.stopPropagation = NOOP + event.preventDefault = NOOP + event.target = event.target || {} + if (!hasOwn(event, 'detail')) { + event.detail = {} + } + if (hasOwn(event, 'markerId')) { + event.detail = typeof event.detail === 'object' ? event.detail : {} + event.detail.markerId = event.markerId + } + if (isPlainObject(event.detail)) { + event.target = Object.assign({}, event.target, event.detail) + } + return event +} +const ONCE = '~' +const CUSTOM = '^' +function matchEventType(eventType, optType) { + return ( + eventType === optType || + (optType === 'regionchange' && + (eventType === 'begin' || eventType === 'end')) + ) +} +function handleEvent(event) { + event = wrapper(event) + // [['tap',[['handle',[1,2,a]],['handle1',[1,2,a]]]]] + const dataset = (event.currentTarget || event.target).dataset + if (!dataset) { + return console.warn('事件信息不存在') + } + const eventOpts = dataset.eventOpts || dataset['event-opts'] // 支付宝 web-view 组件 dataset 非驼峰 + if (!eventOpts) { + return console.warn('事件信息不存在') + } + // [['handle',[1,2,a]],['handle1',[1,2,a]]] + const eventType = event.type + const ret = [] + eventOpts.forEach(eventOpt => { + let type = eventOpt[0] + const eventsArray = eventOpt[1] + const isCustom = type.charAt(0) === CUSTOM + type = isCustom ? type.slice(1) : type + const isOnce = type.charAt(0) === ONCE + type = isOnce ? type.slice(1) : type + if (eventsArray && matchEventType(eventType, type)) { + eventsArray.forEach(eventArray => { + const methodName = eventArray[0] + if (methodName) { + let handlerCtx = this.$vm + if ( + handlerCtx.$options.generic && + handlerCtx.$parent && + handlerCtx.$parent.$parent + ) { + // mp-weixin,mp-toutiao 抽象节点模拟 scoped slots + handlerCtx = handlerCtx.$parent.$parent + } + if (methodName === '$emit') { + handlerCtx.$emit.apply( + handlerCtx, + processEventArgs( + this.$vm, + event, + eventArray[1], + eventArray[2], + isCustom, + methodName + ) + ) + return + } + const handler = handlerCtx[methodName] + if (!isFunction(handler)) { + throw new Error(` _vm.${methodName} is not a function`) + } + if (isOnce) { + if (handler.once) { + return + } + handler.once = true + } + ret.push( + handler.apply( + handlerCtx, + processEventArgs( + this.$vm, + event, + eventArray[1], + eventArray[2], + isCustom, + methodName + ) + ) + ) + } + }) + } + }) + if ( + eventType === 'input' && + ret.length === 1 && + typeof ret[0] !== 'undefined' + ) { + return ret[0] + } +} + +let $createComponentFn +let $destroyComponentFn +function $createComponent(initialVNode, options) { + if (!$createComponentFn) { + $createComponentFn = getApp().$vm.$createComponent + } + return $createComponentFn(initialVNode, options) +} +function $destroyComponent(instance) { + if (!$destroyComponentFn) { + $destroyComponentFn = getApp().$vm.$destroyComponent + } + return $destroyComponentFn(instance) +} + +function onAliAuthError(method, $event) { + $event.type = 'getphonenumber' + $event.detail.errMsg = + 'getPhoneNumber:fail Error: ' + + $event.detail.errorMessage(this)[method]($event) +} +function onAliGetAuthorize(method, $event) { + my.getPhoneNumber({ + success: res => { + $event.type = 'getphonenumber' + const response = JSON.parse(res.response).response + if (response.code === '10000') { + // success + $event.detail.errMsg = 'getPhoneNumber:ok' + $event.detail.encryptedData = res.response + } else { + $event.detail.errMsg = 'getPhoneNumber:fail Error: ' + res.response + } + this[method]($event) + }, + fail: () => { + $event.type = 'getphonenumber' + $event.detail.errMsg = 'getPhoneNumber:fail' + this[method]($event) + } + }) +} +function parse(appOptions) { + const oldOnLaunch = appOptions.onLaunch + appOptions.onLaunch = function onLaunch(options) { + oldOnLaunch.call(this, options) + if (!this.$vm) { + return + } + const globalProperties = this.$vm.$app.config.globalProperties + if (!globalProperties.$onAliAuthError) { + globalProperties.$onAliAuthError = onAliAuthError + globalProperties.$onAliGetAuthorize = onAliGetAuthorize + } + } +} + +var parseAppOptions = /*#__PURE__*/ Object.freeze({ + __proto__: null, + parse: parse +}) + +function handleLink(event) { + // detail 是微信,value 是百度(dipatch) + const detail = event.detail || event.value + const vuePid = detail.vuePid + let parentVm + if (vuePid) { + parentVm = findVmByVueId(this.$vm, vuePid) + } + if (!parentVm) { + parentVm = this.$vm + } + detail.parent = parentVm +} + +function equal(a, b) { + if (a === b) return true + if (a && b && typeof a === 'object' && typeof b === 'object') { + const arrA = isArray(a) + const arrB = isArray(b) + let i, length, key + if (arrA && arrB) { + length = a.length + if (length !== b.length) return false + for (i = length; i-- !== 0; ) { + if (!equal(a[i], b[i])) return false + } + return true + } + if (arrA !== arrB) return false + const dateA = a instanceof Date + const dateB = b instanceof Date + if (dateA !== dateB) return false + if (dateA && dateB) return a.getTime() === b.getTime() + const regexpA = a instanceof RegExp + const regexpB = b instanceof RegExp + if (regexpA !== regexpB) return false + if (regexpA && regexpB) return a.toString() === b.toString() + const keys = Object.keys(a) + length = keys.length + if (length !== Object.keys(b).length) { + return false + } + for (i = length; i-- !== 0; ) { + if (!hasOwn(b, keys[i])) return false + } + for (i = length; i-- !== 0; ) { + key = keys[i] + if (!equal(a[key], b[key])) return false + } + return true + } + return false +} + +const isComponent2 = my.canIUse('component2') +const mocks = ['$id'] +const customizeRE = /:/g +function customize(str) { + return camelize(str.replace(customizeRE, '-')) +} +function initBehavior({ properties }) { + const props = {} + Object.keys(properties).forEach(key => { + props[key] = properties[key].value + }) + return { + props + } +} +function initRelation(mpInstance, detail) { + mpInstance.props.onVueInit(detail) +} +function initSpecialMethods(mpInstance) { + if (!mpInstance.$vm) { + return + } + let path = mpInstance.is || mpInstance.route + if (!path) { + return + } + if (path.indexOf('/') === 0) { + path = path.substr(1) + } + const specialMethods = my.specialMethods && my.specialMethods[path] + if (specialMethods) { + specialMethods.forEach(method => { + if (isFunction(mpInstance.$vm[method])) { + mpInstance[method] = function(event) { + if (hasOwn(event, 'markerId')) { + event.detail = typeof event.detail === 'object' ? event.detail : {} + event.detail.markerId = event.markerId + } + // TODO normalizeEvent + mpInstance.$vm[method](event) + } + } + }) + } +} +function initChildVues(mpInstance) { + // 此时需保证当前 mpInstance 已经存在 $vm + if (!mpInstance.$vm) { + return + } + const childVues = mpInstance._$childVues + if (childVues) { + childVues.forEach(relationOptions => { + // 父子关系 + handleLink.call(mpInstance, { + detail: relationOptions + }) + const { mpInstance: childMPInstance, createComponent } = relationOptions + childMPInstance.$vm = createComponent(relationOptions.parent) + initSpecialMethods(childMPInstance) + if (relationOptions.parent) { + handleRef.call(relationOptions.parent.$scope, childMPInstance) + } + initChildVues(childMPInstance) + childMPInstance.$vm.$callHook('mounted') + childMPInstance.$vm.$callHook('onReady') + }) + } + delete mpInstance._$childVues +} +// TODO vue3 +function handleRef(ref) { + if (!ref) { + return + } + const refName = ref.props['data-ref'] + const refInForName = ref.props['data-ref-in-for'] + if (!refName && !refInForName) { + return + } + const instance = this.$vm.$ + const refs = + instance.refs === EMPTY_OBJ ? (instance.refs = {}) : instance.refs + if (refName) { + refs[refName] = ref.$vm || ref + } else if (refInForName) { + ;(refs[refInForName] || (refs[refInForName] = [])).push(ref.$vm || ref) + } +} +function triggerEvent(type, detail) { + const handler = this.props[customize('on-' + type)] + if (!handler) { + return + } + const eventOpts = this.props['data-event-opts'] + const target = { + dataset: { + eventOpts + } + } + handler({ + type: customize(type), + target, + currentTarget: target, + detail + }) +} +const IGNORES = ['$slots', '$scopedSlots'] +function createObserver(isDidUpdate = false) { + return function observe(props) { + const prevProps = isDidUpdate ? props : this.props + const nextProps = isDidUpdate ? this.props : props + if (equal(prevProps, nextProps)) { + return + } + Object.keys(prevProps).forEach(name => { + if (IGNORES.indexOf(name) === -1) { + const prevValue = prevProps[name] + const nextValue = nextProps[name] + if ( + !isFunction(prevValue) && + !isFunction(nextValue) && + !equal(prevValue, nextValue) + ) { + this.$vm.$.props[name] = nextProps[name] + } + } + }) + } +} +const handleLink$1 = (function() { + if (isComponent2) { + return function handleLink$1(detail) { + return handleLink.call(this, { + detail + }) + } + } + return function handleLink$1(detail) { + if (this.$vm && this.$vm.$.isMounted) { + // 父已初始化 + return handleLink.call(this, { + detail + }) + } + ;(this._$childVues || (this._$childVues = [])).unshift(detail) + } +})() +function createVueComponent(mpType, mpInstance, vueOptions, parent) { + return $createComponent( + { + type: vueOptions, + props: mpInstance.props + }, + { + mpType, + mpInstance, + parentComponent: parent && parent.$, + onBeforeSetup(instance, options) { + initMocks(instance, mpInstance, mocks) + initComponentInstance(instance, options) + } + } + ) +} + +function createPage(vueOptions) { + vueOptions = vueOptions.default || vueOptions + const pageOptions = { + onLoad(query) { + this.options = query + this.$page = { + fullPath: '/' + this.route + stringifyQuery(query) + } + // 初始化 vue 实例 + this.$vm = createVueComponent('page', this, vueOptions) + initSpecialMethods(this) + this.$vm.$callHook('onLoad', query) + }, + onReady() { + initChildVues(this) + this.$vm.$callHook('mounted') + this.$vm.$callHook('onReady') + }, + onUnload() { + if (this.$vm) { + this.$vm.$callHook('onUnload') + $destroyComponent(this.$vm) + } + }, + events: { + // 支付宝小程序有些页面事件只能放在events下 + onBack() { + this.$vm.$callHook('onBackPress') + } + }, + __r: handleRef, + __e: handleEvent, + __l: handleLink$1 + } + if (__VUE_OPTIONS_API__) { + pageOptions.data = initData(vueOptions) + } + initHooks(pageOptions, PAGE_HOOKS) + initUnknownHooks(pageOptions, vueOptions) + initWxsCallMethods(pageOptions, vueOptions.wxsCallMethods) + return Page(pageOptions) +} + +function initComponentProps(rawProps) { + const propertiesOptions = { + properties: {} + } + initProps(propertiesOptions, rawProps, false) + const properties = propertiesOptions.properties + const props = { + onVueInit: function() {} + } + Object.keys(properties).forEach(key => { + if (key !== 'vueSlots') { + props[key] = properties[key].value + } + }) + return props +} +function initVm(mpInstance, createComponent) { + if (mpInstance.$vm) { + return + } + const properties = mpInstance.props + initVueIds(properties.vueId, mpInstance) + const relationOptions = { + vuePid: mpInstance._$vuePid, + mpInstance, + createComponent + } + if (isComponent2) { + // 处理父子关系 + initRelation(mpInstance, relationOptions) + // 初始化 vue 实例 + mpInstance.$vm = createComponent(relationOptions.parent) + } else { + // 处理父子关系 + initRelation(mpInstance, relationOptions) + if (relationOptions.parent) { + // 父组件已经初始化,直接初始化子,否则放到父组件的 didMount 中处理 + // 初始化 vue 实例 + mpInstance.$vm = createComponent(relationOptions.parent) + handleRef.call(relationOptions.parent.$scope, mpInstance) + initChildVues(mpInstance) + mpInstance.$vm.$callHook('mounted') + } + } +} +function createComponent(vueOptions) { + vueOptions = vueOptions.default || vueOptions + const mpComponentOptions = { + props: initComponentProps(vueOptions.props), + didMount() { + const createComponent = parent => { + return createVueComponent('component', this, vueOptions, parent) + } + if (my.dd) { + // 钉钉小程序底层基础库有 bug,组件嵌套使用时,在 didMount 中无法及时调用 props 中的方法 + setTimeout(() => { + initVm(this, createComponent) + }, 4) + } else { + initVm(this, createComponent) + } + initSpecialMethods(this) + if (isComponent2) { + this.$vm.$callHook('mounted') + } + }, + didUnmount() { + $destroyComponent(this.$vm) + }, + methods: { + __r: handleRef, + __e: handleEvent, + __l: handleLink$1, + triggerEvent + } + } + if (__VUE_OPTIONS_API__) { + mpComponentOptions.data = initData(vueOptions) + mpComponentOptions.mixins = initBehaviors(vueOptions, initBehavior) + } + if (isComponent2) { + mpComponentOptions.onInit = function onInit() { + initVm(this, parent => { + return createVueComponent('component', this, vueOptions, parent) + }) + } + mpComponentOptions.deriveDataFromProps = createObserver() + } else { + mpComponentOptions.didUpdate = createObserver(true) + } + initWxsCallMethods(mpComponentOptions.methods, vueOptions.wxsCallMethods) + return Component(mpComponentOptions) +} + +const createApp = initCreateApp(parseAppOptions) + +export { createApp, createComponent, createPage } diff --git a/packages/uni-mp-baidu/dist/uni.api.esm.js b/packages/uni-mp-baidu/dist/uni.api.esm.js new file mode 100644 index 0000000000000000000000000000000000000000..4d2ff7d484e92685c95c14fa6d0814cdf54e3e5e --- /dev/null +++ b/packages/uni-mp-baidu/dist/uni.api.esm.js @@ -0,0 +1,636 @@ +import { + isArray, + isPromise, + isFunction, + isPlainObject, + hasOwn, + isString +} from '@vue/shared' + +function createApi(fn, validate) { + if (process.env.NODE_ENV !== 'production' && validate); + return fn +} + +const Upx2pxProtocol = [ + { + name: 'upx', + type: [Number, String], + required: true + } +] + +const EPS = 1e-4 +const BASE_DEVICE_WIDTH = 750 +let isIOS = false +let deviceWidth = 0 +let deviceDPR = 0 +function checkDeviceWidth() { + const { platform, pixelRatio, windowWidth } = swan.getSystemInfoSync() + deviceWidth = windowWidth + deviceDPR = pixelRatio + isIOS = platform === 'ios' +} +const upx2px = createApi((number, newDeviceWidth) => { + if (deviceWidth === 0) { + checkDeviceWidth() + } + number = Number(number) + if (number === 0) { + return 0 + } + let result = (number / BASE_DEVICE_WIDTH) * (newDeviceWidth || deviceWidth) + if (result < 0) { + result = -result + } + result = Math.floor(result + EPS) + if (result === 0) { + if (deviceDPR === 1 || !isIOS) { + result = 1 + } else { + result = 0.5 + } + } + return number < 0 ? -result : result +}, Upx2pxProtocol) + +var HOOKS +;(function(HOOKS) { + HOOKS['INVOKE'] = 'invoke' + HOOKS['SUCCESS'] = 'success' + HOOKS['FAIL'] = 'fail' + HOOKS['COMPLETE'] = 'complete' + HOOKS['RETURN_VALUE'] = 'returnValue' +})(HOOKS || (HOOKS = {})) +const globalInterceptors = {} +const scopedInterceptors = {} +function wrapperHook(hook) { + return function(data) { + return hook(data) || data + } +} +function queue(hooks, data) { + let promise = false + for (let i = 0; i < hooks.length; i++) { + const hook = hooks[i] + if (promise) { + promise = Promise.resolve(wrapperHook(hook)) + } else { + const res = hook(data) + if (isPromise(res)) { + promise = Promise.resolve(res) + } + if (res === false) { + return { + then() {}, + catch() {} + } + } + } + } + return ( + promise || { + then(callback) { + return callback(data) + }, + catch() {} + } + ) +} +function wrapperOptions(interceptors, options = {}) { + ;[HOOKS.SUCCESS, HOOKS.FAIL, HOOKS.COMPLETE].forEach(name => { + const hooks = interceptors[name] + if (!isArray(hooks)) { + return + } + const oldCallback = options[name] + options[name] = function callbackInterceptor(res) { + queue(hooks, res).then(res => { + return (isFunction(oldCallback) && oldCallback(res)) || res + }) + } + }) + return options +} +function wrapperReturnValue(method, returnValue) { + const returnValueHooks = [] + if (isArray(globalInterceptors.returnValue)) { + returnValueHooks.push(...globalInterceptors.returnValue) + } + const interceptor = scopedInterceptors[method] + if (interceptor && isArray(interceptor.returnValue)) { + returnValueHooks.push(...interceptor.returnValue) + } + returnValueHooks.forEach(hook => { + returnValue = hook(returnValue) || returnValue + }) + return returnValue +} +function getApiInterceptorHooks(method) { + const interceptor = Object.create(null) + Object.keys(globalInterceptors).forEach(hook => { + if (hook !== 'returnValue') { + interceptor[hook] = globalInterceptors[hook].slice() + } + }) + const scopedInterceptor = scopedInterceptors[method] + if (scopedInterceptor) { + Object.keys(scopedInterceptor).forEach(hook => { + if (hook !== 'returnValue') { + interceptor[hook] = (interceptor[hook] || []).concat( + scopedInterceptor[hook] + ) + } + }) + } + return interceptor +} +function invokeApi(method, api, options, ...params) { + const interceptor = getApiInterceptorHooks(method) + if (interceptor && Object.keys(interceptor).length) { + if (isArray(interceptor.invoke)) { + const res = queue(interceptor.invoke, options) + return res.then(options => { + return api(wrapperOptions(interceptor, options), ...params) + }) + } else { + return api(wrapperOptions(interceptor, options), ...params) + } + } + return api(options, ...params) +} + +const AddInterceptorProtocol = [ + { + name: 'method', + type: [String, Object], + required: true + } +] +const RemoveInterceptorProtocol = AddInterceptorProtocol + +function mergeInterceptorHook(interceptors, interceptor) { + Object.keys(interceptor).forEach(hook => { + if (isFunction(interceptor[hook])) { + interceptors[hook] = mergeHook(interceptors[hook], interceptor[hook]) + } + }) +} +function removeInterceptorHook(interceptors, interceptor) { + if (!interceptors || !interceptor) { + return + } + Object.keys(interceptor).forEach(hook => { + if (isFunction(interceptor[hook])) { + removeHook(interceptors[hook], interceptor[hook]) + } + }) +} +function mergeHook(parentVal, childVal) { + const res = childVal + ? parentVal + ? parentVal.concat(childVal) + : isArray(childVal) + ? childVal + : [childVal] + : parentVal + return res ? dedupeHooks(res) : res +} +function dedupeHooks(hooks) { + const res = [] + for (let i = 0; i < hooks.length; i++) { + if (res.indexOf(hooks[i]) === -1) { + res.push(hooks[i]) + } + } + return res +} +function removeHook(hooks, hook) { + if (!hooks) { + return + } + const index = hooks.indexOf(hook) + if (index !== -1) { + hooks.splice(index, 1) + } +} +const addInterceptor = createApi((method, interceptor) => { + if (typeof method === 'string' && isPlainObject(interceptor)) { + mergeInterceptorHook( + scopedInterceptors[method] || (scopedInterceptors[method] = {}), + interceptor + ) + } else if (isPlainObject(method)) { + mergeInterceptorHook(globalInterceptors, method) + } +}, AddInterceptorProtocol) +const removeInterceptor = createApi((method, interceptor) => { + if (typeof method === 'string') { + if (isPlainObject(interceptor)) { + removeInterceptorHook(scopedInterceptors[method], interceptor) + } else { + delete scopedInterceptors[method] + } + } else if (isPlainObject(method)) { + removeInterceptorHook(globalInterceptors, method) + } +}, RemoveInterceptorProtocol) + +const SYNC_API_RE = /^\$|sendNativeEvent|restoreGlobal|getCurrentSubNVue|getMenuButtonBoundingClientRect|^report|interceptors|Interceptor$|getSubNVueById|requireNativePlugin|upx2px|hideKeyboard|canIUse|^create|Sync$|Manager$|base64ToArrayBuffer|arrayBufferToBase64/ +const CONTEXT_API_RE = /^create|Manager$/ +// Context例外情况 +const CONTEXT_API_RE_EXC = ['createBLEConnection'] +// 同步例外情况 +const ASYNC_API = ['createBLEConnection'] +const CALLBACK_API_RE = /^on|^off/ +function isContextApi(name) { + return CONTEXT_API_RE.test(name) && CONTEXT_API_RE_EXC.indexOf(name) === -1 +} +function isSyncApi(name) { + return SYNC_API_RE.test(name) && ASYNC_API.indexOf(name) === -1 +} +function isCallbackApi(name) { + return CALLBACK_API_RE.test(name) && name !== 'onPush' +} +function handlePromise(promise) { + if (!__UNI_PROMISE_API__) { + return promise + } + return promise + .then(data => { + return [null, data] + }) + .catch(err => [err]) +} +function shouldPromise(name) { + if (isContextApi(name) || isSyncApi(name) || isCallbackApi(name)) { + return false + } + return true +} +/* eslint-disable no-extend-native */ +if (!Promise.prototype.finally) { + Promise.prototype.finally = function(onfinally) { + const promise = this.constructor + return this.then( + value => promise.resolve(onfinally && onfinally()).then(() => value), + reason => + promise.resolve(onfinally && onfinally()).then(() => { + throw reason + }) + ) + } +} +function promisify(name, api) { + if (!shouldPromise(name)) { + return api + } + if (!isFunction(api)) { + return api + } + return function promiseApi(options = {}, ...params) { + if ( + isFunction(options.success) || + isFunction(options.fail) || + isFunction(options.complete) + ) { + return wrapperReturnValue(name, invokeApi(name, api, options, ...params)) + } + return wrapperReturnValue( + name, + handlePromise( + new Promise((resolve, reject) => { + invokeApi( + name, + api, + Object.assign({}, options, { + success: resolve, + fail: reject + }), + ...params + ) + }) + ) + ) + } +} + +const CALLBACKS = ['success', 'fail', 'cancel', 'complete'] +function initWrapper(protocols) { + function processCallback(methodName, method, returnValue) { + return function(res) { + return method(processReturnValue(methodName, res, returnValue)) + } + } + function processArgs( + methodName, + fromArgs, + argsOption = {}, + returnValue = {}, + keepFromArgs = false + ) { + if (isPlainObject(fromArgs)) { + // 一般 api 的参数解析 + const toArgs = keepFromArgs === true ? fromArgs : {} // returnValue 为 false 时,说明是格式化返回值,直接在返回值对象上修改赋值 + if (isFunction(argsOption)) { + argsOption = argsOption(fromArgs, toArgs) || {} + } + for (const key in fromArgs) { + if (hasOwn(argsOption, key)) { + let keyOption = argsOption[key] + if (isFunction(keyOption)) { + keyOption = keyOption(fromArgs[key], fromArgs, toArgs) + } + if (!keyOption) { + // 不支持的参数 + console.warn(`百度小程序 ${methodName} 暂不支持 ${key}`) + } else if (isString(keyOption)) { + // 重写参数 key + toArgs[keyOption] = fromArgs[key] + } else if (isPlainObject(keyOption)) { + // {name:newName,value:value}可重新指定参数 key:value + toArgs[keyOption.name ? keyOption.name : key] = keyOption.value + } + } else if (CALLBACKS.indexOf(key) !== -1) { + const callback = fromArgs[key] + if (isFunction(callback)) { + toArgs[key] = processCallback(methodName, callback, returnValue) + } + } else { + if (!keepFromArgs && !hasOwn(toArgs, key)) { + toArgs[key] = fromArgs[key] + } + } + } + return toArgs + } else if (isFunction(fromArgs)) { + fromArgs = processCallback(methodName, fromArgs, returnValue) + } + return fromArgs + } + function processReturnValue( + methodName, + res, + returnValue, + keepReturnValue = false + ) { + if (isFunction(protocols.returnValue)) { + // 处理通用 returnValue + res = protocols.returnValue(methodName, res) + } + return processArgs(methodName, res, returnValue, {}, keepReturnValue) + } + return function wrapper(methodName, method) { + if (!hasOwn(protocols, methodName)) { + return method + } + const protocol = protocols[methodName] + if (!protocol) { + // 暂不支持的 api + return function() { + console.error(`百度小程序 暂不支持${methodName}`) + } + } + return function(arg1, arg2) { + // 目前 api 最多两个参数 + let options = protocol + if (isFunction(protocol)) { + options = protocol(arg1) + } + arg1 = processArgs(methodName, arg1, options.args, options.returnValue) + const args = [arg1] + if (typeof arg2 !== 'undefined') { + args.push(arg2) + } + const returnValue = swan[options.name || methodName].apply(swan, args) + if (isSyncApi(methodName)) { + // 同步 api + return processReturnValue( + methodName, + returnValue, + options.returnValue, + isContextApi(methodName) + ) + } + return returnValue + } + } +} + +const baseApis = { upx2px, addInterceptor, removeInterceptor } +function initUni(api, protocols) { + const wrapper = initWrapper(protocols) + const UniProxyHandlers = { + get(target, key) { + if (hasOwn(target, key)) { + return target[key] + } + if (hasOwn(api, key)) { + return promisify(key, api[key]) + } + if (hasOwn(baseApis, key)) { + return promisify(key, baseApis[key]) + } + // event-api + // provider-api? + return promisify(key, wrapper(key, swan[key])) + } + } + return new Proxy({}, UniProxyHandlers) +} + +function initGetProvider(providers) { + return function getProvider({ service, success, fail, complete }) { + let res + if (providers[service]) { + res = { + errMsg: 'getProvider:ok', + service, + provider: providers[service] + } + isFunction(success) && success(res) + } else { + res = { + errMsg: 'getProvider:fail:服务[' + service + ']不存在' + } + isFunction(fail) && fail(res) + } + isFunction(complete) && complete(res) + } +} + +const previewImage = { + args(fromArgs, toArgs) { + let currentIndex = parseInt(fromArgs.current) + if (isNaN(currentIndex)) { + return + } + const urls = fromArgs.urls + if (!isArray(urls)) { + return + } + const len = urls.length + if (!len) { + return + } + if (currentIndex < 0) { + currentIndex = 0 + } else if (currentIndex >= len) { + currentIndex = len - 1 + } + if (currentIndex > 0) { + toArgs.current = urls[currentIndex] + toArgs.urls = urls.filter( + (item, index) => + index < currentIndex ? item !== urls[currentIndex] : true + ) + } else { + toArgs.current = urls[0] + } + return { + indicator: false, + loop: false + } + } +} +function addSafeAreaInsets(fromRes, toRes) { + if (fromRes.safeArea) { + const safeArea = fromRes.safeArea + toRes.safeAreaInsets = { + top: safeArea.top, + left: safeArea.left, + right: fromRes.windowWidth - safeArea.right, + bottom: fromRes.windowHeight - safeArea.bottom + } + } +} +const getSystemInfo = { + returnValue: addSafeAreaInsets +} +const getSystemInfoSync = getSystemInfo +const redirectTo = {} + +const getProvider = initGetProvider({ + oauth: ['baidu'], + share: ['baidu'], + payment: ['baidu'], + push: ['baidu'] +}) +function requestPayment(params) { + let parseError = false + if (typeof params.orderInfo === 'string') { + try { + params.orderInfo = JSON.parse(params.orderInfo) + } catch (e) { + parseError = true + } + } + if (parseError) { + params.fail && + params.fail({ + errMsg: + 'requestPayment:fail: 参数 orderInfo 数据结构不正确,参考:https://uniapp.dcloud.io/api/plugins/payment?id=orderinfo' + }) + } else { + swan.requestPolymerPayment(params) + } +} + +var shims = /*#__PURE__*/ Object.freeze({ + __proto__: null, + getProvider: getProvider, + requestPayment: requestPayment +}) + +function createTodoMethod(contextName, methodName) { + return function unsupported() { + console.error(`百度小程序 ${contextName}暂不支持${methodName}`) + } +} +const request = { + args() { + // TODO + // data 不支持 ArrayBuffer + // method 不支持 TRACE, CONNECT + return { + method: 'method', + dataType(type) { + return { + name: 'dataType', + value: type === 'json' ? type : 'string' + } + } + } + } +} +const connectSocket = { + args: { + method: false + } +} +const getRecorderManager = { + returnValue(fromRes, toRes) { + toRes.onFrameRecorded = createTodoMethod( + 'RecorderManager', + 'onFrameRecorded' + ) + } +} +const getBackgroundAudioManager = { + returnValue(fromRes, toRes) { + toRes.onPrev = createTodoMethod('BackgroundAudioManager', 'onPrev') + toRes.onNext = createTodoMethod('BackgroundAudioManager', 'onNext') + } +} +const scanCode = { + args: { + onlyFromCamera: false, + scanType: false + } +} +const navigateToMiniProgram = { + name: 'navigateToSmartProgram', + args: { + appId: 'appKey', + envVersion: false + } +} +const navigateBackMiniProgram = { + name: 'navigateBackSmartProgram' +} +const showShareMenu = { + name: 'openShare' +} +const getAccountInfoSync = { + name: 'getEnvInfoSync', + returnValue(fromRes, toRes) { + toRes.miniProgram = { + appId: fromRes.appKey + } + toRes.plugin = { + appId: '', + version: fromRes.sdkVersion + } + } +} + +var protocols = /*#__PURE__*/ Object.freeze({ + __proto__: null, + request: request, + connectSocket: connectSocket, + getRecorderManager: getRecorderManager, + getBackgroundAudioManager: getBackgroundAudioManager, + scanCode: scanCode, + navigateToMiniProgram: navigateToMiniProgram, + navigateBackMiniProgram: navigateBackMiniProgram, + showShareMenu: showShareMenu, + getAccountInfoSync: getAccountInfoSync, + redirectTo: redirectTo, + previewImage: previewImage, + getSystemInfo: getSystemInfo, + getSystemInfoSync: getSystemInfoSync +}) + +var index = initUni(shims, protocols) + +export default index diff --git a/packages/uni-mp-baidu/dist/uni.mp.esm.js b/packages/uni-mp-baidu/dist/uni.mp.esm.js new file mode 100644 index 0000000000000000000000000000000000000000..bf8edf13b9375ba94a9a197d34a4d3855cf011ac --- /dev/null +++ b/packages/uni-mp-baidu/dist/uni.mp.esm.js @@ -0,0 +1,1035 @@ +import { + isArray, + hasOwn, + toNumber, + isPlainObject, + isObject, + isFunction, + extend, + NOOP, + camelize +} from '@vue/shared' +import { stringifyQuery } from '@dcloudio/uni-shared' + +function setModel(target, key, value, modifiers) { + if (isArray(modifiers)) { + if (modifiers.indexOf('trim') !== -1) { + value = value.trim() + } + if (modifiers.indexOf('number') !== -1) { + value = toNumber(value) + } + } + if (!target) { + target = this + } + target[key] = value +} +function setSync(target, key, value) { + if (!target) { + target = this + } + target[key] = value +} +function getOrig(data) { + if (isPlainObject(data)) { + return data.$orig || data + } + return data +} +function map(val, iteratee) { + let ret, i, l, keys, key + if (isArray(val)) { + ret = new Array(val.length) + for (i = 0, l = val.length; i < l; i++) { + ret[i] = iteratee(val[i], i) + } + return ret + } else if (isObject(val)) { + keys = Object.keys(val) + ret = Object.create(null) + for (i = 0, l = keys.length; i < l; i++) { + key = keys[i] + ret[key] = iteratee(val[key], key, i) + } + return ret + } + return [] +} +const MP_METHODS = [ + 'createSelectorQuery', + 'createIntersectionObserver', + 'selectAllComponents', + 'selectComponent' +] +function createEmitFn(oldEmit, ctx) { + return function emit(event, ...args) { + if (ctx.$scope && event) { + ctx.$scope.triggerEvent(event, { __args__: args }) + } + return oldEmit.apply(this, [event, ...args]) + } +} +function initBaseInstance(instance, options) { + const ctx = instance.ctx + // mp + ctx.mpType = options.mpType // @deprecated + ctx.$mpType = options.mpType + ctx.$scope = options.mpInstance + // TODO @deprecated + ctx.$mp = {} + if (__VUE_OPTIONS_API__) { + ctx._self = {} + } + // $vm + ctx.$scope.$vm = instance.proxy + // slots + { + instance.slots = {} + if (isArray(options.slots) && options.slots.length) { + options.slots.forEach(name => { + instance.slots[name] = true + }) + } + } + // $emit + instance.emit = createEmitFn(instance.emit, ctx) +} +function initComponentInstance(instance, options) { + initBaseInstance(instance, options) + const ctx = instance.ctx + MP_METHODS.forEach(method => { + ctx[method] = function(...args) { + const mpInstance = ctx.$scope + if (mpInstance && mpInstance[method]) { + return mpInstance[method].apply(mpInstance, args) + } + } + }) + // TODO other + ctx.__set_model = setModel + ctx.__set_sync = setSync + ctx.__get_orig = getOrig + // TODO + // ctx.__get_style = getStyle + ctx.__map = map +} +function initMocks(instance, mpInstance, mocks) { + const ctx = instance.ctx + mocks.forEach(mock => { + if (hasOwn(mpInstance, mock)) { + ctx[mock] = mpInstance[mock] + } + }) +} + +const PAGE_HOOKS = [ + 'onLoad', + 'onShow', + // 'onReady', // lifetimes.ready + 'onHide', + 'onUnload', + 'onResize', + // 'onPageScroll', // 影响性能,开发者手动注册 + 'onTabItemTap', + 'onReachBottom', + 'onPullDownRefresh', + // 'onShareTimeline', // 右上角菜单,开发者手动注册 + 'onAddToFavorites' + // 'onShareAppMessage' // 右上角菜单,开发者手动注册 +] +function findHooks(vueOptions, hooks = new Set()) { + if (vueOptions) { + Object.keys(vueOptions).forEach(name => { + if (name.indexOf('on') === 0 && isFunction(vueOptions[name])) { + hooks.add(name) + } + }) + if (__VUE_OPTIONS_API__) { + const { extends: extendsOptions, mixins } = vueOptions + if (mixins) { + mixins.forEach(mixin => findHooks(mixin, hooks)) + } + if (extendsOptions) { + findHooks(extendsOptions, hooks) + } + } + } + return hooks +} +function initHook(mpOptions, hook, excludes) { + if (excludes.indexOf(hook) === -1 && !hasOwn(mpOptions, hook)) { + mpOptions[hook] = function(args) { + return this.$vm && this.$vm.$callHook(hook, args) + } + } +} +const EXCLUDE_HOOKS = ['onReady'] +function initHooks(mpOptions, hooks, excludes = EXCLUDE_HOOKS) { + hooks.forEach(hook => initHook(mpOptions, hook, excludes)) +} +function initUnknownHooks(mpOptions, vueOptions, excludes = EXCLUDE_HOOKS) { + findHooks(vueOptions).forEach(hook => initHook(mpOptions, hook, excludes)) +} + +const HOOKS = [ + 'onShow', + 'onHide', + 'onError', + 'onThemeChange', + 'onPageNotFound', + 'onUnhandledRejection' +] +function parseApp(instance, parseAppOptions) { + const internalInstance = instance.$ + const appOptions = { + globalData: (instance.$options && instance.$options.globalData) || {}, + $vm: instance, + onLaunch(options) { + const ctx = internalInstance.ctx + if (this.$vm && ctx.$scope) { + // 已经初始化过了,主要是为了百度,百度 onShow 在 onLaunch 之前 + return + } + initBaseInstance(internalInstance, { + mpType: 'app', + mpInstance: this, + slots: [] + }) + ctx.globalData = this.globalData + instance.$callHook('onLaunch', options) + } + } + const vueOptions = instance.$.type + initHooks(appOptions, HOOKS) + initUnknownHooks(appOptions, vueOptions) + if (__VUE_OPTIONS_API__) { + const methods = vueOptions.methods + methods && extend(appOptions, methods) + } + if (parseAppOptions) { + parseAppOptions.parse(appOptions) + } + return appOptions +} +function initCreateApp(parseAppOptions) { + return function createApp(vm) { + return App(parseApp(vm, parseAppOptions)) + } +} + +function initBehavior(options) { + return Behavior(options) +} +function initVueIds(vueIds, mpInstance) { + if (!vueIds) { + return + } + const ids = vueIds.split(',') + const len = ids.length + if (len === 1) { + mpInstance._$vueId = ids[0] + } else if (len === 2) { + mpInstance._$vueId = ids[0] + mpInstance._$vuePid = ids[1] + } +} +const EXTRAS = ['externalClasses'] +function initExtraOptions(miniProgramComponentOptions, vueOptions) { + EXTRAS.forEach(name => { + if (hasOwn(vueOptions, name)) { + miniProgramComponentOptions[name] = vueOptions[name] + } + }) +} +function initWxsCallMethods(methods, wxsCallMethods) { + if (!isArray(wxsCallMethods)) { + return + } + wxsCallMethods.forEach(callMethod => { + methods[callMethod] = function(args) { + return this.$vm[callMethod](args) + } + }) +} +function initRefs(instance, mpInstance) { + Object.defineProperty(instance, 'refs', { + get() { + const $refs = {} + const components = mpInstance.selectAllComponents('.vue-ref') + components.forEach(component => { + const ref = component.dataset.ref + $refs[ref] = component.$vm || component + }) + const forComponents = mpInstance.selectAllComponents('.vue-ref-in-for') + forComponents.forEach(component => { + const ref = component.dataset.ref + if (!$refs[ref]) { + $refs[ref] = [] + } + $refs[ref].push(component.$vm || component) + }) + return $refs + } + }) +} +function findVmByVueId(instance, vuePid) { + // TODO vue3 中 没有 $children + const $children = instance.$children + // 优先查找直属(反向查找:https://github.com/dcloudio/uni-app/issues/1200) + for (let i = $children.length - 1; i >= 0; i--) { + const childVm = $children[i] + if (childVm.$scope._$vueId === vuePid) { + return childVm + } + } + // 反向递归查找 + let parentVm + for (let i = $children.length - 1; i >= 0; i--) { + parentVm = findVmByVueId($children[i], vuePid) + if (parentVm) { + return parentVm + } + } +} + +const PROP_TYPES = [String, Number, Boolean, Object, Array, null] +function createObserver(name) { + return function observer(newVal) { + if (this.$vm) { + this.$vm.$.props[name] = newVal // 为了触发其他非 render watcher + } + } +} +function parsePropType(key, type, defaultValue) { + // [String]=>String + if (isArray(type) && type.length === 1) { + return type[0] + } + { + if ( + // [String,Boolean]=>Boolean + defaultValue === false && + isArray(type) && + type.length === 2 && + type.indexOf(String) !== -1 && + type.indexOf(Boolean) !== -1 + ) { + return Boolean + } + } + return type +} +function initDefaultProps(isBehavior = false) { + const properties = {} + if (!isBehavior) { + properties.vueId = { + type: String, + value: '' + } + // 小程序不能直接定义 $slots 的 props,所以通过 vueSlots 转换到 $slots + properties.vueSlots = { + type: null, + value: [], + observer: function(newVal) { + const $slots = Object.create(null) + newVal.forEach(slotName => { + $slots[slotName] = true + }) + this.setData({ + $slots + }) + } + } + } + return properties +} +function createProperty(key, prop) { + prop.observer = createObserver(key) + return prop +} +function initProps(mpComponentOptions, rawProps, isBehavior = false) { + const properties = initDefaultProps(isBehavior) + if (isArray(rawProps)) { + rawProps.forEach(key => { + properties[key] = createProperty(key, { + type: null + }) + }) + } else if (isPlainObject(rawProps)) { + Object.keys(rawProps).forEach(key => { + const opts = rawProps[key] + if (isPlainObject(opts)) { + // title:{type:String,default:''} + let value = opts.default + if (isFunction(value)) { + value = value() + } + const type = opts.type + opts.type = parsePropType(key, type, value) + properties[key] = createProperty(key, { + type: PROP_TYPES.indexOf(type) !== -1 ? type : null, + value + }) + } else { + // content:String + const type = parsePropType(key, opts, null) + properties[key] = createProperty(key, { + type: PROP_TYPES.indexOf(type) !== -1 ? type : null + }) + } + }) + } + mpComponentOptions.properties = properties +} + +function initData(vueOptions) { + let data = vueOptions.data || {} + if (typeof data === 'function') { + try { + const appConfig = getApp().$vm.$.appContext.config + data = data.call(appConfig.globalProperties) + } catch (e) { + if (process.env.VUE_APP_DEBUG) { + console.warn( + '根据 Vue 的 data 函数初始化小程序 data 失败,请尽量确保 data 函数中不访问 vm 对象,否则可能影响首次数据渲染速度。', + data, + e + ) + } + } + } else { + try { + // 对 data 格式化 + data = JSON.parse(JSON.stringify(data)) + } catch (e) {} + } + if (!isPlainObject(data)) { + data = {} + } + return data +} +function initBehaviors(vueOptions, initBehavior) { + const vueBehaviors = vueOptions.behaviors + const vueExtends = vueOptions.extends + const vueMixins = vueOptions.mixins + let vueProps = vueOptions.props + if (!vueProps) { + vueOptions.props = vueProps = [] + } + const behaviors = [] + if (isArray(vueBehaviors)) { + vueBehaviors.forEach(behavior => { + behaviors.push(behavior.replace('uni://', `${__PLATFORM_PREFIX__}://`)) + if (behavior === 'uni://form-field') { + if (isArray(vueProps)) { + vueProps.push('name') + vueProps.push('value') + } else { + vueProps.name = { + type: String, + default: '' + } + vueProps.value = { + type: [String, Number, Boolean, Array, Object, Date], + default: '' + } + } + } + }) + } + if (isPlainObject(vueExtends) && vueExtends.props) { + const behavior = {} + initProps(behavior, vueExtends.props, true) + behaviors.push(initBehavior(behavior)) + } + if (isArray(vueMixins)) { + vueMixins.forEach(vueMixin => { + if (isPlainObject(vueMixin) && vueMixin.props) { + const behavior = {} + initProps(behavior, vueMixin.props, true) + behaviors.push(initBehavior(behavior)) + } + }) + } + return behaviors +} +function applyOptions(componentOptions, vueOptions, initBehavior) { + componentOptions.data = initData(vueOptions) + componentOptions.behaviors = initBehaviors(vueOptions, initBehavior) +} + +function getValue(obj, path) { + const parts = path.split('.') + let key = parts[0] + if (key.indexOf('__$n') === 0) { + //number index + key = parseInt(key.replace('__$n', '')) + } + if (parts.length === 1) { + return obj[key] + } + return getValue(obj[key], parts.slice(1).join('.')) +} +function getExtraValue(instance, dataPathsArray) { + let context = instance + dataPathsArray.forEach(dataPathArray => { + const dataPath = dataPathArray[0] + const value = dataPathArray[2] + if (dataPath || typeof value !== 'undefined') { + // ['','',index,'disable'] + const propPath = dataPathArray[1] + const valuePath = dataPathArray[3] + let vFor + if (Number.isInteger(dataPath)) { + vFor = dataPath + } else if (!dataPath) { + vFor = context + } else if (typeof dataPath === 'string' && dataPath) { + if (dataPath.indexOf('#s#') === 0) { + vFor = dataPath.substr(3) + } else { + vFor = getValue(context, dataPath) + } + } + if (Number.isInteger(vFor)) { + context = value + } else if (!propPath) { + context = vFor[value] + } else { + if (isArray(vFor)) { + context = vFor.find(vForItem => { + return getValue(vForItem, propPath) === value + }) + } else if (isPlainObject(vFor)) { + context = Object.keys(vFor).find(vForKey => { + return getValue(vFor[vForKey], propPath) === value + }) + } else { + console.error('v-for 暂不支持循环数据:', vFor) + } + } + if (valuePath) { + context = getValue(context, valuePath) + } + } + }) + return context +} +function processEventExtra(instance, extra, event) { + const extraObj = {} + if (isArray(extra) && extra.length) { + /** + *[ + * ['data.items', 'data.id', item.data.id], + * ['metas', 'id', meta.id] + *], + *[ + * ['data.items', 'data.id', item.data.id], + * ['metas', 'id', meta.id] + *], + *'test' + */ + extra.forEach((dataPath, index) => { + if (typeof dataPath === 'string') { + if (!dataPath) { + // model,prop.sync + extraObj['$' + index] = instance + } else { + if (dataPath === '$event') { + // $event + extraObj['$' + index] = event + } else if (dataPath === 'arguments') { + if (event.detail && event.detail.__args__) { + extraObj['$' + index] = event.detail.__args__ + } else { + extraObj['$' + index] = [event] + } + } else if (dataPath.indexOf('$event.') === 0) { + // $event.target.value + extraObj['$' + index] = getValue( + event, + dataPath.replace('$event.', '') + ) + } else { + extraObj['$' + index] = getValue(instance, dataPath) + } + } + } else { + extraObj['$' + index] = getExtraValue(instance, dataPath) + } + }) + } + return extraObj +} +function getObjByArray(arr) { + const obj = {} + for (let i = 1; i < arr.length; i++) { + const element = arr[i] + obj[element[0]] = element[1] + } + return obj +} +function processEventArgs( + instance, + event, + args = [], + extra = [], + isCustom, + methodName +) { + let isCustomMPEvent = false // wxcomponent 组件,传递原始 event 对象 + if (isCustom) { + // 自定义事件 + isCustomMPEvent = + event.currentTarget && + event.currentTarget.dataset && + event.currentTarget.dataset.comType === 'wx' + if (!args.length) { + // 无参数,直接传入 event 或 detail 数组 + if (isCustomMPEvent) { + return [event] + } + return event.detail.__args__ || event.detail + } + } + const extraObj = processEventExtra(instance, extra, event) + const ret = [] + args.forEach(arg => { + if (arg === '$event') { + if (methodName === '__set_model' && !isCustom) { + // input v-model value + ret.push(event.target.value) + } else { + if (isCustom && !isCustomMPEvent) { + ret.push(event.detail.__args__[0]) + } else { + // wxcomponent 组件或内置组件 + ret.push(event) + } + } + } else { + if (isArray(arg) && arg[0] === 'o') { + ret.push(getObjByArray(arg)) + } else if (typeof arg === 'string' && hasOwn(extraObj, arg)) { + ret.push(extraObj[arg]) + } else { + ret.push(arg) + } + } + }) + return ret +} +function wrapper(event) { + event.stopPropagation = NOOP + event.preventDefault = NOOP + event.target = event.target || {} + if (!hasOwn(event, 'detail')) { + event.detail = {} + } + if (hasOwn(event, 'markerId')) { + event.detail = typeof event.detail === 'object' ? event.detail : {} + event.detail.markerId = event.markerId + } + { + // mp-baidu,checked=>value + if ( + isPlainObject(event.detail) && + hasOwn(event.detail, 'checked') && + !hasOwn(event.detail, 'value') + ) { + event.detail.value = event.detail.checked + } + } + if (isPlainObject(event.detail)) { + event.target = Object.assign({}, event.target, event.detail) + } + return event +} +const ONCE = '~' +const CUSTOM = '^' +function matchEventType(eventType, optType) { + return ( + eventType === optType || + (optType === 'regionchange' && + (eventType === 'begin' || eventType === 'end')) + ) +} +function handleEvent(event) { + event = wrapper(event) + // [['tap',[['handle',[1,2,a]],['handle1',[1,2,a]]]]] + const dataset = (event.currentTarget || event.target).dataset + if (!dataset) { + return console.warn('事件信息不存在') + } + const eventOpts = dataset.eventOpts || dataset['event-opts'] // 支付宝 web-view 组件 dataset 非驼峰 + if (!eventOpts) { + return console.warn('事件信息不存在') + } + // [['handle',[1,2,a]],['handle1',[1,2,a]]] + const eventType = event.type + const ret = [] + eventOpts.forEach(eventOpt => { + let type = eventOpt[0] + const eventsArray = eventOpt[1] + const isCustom = type.charAt(0) === CUSTOM + type = isCustom ? type.slice(1) : type + const isOnce = type.charAt(0) === ONCE + type = isOnce ? type.slice(1) : type + if (eventsArray && matchEventType(eventType, type)) { + eventsArray.forEach(eventArray => { + const methodName = eventArray[0] + if (methodName) { + let handlerCtx = this.$vm + if ( + handlerCtx.$options.generic && + handlerCtx.$parent && + handlerCtx.$parent.$parent + ) { + // mp-weixin,mp-toutiao 抽象节点模拟 scoped slots + handlerCtx = handlerCtx.$parent.$parent + } + if (methodName === '$emit') { + handlerCtx.$emit.apply( + handlerCtx, + processEventArgs( + this.$vm, + event, + eventArray[1], + eventArray[2], + isCustom, + methodName + ) + ) + return + } + const handler = handlerCtx[methodName] + if (!isFunction(handler)) { + throw new Error(` _vm.${methodName} is not a function`) + } + if (isOnce) { + if (handler.once) { + return + } + handler.once = true + } + ret.push( + handler.apply( + handlerCtx, + processEventArgs( + this.$vm, + event, + eventArray[1], + eventArray[2], + isCustom, + methodName + ) + ) + ) + } + }) + } + }) + if ( + eventType === 'input' && + ret.length === 1 && + typeof ret[0] !== 'undefined' + ) { + return ret[0] + } +} + +function parseComponent( + vueOptions, + { parse, mocks, isPage, initRelation, handleLink, initLifetimes } +) { + vueOptions = vueOptions.default || vueOptions + const options = { + multipleSlots: true, + addGlobalClass: true + } + if (vueOptions.options) { + extend(options, vueOptions.options) + } + const mpComponentOptions = { + options, + lifetimes: initLifetimes({ mocks, isPage, initRelation, vueOptions }), + pageLifetimes: { + show() { + this.$vm && this.$vm.$callHook('onPageShow') + }, + hide() { + this.$vm && this.$vm.$callHook('onPageHide') + }, + resize(size) { + this.$vm && this.$vm.$callHook('onPageResize', size) + } + }, + methods: { + __l: handleLink, + __e: handleEvent + } + } + if (__VUE_OPTIONS_API__) { + applyOptions(mpComponentOptions, vueOptions, initBehavior) + } + initProps(mpComponentOptions, vueOptions.props, false) + initExtraOptions(mpComponentOptions, vueOptions) + initWxsCallMethods(mpComponentOptions.methods, vueOptions.wxsCallMethods) + if (parse) { + parse(mpComponentOptions, { handleLink }) + } + return mpComponentOptions +} +function initCreateComponent(parseOptions) { + return function createComponent(vueComponentOptions) { + return Component(parseComponent(vueComponentOptions, parseOptions)) + } +} +let $createComponentFn +let $destroyComponentFn +function $createComponent(initialVNode, options) { + if (!$createComponentFn) { + $createComponentFn = getApp().$vm.$createComponent + } + return $createComponentFn(initialVNode, options) +} +function $destroyComponent(instance) { + if (!$destroyComponentFn) { + $destroyComponentFn = getApp().$vm.$destroyComponent + } + return $destroyComponentFn(instance) +} + +function parsePage(vueOptions, parseOptions) { + const { + parse, + mocks, + isPage, + initRelation, + handleLink, + initLifetimes + } = parseOptions + const miniProgramPageOptions = parseComponent(vueOptions, { + mocks, + isPage, + initRelation, + handleLink, + initLifetimes + }) + const methods = miniProgramPageOptions.methods + methods.onLoad = function(query) { + this.options = query + this.$page = { + fullPath: '/' + this.route + stringifyQuery(query) + } + return this.$vm && this.$vm.$callHook('onLoad', query) + } + initHooks(methods, PAGE_HOOKS) + initUnknownHooks(methods, vueOptions) + parse && parse(miniProgramPageOptions, { handleLink }) + return miniProgramPageOptions +} +function initCreatePage(parseOptions) { + return function createPage(vuePageOptions) { + return Component(parsePage(vuePageOptions, parseOptions)) + } +} + +const MPPage = Page +const MPComponent = Component +const customizeRE = /:/g +function customize(str) { + return camelize(str.replace(customizeRE, '-')) +} +function initTriggerEvent(mpInstance) { + const oldTriggerEvent = mpInstance.triggerEvent + mpInstance.triggerEvent = function(event, ...args) { + return oldTriggerEvent.apply(mpInstance, [customize(event), ...args]) + } +} +function initHook$1(name, options) { + const oldHook = options[name] + if (!oldHook) { + options[name] = function() { + initTriggerEvent(this) + } + } else { + options[name] = function(...args) { + initTriggerEvent(this) + return oldHook.apply(this, args) + } + } +} +Page = function(options) { + initHook$1('onLoad', options) + return MPPage(options) +} +Component = function(options) { + initHook$1('created', options) + return MPComponent(options) +} + +function parse(appOptions) { + // 百度 onShow 竟然会在 onLaunch 之前 + appOptions.onShow = function onShow(args) { + if (!this.$vm) { + this.onLaunch(args) + } + this.$vm.$callHook('onShow', args) + } +} + +var parseAppOptions = /*#__PURE__*/ Object.freeze({ + __proto__: null, + parse: parse +}) + +function initLifetimes({ mocks, isPage, initRelation, vueOptions }) { + return { + attached() { + const properties = this.properties + initVueIds(properties.vueId, this) + const relationOptions = { + vuePid: this._$vuePid + } + // 处理父子关系 + initRelation(this, relationOptions) + // 初始化 vue 实例 + const mpInstance = this + this.$vm = $createComponent( + { + type: vueOptions, + props: properties + }, + { + mpType: isPage(mpInstance) ? 'page' : 'component', + mpInstance, + slots: properties.vueSlots, + parentComponent: relationOptions.parent && relationOptions.parent.$, + onBeforeSetup(instance, options) { + initRefs(instance, mpInstance) + initMocks(instance, mpInstance, mocks) + initComponentInstance(instance, options) + } + } + ) + }, + ready() { + // 当组件 props 默认值为 true,初始化时传入 false 会导致 created,ready 触发, 但 attached 不触发 + // https://developers.weixin.qq.com/community/develop/doc/00066ae2844cc0f8eb883e2a557800 + if (this.$vm) { + this.$vm.$callHook('mounted') + this.$vm.$callHook('onReady') + } + }, + detached() { + this.$vm && $destroyComponent(this.$vm) + } + } +} + +function handleLink(event) { + // detail 是微信,value 是百度(dipatch) + const detail = event.detail || event.value + const vuePid = detail.vuePid + let parentVm + if (vuePid) { + parentVm = findVmByVueId(this.$vm, vuePid) + } + if (!parentVm) { + parentVm = this.$vm + } + detail.parent = parentVm +} + +const mocks = ['nodeId', 'componentName', '_componentId', 'uniquePrefix'] +function isPage(mpInstance) { + return !hasOwn(mpInstance, 'ownerId') +} +function initRelation(mpInstance, detail) { + mpInstance.dispatch('__l', detail) +} +const newLifecycle = /*#__PURE__*/ swan.canIUse('lifecycle-2-0') +function parse$1(componentOptions) { + const methods = componentOptions.methods + const lifetimes = componentOptions.lifetimes + // 关于百度小程序生命周期的说明(组件作为页面时): + // lifetimes:attached --> methods:onShow --> methods:onLoad --> methods:onReady + // 这里在强制将onShow挪到onLoad之后触发,另外一处修改在page-parser.js + const oldAttached = lifetimes.attached + lifetimes.attached = function attached() { + oldAttached.call(this) + if (isPage(this) && this.$vm) { + // 百度 onLoad 在 attached 之前触发 + // 百度 当组件作为页面时 pageinstance 不是原来组件的 instance + const pageInstance = this.pageinstance + pageInstance.$vm = this.$vm + if (hasOwn(pageInstance, '_$args')) { + this.$vm.$callHook('onLoad', pageInstance._$args) + this.$vm.$callHook('onShow') + delete pageInstance._$args + } + } else { + // 百度小程序组件不触发methods内的onReady + if (this.$vm) { + this.$vm.$callHook('mounted') + } + } + } + if (newLifecycle) { + methods.onReady = lifetimes.ready + delete lifetimes.ready + } + componentOptions.messages = { + __l: methods.__l + } + delete methods.__l +} + +var parseComponentOptions = /*#__PURE__*/ Object.freeze({ + __proto__: null, + mocks: mocks, + isPage: isPage, + initRelation: initRelation, + parse: parse$1, + handleLink: handleLink, + initLifetimes: initLifetimes +}) + +function parse$2(pageOptions) { + parse$1(pageOptions) + const methods = pageOptions.methods + // 纠正百度小程序生命周期methods:onShow在methods:onLoad之前触发的问题 + methods.onShow = function onShow() { + if (this.$vm && this._$loaded) { + this.$vm.$callHook('onShow') + } + } + methods.onLoad = function onLoad(args) { + // 百度 onLoad 在 attached 之前触发,先存储 args, 在 attached 里边触发 onLoad + if (this.$vm) { + this._$loaded = true + this.$vm.$callHook('onLoad', args) + this.$vm.$callHook('onShow') + } else { + this.pageinstance._$args = args + } + } +} + +var parsePageOptions = /*#__PURE__*/ Object.freeze({ + __proto__: null, + parse: parse$2, + handleLink: handleLink, + initLifetimes: initLifetimes, + mocks: mocks, + isPage: isPage, + initRelation: initRelation +}) + +const createApp = initCreateApp(parseAppOptions) +const createPage = initCreatePage(parsePageOptions) +const createComponent = initCreateComponent(parseComponentOptions) + +export { createApp, createComponent, createPage } diff --git a/packages/uni-mp-qq/dist/uni.api.esm.js b/packages/uni-mp-qq/dist/uni.api.esm.js new file mode 100644 index 0000000000000000000000000000000000000000..9ab4b593a9993bae75e14e51545184cc16adf39e --- /dev/null +++ b/packages/uni-mp-qq/dist/uni.api.esm.js @@ -0,0 +1,535 @@ +import { + isArray, + isPromise, + isFunction, + isPlainObject, + hasOwn, + isString +} from '@vue/shared' + +function createApi(fn, validate) { + if (process.env.NODE_ENV !== 'production' && validate); + return fn +} + +const Upx2pxProtocol = [ + { + name: 'upx', + type: [Number, String], + required: true + } +] + +const EPS = 1e-4 +const BASE_DEVICE_WIDTH = 750 +let isIOS = false +let deviceWidth = 0 +let deviceDPR = 0 +function checkDeviceWidth() { + const { platform, pixelRatio, windowWidth } = qq.getSystemInfoSync() + deviceWidth = windowWidth + deviceDPR = pixelRatio + isIOS = platform === 'ios' +} +const upx2px = createApi((number, newDeviceWidth) => { + if (deviceWidth === 0) { + checkDeviceWidth() + } + number = Number(number) + if (number === 0) { + return 0 + } + let result = (number / BASE_DEVICE_WIDTH) * (newDeviceWidth || deviceWidth) + if (result < 0) { + result = -result + } + result = Math.floor(result + EPS) + if (result === 0) { + if (deviceDPR === 1 || !isIOS) { + result = 1 + } else { + result = 0.5 + } + } + return number < 0 ? -result : result +}, Upx2pxProtocol) + +var HOOKS +;(function(HOOKS) { + HOOKS['INVOKE'] = 'invoke' + HOOKS['SUCCESS'] = 'success' + HOOKS['FAIL'] = 'fail' + HOOKS['COMPLETE'] = 'complete' + HOOKS['RETURN_VALUE'] = 'returnValue' +})(HOOKS || (HOOKS = {})) +const globalInterceptors = {} +const scopedInterceptors = {} +function wrapperHook(hook) { + return function(data) { + return hook(data) || data + } +} +function queue(hooks, data) { + let promise = false + for (let i = 0; i < hooks.length; i++) { + const hook = hooks[i] + if (promise) { + promise = Promise.resolve(wrapperHook(hook)) + } else { + const res = hook(data) + if (isPromise(res)) { + promise = Promise.resolve(res) + } + if (res === false) { + return { + then() {}, + catch() {} + } + } + } + } + return ( + promise || { + then(callback) { + return callback(data) + }, + catch() {} + } + ) +} +function wrapperOptions(interceptors, options = {}) { + ;[HOOKS.SUCCESS, HOOKS.FAIL, HOOKS.COMPLETE].forEach(name => { + const hooks = interceptors[name] + if (!isArray(hooks)) { + return + } + const oldCallback = options[name] + options[name] = function callbackInterceptor(res) { + queue(hooks, res).then(res => { + return (isFunction(oldCallback) && oldCallback(res)) || res + }) + } + }) + return options +} +function wrapperReturnValue(method, returnValue) { + const returnValueHooks = [] + if (isArray(globalInterceptors.returnValue)) { + returnValueHooks.push(...globalInterceptors.returnValue) + } + const interceptor = scopedInterceptors[method] + if (interceptor && isArray(interceptor.returnValue)) { + returnValueHooks.push(...interceptor.returnValue) + } + returnValueHooks.forEach(hook => { + returnValue = hook(returnValue) || returnValue + }) + return returnValue +} +function getApiInterceptorHooks(method) { + const interceptor = Object.create(null) + Object.keys(globalInterceptors).forEach(hook => { + if (hook !== 'returnValue') { + interceptor[hook] = globalInterceptors[hook].slice() + } + }) + const scopedInterceptor = scopedInterceptors[method] + if (scopedInterceptor) { + Object.keys(scopedInterceptor).forEach(hook => { + if (hook !== 'returnValue') { + interceptor[hook] = (interceptor[hook] || []).concat( + scopedInterceptor[hook] + ) + } + }) + } + return interceptor +} +function invokeApi(method, api, options, ...params) { + const interceptor = getApiInterceptorHooks(method) + if (interceptor && Object.keys(interceptor).length) { + if (isArray(interceptor.invoke)) { + const res = queue(interceptor.invoke, options) + return res.then(options => { + return api(wrapperOptions(interceptor, options), ...params) + }) + } else { + return api(wrapperOptions(interceptor, options), ...params) + } + } + return api(options, ...params) +} + +const AddInterceptorProtocol = [ + { + name: 'method', + type: [String, Object], + required: true + } +] +const RemoveInterceptorProtocol = AddInterceptorProtocol + +function mergeInterceptorHook(interceptors, interceptor) { + Object.keys(interceptor).forEach(hook => { + if (isFunction(interceptor[hook])) { + interceptors[hook] = mergeHook(interceptors[hook], interceptor[hook]) + } + }) +} +function removeInterceptorHook(interceptors, interceptor) { + if (!interceptors || !interceptor) { + return + } + Object.keys(interceptor).forEach(hook => { + if (isFunction(interceptor[hook])) { + removeHook(interceptors[hook], interceptor[hook]) + } + }) +} +function mergeHook(parentVal, childVal) { + const res = childVal + ? parentVal + ? parentVal.concat(childVal) + : isArray(childVal) + ? childVal + : [childVal] + : parentVal + return res ? dedupeHooks(res) : res +} +function dedupeHooks(hooks) { + const res = [] + for (let i = 0; i < hooks.length; i++) { + if (res.indexOf(hooks[i]) === -1) { + res.push(hooks[i]) + } + } + return res +} +function removeHook(hooks, hook) { + if (!hooks) { + return + } + const index = hooks.indexOf(hook) + if (index !== -1) { + hooks.splice(index, 1) + } +} +const addInterceptor = createApi((method, interceptor) => { + if (typeof method === 'string' && isPlainObject(interceptor)) { + mergeInterceptorHook( + scopedInterceptors[method] || (scopedInterceptors[method] = {}), + interceptor + ) + } else if (isPlainObject(method)) { + mergeInterceptorHook(globalInterceptors, method) + } +}, AddInterceptorProtocol) +const removeInterceptor = createApi((method, interceptor) => { + if (typeof method === 'string') { + if (isPlainObject(interceptor)) { + removeInterceptorHook(scopedInterceptors[method], interceptor) + } else { + delete scopedInterceptors[method] + } + } else if (isPlainObject(method)) { + removeInterceptorHook(globalInterceptors, method) + } +}, RemoveInterceptorProtocol) + +const SYNC_API_RE = /^\$|sendNativeEvent|restoreGlobal|getCurrentSubNVue|getMenuButtonBoundingClientRect|^report|interceptors|Interceptor$|getSubNVueById|requireNativePlugin|upx2px|hideKeyboard|canIUse|^create|Sync$|Manager$|base64ToArrayBuffer|arrayBufferToBase64/ +const CONTEXT_API_RE = /^create|Manager$/ +// Context例外情况 +const CONTEXT_API_RE_EXC = ['createBLEConnection'] +// 同步例外情况 +const ASYNC_API = ['createBLEConnection'] +const CALLBACK_API_RE = /^on|^off/ +function isContextApi(name) { + return CONTEXT_API_RE.test(name) && CONTEXT_API_RE_EXC.indexOf(name) === -1 +} +function isSyncApi(name) { + return SYNC_API_RE.test(name) && ASYNC_API.indexOf(name) === -1 +} +function isCallbackApi(name) { + return CALLBACK_API_RE.test(name) && name !== 'onPush' +} +function handlePromise(promise) { + if (!__UNI_PROMISE_API__) { + return promise + } + return promise + .then(data => { + return [null, data] + }) + .catch(err => [err]) +} +function shouldPromise(name) { + if (isContextApi(name) || isSyncApi(name) || isCallbackApi(name)) { + return false + } + return true +} +/* eslint-disable no-extend-native */ +if (!Promise.prototype.finally) { + Promise.prototype.finally = function(onfinally) { + const promise = this.constructor + return this.then( + value => promise.resolve(onfinally && onfinally()).then(() => value), + reason => + promise.resolve(onfinally && onfinally()).then(() => { + throw reason + }) + ) + } +} +function promisify(name, api) { + if (!shouldPromise(name)) { + return api + } + if (!isFunction(api)) { + return api + } + return function promiseApi(options = {}, ...params) { + if ( + isFunction(options.success) || + isFunction(options.fail) || + isFunction(options.complete) + ) { + return wrapperReturnValue(name, invokeApi(name, api, options, ...params)) + } + return wrapperReturnValue( + name, + handlePromise( + new Promise((resolve, reject) => { + invokeApi( + name, + api, + Object.assign({}, options, { + success: resolve, + fail: reject + }), + ...params + ) + }) + ) + ) + } +} + +const CALLBACKS = ['success', 'fail', 'cancel', 'complete'] +function initWrapper(protocols) { + function processCallback(methodName, method, returnValue) { + return function(res) { + return method(processReturnValue(methodName, res, returnValue)) + } + } + function processArgs( + methodName, + fromArgs, + argsOption = {}, + returnValue = {}, + keepFromArgs = false + ) { + if (isPlainObject(fromArgs)) { + // 一般 api 的参数解析 + const toArgs = keepFromArgs === true ? fromArgs : {} // returnValue 为 false 时,说明是格式化返回值,直接在返回值对象上修改赋值 + if (isFunction(argsOption)) { + argsOption = argsOption(fromArgs, toArgs) || {} + } + for (const key in fromArgs) { + if (hasOwn(argsOption, key)) { + let keyOption = argsOption[key] + if (isFunction(keyOption)) { + keyOption = keyOption(fromArgs[key], fromArgs, toArgs) + } + if (!keyOption) { + // 不支持的参数 + console.warn(`QQ小程序 ${methodName} 暂不支持 ${key}`) + } else if (isString(keyOption)) { + // 重写参数 key + toArgs[keyOption] = fromArgs[key] + } else if (isPlainObject(keyOption)) { + // {name:newName,value:value}可重新指定参数 key:value + toArgs[keyOption.name ? keyOption.name : key] = keyOption.value + } + } else if (CALLBACKS.indexOf(key) !== -1) { + const callback = fromArgs[key] + if (isFunction(callback)) { + toArgs[key] = processCallback(methodName, callback, returnValue) + } + } else { + if (!keepFromArgs && !hasOwn(toArgs, key)) { + toArgs[key] = fromArgs[key] + } + } + } + return toArgs + } else if (isFunction(fromArgs)) { + fromArgs = processCallback(methodName, fromArgs, returnValue) + } + return fromArgs + } + function processReturnValue( + methodName, + res, + returnValue, + keepReturnValue = false + ) { + if (isFunction(protocols.returnValue)) { + // 处理通用 returnValue + res = protocols.returnValue(methodName, res) + } + return processArgs(methodName, res, returnValue, {}, keepReturnValue) + } + return function wrapper(methodName, method) { + if (!hasOwn(protocols, methodName)) { + return method + } + const protocol = protocols[methodName] + if (!protocol) { + // 暂不支持的 api + return function() { + console.error(`QQ小程序 暂不支持${methodName}`) + } + } + return function(arg1, arg2) { + // 目前 api 最多两个参数 + let options = protocol + if (isFunction(protocol)) { + options = protocol(arg1) + } + arg1 = processArgs(methodName, arg1, options.args, options.returnValue) + const args = [arg1] + if (typeof arg2 !== 'undefined') { + args.push(arg2) + } + const returnValue = qq[options.name || methodName].apply(qq, args) + if (isSyncApi(methodName)) { + // 同步 api + return processReturnValue( + methodName, + returnValue, + options.returnValue, + isContextApi(methodName) + ) + } + return returnValue + } + } +} + +const baseApis = { upx2px, addInterceptor, removeInterceptor } +function initUni(api, protocols) { + const wrapper = initWrapper(protocols) + const UniProxyHandlers = { + get(target, key) { + if (hasOwn(target, key)) { + return target[key] + } + if (hasOwn(api, key)) { + return promisify(key, api[key]) + } + if (hasOwn(baseApis, key)) { + return promisify(key, baseApis[key]) + } + // event-api + // provider-api? + return promisify(key, wrapper(key, qq[key])) + } + } + return new Proxy({}, UniProxyHandlers) +} + +function initGetProvider(providers) { + return function getProvider({ service, success, fail, complete }) { + let res + if (providers[service]) { + res = { + errMsg: 'getProvider:ok', + service, + provider: providers[service] + } + isFunction(success) && success(res) + } else { + res = { + errMsg: 'getProvider:fail:服务[' + service + ']不存在' + } + isFunction(fail) && fail(res) + } + isFunction(complete) && complete(res) + } +} + +const previewImage = { + args(fromArgs, toArgs) { + let currentIndex = parseInt(fromArgs.current) + if (isNaN(currentIndex)) { + return + } + const urls = fromArgs.urls + if (!isArray(urls)) { + return + } + const len = urls.length + if (!len) { + return + } + if (currentIndex < 0) { + currentIndex = 0 + } else if (currentIndex >= len) { + currentIndex = len - 1 + } + if (currentIndex > 0) { + toArgs.current = urls[currentIndex] + toArgs.urls = urls.filter( + (item, index) => + index < currentIndex ? item !== urls[currentIndex] : true + ) + } else { + toArgs.current = urls[0] + } + return { + indicator: false, + loop: false + } + } +} +function addSafeAreaInsets(fromRes, toRes) { + if (fromRes.safeArea) { + const safeArea = fromRes.safeArea + toRes.safeAreaInsets = { + top: safeArea.top, + left: safeArea.left, + right: fromRes.windowWidth - safeArea.right, + bottom: fromRes.windowHeight - safeArea.bottom + } + } +} +const getSystemInfo = { + returnValue: addSafeAreaInsets +} +const getSystemInfoSync = getSystemInfo +const redirectTo = {} + +const getProvider = initGetProvider({ + oauth: ['qq'], + share: ['qq'], + payment: ['qqpay'], + push: ['qq'] +}) + +var shims = /*#__PURE__*/ Object.freeze({ + __proto__: null, + getProvider: getProvider +}) + +var protocols = /*#__PURE__*/ Object.freeze({ + __proto__: null, + redirectTo: redirectTo, + previewImage: previewImage, + getSystemInfo: getSystemInfo, + getSystemInfoSync: getSystemInfoSync +}) + +var index = initUni(shims, protocols) + +export default index diff --git a/packages/uni-mp-qq/dist/uni.mp.esm.js b/packages/uni-mp-qq/dist/uni.mp.esm.js new file mode 100644 index 0000000000000000000000000000000000000000..23526112bd24bc30ec0e69ebd43c2909cc60c26d --- /dev/null +++ b/packages/uni-mp-qq/dist/uni.mp.esm.js @@ -0,0 +1,929 @@ +import { + isArray, + hasOwn, + toNumber, + isPlainObject, + isObject, + isFunction, + extend, + NOOP, + camelize +} from '@vue/shared' +import { stringifyQuery } from '@dcloudio/uni-shared' + +function setModel(target, key, value, modifiers) { + if (isArray(modifiers)) { + if (modifiers.indexOf('trim') !== -1) { + value = value.trim() + } + if (modifiers.indexOf('number') !== -1) { + value = toNumber(value) + } + } + if (!target) { + target = this + } + target[key] = value +} +function setSync(target, key, value) { + if (!target) { + target = this + } + target[key] = value +} +function getOrig(data) { + if (isPlainObject(data)) { + return data.$orig || data + } + return data +} +function map(val, iteratee) { + let ret, i, l, keys, key + if (isArray(val)) { + ret = new Array(val.length) + for (i = 0, l = val.length; i < l; i++) { + ret[i] = iteratee(val[i], i) + } + return ret + } else if (isObject(val)) { + keys = Object.keys(val) + ret = Object.create(null) + for (i = 0, l = keys.length; i < l; i++) { + key = keys[i] + ret[key] = iteratee(val[key], key, i) + } + return ret + } + return [] +} +const MP_METHODS = [ + 'createSelectorQuery', + 'createIntersectionObserver', + 'selectAllComponents', + 'selectComponent' +] +function createEmitFn(oldEmit, ctx) { + return function emit(event, ...args) { + if (ctx.$scope && event) { + ctx.$scope.triggerEvent(event, { __args__: args }) + } + return oldEmit.apply(this, [event, ...args]) + } +} +function initBaseInstance(instance, options) { + const ctx = instance.ctx + // mp + ctx.mpType = options.mpType // @deprecated + ctx.$mpType = options.mpType + ctx.$scope = options.mpInstance + // TODO @deprecated + ctx.$mp = {} + if (__VUE_OPTIONS_API__) { + ctx._self = {} + } + // $vm + ctx.$scope.$vm = instance.proxy + // slots + { + instance.slots = {} + if (isArray(options.slots) && options.slots.length) { + options.slots.forEach(name => { + instance.slots[name] = true + }) + } + } + // $emit + instance.emit = createEmitFn(instance.emit, ctx) +} +function initComponentInstance(instance, options) { + initBaseInstance(instance, options) + const ctx = instance.ctx + MP_METHODS.forEach(method => { + ctx[method] = function(...args) { + const mpInstance = ctx.$scope + if (mpInstance && mpInstance[method]) { + return mpInstance[method].apply(mpInstance, args) + } + } + }) + // TODO other + ctx.__set_model = setModel + ctx.__set_sync = setSync + ctx.__get_orig = getOrig + // TODO + // ctx.__get_style = getStyle + ctx.__map = map +} +function initMocks(instance, mpInstance, mocks) { + const ctx = instance.ctx + mocks.forEach(mock => { + if (hasOwn(mpInstance, mock)) { + ctx[mock] = mpInstance[mock] + } + }) +} + +const PAGE_HOOKS = [ + 'onLoad', + 'onShow', + // 'onReady', // lifetimes.ready + 'onHide', + 'onUnload', + 'onResize', + // 'onPageScroll', // 影响性能,开发者手动注册 + 'onTabItemTap', + 'onReachBottom', + 'onPullDownRefresh', + // 'onShareTimeline', // 右上角菜单,开发者手动注册 + 'onAddToFavorites' + // 'onShareAppMessage' // 右上角菜单,开发者手动注册 +] +function findHooks(vueOptions, hooks = new Set()) { + if (vueOptions) { + Object.keys(vueOptions).forEach(name => { + if (name.indexOf('on') === 0 && isFunction(vueOptions[name])) { + hooks.add(name) + } + }) + if (__VUE_OPTIONS_API__) { + const { extends: extendsOptions, mixins } = vueOptions + if (mixins) { + mixins.forEach(mixin => findHooks(mixin, hooks)) + } + if (extendsOptions) { + findHooks(extendsOptions, hooks) + } + } + } + return hooks +} +function initHook(mpOptions, hook, excludes) { + if (excludes.indexOf(hook) === -1 && !hasOwn(mpOptions, hook)) { + mpOptions[hook] = function(args) { + return this.$vm && this.$vm.$callHook(hook, args) + } + } +} +const EXCLUDE_HOOKS = ['onReady'] +function initHooks(mpOptions, hooks, excludes = EXCLUDE_HOOKS) { + hooks.forEach(hook => initHook(mpOptions, hook, excludes)) +} +function initUnknownHooks(mpOptions, vueOptions, excludes = EXCLUDE_HOOKS) { + findHooks(vueOptions).forEach(hook => initHook(mpOptions, hook, excludes)) +} + +const HOOKS = [ + 'onShow', + 'onHide', + 'onError', + 'onThemeChange', + 'onPageNotFound', + 'onUnhandledRejection' +] +function parseApp(instance, parseAppOptions) { + const internalInstance = instance.$ + const appOptions = { + globalData: (instance.$options && instance.$options.globalData) || {}, + $vm: instance, + onLaunch(options) { + const ctx = internalInstance.ctx + if (this.$vm && ctx.$scope) { + // 已经初始化过了,主要是为了百度,百度 onShow 在 onLaunch 之前 + return + } + initBaseInstance(internalInstance, { + mpType: 'app', + mpInstance: this, + slots: [] + }) + ctx.globalData = this.globalData + instance.$callHook('onLaunch', options) + } + } + const vueOptions = instance.$.type + initHooks(appOptions, HOOKS) + initUnknownHooks(appOptions, vueOptions) + if (__VUE_OPTIONS_API__) { + const methods = vueOptions.methods + methods && extend(appOptions, methods) + } + if (parseAppOptions) { + parseAppOptions.parse(appOptions) + } + return appOptions +} +function initCreateApp(parseAppOptions) { + return function createApp(vm) { + return App(parseApp(vm, parseAppOptions)) + } +} + +function initBehavior(options) { + return Behavior(options) +} +function initVueIds(vueIds, mpInstance) { + if (!vueIds) { + return + } + const ids = vueIds.split(',') + const len = ids.length + if (len === 1) { + mpInstance._$vueId = ids[0] + } else if (len === 2) { + mpInstance._$vueId = ids[0] + mpInstance._$vuePid = ids[1] + } +} +const EXTRAS = ['externalClasses'] +function initExtraOptions(miniProgramComponentOptions, vueOptions) { + EXTRAS.forEach(name => { + if (hasOwn(vueOptions, name)) { + miniProgramComponentOptions[name] = vueOptions[name] + } + }) +} +function initWxsCallMethods(methods, wxsCallMethods) { + if (!isArray(wxsCallMethods)) { + return + } + wxsCallMethods.forEach(callMethod => { + methods[callMethod] = function(args) { + return this.$vm[callMethod](args) + } + }) +} +function initRefs(instance, mpInstance) { + Object.defineProperty(instance, 'refs', { + get() { + const $refs = {} + const components = mpInstance.selectAllComponents('.vue-ref') + components.forEach(component => { + const ref = component.dataset.ref + $refs[ref] = component.$vm || component + }) + const forComponents = mpInstance.selectAllComponents('.vue-ref-in-for') + forComponents.forEach(component => { + const ref = component.dataset.ref + if (!$refs[ref]) { + $refs[ref] = [] + } + $refs[ref].push(component.$vm || component) + }) + return $refs + } + }) +} +function findVmByVueId(instance, vuePid) { + // TODO vue3 中 没有 $children + const $children = instance.$children + // 优先查找直属(反向查找:https://github.com/dcloudio/uni-app/issues/1200) + for (let i = $children.length - 1; i >= 0; i--) { + const childVm = $children[i] + if (childVm.$scope._$vueId === vuePid) { + return childVm + } + } + // 反向递归查找 + let parentVm + for (let i = $children.length - 1; i >= 0; i--) { + parentVm = findVmByVueId($children[i], vuePid) + if (parentVm) { + return parentVm + } + } +} + +const PROP_TYPES = [String, Number, Boolean, Object, Array, null] +function createObserver(name) { + return function observer(newVal) { + if (this.$vm) { + this.$vm.$.props[name] = newVal // 为了触发其他非 render watcher + } + } +} +function parsePropType(key, type, defaultValue) { + // [String]=>String + if (isArray(type) && type.length === 1) { + return type[0] + } + return type +} +function initDefaultProps(isBehavior = false) { + const properties = {} + if (!isBehavior) { + properties.vueId = { + type: String, + value: '' + } + // 小程序不能直接定义 $slots 的 props,所以通过 vueSlots 转换到 $slots + properties.vueSlots = { + type: null, + value: [], + observer: function(newVal) { + const $slots = Object.create(null) + newVal.forEach(slotName => { + $slots[slotName] = true + }) + this.setData({ + $slots + }) + } + } + } + return properties +} +function createProperty(key, prop) { + prop.observer = createObserver(key) + return prop +} +function initProps(mpComponentOptions, rawProps, isBehavior = false) { + const properties = initDefaultProps(isBehavior) + if (isArray(rawProps)) { + rawProps.forEach(key => { + properties[key] = createProperty(key, { + type: null + }) + }) + } else if (isPlainObject(rawProps)) { + Object.keys(rawProps).forEach(key => { + const opts = rawProps[key] + if (isPlainObject(opts)) { + // title:{type:String,default:''} + let value = opts.default + if (isFunction(value)) { + value = value() + } + const type = opts.type + opts.type = parsePropType(key, type) + properties[key] = createProperty(key, { + type: PROP_TYPES.indexOf(type) !== -1 ? type : null, + value + }) + } else { + // content:String + const type = parsePropType(key, opts) + properties[key] = createProperty(key, { + type: PROP_TYPES.indexOf(type) !== -1 ? type : null + }) + } + }) + } + mpComponentOptions.properties = properties +} + +function initData(vueOptions) { + let data = vueOptions.data || {} + if (typeof data === 'function') { + try { + const appConfig = getApp().$vm.$.appContext.config + data = data.call(appConfig.globalProperties) + } catch (e) { + if (process.env.VUE_APP_DEBUG) { + console.warn( + '根据 Vue 的 data 函数初始化小程序 data 失败,请尽量确保 data 函数中不访问 vm 对象,否则可能影响首次数据渲染速度。', + data, + e + ) + } + } + } else { + try { + // 对 data 格式化 + data = JSON.parse(JSON.stringify(data)) + } catch (e) {} + } + if (!isPlainObject(data)) { + data = {} + } + return data +} +function initBehaviors(vueOptions, initBehavior) { + const vueBehaviors = vueOptions.behaviors + const vueExtends = vueOptions.extends + const vueMixins = vueOptions.mixins + let vueProps = vueOptions.props + if (!vueProps) { + vueOptions.props = vueProps = [] + } + const behaviors = [] + if (isArray(vueBehaviors)) { + vueBehaviors.forEach(behavior => { + behaviors.push(behavior.replace('uni://', `${__PLATFORM_PREFIX__}://`)) + if (behavior === 'uni://form-field') { + if (isArray(vueProps)) { + vueProps.push('name') + vueProps.push('value') + } else { + vueProps.name = { + type: String, + default: '' + } + vueProps.value = { + type: [String, Number, Boolean, Array, Object, Date], + default: '' + } + } + } + }) + } + if (isPlainObject(vueExtends) && vueExtends.props) { + const behavior = {} + initProps(behavior, vueExtends.props, true) + behaviors.push(initBehavior(behavior)) + } + if (isArray(vueMixins)) { + vueMixins.forEach(vueMixin => { + if (isPlainObject(vueMixin) && vueMixin.props) { + const behavior = {} + initProps(behavior, vueMixin.props, true) + behaviors.push(initBehavior(behavior)) + } + }) + } + return behaviors +} +function applyOptions(componentOptions, vueOptions, initBehavior) { + componentOptions.data = initData(vueOptions) + componentOptions.behaviors = initBehaviors(vueOptions, initBehavior) +} + +function getValue(obj, path) { + const parts = path.split('.') + let key = parts[0] + if (key.indexOf('__$n') === 0) { + //number index + key = parseInt(key.replace('__$n', '')) + } + if (parts.length === 1) { + return obj[key] + } + return getValue(obj[key], parts.slice(1).join('.')) +} +function getExtraValue(instance, dataPathsArray) { + let context = instance + dataPathsArray.forEach(dataPathArray => { + const dataPath = dataPathArray[0] + const value = dataPathArray[2] + if (dataPath || typeof value !== 'undefined') { + // ['','',index,'disable'] + const propPath = dataPathArray[1] + const valuePath = dataPathArray[3] + let vFor + if (Number.isInteger(dataPath)) { + vFor = dataPath + } else if (!dataPath) { + vFor = context + } else if (typeof dataPath === 'string' && dataPath) { + if (dataPath.indexOf('#s#') === 0) { + vFor = dataPath.substr(3) + } else { + vFor = getValue(context, dataPath) + } + } + if (Number.isInteger(vFor)) { + context = value + } else if (!propPath) { + context = vFor[value] + } else { + if (isArray(vFor)) { + context = vFor.find(vForItem => { + return getValue(vForItem, propPath) === value + }) + } else if (isPlainObject(vFor)) { + context = Object.keys(vFor).find(vForKey => { + return getValue(vFor[vForKey], propPath) === value + }) + } else { + console.error('v-for 暂不支持循环数据:', vFor) + } + } + if (valuePath) { + context = getValue(context, valuePath) + } + } + }) + return context +} +function processEventExtra(instance, extra, event) { + const extraObj = {} + if (isArray(extra) && extra.length) { + /** + *[ + * ['data.items', 'data.id', item.data.id], + * ['metas', 'id', meta.id] + *], + *[ + * ['data.items', 'data.id', item.data.id], + * ['metas', 'id', meta.id] + *], + *'test' + */ + extra.forEach((dataPath, index) => { + if (typeof dataPath === 'string') { + if (!dataPath) { + // model,prop.sync + extraObj['$' + index] = instance + } else { + if (dataPath === '$event') { + // $event + extraObj['$' + index] = event + } else if (dataPath === 'arguments') { + if (event.detail && event.detail.__args__) { + extraObj['$' + index] = event.detail.__args__ + } else { + extraObj['$' + index] = [event] + } + } else if (dataPath.indexOf('$event.') === 0) { + // $event.target.value + extraObj['$' + index] = getValue( + event, + dataPath.replace('$event.', '') + ) + } else { + extraObj['$' + index] = getValue(instance, dataPath) + } + } + } else { + extraObj['$' + index] = getExtraValue(instance, dataPath) + } + }) + } + return extraObj +} +function getObjByArray(arr) { + const obj = {} + for (let i = 1; i < arr.length; i++) { + const element = arr[i] + obj[element[0]] = element[1] + } + return obj +} +function processEventArgs( + instance, + event, + args = [], + extra = [], + isCustom, + methodName +) { + let isCustomMPEvent = false // wxcomponent 组件,传递原始 event 对象 + if (isCustom) { + // 自定义事件 + isCustomMPEvent = + event.currentTarget && + event.currentTarget.dataset && + event.currentTarget.dataset.comType === 'wx' + if (!args.length) { + // 无参数,直接传入 event 或 detail 数组 + if (isCustomMPEvent) { + return [event] + } + return event.detail.__args__ || event.detail + } + } + const extraObj = processEventExtra(instance, extra, event) + const ret = [] + args.forEach(arg => { + if (arg === '$event') { + if (methodName === '__set_model' && !isCustom) { + // input v-model value + ret.push(event.target.value) + } else { + if (isCustom && !isCustomMPEvent) { + ret.push(event.detail.__args__[0]) + } else { + // wxcomponent 组件或内置组件 + ret.push(event) + } + } + } else { + if (isArray(arg) && arg[0] === 'o') { + ret.push(getObjByArray(arg)) + } else if (typeof arg === 'string' && hasOwn(extraObj, arg)) { + ret.push(extraObj[arg]) + } else { + ret.push(arg) + } + } + }) + return ret +} +function wrapper(event) { + event.stopPropagation = NOOP + event.preventDefault = NOOP + event.target = event.target || {} + if (!hasOwn(event, 'detail')) { + event.detail = {} + } + if (hasOwn(event, 'markerId')) { + event.detail = typeof event.detail === 'object' ? event.detail : {} + event.detail.markerId = event.markerId + } + if (isPlainObject(event.detail)) { + event.target = Object.assign({}, event.target, event.detail) + } + return event +} +const ONCE = '~' +const CUSTOM = '^' +function matchEventType(eventType, optType) { + return ( + eventType === optType || + (optType === 'regionchange' && + (eventType === 'begin' || eventType === 'end')) + ) +} +function handleEvent(event) { + event = wrapper(event) + // [['tap',[['handle',[1,2,a]],['handle1',[1,2,a]]]]] + const dataset = (event.currentTarget || event.target).dataset + if (!dataset) { + return console.warn('事件信息不存在') + } + const eventOpts = dataset.eventOpts || dataset['event-opts'] // 支付宝 web-view 组件 dataset 非驼峰 + if (!eventOpts) { + return console.warn('事件信息不存在') + } + // [['handle',[1,2,a]],['handle1',[1,2,a]]] + const eventType = event.type + const ret = [] + eventOpts.forEach(eventOpt => { + let type = eventOpt[0] + const eventsArray = eventOpt[1] + const isCustom = type.charAt(0) === CUSTOM + type = isCustom ? type.slice(1) : type + const isOnce = type.charAt(0) === ONCE + type = isOnce ? type.slice(1) : type + if (eventsArray && matchEventType(eventType, type)) { + eventsArray.forEach(eventArray => { + const methodName = eventArray[0] + if (methodName) { + let handlerCtx = this.$vm + if ( + handlerCtx.$options.generic && + handlerCtx.$parent && + handlerCtx.$parent.$parent + ) { + // mp-weixin,mp-toutiao 抽象节点模拟 scoped slots + handlerCtx = handlerCtx.$parent.$parent + } + if (methodName === '$emit') { + handlerCtx.$emit.apply( + handlerCtx, + processEventArgs( + this.$vm, + event, + eventArray[1], + eventArray[2], + isCustom, + methodName + ) + ) + return + } + const handler = handlerCtx[methodName] + if (!isFunction(handler)) { + throw new Error(` _vm.${methodName} is not a function`) + } + if (isOnce) { + if (handler.once) { + return + } + handler.once = true + } + ret.push( + handler.apply( + handlerCtx, + processEventArgs( + this.$vm, + event, + eventArray[1], + eventArray[2], + isCustom, + methodName + ) + ) + ) + } + }) + } + }) + if ( + eventType === 'input' && + ret.length === 1 && + typeof ret[0] !== 'undefined' + ) { + return ret[0] + } +} + +function parseComponent( + vueOptions, + { parse, mocks, isPage, initRelation, handleLink, initLifetimes } +) { + vueOptions = vueOptions.default || vueOptions + const options = { + multipleSlots: true, + addGlobalClass: true + } + if (vueOptions.options) { + extend(options, vueOptions.options) + } + const mpComponentOptions = { + options, + lifetimes: initLifetimes({ mocks, isPage, initRelation, vueOptions }), + pageLifetimes: { + show() { + this.$vm && this.$vm.$callHook('onPageShow') + }, + hide() { + this.$vm && this.$vm.$callHook('onPageHide') + }, + resize(size) { + this.$vm && this.$vm.$callHook('onPageResize', size) + } + }, + methods: { + __l: handleLink, + __e: handleEvent + } + } + if (__VUE_OPTIONS_API__) { + applyOptions(mpComponentOptions, vueOptions, initBehavior) + } + initProps(mpComponentOptions, vueOptions.props, false) + initExtraOptions(mpComponentOptions, vueOptions) + initWxsCallMethods(mpComponentOptions.methods, vueOptions.wxsCallMethods) + if (parse) { + parse(mpComponentOptions, { handleLink }) + } + return mpComponentOptions +} +function initCreateComponent(parseOptions) { + return function createComponent(vueComponentOptions) { + return Component(parseComponent(vueComponentOptions, parseOptions)) + } +} +let $createComponentFn +let $destroyComponentFn +function $createComponent(initialVNode, options) { + if (!$createComponentFn) { + $createComponentFn = getApp().$vm.$createComponent + } + return $createComponentFn(initialVNode, options) +} +function $destroyComponent(instance) { + if (!$destroyComponentFn) { + $destroyComponentFn = getApp().$vm.$destroyComponent + } + return $destroyComponentFn(instance) +} + +function parsePage(vueOptions, parseOptions) { + const { + parse, + mocks, + isPage, + initRelation, + handleLink, + initLifetimes + } = parseOptions + const miniProgramPageOptions = parseComponent(vueOptions, { + mocks, + isPage, + initRelation, + handleLink, + initLifetimes + }) + const methods = miniProgramPageOptions.methods + methods.onLoad = function(query) { + this.options = query + this.$page = { + fullPath: '/' + this.route + stringifyQuery(query) + } + return this.$vm && this.$vm.$callHook('onLoad', query) + } + initHooks(methods, PAGE_HOOKS) + initUnknownHooks(methods, vueOptions) + parse && parse(miniProgramPageOptions, { handleLink }) + return miniProgramPageOptions +} +function initCreatePage(parseOptions) { + return function createPage(vuePageOptions) { + return Component(parsePage(vuePageOptions, parseOptions)) + } +} + +const MPPage = Page +const MPComponent = Component +const customizeRE = /:/g +function customize(str) { + return camelize(str.replace(customizeRE, '-')) +} +function initTriggerEvent(mpInstance) { + const oldTriggerEvent = mpInstance.triggerEvent + mpInstance.triggerEvent = function(event, ...args) { + return oldTriggerEvent.apply(mpInstance, [customize(event), ...args]) + } +} +function initHook$1(name, options) { + const oldHook = options[name] + if (!oldHook) { + options[name] = function() { + initTriggerEvent(this) + } + } else { + options[name] = function(...args) { + initTriggerEvent(this) + return oldHook.apply(this, args) + } + } +} +Page = function(options) { + initHook$1('onLoad', options) + return MPPage(options) +} +Component = function(options) { + initHook$1('created', options) + return MPComponent(options) +} + +function initLifetimes({ mocks, isPage, initRelation, vueOptions }) { + return { + attached() { + const properties = this.properties + initVueIds(properties.vueId, this) + const relationOptions = { + vuePid: this._$vuePid + } + // 处理父子关系 + initRelation(this, relationOptions) + // 初始化 vue 实例 + const mpInstance = this + this.$vm = $createComponent( + { + type: vueOptions, + props: properties + }, + { + mpType: isPage(mpInstance) ? 'page' : 'component', + mpInstance, + slots: properties.vueSlots, + parentComponent: relationOptions.parent && relationOptions.parent.$, + onBeforeSetup(instance, options) { + initRefs(instance, mpInstance) + initMocks(instance, mpInstance, mocks) + initComponentInstance(instance, options) + } + } + ) + }, + ready() { + // 当组件 props 默认值为 true,初始化时传入 false 会导致 created,ready 触发, 但 attached 不触发 + // https://developers.weixin.qq.com/community/develop/doc/00066ae2844cc0f8eb883e2a557800 + if (this.$vm) { + this.$vm.$callHook('mounted') + this.$vm.$callHook('onReady') + } + }, + detached() { + this.$vm && $destroyComponent(this.$vm) + } + } +} + +const mocks = ['__route__', '__wxExparserNodeId__', '__wxWebviewId__'] +function isPage(mpInstance) { + return !!mpInstance.route +} +function initRelation(mpInstance, detail) { + mpInstance.triggerEvent('__l', detail) +} +function handleLink(event) { + // detail 是微信,value 是百度(dipatch) + const detail = event.detail || event.value + const vuePid = detail.vuePid + let parentVm + if (vuePid) { + parentVm = findVmByVueId(this.$vm, vuePid) + } + if (!parentVm) { + parentVm = this.$vm + } + detail.parent = parentVm +} + +var parseOptions = /*#__PURE__*/ Object.freeze({ + __proto__: null, + mocks: mocks, + isPage: isPage, + initRelation: initRelation, + handleLink: handleLink, + initLifetimes: initLifetimes +}) + +const createApp = initCreateApp() +const createPage = initCreatePage(parseOptions) +const createComponent = initCreateComponent(parseOptions) + +export { createApp, createComponent, createPage } diff --git a/packages/uni-mp-toutiao/dist/uni.api.esm.js b/packages/uni-mp-toutiao/dist/uni.api.esm.js new file mode 100644 index 0000000000000000000000000000000000000000..2317e273d0aa85131f0f3e5f5ec469c8059be915 --- /dev/null +++ b/packages/uni-mp-toutiao/dist/uni.api.esm.js @@ -0,0 +1,603 @@ +import { + isArray, + isPromise, + isFunction, + isPlainObject, + hasOwn, + isString +} from '@vue/shared' + +function createApi(fn, validate) { + if (process.env.NODE_ENV !== 'production' && validate); + return fn +} + +const Upx2pxProtocol = [ + { + name: 'upx', + type: [Number, String], + required: true + } +] + +const EPS = 1e-4 +const BASE_DEVICE_WIDTH = 750 +let isIOS = false +let deviceWidth = 0 +let deviceDPR = 0 +function checkDeviceWidth() { + const { platform, pixelRatio, windowWidth } = tt.getSystemInfoSync() + deviceWidth = windowWidth + deviceDPR = pixelRatio + isIOS = platform === 'ios' +} +const upx2px = createApi((number, newDeviceWidth) => { + if (deviceWidth === 0) { + checkDeviceWidth() + } + number = Number(number) + if (number === 0) { + return 0 + } + let result = (number / BASE_DEVICE_WIDTH) * (newDeviceWidth || deviceWidth) + if (result < 0) { + result = -result + } + result = Math.floor(result + EPS) + if (result === 0) { + if (deviceDPR === 1 || !isIOS) { + result = 1 + } else { + result = 0.5 + } + } + return number < 0 ? -result : result +}, Upx2pxProtocol) + +var HOOKS +;(function(HOOKS) { + HOOKS['INVOKE'] = 'invoke' + HOOKS['SUCCESS'] = 'success' + HOOKS['FAIL'] = 'fail' + HOOKS['COMPLETE'] = 'complete' + HOOKS['RETURN_VALUE'] = 'returnValue' +})(HOOKS || (HOOKS = {})) +const globalInterceptors = {} +const scopedInterceptors = {} +function wrapperHook(hook) { + return function(data) { + return hook(data) || data + } +} +function queue(hooks, data) { + let promise = false + for (let i = 0; i < hooks.length; i++) { + const hook = hooks[i] + if (promise) { + promise = Promise.resolve(wrapperHook(hook)) + } else { + const res = hook(data) + if (isPromise(res)) { + promise = Promise.resolve(res) + } + if (res === false) { + return { + then() {}, + catch() {} + } + } + } + } + return ( + promise || { + then(callback) { + return callback(data) + }, + catch() {} + } + ) +} +function wrapperOptions(interceptors, options = {}) { + ;[HOOKS.SUCCESS, HOOKS.FAIL, HOOKS.COMPLETE].forEach(name => { + const hooks = interceptors[name] + if (!isArray(hooks)) { + return + } + const oldCallback = options[name] + options[name] = function callbackInterceptor(res) { + queue(hooks, res).then(res => { + return (isFunction(oldCallback) && oldCallback(res)) || res + }) + } + }) + return options +} +function wrapperReturnValue(method, returnValue) { + const returnValueHooks = [] + if (isArray(globalInterceptors.returnValue)) { + returnValueHooks.push(...globalInterceptors.returnValue) + } + const interceptor = scopedInterceptors[method] + if (interceptor && isArray(interceptor.returnValue)) { + returnValueHooks.push(...interceptor.returnValue) + } + returnValueHooks.forEach(hook => { + returnValue = hook(returnValue) || returnValue + }) + return returnValue +} +function getApiInterceptorHooks(method) { + const interceptor = Object.create(null) + Object.keys(globalInterceptors).forEach(hook => { + if (hook !== 'returnValue') { + interceptor[hook] = globalInterceptors[hook].slice() + } + }) + const scopedInterceptor = scopedInterceptors[method] + if (scopedInterceptor) { + Object.keys(scopedInterceptor).forEach(hook => { + if (hook !== 'returnValue') { + interceptor[hook] = (interceptor[hook] || []).concat( + scopedInterceptor[hook] + ) + } + }) + } + return interceptor +} +function invokeApi(method, api, options, ...params) { + const interceptor = getApiInterceptorHooks(method) + if (interceptor && Object.keys(interceptor).length) { + if (isArray(interceptor.invoke)) { + const res = queue(interceptor.invoke, options) + return res.then(options => { + return api(wrapperOptions(interceptor, options), ...params) + }) + } else { + return api(wrapperOptions(interceptor, options), ...params) + } + } + return api(options, ...params) +} + +const AddInterceptorProtocol = [ + { + name: 'method', + type: [String, Object], + required: true + } +] +const RemoveInterceptorProtocol = AddInterceptorProtocol + +function mergeInterceptorHook(interceptors, interceptor) { + Object.keys(interceptor).forEach(hook => { + if (isFunction(interceptor[hook])) { + interceptors[hook] = mergeHook(interceptors[hook], interceptor[hook]) + } + }) +} +function removeInterceptorHook(interceptors, interceptor) { + if (!interceptors || !interceptor) { + return + } + Object.keys(interceptor).forEach(hook => { + if (isFunction(interceptor[hook])) { + removeHook(interceptors[hook], interceptor[hook]) + } + }) +} +function mergeHook(parentVal, childVal) { + const res = childVal + ? parentVal + ? parentVal.concat(childVal) + : isArray(childVal) + ? childVal + : [childVal] + : parentVal + return res ? dedupeHooks(res) : res +} +function dedupeHooks(hooks) { + const res = [] + for (let i = 0; i < hooks.length; i++) { + if (res.indexOf(hooks[i]) === -1) { + res.push(hooks[i]) + } + } + return res +} +function removeHook(hooks, hook) { + if (!hooks) { + return + } + const index = hooks.indexOf(hook) + if (index !== -1) { + hooks.splice(index, 1) + } +} +const addInterceptor = createApi((method, interceptor) => { + if (typeof method === 'string' && isPlainObject(interceptor)) { + mergeInterceptorHook( + scopedInterceptors[method] || (scopedInterceptors[method] = {}), + interceptor + ) + } else if (isPlainObject(method)) { + mergeInterceptorHook(globalInterceptors, method) + } +}, AddInterceptorProtocol) +const removeInterceptor = createApi((method, interceptor) => { + if (typeof method === 'string') { + if (isPlainObject(interceptor)) { + removeInterceptorHook(scopedInterceptors[method], interceptor) + } else { + delete scopedInterceptors[method] + } + } else if (isPlainObject(method)) { + removeInterceptorHook(globalInterceptors, method) + } +}, RemoveInterceptorProtocol) + +const SYNC_API_RE = /^\$|sendNativeEvent|restoreGlobal|getCurrentSubNVue|getMenuButtonBoundingClientRect|^report|interceptors|Interceptor$|getSubNVueById|requireNativePlugin|upx2px|hideKeyboard|canIUse|^create|Sync$|Manager$|base64ToArrayBuffer|arrayBufferToBase64/ +const CONTEXT_API_RE = /^create|Manager$/ +// Context例外情况 +const CONTEXT_API_RE_EXC = ['createBLEConnection'] +// 同步例外情况 +const ASYNC_API = ['createBLEConnection'] +const CALLBACK_API_RE = /^on|^off/ +function isContextApi(name) { + return CONTEXT_API_RE.test(name) && CONTEXT_API_RE_EXC.indexOf(name) === -1 +} +function isSyncApi(name) { + return SYNC_API_RE.test(name) && ASYNC_API.indexOf(name) === -1 +} +function isCallbackApi(name) { + return CALLBACK_API_RE.test(name) && name !== 'onPush' +} +function handlePromise(promise) { + if (!__UNI_PROMISE_API__) { + return promise + } + return promise + .then(data => { + return [null, data] + }) + .catch(err => [err]) +} +function shouldPromise(name) { + if (isContextApi(name) || isSyncApi(name) || isCallbackApi(name)) { + return false + } + return true +} +/* eslint-disable no-extend-native */ +if (!Promise.prototype.finally) { + Promise.prototype.finally = function(onfinally) { + const promise = this.constructor + return this.then( + value => promise.resolve(onfinally && onfinally()).then(() => value), + reason => + promise.resolve(onfinally && onfinally()).then(() => { + throw reason + }) + ) + } +} +function promisify(name, api) { + if (!shouldPromise(name)) { + return api + } + if (!isFunction(api)) { + return api + } + return function promiseApi(options = {}, ...params) { + if ( + isFunction(options.success) || + isFunction(options.fail) || + isFunction(options.complete) + ) { + return wrapperReturnValue(name, invokeApi(name, api, options, ...params)) + } + return wrapperReturnValue( + name, + handlePromise( + new Promise((resolve, reject) => { + invokeApi( + name, + api, + Object.assign({}, options, { + success: resolve, + fail: reject + }), + ...params + ) + }) + ) + ) + } +} + +const CALLBACKS = ['success', 'fail', 'cancel', 'complete'] +function initWrapper(protocols) { + function processCallback(methodName, method, returnValue) { + return function(res) { + return method(processReturnValue(methodName, res, returnValue)) + } + } + function processArgs( + methodName, + fromArgs, + argsOption = {}, + returnValue = {}, + keepFromArgs = false + ) { + if (isPlainObject(fromArgs)) { + // 一般 api 的参数解析 + const toArgs = keepFromArgs === true ? fromArgs : {} // returnValue 为 false 时,说明是格式化返回值,直接在返回值对象上修改赋值 + if (isFunction(argsOption)) { + argsOption = argsOption(fromArgs, toArgs) || {} + } + for (const key in fromArgs) { + if (hasOwn(argsOption, key)) { + let keyOption = argsOption[key] + if (isFunction(keyOption)) { + keyOption = keyOption(fromArgs[key], fromArgs, toArgs) + } + if (!keyOption) { + // 不支持的参数 + console.warn(`字节跳动小程序 ${methodName} 暂不支持 ${key}`) + } else if (isString(keyOption)) { + // 重写参数 key + toArgs[keyOption] = fromArgs[key] + } else if (isPlainObject(keyOption)) { + // {name:newName,value:value}可重新指定参数 key:value + toArgs[keyOption.name ? keyOption.name : key] = keyOption.value + } + } else if (CALLBACKS.indexOf(key) !== -1) { + const callback = fromArgs[key] + if (isFunction(callback)) { + toArgs[key] = processCallback(methodName, callback, returnValue) + } + } else { + if (!keepFromArgs && !hasOwn(toArgs, key)) { + toArgs[key] = fromArgs[key] + } + } + } + return toArgs + } else if (isFunction(fromArgs)) { + fromArgs = processCallback(methodName, fromArgs, returnValue) + } + return fromArgs + } + function processReturnValue( + methodName, + res, + returnValue, + keepReturnValue = false + ) { + if (isFunction(protocols.returnValue)) { + // 处理通用 returnValue + res = protocols.returnValue(methodName, res) + } + return processArgs(methodName, res, returnValue, {}, keepReturnValue) + } + return function wrapper(methodName, method) { + if (!hasOwn(protocols, methodName)) { + return method + } + const protocol = protocols[methodName] + if (!protocol) { + // 暂不支持的 api + return function() { + console.error(`字节跳动小程序 暂不支持${methodName}`) + } + } + return function(arg1, arg2) { + // 目前 api 最多两个参数 + let options = protocol + if (isFunction(protocol)) { + options = protocol(arg1) + } + arg1 = processArgs(methodName, arg1, options.args, options.returnValue) + const args = [arg1] + if (typeof arg2 !== 'undefined') { + args.push(arg2) + } + const returnValue = tt[options.name || methodName].apply(tt, args) + if (isSyncApi(methodName)) { + // 同步 api + return processReturnValue( + methodName, + returnValue, + options.returnValue, + isContextApi(methodName) + ) + } + return returnValue + } + } +} + +const baseApis = { upx2px, addInterceptor, removeInterceptor } +function initUni(api, protocols) { + const wrapper = initWrapper(protocols) + const UniProxyHandlers = { + get(target, key) { + if (hasOwn(target, key)) { + return target[key] + } + if (hasOwn(api, key)) { + return promisify(key, api[key]) + } + if (hasOwn(baseApis, key)) { + return promisify(key, baseApis[key]) + } + // event-api + // provider-api? + return promisify(key, wrapper(key, tt[key])) + } + } + return new Proxy({}, UniProxyHandlers) +} + +function initGetProvider(providers) { + return function getProvider({ service, success, fail, complete }) { + let res + if (providers[service]) { + res = { + errMsg: 'getProvider:ok', + service, + provider: providers[service] + } + isFunction(success) && success(res) + } else { + res = { + errMsg: 'getProvider:fail:服务[' + service + ']不存在' + } + isFunction(fail) && fail(res) + } + isFunction(complete) && complete(res) + } +} + +const previewImage = { + args(fromArgs, toArgs) { + let currentIndex = parseInt(fromArgs.current) + if (isNaN(currentIndex)) { + return + } + const urls = fromArgs.urls + if (!isArray(urls)) { + return + } + const len = urls.length + if (!len) { + return + } + if (currentIndex < 0) { + currentIndex = 0 + } else if (currentIndex >= len) { + currentIndex = len - 1 + } + if (currentIndex > 0) { + toArgs.current = urls[currentIndex] + toArgs.urls = urls.filter( + (item, index) => + index < currentIndex ? item !== urls[currentIndex] : true + ) + } else { + toArgs.current = urls[0] + } + return { + indicator: false, + loop: false + } + } +} +const redirectTo = {} + +const getProvider = initGetProvider({ + oauth: ['toutiao'], + share: ['toutiao'], + payment: ['toutiao'], + push: ['toutiao'] +}) + +var shims = /*#__PURE__*/ Object.freeze({ + __proto__: null, + getProvider: getProvider +}) + +const chooseImage = { + args: { + sizeType: false + } +} +const connectSocket = { + args: { + method: false + } +} +const chooseVideo = { + args: { + camera: false + } +} +const scanCode = { + args: { + onlyFromCamera: false, + scanType: false + } +} +const startAccelerometer = { + args: { + interval: false + } +} +const showToast = { + args: { + image: false, + mask: false + } +} +const showLoading = { + args: { + mask: false + } +} +const showModal = { + args: { + cancelColor: false, + confirmColor: false + } +} +const showActionSheet = { + args: { + itemColor: false + } +} +const login = { + args: { + scopes: false, + timeout: false + } +} +const getUserInfo = { + args: { + lang: false, + timeout: false + } +} +const requestPayment = { + name: tt.pay ? 'pay' : 'requestPayment', + args: { + orderInfo: tt.pay ? 'orderInfo' : 'data' + } +} +const getFileInfo = { + args: { + digestAlgorithm: false + } +} + +var protocols = /*#__PURE__*/ Object.freeze({ + __proto__: null, + chooseImage: chooseImage, + connectSocket: connectSocket, + chooseVideo: chooseVideo, + scanCode: scanCode, + startAccelerometer: startAccelerometer, + showToast: showToast, + showLoading: showLoading, + showModal: showModal, + showActionSheet: showActionSheet, + login: login, + getUserInfo: getUserInfo, + requestPayment: requestPayment, + getFileInfo: getFileInfo, + redirectTo: redirectTo, + previewImage: previewImage +}) + +var index = initUni(shims, protocols) + +export default index diff --git a/packages/uni-mp-toutiao/dist/uni.mp.esm.js b/packages/uni-mp-toutiao/dist/uni.mp.esm.js new file mode 100644 index 0000000000000000000000000000000000000000..1250b506b1560f3c9d3113cd23a134d95f6d4cec --- /dev/null +++ b/packages/uni-mp-toutiao/dist/uni.mp.esm.js @@ -0,0 +1,1077 @@ +import { + isArray, + hasOwn, + toNumber, + isPlainObject, + isObject, + isFunction, + extend, + NOOP, + camelize +} from '@vue/shared' +import { stringifyQuery } from '@dcloudio/uni-shared' + +function setModel(target, key, value, modifiers) { + if (isArray(modifiers)) { + if (modifiers.indexOf('trim') !== -1) { + value = value.trim() + } + if (modifiers.indexOf('number') !== -1) { + value = toNumber(value) + } + } + if (!target) { + target = this + } + target[key] = value +} +function setSync(target, key, value) { + if (!target) { + target = this + } + target[key] = value +} +function getOrig(data) { + if (isPlainObject(data)) { + return data.$orig || data + } + return data +} +function map(val, iteratee) { + let ret, i, l, keys, key + if (isArray(val)) { + ret = new Array(val.length) + for (i = 0, l = val.length; i < l; i++) { + ret[i] = iteratee(val[i], i) + } + return ret + } else if (isObject(val)) { + keys = Object.keys(val) + ret = Object.create(null) + for (i = 0, l = keys.length; i < l; i++) { + key = keys[i] + ret[key] = iteratee(val[key], key, i) + } + return ret + } + return [] +} +const MP_METHODS = [ + 'createSelectorQuery', + 'createIntersectionObserver', + 'selectAllComponents', + 'selectComponent' +] +function createEmitFn(oldEmit, ctx) { + return function emit(event, ...args) { + if (ctx.$scope && event) { + ctx.$scope.triggerEvent(event, { __args__: args }) + } + return oldEmit.apply(this, [event, ...args]) + } +} +function initBaseInstance(instance, options) { + const ctx = instance.ctx + // mp + ctx.mpType = options.mpType // @deprecated + ctx.$mpType = options.mpType + ctx.$scope = options.mpInstance + // TODO @deprecated + ctx.$mp = {} + if (__VUE_OPTIONS_API__) { + ctx._self = {} + } + // $vm + ctx.$scope.$vm = instance.proxy + // slots + { + instance.slots = {} + if (isArray(options.slots) && options.slots.length) { + options.slots.forEach(name => { + instance.slots[name] = true + }) + } + } + // $emit + instance.emit = createEmitFn(instance.emit, ctx) +} +function initComponentInstance(instance, options) { + initBaseInstance(instance, options) + const ctx = instance.ctx + MP_METHODS.forEach(method => { + ctx[method] = function(...args) { + const mpInstance = ctx.$scope + if (mpInstance && mpInstance[method]) { + return mpInstance[method].apply(mpInstance, args) + } + } + }) + // TODO other + ctx.__set_model = setModel + ctx.__set_sync = setSync + ctx.__get_orig = getOrig + // TODO + // ctx.__get_style = getStyle + ctx.__map = map +} +function initMocks(instance, mpInstance, mocks) { + const ctx = instance.ctx + mocks.forEach(mock => { + if (hasOwn(mpInstance, mock)) { + ctx[mock] = mpInstance[mock] + } + }) +} + +const PAGE_HOOKS = [ + 'onLoad', + 'onShow', + // 'onReady', // lifetimes.ready + 'onHide', + 'onUnload', + 'onResize', + // 'onPageScroll', // 影响性能,开发者手动注册 + 'onTabItemTap', + 'onReachBottom', + 'onPullDownRefresh', + // 'onShareTimeline', // 右上角菜单,开发者手动注册 + 'onAddToFavorites' + // 'onShareAppMessage' // 右上角菜单,开发者手动注册 +] +function findHooks(vueOptions, hooks = new Set()) { + if (vueOptions) { + Object.keys(vueOptions).forEach(name => { + if (name.indexOf('on') === 0 && isFunction(vueOptions[name])) { + hooks.add(name) + } + }) + if (__VUE_OPTIONS_API__) { + const { extends: extendsOptions, mixins } = vueOptions + if (mixins) { + mixins.forEach(mixin => findHooks(mixin, hooks)) + } + if (extendsOptions) { + findHooks(extendsOptions, hooks) + } + } + } + return hooks +} +function initHook(mpOptions, hook, excludes) { + if (excludes.indexOf(hook) === -1 && !hasOwn(mpOptions, hook)) { + mpOptions[hook] = function(args) { + if (hook === 'onError') { + return getApp().$vm.$callHook(hook, args) + } + return this.$vm && this.$vm.$callHook(hook, args) + } + } +} +const EXCLUDE_HOOKS = ['onReady'] +function initHooks(mpOptions, hooks, excludes = EXCLUDE_HOOKS) { + hooks.forEach(hook => initHook(mpOptions, hook, excludes)) +} +function initUnknownHooks(mpOptions, vueOptions, excludes = EXCLUDE_HOOKS) { + findHooks(vueOptions).forEach(hook => initHook(mpOptions, hook, excludes)) +} + +const HOOKS = [ + 'onShow', + 'onHide', + 'onError', + 'onThemeChange', + 'onPageNotFound', + 'onUnhandledRejection' +] +function parseApp(instance, parseAppOptions) { + const internalInstance = instance.$ + const appOptions = { + globalData: (instance.$options && instance.$options.globalData) || {}, + $vm: instance, + onLaunch(options) { + const ctx = internalInstance.ctx + if (this.$vm && ctx.$scope) { + // 已经初始化过了,主要是为了百度,百度 onShow 在 onLaunch 之前 + return + } + initBaseInstance(internalInstance, { + mpType: 'app', + mpInstance: this, + slots: [] + }) + ctx.globalData = this.globalData + instance.$callHook('onLaunch', options) + } + } + const vueOptions = instance.$.type + initHooks(appOptions, HOOKS) + initUnknownHooks(appOptions, vueOptions) + if (__VUE_OPTIONS_API__) { + const methods = vueOptions.methods + methods && extend(appOptions, methods) + } + if (parseAppOptions) { + parseAppOptions.parse(appOptions) + } + return appOptions +} +function initCreateApp(parseAppOptions) { + return function createApp(vm) { + return App(parseApp(vm, parseAppOptions)) + } +} + +function initBehavior(options) { + return Behavior(options) +} +function initVueIds(vueIds, mpInstance) { + if (!vueIds) { + return + } + const ids = vueIds.split(',') + const len = ids.length + if (len === 1) { + mpInstance._$vueId = ids[0] + } else if (len === 2) { + mpInstance._$vueId = ids[0] + mpInstance._$vuePid = ids[1] + } +} +const EXTRAS = ['externalClasses'] +function initExtraOptions(miniProgramComponentOptions, vueOptions) { + EXTRAS.forEach(name => { + if (hasOwn(vueOptions, name)) { + miniProgramComponentOptions[name] = vueOptions[name] + } + }) +} +function initWxsCallMethods(methods, wxsCallMethods) { + if (!isArray(wxsCallMethods)) { + return + } + wxsCallMethods.forEach(callMethod => { + methods[callMethod] = function(args) { + return this.$vm[callMethod](args) + } + }) +} +function initRefs(instance, mpInstance) { + Object.defineProperty(instance, 'refs', { + get() { + const $refs = {} + const components = mpInstance.selectAllComponents('.vue-ref') + components.forEach(component => { + const ref = component.dataset.ref + $refs[ref] = component.$vm || component + }) + const forComponents = mpInstance.selectAllComponents('.vue-ref-in-for') + forComponents.forEach(component => { + const ref = component.dataset.ref + if (!$refs[ref]) { + $refs[ref] = [] + } + $refs[ref].push(component.$vm || component) + }) + return $refs + } + }) +} +function findVmByVueId(instance, vuePid) { + // TODO vue3 中 没有 $children + const $children = instance.$children + // 优先查找直属(反向查找:https://github.com/dcloudio/uni-app/issues/1200) + for (let i = $children.length - 1; i >= 0; i--) { + const childVm = $children[i] + if (childVm.$scope._$vueId === vuePid) { + return childVm + } + } + // 反向递归查找 + let parentVm + for (let i = $children.length - 1; i >= 0; i--) { + parentVm = findVmByVueId($children[i], vuePid) + if (parentVm) { + return parentVm + } + } +} + +const PROP_TYPES = [String, Number, Boolean, Object, Array, null] +function createObserver(name) { + return function observer(newVal) { + if (this.$vm) { + this.$vm.$.props[name] = newVal // 为了触发其他非 render watcher + } + } +} +function parsePropType(key, type, defaultValue) { + // [String]=>String + if (isArray(type) && type.length === 1) { + return type[0] + } + return type +} +function initDefaultProps(isBehavior = false) { + const properties = {} + if (!isBehavior) { + properties.vueId = { + type: String, + value: '' + } + { + // 用于字节跳动小程序模拟抽象节点 + properties.generic = { + type: Object + } + } + // 小程序不能直接定义 $slots 的 props,所以通过 vueSlots 转换到 $slots + properties.vueSlots = { + type: null, + value: [], + observer: function(newVal) { + const $slots = Object.create(null) + newVal.forEach(slotName => { + $slots[slotName] = true + }) + this.setData({ + $slots + }) + } + } + } + return properties +} +function createProperty(key, prop) { + prop.observer = createObserver(key) + return prop +} +function initProps(mpComponentOptions, rawProps, isBehavior = false) { + const properties = initDefaultProps(isBehavior) + if (isArray(rawProps)) { + rawProps.forEach(key => { + properties[key] = createProperty(key, { + type: null + }) + }) + } else if (isPlainObject(rawProps)) { + Object.keys(rawProps).forEach(key => { + const opts = rawProps[key] + if (isPlainObject(opts)) { + // title:{type:String,default:''} + let value = opts.default + if (isFunction(value)) { + value = value() + } + const type = opts.type + opts.type = parsePropType(key, type) + properties[key] = createProperty(key, { + type: PROP_TYPES.indexOf(type) !== -1 ? type : null, + value + }) + } else { + // content:String + const type = parsePropType(key, opts) + properties[key] = createProperty(key, { + type: PROP_TYPES.indexOf(type) !== -1 ? type : null + }) + } + }) + } + mpComponentOptions.properties = properties +} + +function initData(vueOptions) { + let data = vueOptions.data || {} + if (typeof data === 'function') { + try { + const appConfig = getApp().$vm.$.appContext.config + data = data.call(appConfig.globalProperties) + } catch (e) { + if (process.env.VUE_APP_DEBUG) { + console.warn( + '根据 Vue 的 data 函数初始化小程序 data 失败,请尽量确保 data 函数中不访问 vm 对象,否则可能影响首次数据渲染速度。', + data, + e + ) + } + } + } else { + try { + // 对 data 格式化 + data = JSON.parse(JSON.stringify(data)) + } catch (e) {} + } + if (!isPlainObject(data)) { + data = {} + } + return data +} +function initBehaviors(vueOptions, initBehavior) { + const vueBehaviors = vueOptions.behaviors + const vueExtends = vueOptions.extends + const vueMixins = vueOptions.mixins + let vueProps = vueOptions.props + if (!vueProps) { + vueOptions.props = vueProps = [] + } + const behaviors = [] + if (isArray(vueBehaviors)) { + vueBehaviors.forEach(behavior => { + behaviors.push(behavior.replace('uni://', `${__PLATFORM_PREFIX__}://`)) + if (behavior === 'uni://form-field') { + if (isArray(vueProps)) { + vueProps.push('name') + vueProps.push('value') + } else { + vueProps.name = { + type: String, + default: '' + } + vueProps.value = { + type: [String, Number, Boolean, Array, Object, Date], + default: '' + } + } + } + }) + } + if (isPlainObject(vueExtends) && vueExtends.props) { + const behavior = {} + initProps(behavior, vueExtends.props, true) + behaviors.push(initBehavior(behavior)) + } + if (isArray(vueMixins)) { + vueMixins.forEach(vueMixin => { + if (isPlainObject(vueMixin) && vueMixin.props) { + const behavior = {} + initProps(behavior, vueMixin.props, true) + behaviors.push(initBehavior(behavior)) + } + }) + } + return behaviors +} +function applyOptions(componentOptions, vueOptions, initBehavior) { + componentOptions.data = initData(vueOptions) + componentOptions.behaviors = initBehaviors(vueOptions, initBehavior) +} + +function getValue(obj, path) { + const parts = path.split('.') + let key = parts[0] + if (key.indexOf('__$n') === 0) { + //number index + key = parseInt(key.replace('__$n', '')) + } + if (parts.length === 1) { + return obj[key] + } + return getValue(obj[key], parts.slice(1).join('.')) +} +function getExtraValue(instance, dataPathsArray) { + let context = instance + dataPathsArray.forEach(dataPathArray => { + const dataPath = dataPathArray[0] + const value = dataPathArray[2] + if (dataPath || typeof value !== 'undefined') { + // ['','',index,'disable'] + const propPath = dataPathArray[1] + const valuePath = dataPathArray[3] + let vFor + if (Number.isInteger(dataPath)) { + vFor = dataPath + } else if (!dataPath) { + vFor = context + } else if (typeof dataPath === 'string' && dataPath) { + if (dataPath.indexOf('#s#') === 0) { + vFor = dataPath.substr(3) + } else { + vFor = getValue(context, dataPath) + } + } + if (Number.isInteger(vFor)) { + context = value + } else if (!propPath) { + context = vFor[value] + } else { + if (isArray(vFor)) { + context = vFor.find(vForItem => { + return getValue(vForItem, propPath) === value + }) + } else if (isPlainObject(vFor)) { + context = Object.keys(vFor).find(vForKey => { + return getValue(vFor[vForKey], propPath) === value + }) + } else { + console.error('v-for 暂不支持循环数据:', vFor) + } + } + if (valuePath) { + context = getValue(context, valuePath) + } + } + }) + return context +} +function processEventExtra(instance, extra, event) { + const extraObj = {} + if (isArray(extra) && extra.length) { + /** + *[ + * ['data.items', 'data.id', item.data.id], + * ['metas', 'id', meta.id] + *], + *[ + * ['data.items', 'data.id', item.data.id], + * ['metas', 'id', meta.id] + *], + *'test' + */ + extra.forEach((dataPath, index) => { + if (typeof dataPath === 'string') { + if (!dataPath) { + // model,prop.sync + extraObj['$' + index] = instance + } else { + if (dataPath === '$event') { + // $event + extraObj['$' + index] = event + } else if (dataPath === 'arguments') { + if (event.detail && event.detail.__args__) { + extraObj['$' + index] = event.detail.__args__ + } else { + extraObj['$' + index] = [event] + } + } else if (dataPath.indexOf('$event.') === 0) { + // $event.target.value + extraObj['$' + index] = getValue( + event, + dataPath.replace('$event.', '') + ) + } else { + extraObj['$' + index] = getValue(instance, dataPath) + } + } + } else { + extraObj['$' + index] = getExtraValue(instance, dataPath) + } + }) + } + return extraObj +} +function getObjByArray(arr) { + const obj = {} + for (let i = 1; i < arr.length; i++) { + const element = arr[i] + obj[element[0]] = element[1] + } + return obj +} +function processEventArgs( + instance, + event, + args = [], + extra = [], + isCustom, + methodName +) { + let isCustomMPEvent = false // wxcomponent 组件,传递原始 event 对象 + if (isCustom) { + // 自定义事件 + isCustomMPEvent = + event.currentTarget && + event.currentTarget.dataset && + event.currentTarget.dataset.comType === 'wx' + if (!args.length) { + // 无参数,直接传入 event 或 detail 数组 + if (isCustomMPEvent) { + return [event] + } + return event.detail.__args__ || event.detail + } + } + const extraObj = processEventExtra(instance, extra, event) + const ret = [] + args.forEach(arg => { + if (arg === '$event') { + if (methodName === '__set_model' && !isCustom) { + // input v-model value + ret.push(event.target.value) + } else { + if (isCustom && !isCustomMPEvent) { + ret.push(event.detail.__args__[0]) + } else { + // wxcomponent 组件或内置组件 + ret.push(event) + } + } + } else { + if (isArray(arg) && arg[0] === 'o') { + ret.push(getObjByArray(arg)) + } else if (typeof arg === 'string' && hasOwn(extraObj, arg)) { + ret.push(extraObj[arg]) + } else { + ret.push(arg) + } + } + }) + return ret +} +function wrapper(event) { + event.stopPropagation = NOOP + event.preventDefault = NOOP + event.target = event.target || {} + if (!hasOwn(event, 'detail')) { + event.detail = {} + } + if (hasOwn(event, 'markerId')) { + event.detail = typeof event.detail === 'object' ? event.detail : {} + event.detail.markerId = event.markerId + } + if (isPlainObject(event.detail)) { + event.target = Object.assign({}, event.target, event.detail) + } + return event +} +const ONCE = '~' +const CUSTOM = '^' +function matchEventType(eventType, optType) { + return ( + eventType === optType || + (optType === 'regionchange' && + (eventType === 'begin' || eventType === 'end')) + ) +} +function handleEvent(event) { + event = wrapper(event) + // [['tap',[['handle',[1,2,a]],['handle1',[1,2,a]]]]] + const dataset = (event.currentTarget || event.target).dataset + if (!dataset) { + return console.warn('事件信息不存在') + } + const eventOpts = dataset.eventOpts || dataset['event-opts'] // 支付宝 web-view 组件 dataset 非驼峰 + if (!eventOpts) { + return console.warn('事件信息不存在') + } + // [['handle',[1,2,a]],['handle1',[1,2,a]]] + const eventType = event.type + const ret = [] + eventOpts.forEach(eventOpt => { + let type = eventOpt[0] + const eventsArray = eventOpt[1] + const isCustom = type.charAt(0) === CUSTOM + type = isCustom ? type.slice(1) : type + const isOnce = type.charAt(0) === ONCE + type = isOnce ? type.slice(1) : type + if (eventsArray && matchEventType(eventType, type)) { + eventsArray.forEach(eventArray => { + const methodName = eventArray[0] + if (methodName) { + let handlerCtx = this.$vm + if ( + handlerCtx.$options.generic && + handlerCtx.$parent && + handlerCtx.$parent.$parent + ) { + // mp-weixin,mp-toutiao 抽象节点模拟 scoped slots + handlerCtx = handlerCtx.$parent.$parent + } + if (methodName === '$emit') { + handlerCtx.$emit.apply( + handlerCtx, + processEventArgs( + this.$vm, + event, + eventArray[1], + eventArray[2], + isCustom, + methodName + ) + ) + return + } + const handler = handlerCtx[methodName] + if (!isFunction(handler)) { + throw new Error(` _vm.${methodName} is not a function`) + } + if (isOnce) { + if (handler.once) { + return + } + handler.once = true + } + ret.push( + handler.apply( + handlerCtx, + processEventArgs( + this.$vm, + event, + eventArray[1], + eventArray[2], + isCustom, + methodName + ) + ) + ) + } + }) + } + }) + if ( + eventType === 'input' && + ret.length === 1 && + typeof ret[0] !== 'undefined' + ) { + return ret[0] + } +} + +function parseComponent( + vueOptions, + { parse, mocks, isPage, initRelation, handleLink, initLifetimes } +) { + vueOptions = vueOptions.default || vueOptions + const options = { + multipleSlots: true, + addGlobalClass: true + } + if (vueOptions.options) { + extend(options, vueOptions.options) + } + const mpComponentOptions = { + options, + lifetimes: initLifetimes({ mocks, isPage, initRelation, vueOptions }), + pageLifetimes: { + show() { + this.$vm && this.$vm.$callHook('onPageShow') + }, + hide() { + this.$vm && this.$vm.$callHook('onPageHide') + }, + resize(size) { + this.$vm && this.$vm.$callHook('onPageResize', size) + } + }, + methods: { + __l: handleLink, + __e: handleEvent + } + } + if (__VUE_OPTIONS_API__) { + applyOptions(mpComponentOptions, vueOptions, initBehavior) + } + initProps(mpComponentOptions, vueOptions.props, false) + initExtraOptions(mpComponentOptions, vueOptions) + initWxsCallMethods(mpComponentOptions.methods, vueOptions.wxsCallMethods) + if (parse) { + parse(mpComponentOptions, { handleLink }) + } + return mpComponentOptions +} +function initCreateComponent(parseOptions) { + return function createComponent(vueComponentOptions) { + return Component(parseComponent(vueComponentOptions, parseOptions)) + } +} +let $createComponentFn +let $destroyComponentFn +function $createComponent(initialVNode, options) { + if (!$createComponentFn) { + $createComponentFn = getApp().$vm.$createComponent + } + return $createComponentFn(initialVNode, options) +} +function $destroyComponent(instance) { + if (!$destroyComponentFn) { + $destroyComponentFn = getApp().$vm.$destroyComponent + } + return $destroyComponentFn(instance) +} + +function parsePage(vueOptions, parseOptions) { + const { + parse, + mocks, + isPage, + initRelation, + handleLink, + initLifetimes + } = parseOptions + const miniProgramPageOptions = parseComponent(vueOptions, { + mocks, + isPage, + initRelation, + handleLink, + initLifetimes + }) + const methods = miniProgramPageOptions.methods + methods.onLoad = function(query) { + this.options = query + this.$page = { + fullPath: '/' + this.route + stringifyQuery(query) + } + return this.$vm && this.$vm.$callHook('onLoad', query) + } + initHooks(methods, PAGE_HOOKS) + initUnknownHooks(methods, vueOptions) + parse && parse(miniProgramPageOptions, { handleLink }) + return miniProgramPageOptions +} +function initCreatePage(parseOptions) { + return function createPage(vuePageOptions) { + return Component(parsePage(vuePageOptions, parseOptions)) + } +} + +const MPPage = Page +const MPComponent = Component +const customizeRE = /:/g +function customize(str) { + return camelize(str.replace(customizeRE, '-')) +} +function initTriggerEvent(mpInstance) { + const oldTriggerEvent = mpInstance.triggerEvent + mpInstance.triggerEvent = function(event, ...args) { + return oldTriggerEvent.apply(mpInstance, [customize(event), ...args]) + } +} +function initHook$1(name, options) { + const oldHook = options[name] + if (!oldHook) { + options[name] = function() { + initTriggerEvent(this) + } + } else { + options[name] = function(...args) { + initTriggerEvent(this) + return oldHook.apply(this, args) + } + } +} +Page = function(options) { + initHook$1('onLoad', options) + return MPPage(options) +} +Component = function(options) { + initHook$1('created', options) + return MPComponent(options) +} + +function provide(instance, key, value) { + if (!instance) { + if (process.env.NODE_ENV !== 'production') { + console.warn(`provide() can only be used inside setup().`) + } + } else { + let provides = instance.provides + // by default an instance inherits its parent's provides object + // but when it needs to provide values of its own, it creates its + // own provides object using parent provides object as prototype. + // this way in `inject` we can simply look up injections from direct + // parent and let the prototype chain do the work. + const parentProvides = instance.parent && instance.parent.provides + if (parentProvides === provides) { + provides = instance.provides = Object.create(parentProvides) + } + // TS doesn't allow symbol as index type + provides[key] = value + } +} +function initProvide(instance) { + const provideOptions = instance.$options.provide + if (!provideOptions) { + return + } + const provides = isFunction(provideOptions) + ? provideOptions.call(instance) + : provideOptions + const internalInstance = instance.$ + for (const key in provides) { + provide(internalInstance, key, provides[key]) + } +} +function inject(instance, key, defaultValue) { + if (instance) { + const provides = instance.provides + if (key in provides) { + // TS doesn't allow symbol as index type + return provides[key] + } else if (arguments.length > 1) { + return defaultValue + } else if (process.env.NODE_ENV !== 'production') { + console.warn(`injection "${String(key)}" not found.`) + } + } else if (process.env.NODE_ENV !== 'production') { + console.warn( + `inject() can only be used inside setup() or functional components.` + ) + } +} +function initInjections(instance) { + const injectOptions = instance.$options.inject + if (!injectOptions) { + return + } + const internalInstance = instance.$ + const ctx = internalInstance.ctx + if (isArray(injectOptions)) { + for (let i = 0; i < injectOptions.length; i++) { + const key = injectOptions[i] + ctx[key] = inject(internalInstance, key) + } + } else { + for (const key in injectOptions) { + const opt = injectOptions[key] + if (isObject(opt)) { + ctx[key] = inject(internalInstance, opt.from, opt.default) + } else { + ctx[key] = inject(internalInstance, opt) + } + } + } +} + +function initLifetimes({ mocks, isPage, initRelation, vueOptions }) { + return { + attached() { + const properties = this.properties + initVueIds(properties.vueId, this) + const relationOptions = { + vuePid: this._$vuePid + } + // 初始化 vue 实例 + const mpInstance = this + const mpType = isPage(mpInstance) ? 'page' : 'component' + if (mpType === 'page' && !mpInstance.route && mpInstance.__route__) { + mpInstance.route = mpInstance.__route__ + } + this.$vm = $createComponent( + { + type: vueOptions, + props: properties + }, + { + mpType, + mpInstance, + slots: properties.vueSlots, + parentComponent: relationOptions.parent && relationOptions.parent.$, + onBeforeSetup(instance, options) { + initRefs(instance, mpInstance) + initMocks(instance, mpInstance, mocks) + initComponentInstance(instance, options) + } + } + ) + // 处理父子关系 + initRelation(this, relationOptions) + }, + detached() { + this.$vm && $destroyComponent(this.$vm) + } + } +} + +const mocks = [ + '__route__', + '__webviewId__', + '__nodeId__', + '__nodeid__' /* @Deprecated */ +] +function isPage(mpInstance) { + return mpInstance.__nodeId__ === 0 || mpInstance.__nodeid__ === 0 +} +const instances = Object.create(null) +function initRelation(mpInstance, detail) { + // 头条 triggerEvent 后,接收事件时机特别晚,已经到了 ready 之后 + const nodeId = hasOwn(mpInstance, '__nodeId__') + ? mpInstance.__nodeId__ + : mpInstance.__nodeid__ + const webviewId = mpInstance.__webviewId__ + '' + instances[webviewId + '_' + nodeId] = mpInstance.$vm + mpInstance.triggerEvent('__l', { + vuePid: detail.vuePid, + nodeId, + webviewId + }) +} +function handleLink({ detail: { vuePid, nodeId, webviewId } }) { + const vm = instances[webviewId + '_' + nodeId] + if (!vm) { + return + } + let parentVm + if (vuePid) { + parentVm = findVmByVueId(this.$vm, vuePid) + } + if (!parentVm) { + parentVm = this.$vm + } + vm.$.parent = parentVm.$ + if (__VUE_OPTIONS_API__) { + parentVm.$children.push(vm) + const parent = parentVm.$ + vm.$.provides = parent + ? parent.provides + : Object.create(parent.appContext.provides) + initInjections(vm) + initProvide(vm) + } + vm.$callSyncHook('created') + vm.$callHook('mounted') + vm.$callHook('onReady') +} +function parse(componentOptions, { handleLink }) { + componentOptions.methods.__l = handleLink +} + +var parseComponentOptions = /*#__PURE__*/ Object.freeze({ + __proto__: null, + mocks: mocks, + isPage: isPage, + instances: instances, + initRelation: initRelation, + handleLink: handleLink, + parse: parse, + initLifetimes: initLifetimes +}) + +function initLifetimes$1(lifetimesOptions) { + return extend(initLifetimes(lifetimesOptions), { + ready() { + if (this.$vm && lifetimesOptions.isPage(this)) { + this.$vm.$callSyncHook('created') + this.$vm.$callHook('mounted') + this.$vm.$callHook('onReady') + } else { + this.is && console.warn(this.is + ' is not ready') + } + }, + detached() { + this.$vm && $destroyComponent(this.$vm) + // 清理 + const webviewId = this.__webviewId__ + webviewId && + Object.keys(instances).forEach(key => { + if (key.indexOf(webviewId + '_') === 0) { + delete instances[key] + } + }) + } + }) +} + +var parsePageOptions = /*#__PURE__*/ Object.freeze({ + __proto__: null, + mocks: mocks, + isPage: isPage, + initRelation: initRelation, + handleLink: handleLink, + parse: parse, + initLifetimes: initLifetimes$1 +}) + +const createApp = initCreateApp() +const createPage = initCreatePage(parsePageOptions) +const createComponent = initCreateComponent(parseComponentOptions) + +export { createApp, createComponent, createPage } diff --git a/packages/uni-mp-vue/dist/vue.runtime.esm.js b/packages/uni-mp-vue/dist/vue.runtime.esm.js new file mode 100644 index 0000000000000000000000000000000000000000..2fd1baabf6cc4b476ca4e3acf48bb74702db0fd3 --- /dev/null +++ b/packages/uni-mp-vue/dist/vue.runtime.esm.js @@ -0,0 +1,3879 @@ +import { + isSymbol, + extend, + isObject, + toRawType, + def, + isArray, + isString, + isFunction, + isPromise, + capitalize, + remove, + EMPTY_OBJ, + NOOP, + isGloballyWhitelisted, + isIntegerKey, + hasOwn, + hasChanged, + NO, + invokeArrayFns, + EMPTY_ARR, + camelize, + makeMap, + hyphenate, + isReservedProp, + toTypeString, + isOn +} from '@vue/shared' +export { camelize } from '@vue/shared' +import { isCustomElement } from '@dcloudio/uni-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, + has, + ownKeys, + 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 + : type // fixed by xxxxxxx + 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) +} +// fixed by xxxxxx +function logError(err, type, contextVNode) { + if (process.env.NODE_ENV !== 'production') { + const info = ErrorTypeStrings[type] || type // fixed by xxxxxx + 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 +// fixed by xxxxxx +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 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) + } + } +} + +// mark the current rendering instance for asset resolution (e.g. +// resolveComponent, resolveDirective) during render +let currentRenderingInstance = null +function markAttrsAccessed() {} + +function emit(instance, event, ...args) { + const props = instance.vnode.props || EMPTY_OBJ + if (process.env.NODE_ENV !== 'production') { + const options = normalizeEmitsOptions(instance.type) + if (options) { + if (!(event in options)) { + const propsOptions = normalizePropsOptions(instance.type)[0] + 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 = options[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' || false); + 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) { + if (hasOwn(comp, '__emits')) { + return comp.__emits + } + const raw = comp.emits + let normalized = {} + // apply mixin/extends props + let hasExtends = false + if (__VUE_OPTIONS_API__ && !isFunction(comp)) { + if (comp.extends) { + hasExtends = true + extend(normalized, normalizeEmitsOptions(comp.extends)) + } + if (comp.mixins) { + hasExtends = true + comp.mixins.forEach(m => extend(normalized, normalizeEmitsOptions(m))) + } + } + if (!raw && !hasExtends) { + return (comp.__emits = undefined) + } + if (isArray(raw)) { + raw.forEach(key => (normalized[key] = null)) + } else { + extend(normalized, raw) + } + return (comp.__emits = 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(comp, key) { + let emits + if (!isOn(key) || !(emits = normalizeEmitsOptions(comp))) { + return false + } + key = key.replace(/Once$/, '') + return ( + hasOwn(emits, key[2].toLowerCase() + key.slice(3)) || + hasOwn(emits, key.slice(2)) + ) +} + +function initProps( + instance, + rawProps, + isStateful, // result of bitwise flag comparison + isSSR = false +) { + const props = {} + const attrs = {} + // def(attrs, InternalObjectKey, 1) // fixed by xxxxx + def(attrs, '__vInternal', 1) + setFullProps(instance, rawProps, props, attrs) + // validation + if (process.env.NODE_ENV !== 'production') { + validateProps(props, instance.type) + } + 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 setFullProps(instance, rawProps, props, attrs) { + const [options, needCastKeys] = normalizePropsOptions(instance.type) + 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.type, 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) { + if (comp.__props) { + return comp.__props + } + const raw = comp.props + const normalized = {} + const needCastKeys = [] + // apply mixin/extends props + let hasExtends = false + if (__VUE_OPTIONS_API__ && !isFunction(comp)) { + const extendProps = raw => { + const [props, keys] = normalizePropsOptions(raw) + extend(normalized, props) + if (keys) needCastKeys.push(...keys) + } + if (comp.extends) { + hasExtends = true + extendProps(comp.extends) + } + if (comp.mixins) { + hasExtends = true + comp.mixins.forEach(extendProps) + } + } + if (!raw && !hasExtends) { + return (comp.__props = EMPTY_ARR) + } + if (isArray(raw)) { + for (let i = 0; i < raw.length; i++) { + if (process.env.NODE_ENV !== 'production' && !isString(raw[i])) { + warn(`props must be strings when using array syntax.`, raw[i]) + } + const normalizedKey = camelize(raw[i]) + if (validatePropName(normalizedKey)) { + normalized[normalizedKey] = EMPTY_OBJ + } + } + } else if (raw) { + if (process.env.NODE_ENV !== 'production' && !isObject(raw)) { + warn(`invalid props options`, raw) + } + for (const key in raw) { + const normalizedKey = camelize(key) + if (validatePropName(normalizedKey)) { + const opt = raw[key] + const prop = (normalized[normalizedKey] = + isArray(opt) || isFunction(opt) ? { type: opt } : opt) + if (prop) { + const booleanIndex = getTypeIndex(Boolean, prop.type) + const stringIndex = getTypeIndex(String, prop.type) + prop[0 /* shouldCast */] = booleanIndex > -1 + prop[1 /* shouldCastTrue */] = + stringIndex < 0 || booleanIndex < stringIndex + // if the prop needs boolean casting or default value + if (booleanIndex > -1 || hasOwn(prop, 'default')) { + needCastKeys.push(normalizedKey) + } + } + } + } + } + const normalizedEntry = [normalized, needCastKeys] + comp.__props = normalizedEntry + return normalizedEntry +} +// 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, comp) { + const rawValues = toRaw(props) + const options = normalizePropsOptions(comp)[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().` + + `` + ) + } +} +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) +} + +const isKeepAlive = vnode => vnode.type.__isKeepAlive +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) +} + +/** +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) + } +} + +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) + } +} +// fixed by xxxxxx +function createAppAPI() { + // render: RootRenderFunction, + // hydrate?: RootHydrateFunction + 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() + // fixed by xxxxxx + // let isMounted = false + const app = (context.app = { + _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 + }, + // fixed by xxxxxx + mount() {}, + // fixed by xxxxxx + unmount() {}, + 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 + } +} + +const queuePostRenderEffect = queuePostFlushCb + +// Simple effect. +function watchEffect(effect, options) { + return doWatch(effect, null, options) +} +// initial value for watchers to trigger on undefined initial values +const INITIAL_WATCHER_VALUE = {} +// implementation +function watch(source, cb, options) { + if (process.env.NODE_ENV !== 'production' && !isFunction(cb)) { + warn( + `\`watch(fn, options?)\` signature has been moved to a separate API. ` + + `Use \`watchEffect(fn, options?)\` instead. \`watch\` now only ` + + `supports \`watch(source, cb, options?) signature.` + ) + } + return doWatch(source, cb, options) +} +function doWatch( + source, + cb, + { immediate, deep, flush, onTrack, onTrigger } = EMPTY_OBJ, + instance = currentInstance +) { + if (process.env.NODE_ENV !== 'production' && !cb) { + if (immediate !== undefined) { + warn( + `watch() "immediate" option is only respected when using the ` + + `watch(source, callback, options?) signature.` + ) + } + if (deep !== undefined) { + warn( + `watch() "deep" option is only respected when using the ` + + `watch(source, callback, options?) signature.` + ) + } + } + const warnInvalidSource = s => { + warn( + `Invalid watch source: `, + s, + `A watch source can only be a getter/effect function, a ref, ` + + `a reactive object, or an array of these types.` + ) + } + let getter + const isRefSource = isRef(source) + if (isRefSource) { + getter = () => source.value + } else if (isReactive(source)) { + getter = () => source + deep = true + } else if (isArray(source)) { + getter = () => + source.map(s => { + if (isRef(s)) { + return s.value + } else if (isReactive(s)) { + return traverse(s) + } else if (isFunction(s)) { + return callWithErrorHandling(s, instance, 2 /* WATCH_GETTER */) + } else { + process.env.NODE_ENV !== 'production' && warnInvalidSource(s) + } + }) + } else if (isFunction(source)) { + if (cb) { + // getter with cb + getter = () => + callWithErrorHandling(source, instance, 2 /* WATCH_GETTER */) + } else { + // no cb -> simple effect + getter = () => { + if (instance && instance.isUnmounted) { + return + } + if (cleanup) { + cleanup() + } + return callWithErrorHandling(source, instance, 3 /* WATCH_CALLBACK */, [ + onInvalidate + ]) + } + } + } else { + getter = NOOP + process.env.NODE_ENV !== 'production' && warnInvalidSource(source) + } + if (cb && deep) { + const baseGetter = getter + getter = () => traverse(baseGetter()) + } + let cleanup + const onInvalidate = fn => { + cleanup = runner.options.onStop = () => { + callWithErrorHandling(fn, instance, 4 /* WATCH_CLEANUP */) + } + } + let oldValue = isArray(source) ? [] : INITIAL_WATCHER_VALUE + const job = () => { + if (!runner.active) { + return + } + if (cb) { + // watch(source, cb) + const newValue = runner() + if (deep || isRefSource || hasChanged(newValue, oldValue)) { + // cleanup before running cb again + if (cleanup) { + cleanup() + } + callWithAsyncErrorHandling(cb, instance, 3 /* WATCH_CALLBACK */, [ + newValue, + // pass undefined as the old value when it's changed for the first time + oldValue === INITIAL_WATCHER_VALUE ? undefined : oldValue, + onInvalidate + ]) + oldValue = newValue + } + } else { + // watchEffect + runner() + } + } + // important: mark the job as a watcher callback so that scheduler knows it + // it is allowed to self-trigger (#1727) + job.allowRecurse = !!cb + let scheduler + if (flush === 'sync') { + scheduler = job + } else if (flush === 'pre') { + // ensure it's queued before component updates (which have positive ids) + job.id = -1 + scheduler = () => { + if (!instance || instance.isMounted) { + queuePreFlushCb(job) + } else { + // with 'pre' option, the first call must happen before + // the component is mounted so it is called synchronously. + job() + } + } + } else { + scheduler = () => queuePostRenderEffect(job, instance && instance.suspense) + } + const runner = effect(getter, { + lazy: true, + onTrack, + onTrigger, + scheduler + }) + recordInstanceBoundEffect(runner) + // initial run + if (cb) { + if (immediate) { + job() + } else { + oldValue = runner() + } + } else { + runner() + } + return () => { + stop(runner) + if (instance) { + remove(instance.effects, runner) + } + } +} +// this.$watch +function instanceWatch(source, cb, options) { + const publicThis = this.proxy + const getter = isString(source) + ? () => publicThis[source] + : source.bind(publicThis) + return doWatch(getter, cb.bind(publicThis), options, this) +} +function traverse(value, seen = new Set()) { + if (!isObject(value) || seen.has(value)) { + return value + } + seen.add(value) + if (isRef(value)) { + traverse(value.value, seen) + } else if (isArray(value)) { + for (let i = 0; i < value.length; i++) { + traverse(value[i], seen) + } + } else if (value instanceof Map) { + value.forEach((v, key) => { + // to register mutation dep for existing keys + traverse(value.get(key), seen) + }) + } else if (value instanceof Set) { + value.forEach(v => { + traverse(v, seen) + }) + } else { + for (const key in value) { + traverse(value[key], seen) + } + } + return value +} + +function provide(key, value) { + if (!currentInstance) { + if (process.env.NODE_ENV !== 'production') { + warn(`provide() can only be used inside setup().`) + } + } else { + let provides = currentInstance.provides + // by default an instance inherits its parent's provides object + // but when it needs to provide values of its own, it creates its + // own provides object using parent provides object as prototype. + // this way in `inject` we can simply look up injections from direct + // parent and let the prototype chain do the work. + const parentProvides = + currentInstance.parent && currentInstance.parent.provides + if (parentProvides === provides) { + provides = currentInstance.provides = Object.create(parentProvides) + } + // TS doesn't allow symbol as index type + provides[key] = value + } +} +function inject(key, defaultValue) { + // fallback to `currentRenderingInstance` so that this can be called in + // a functional component + const instance = currentInstance || currentRenderingInstance + if (instance) { + const provides = instance.provides + if (key in provides) { + // TS doesn't allow symbol as index type + return provides[key] + } else if (arguments.length > 1) { + return defaultValue + } else if (process.env.NODE_ENV !== 'production') { + warn(`injection "${String(key)}" not found.`) + } + } else if (process.env.NODE_ENV !== 'production') { + warn(`inject() can only be used inside setup() or functional components.`) + } +} + +function createDuplicateChecker() { + const cache = Object.create(null) + return (type, key) => { + if (cache[key]) { + warn(`${type} property "${key}" is already defined in ${cache[key]}.`) + } else { + cache[key] = type + } + } +} +let isInBeforeCreate = false +function applyOptions( + instance, + options, + deferredData = [], + deferredWatch = [], + asMixin = false +) { + const { + // composition + mixins, + extends: extendsOptions, + // state + data: dataOptions, + computed: computedOptions, + methods, + watch: watchOptions, + provide: provideOptions, + inject: injectOptions, + // assets + components, + directives, + // lifecycle + beforeMount, + mounted, + beforeUpdate, + updated, + activated, + deactivated, + beforeUnmount, + unmounted, + render, + renderTracked, + renderTriggered, + errorCaptured + } = options + const publicThis = instance.proxy + const ctx = instance.ctx + const globalMixins = instance.appContext.mixins + if (asMixin && render && instance.render === NOOP) { + instance.render = render + } + // applyOptions is called non-as-mixin once per instance + if (!asMixin) { + isInBeforeCreate = true + callSyncHook('beforeCreate', options, publicThis, globalMixins) + isInBeforeCreate = false + // global mixins are applied first + applyMixins(instance, globalMixins, deferredData, deferredWatch) + } + // extending a base component... + if (extendsOptions) { + applyOptions(instance, extendsOptions, deferredData, deferredWatch, true) + } + // local mixins + if (mixins) { + applyMixins(instance, mixins, deferredData, deferredWatch) + } + const checkDuplicateProperties = + process.env.NODE_ENV !== 'production' ? createDuplicateChecker() : null + if (process.env.NODE_ENV !== 'production') { + const propsOptions = normalizePropsOptions(options)[0] + if (propsOptions) { + for (const key in propsOptions) { + checkDuplicateProperties('Props' /* PROPS */, key) + } + } + } + // options initialization order (to be consistent with Vue 2): + // - props (already done outside of this function) + // - inject + // - methods + // - data (deferred since it relies on `this` access) + // - computed + // - watch (deferred since it relies on `this` access) + // fixed by xxxxxx + if (!__VUE_CREATED_DEFERRED__ && injectOptions) { + if (isArray(injectOptions)) { + for (let i = 0; i < injectOptions.length; i++) { + const key = injectOptions[i] + ctx[key] = inject(key) + if (process.env.NODE_ENV !== 'production') { + checkDuplicateProperties('Inject' /* INJECT */, key) + } + } + } else { + for (const key in injectOptions) { + const opt = injectOptions[key] + if (isObject(opt)) { + ctx[key] = inject(opt.from, opt.default) + } else { + ctx[key] = inject(opt) + } + if (process.env.NODE_ENV !== 'production') { + checkDuplicateProperties('Inject' /* INJECT */, key) + } + } + } + } + if (methods) { + for (const key in methods) { + const methodHandler = methods[key] + if (isFunction(methodHandler)) { + ctx[key] = methodHandler.bind(publicThis) + if (process.env.NODE_ENV !== 'production') { + checkDuplicateProperties('Methods' /* METHODS */, key) + } + } else if (process.env.NODE_ENV !== 'production') { + warn( + `Method "${key}" has type "${typeof methodHandler}" in the component definition. ` + + `Did you reference the function correctly?` + ) + } + } + } + if (!asMixin) { + if (deferredData.length) { + deferredData.forEach(dataFn => resolveData(instance, dataFn, publicThis)) + } + if (dataOptions) { + resolveData(instance, dataOptions, publicThis) + } + if (process.env.NODE_ENV !== 'production') { + const rawData = toRaw(instance.data) + for (const key in rawData) { + checkDuplicateProperties('Data' /* DATA */, key) + // expose data on ctx during dev + if (key[0] !== '$' && key[0] !== '_') { + Object.defineProperty(ctx, key, { + configurable: true, + enumerable: true, + get: () => rawData[key], + set: NOOP + }) + } + } + } + } else if (dataOptions) { + deferredData.push(dataOptions) + } + if (computedOptions) { + for (const key in computedOptions) { + const opt = computedOptions[key] + const get = isFunction(opt) + ? opt.bind(publicThis, publicThis) + : isFunction(opt.get) + ? opt.get.bind(publicThis, publicThis) + : NOOP + if (process.env.NODE_ENV !== 'production' && get === NOOP) { + warn(`Computed property "${key}" has no getter.`) + } + const set = + !isFunction(opt) && isFunction(opt.set) + ? opt.set.bind(publicThis) + : process.env.NODE_ENV !== 'production' + ? () => { + warn( + `Write operation failed: computed property "${key}" is readonly.` + ) + } + : NOOP + const c = computed$1({ + get, + set + }) + Object.defineProperty(ctx, key, { + enumerable: true, + configurable: true, + get: () => c.value, + set: v => (c.value = v) + }) + if (process.env.NODE_ENV !== 'production') { + checkDuplicateProperties('Computed' /* COMPUTED */, key) + } + } + } + if (watchOptions) { + deferredWatch.push(watchOptions) + } + if (!asMixin && deferredWatch.length) { + deferredWatch.forEach(watchOptions => { + for (const key in watchOptions) { + createWatcher(watchOptions[key], ctx, publicThis, key) + } + }) + } + // fixed by xxxxxx + if (!__VUE_CREATED_DEFERRED__ && provideOptions) { + const provides = isFunction(provideOptions) + ? provideOptions.call(publicThis) + : provideOptions + for (const key in provides) { + provide(key, provides[key]) + } + } + // asset options. + // To reduce memory usage, only components with mixins or extends will have + // resolved asset registry attached to instance. + if (asMixin) { + if (components) { + extend( + instance.components || + (instance.components = extend({}, instance.type.components)), + components + ) + } + if (directives) { + extend( + instance.directives || + (instance.directives = extend({}, instance.type.directives)), + directives + ) + } + } + // fixed by xxxxxx + // lifecycle options + if (__VUE_CREATED_DEFERRED__) { + ctx.$callSyncHook = function(name) { + return callSyncHook(name, options, publicThis, globalMixins) + } + } else if (!asMixin) { + callSyncHook('created', options, publicThis, globalMixins) + } + if (beforeMount) { + onBeforeMount(beforeMount.bind(publicThis)) + } + if (mounted) { + onMounted(mounted.bind(publicThis)) + } + if (beforeUpdate) { + onBeforeUpdate(beforeUpdate.bind(publicThis)) + } + if (updated) { + onUpdated(updated.bind(publicThis)) + } + if (activated) { + onActivated(activated.bind(publicThis)) + } + if (deactivated) { + onDeactivated(deactivated.bind(publicThis)) + } + if (errorCaptured) { + onErrorCaptured(errorCaptured.bind(publicThis)) + } + if (renderTracked) { + onRenderTracked(renderTracked.bind(publicThis)) + } + if (renderTriggered) { + onRenderTriggered(renderTriggered.bind(publicThis)) + } + if (beforeUnmount) { + onBeforeUnmount(beforeUnmount.bind(publicThis)) + } + if (unmounted) { + onUnmounted(unmounted.bind(publicThis)) + } + // fixed by xxxxxx + if (instance.ctx.$onApplyOptions) { + instance.ctx.$onApplyOptions(options, instance, publicThis) + } +} +function callSyncHook(name, options, ctx, globalMixins) { + callHookFromMixins(name, globalMixins, ctx) + const { extends: base, mixins } = options + if (base) { + callHookFromExtends(name, base, ctx) + } + if (mixins) { + callHookFromMixins(name, mixins, ctx) + } + const selfHook = options[name] + if (selfHook) { + selfHook.call(ctx) + } +} +function callHookFromExtends(name, base, ctx) { + if (base.extends) { + callHookFromExtends(name, base.extends, ctx) + } + const baseHook = base[name] + if (baseHook) { + baseHook.call(ctx) + } +} +function callHookFromMixins(name, mixins, ctx) { + for (let i = 0; i < mixins.length; i++) { + const chainedMixins = mixins[i].mixins + if (chainedMixins) { + callHookFromMixins(name, chainedMixins, ctx) + } + const fn = mixins[i][name] + if (fn) { + fn.call(ctx) + } + } +} +function applyMixins(instance, mixins, deferredData, deferredWatch) { + for (let i = 0; i < mixins.length; i++) { + applyOptions(instance, mixins[i], deferredData, deferredWatch, true) + } +} +function resolveData(instance, dataFn, publicThis) { + if (process.env.NODE_ENV !== 'production' && !isFunction(dataFn)) { + warn( + `The data option must be a function. ` + + `Plain object usage is no longer supported.` + ) + } + const data = dataFn.call(publicThis, publicThis) + if (process.env.NODE_ENV !== 'production' && isPromise(data)) { + warn( + `data() returned a Promise - note data() cannot be async; If you ` + + `intend to perform data fetching before component renders, use ` + + `async setup() + .` + ) + } + if (!isObject(data)) { + process.env.NODE_ENV !== 'production' && + warn(`data() should return an object.`) + } else if (instance.data === EMPTY_OBJ) { + instance.data = reactive(data) + } else { + // existing data: this is a mixin or extends. + extend(instance.data, data) + } +} +function createWatcher(raw, ctx, publicThis, key) { + const getter = () => publicThis[key] + if (isString(raw)) { + const handler = ctx[raw] + if (isFunction(handler)) { + watch(getter, handler) + } else if (process.env.NODE_ENV !== 'production') { + warn(`Invalid watch handler specified by key "${raw}"`, handler) + } + } else if (isFunction(raw)) { + watch(getter, raw.bind(publicThis)) + } else if (isObject(raw)) { + if (isArray(raw)) { + raw.forEach(r => createWatcher(r, ctx, publicThis, key)) + } else { + const handler = isFunction(raw.handler) + ? raw.handler.bind(publicThis) + : ctx[raw.handler] + if (isFunction(handler)) { + watch(getter, handler, raw) + } else if (process.env.NODE_ENV !== 'production') { + warn(`Invalid watch handler specified by key "${raw.handler}"`, handler) + } + } + } else if (process.env.NODE_ENV !== 'production') { + warn(`Invalid watch option: "${key}"`) + } +} +function resolveMergedOptions(instance) { + const raw = instance.type + const { __merged, mixins, extends: extendsOptions } = raw + if (__merged) return __merged + const globalMixins = instance.appContext.mixins + if (!globalMixins.length && !mixins && !extendsOptions) return raw + const options = {} + globalMixins.forEach(m => mergeOptions(options, m, instance)) + extendsOptions && mergeOptions(options, extendsOptions, instance) + mixins && mixins.forEach(m => mergeOptions(options, m, instance)) + mergeOptions(options, raw, instance) + return (raw.__merged = options) +} +function mergeOptions(to, from, instance) { + const strats = instance.appContext.config.optionMergeStrategies + for (const key in from) { + if (strats && hasOwn(strats, key)) { + to[key] = strats[key](to[key], from[key], instance.proxy, key) + } else if (!hasOwn(to, key)) { + to[key] = from[key] + } + } +} + +const publicPropertiesMap = extend(Object.create(null), { + $: i => i, + $el: i => i.vnode.el, + $data: i => i.data, + $props: i => + process.env.NODE_ENV !== 'production' ? shallowReadonly(i.props) : i.props, + $attrs: i => + process.env.NODE_ENV !== 'production' ? shallowReadonly(i.attrs) : i.attrs, + $slots: i => + process.env.NODE_ENV !== 'production' ? shallowReadonly(i.slots) : i.slots, + $refs: i => + process.env.NODE_ENV !== 'production' ? shallowReadonly(i.refs) : i.refs, + $parent: i => i.parent && i.parent.proxy, + $root: i => i.root && i.root.proxy, + $emit: i => i.emit, + $options: i => (__VUE_OPTIONS_API__ ? resolveMergedOptions(i) : i.type), + $forceUpdate: i => () => queueJob(i.update), + // $nextTick: () => nextTick, // fixed by xxxxxx + $watch: i => (__VUE_OPTIONS_API__ ? instanceWatch.bind(i) : NOOP) +}) +const PublicInstanceProxyHandlers = { + get({ _: instance }, key) { + const { + ctx, + setupState, + data, + props, + accessCache, + type, + appContext + } = instance + // let @vue/reactivity know it should never observe Vue public instances. + if (key === '__v_skip' /* SKIP */) { + return true + } + // data / props / ctx + // This getter gets called for every property access on the render context + // during render and is a major hotspot. The most expensive part of this + // is the multiple hasOwn() calls. It's much faster to do a simple property + // access on a plain object, so we use an accessCache object (with null + // prototype) to memoize what access type a key corresponds to. + let normalizedProps + if (key[0] !== '$') { + const n = accessCache[key] + if (n !== undefined) { + switch (n) { + case 0 /* SETUP */: + return setupState[key] + case 1 /* DATA */: + return data[key] + case 3 /* CONTEXT */: + return ctx[key] + case 2 /* PROPS */: + return props[key] + // default: just fallthrough + } + } else if (setupState !== EMPTY_OBJ && hasOwn(setupState, key)) { + accessCache[key] = 0 /* SETUP */ + return setupState[key] + } else if (data !== EMPTY_OBJ && hasOwn(data, key)) { + accessCache[key] = 1 /* DATA */ + return data[key] + } else if ( + // only cache other properties when instance has declared (thus stable) + // props + (normalizedProps = normalizePropsOptions(type)[0]) && + hasOwn(normalizedProps, key) + ) { + accessCache[key] = 2 /* PROPS */ + return props[key] + } else if (ctx !== EMPTY_OBJ && hasOwn(ctx, key)) { + accessCache[key] = 3 /* CONTEXT */ + return ctx[key] + } else if (!__VUE_OPTIONS_API__ || !isInBeforeCreate) { + accessCache[key] = 4 /* OTHER */ + } + } + const publicGetter = publicPropertiesMap[key] + let cssModule, globalProperties + // public $xxx properties + if (publicGetter) { + if (key === '$attrs') { + track(instance, 'get' /* GET */, key) + process.env.NODE_ENV !== 'production' && markAttrsAccessed() + } + return publicGetter(instance) + } else if ( + // css module (injected by vue-loader) + (cssModule = type.__cssModules) && + (cssModule = cssModule[key]) + ) { + return cssModule + } else if (ctx !== EMPTY_OBJ && hasOwn(ctx, key)) { + // user may set custom properties to `this` that start with `$` + accessCache[key] = 3 /* CONTEXT */ + return ctx[key] + } else if ( + // global properties + ((globalProperties = appContext.config.globalProperties), + hasOwn(globalProperties, key)) + ) { + return globalProperties[key] + } else if ( + process.env.NODE_ENV !== 'production' && + currentRenderingInstance && + (!isString(key) || + // #1091 avoid internal isRef/isVNode checks on component instance leading + // to infinite warning loop + key.indexOf('__v') !== 0) + ) { + if (data !== EMPTY_OBJ && key[0] === '$' && hasOwn(data, key)) { + warn( + `Property ${JSON.stringify( + key + )} must be accessed via $data because it starts with a reserved ` + + `character and is not proxied on the render context.` + ) + } else { + warn( + `Property ${JSON.stringify(key)} was accessed during render ` + + `but is not defined on instance.` + ) + } + } + }, + set({ _: instance }, key, value) { + const { data, setupState, ctx } = instance + if (setupState !== EMPTY_OBJ && hasOwn(setupState, key)) { + setupState[key] = value + } else if (data !== EMPTY_OBJ && hasOwn(data, key)) { + data[key] = value + } else if (key in instance.props) { + process.env.NODE_ENV !== 'production' && + warn( + `Attempting to mutate prop "${key}". Props are readonly.`, + instance + ) + return false + } + if (key[0] === '$' && key.slice(1) in instance) { + process.env.NODE_ENV !== 'production' && + warn( + `Attempting to mutate public property "${key}". ` + + `Properties starting with $ are reserved and readonly.`, + instance + ) + return false + } else { + if ( + process.env.NODE_ENV !== 'production' && + key in instance.appContext.config.globalProperties + ) { + Object.defineProperty(ctx, key, { + enumerable: true, + configurable: true, + value + }) + } else { + ctx[key] = value + } + } + return true + }, + has( + { + _: { data, setupState, accessCache, ctx, type, appContext } + }, + key + ) { + let normalizedProps + return ( + accessCache[key] !== undefined || + (data !== EMPTY_OBJ && hasOwn(data, key)) || + (setupState !== EMPTY_OBJ && hasOwn(setupState, key)) || + ((normalizedProps = normalizePropsOptions(type)[0]) && + hasOwn(normalizedProps, key)) || + hasOwn(ctx, key) || + hasOwn(publicPropertiesMap, key) || + hasOwn(appContext.config.globalProperties, key) + ) + } +} +if (process.env.NODE_ENV !== 'production' && !false) { + PublicInstanceProxyHandlers.ownKeys = target => { + warn( + `Avoid app logic that relies on enumerating keys on a component instance. ` + + `The keys will be empty in production mode to avoid performance overhead.` + ) + return Reflect.ownKeys(target) + } +} +const RuntimeCompiledPublicInstanceProxyHandlers = extend( + {}, + PublicInstanceProxyHandlers, + { + get(target, key) { + // fast path for unscopables when using `with` block + if (key === Symbol.unscopables) { + return + } + return PublicInstanceProxyHandlers.get(target, key, target) + }, + has(_, key) { + const has = key[0] !== '_' && !isGloballyWhitelisted(key) + if ( + process.env.NODE_ENV !== 'production' && + !has && + PublicInstanceProxyHandlers.has(_, key) + ) { + warn( + `Property ${JSON.stringify( + key + )} should not start with _ which is a reserved prefix for Vue internals.` + ) + } + return has + } + } +) +// In dev mode, the proxy target exposes the same properties as seen on `this` +// for easier console inspection. In prod mode it will be an empty object so +// these properties definitions can be skipped. +function createRenderContext(instance) { + const target = {} + // expose internal instance for proxy handlers + Object.defineProperty(target, `_`, { + configurable: true, + enumerable: false, + get: () => instance + }) + // expose public properties + Object.keys(publicPropertiesMap).forEach(key => { + Object.defineProperty(target, key, { + configurable: true, + enumerable: false, + get: () => publicPropertiesMap[key](instance), + // intercepted by the proxy so no need for implementation, + // but needed to prevent set errors + set: NOOP + }) + }) + // expose global properties + const { globalProperties } = instance.appContext.config + Object.keys(globalProperties).forEach(key => { + Object.defineProperty(target, key, { + configurable: true, + enumerable: false, + get: () => globalProperties[key], + set: NOOP + }) + }) + return target +} +// dev only +function exposePropsOnRenderContext(instance) { + const { ctx, type } = instance + const propsOptions = normalizePropsOptions(type)[0] + if (propsOptions) { + Object.keys(propsOptions).forEach(key => { + Object.defineProperty(ctx, key, { + enumerable: true, + configurable: true, + get: () => instance.props[key], + set: NOOP + }) + }) + } +} +// dev only +function exposeSetupStateOnRenderContext(instance) { + const { ctx, setupState } = instance + Object.keys(toRaw(setupState)).forEach(key => { + Object.defineProperty(ctx, key, { + enumerable: true, + configurable: true, + get: () => setupState[key], + set: NOOP + }) + }) +} + +const emptyAppContext = createAppContext() +let uid$1 = 0 +function createComponentInstance(vnode, parent, suspense) { + const type = vnode.type + // inherit parent app context - or - if root, adopt from root vnode + const appContext = + (parent ? parent.appContext : vnode.appContext) || emptyAppContext + const instance = { + uid: uid$1++, + vnode, + type, + parent, + appContext, + root: null, + next: null, + subTree: null, + update: null, + render: null, + proxy: null, + withProxy: null, + effects: null, + provides: parent ? parent.provides : Object.create(appContext.provides), + accessCache: null, + renderCache: [], + // local resovled assets + components: null, + directives: null, + // state + ctx: EMPTY_OBJ, + data: EMPTY_OBJ, + props: EMPTY_OBJ, + attrs: EMPTY_OBJ, + slots: EMPTY_OBJ, + refs: EMPTY_OBJ, + setupState: EMPTY_OBJ, + setupContext: null, + // suspense related + suspense, + asyncDep: null, + asyncResolved: false, + // lifecycle hooks + // not using enums here because it results in computed properties + isMounted: false, + isUnmounted: false, + isDeactivated: false, + bc: null, + c: null, + bm: null, + m: null, + bu: null, + u: null, + um: null, + bum: null, + da: null, + a: null, + rtg: null, + rtc: null, + ec: null, + emit: null, + emitted: null + } + if (process.env.NODE_ENV !== 'production') { + instance.ctx = createRenderContext(instance) + } else { + instance.ctx = { _: instance } + } + instance.root = parent ? parent.root : instance + instance.emit = emit.bind(null, instance) + if (process.env.NODE_ENV !== 'production' || false); + return instance +} +let currentInstance = null +const setCurrentInstance = instance => { + currentInstance = instance +} +const isBuiltInTag = /*#__PURE__*/ makeMap('slot,component') +function validateComponentName(name, config) { + const appIsNativeTag = config.isNativeTag || NO + if (isBuiltInTag(name) || appIsNativeTag(name)) { + warn( + 'Do not use built-in or reserved HTML elements as component id: ' + name + ) + } +} +let isInSSRComponentSetup = false +function setupComponent(instance, isSSR = false) { + isInSSRComponentSetup = isSSR + const { props, /* children, */ shapeFlag } = instance.vnode + const isStateful = shapeFlag & 4 /* STATEFUL_COMPONENT */ + initProps(instance, props, isStateful, isSSR) + // initSlots(instance, children) // fixed by xxxxxx + const setupResult = isStateful + ? setupStatefulComponent(instance, isSSR) + : undefined + isInSSRComponentSetup = false + return setupResult +} +function setupStatefulComponent(instance, isSSR) { + const Component = instance.type + if (process.env.NODE_ENV !== 'production') { + if (Component.name) { + validateComponentName(Component.name, instance.appContext.config) + } + if (Component.components) { + const names = Object.keys(Component.components) + for (let i = 0; i < names.length; i++) { + validateComponentName(names[i], instance.appContext.config) + } + } + if (Component.directives) { + const names = Object.keys(Component.directives) + for (let i = 0; i < names.length; i++) { + validateDirectiveName(names[i]) + } + } + } + // 0. create render proxy property access cache + instance.accessCache = {} + // 1. create public instance / render proxy + // also mark it raw so it's never observed + instance.proxy = new Proxy(instance.ctx, PublicInstanceProxyHandlers) + if (process.env.NODE_ENV !== 'production') { + exposePropsOnRenderContext(instance) + } + // 2. call setup() + const { setup } = Component + if (setup) { + const setupContext = (instance.setupContext = + setup.length > 1 ? createSetupContext(instance) : null) + currentInstance = instance + pauseTracking() + const setupResult = callWithErrorHandling( + setup, + instance, + 0 /* SETUP_FUNCTION */, + [ + process.env.NODE_ENV !== 'production' + ? shallowReadonly(instance.props) + : instance.props, + setupContext + ] + ) + resetTracking() + currentInstance = null + if (isPromise(setupResult)) { + if (isSSR) { + // return the promise so server-renderer can wait on it + return setupResult.then(resolvedResult => { + handleSetupResult(instance, resolvedResult) + }) + } else if (process.env.NODE_ENV !== 'production') { + warn( + `setup() returned a Promise, but the version of Vue you are using ` + + `does not support it yet.` + ) + } + } else { + handleSetupResult(instance, setupResult) + } + } else { + finishComponentSetup(instance) + } +} +function handleSetupResult(instance, setupResult, isSSR) { + if (isFunction(setupResult)) { + // setup returned an inline render function + instance.render = setupResult + } else if (isObject(setupResult)) { + // if ((process.env.NODE_ENV !== 'production') && isVNode(setupResult)) { + // warn( + // `setup() should not return VNodes directly - ` + + // `return a render function instead.` + // ) + // } + // setup returned bindings. + // assuming a render function compiled from template is present. + if (process.env.NODE_ENV !== 'production' || false) { + instance.devtoolsRawSetupState = setupResult + } + instance.setupState = proxyRefs(setupResult) + if (process.env.NODE_ENV !== 'production') { + exposeSetupStateOnRenderContext(instance) + } + } else if ( + process.env.NODE_ENV !== 'production' && + setupResult !== undefined + ) { + warn( + `setup() should return an object. Received: ${ + setupResult === null ? 'null' : typeof setupResult + }` + ) + } + finishComponentSetup(instance) +} +function finishComponentSetup(instance, isSSR) { + const Component = instance.type + // template / render function normalization + if (!instance.render) { + instance.render = Component.render || NOOP + // for runtime-compiled render functions using `with` blocks, the render + // proxy used needs a different `has` handler which is more performant and + // also only allows a whitelist of globals to fallthrough. + if (instance.render._rc) { + instance.withProxy = new Proxy( + instance.ctx, + RuntimeCompiledPublicInstanceProxyHandlers + ) + } + } + // support for 2.x options + if (__VUE_OPTIONS_API__) { + currentInstance = instance + applyOptions(instance, Component) + currentInstance = null + } + // warn missing template/render + if ( + process.env.NODE_ENV !== 'production' && + !Component.render && + instance.render === NOOP + ) { + /* istanbul ignore if */ + if (Component.template) { + warn( + `Component provided template option but ` + + `runtime compilation is not supported in this build of Vue.` + + ` Configure your bundler to alias "vue" to "vue/dist/vue.esm-bundler.js".` /* should not happen */ + ) + } else { + warn(`Component is missing template or render function.`) + } + } +} +const attrHandlers = { + get: (target, key) => { + if (process.env.NODE_ENV !== 'production'); + return target[key] + }, + set: () => { + warn(`setupContext.attrs is readonly.`) + return false + }, + deleteProperty: () => { + warn(`setupContext.attrs is readonly.`) + return false + } +} +function createSetupContext(instance) { + if (process.env.NODE_ENV !== 'production') { + // We use getters in dev in case libs like test-utils overwrite instance + // properties (overwrites should not be done in prod) + return Object.freeze({ + get attrs() { + return new Proxy(instance.attrs, attrHandlers) + }, + get slots() { + return shallowReadonly(instance.slots) + }, + get emit() { + return (event, ...args) => instance.emit(event, ...args) + } + }) + } else { + return { + attrs: instance.attrs, + slots: instance.slots, + emit: instance.emit + } + } +} +// record effects created during a component's setup() so that they can be +// stopped when the component unmounts +function recordInstanceBoundEffect(effect) { + if (currentInstance) { + ;(currentInstance.effects || (currentInstance.effects = [])).push(effect) + } +} +const classifyRE = /(?:^|[-_])(\w)/g +const classify = str => + str.replace(classifyRE, c => c.toUpperCase()).replace(/[-_]/g, '') +/* istanbul ignore next */ +function formatComponentName(instance, Component, isRoot = false) { + let name = isFunction(Component) + ? Component.displayName || Component.name + : Component.name + if (!name && Component.__file) { + const match = Component.__file.match(/([^/\\]+)\.vue$/) + if (match) { + name = match[1] + } + } + if (!name && instance && instance.parent) { + // try to infer the name based on reverse resolution + const inferFromRegistry = registry => { + for (const key in registry) { + if (registry[key] === Component) { + return key + } + } + } + name = + inferFromRegistry( + instance.components || instance.parent.type.components + ) || inferFromRegistry(instance.appContext.components) + } + return name ? classify(name) : isRoot ? `App` : `Anonymous` +} + +function computed$1(getterOrOptions) { + const c = computed(getterOrOptions) + recordInstanceBoundEffect(c.effect) + return c +} + +// Core API ------------------------------------------------------------------ +const version = '3.0.0-rc.9' + +// import deepCopy from './deepCopy' +/** + * https://raw.githubusercontent.com/Tencent/westore/master/packages/westore/utils/diff.js + */ +const ARRAYTYPE = '[object Array]' +const OBJECTTYPE = '[object Object]' +// const FUNCTIONTYPE = '[object Function]' +function diff(current, pre) { + const result = {} + syncKeys(current, pre) + _diff(current, pre, '', result) + return result +} +function syncKeys(current, pre) { + current = unref(current) + if (current === pre) return + const rootCurrentType = toTypeString(current) + const rootPreType = toTypeString(pre) + if (rootCurrentType == OBJECTTYPE && rootPreType == OBJECTTYPE) { + for (let key in pre) { + const currentValue = current[key] + if (currentValue === undefined) { + current[key] = null + } else { + syncKeys(currentValue, pre[key]) + } + } + } else if (rootCurrentType == ARRAYTYPE && rootPreType == ARRAYTYPE) { + if (current.length >= pre.length) { + pre.forEach((item, index) => { + syncKeys(current[index], item) + }) + } + } +} +function _diff(current, pre, path, result) { + current = unref(current) + if (current === pre) return + const rootCurrentType = toTypeString(current) + const rootPreType = toTypeString(pre) + if (rootCurrentType == OBJECTTYPE) { + if ( + rootPreType != OBJECTTYPE || + Object.keys(current).length < Object.keys(pre).length + ) { + setResult(result, path, current) + } else { + for (let key in current) { + const currentValue = unref(current[key]) + const preValue = pre[key] + const currentType = toTypeString(currentValue) + const preType = toTypeString(preValue) + if (currentType != ARRAYTYPE && currentType != OBJECTTYPE) { + if (currentValue != preValue) { + setResult( + result, + (path == '' ? '' : path + '.') + key, + currentValue + ) + } + } else if (currentType == ARRAYTYPE) { + if (preType != ARRAYTYPE) { + setResult( + result, + (path == '' ? '' : path + '.') + key, + currentValue + ) + } else { + if (currentValue.length < preValue.length) { + setResult( + result, + (path == '' ? '' : path + '.') + key, + currentValue + ) + } else { + currentValue.forEach((item, index) => { + _diff( + item, + preValue[index], + (path == '' ? '' : path + '.') + key + '[' + index + ']', + result + ) + }) + } + } + } else if (currentType == OBJECTTYPE) { + if ( + preType != OBJECTTYPE || + Object.keys(currentValue).length < Object.keys(preValue).length + ) { + setResult( + result, + (path == '' ? '' : path + '.') + key, + currentValue + ) + } else { + for (let subKey in currentValue) { + _diff( + currentValue[subKey], + preValue[subKey], + (path == '' ? '' : path + '.') + key + '.' + subKey, + result + ) + } + } + } + } + } + } else if (rootCurrentType == ARRAYTYPE) { + if (rootPreType != ARRAYTYPE) { + setResult(result, path, current) + } else { + if (current.length < pre.length) { + setResult(result, path, current) + } else { + current.forEach((item, index) => { + _diff(item, pre[index], path + '[' + index + ']', result) + }) + } + } + } else { + setResult(result, path, current) + } +} +function setResult(result, k, v) { + result[k] = v //deepCopy(v) +} + +function hasComponentEffect(instance) { + return queue.includes(instance.update) +} +function flushCallbacks(instance) { + const ctx = instance.ctx + const callbacks = ctx.__next_tick_callbacks + if (callbacks && callbacks.length) { + if (process.env.VUE_APP_DEBUG) { + const mpInstance = ctx.$scope + console.log( + '[' + + +new Date() + + '][' + + (mpInstance.is || mpInstance.route) + + '][' + + instance.uid + + ']:flushCallbacks[' + + callbacks.length + + ']' + ) + } + const copies = callbacks.slice(0) + callbacks.length = 0 + for (let i = 0; i < copies.length; i++) { + copies[i]() + } + } +} +function nextTick$1(instance, fn) { + const ctx = instance.ctx + if (!ctx.__next_tick_pending && !hasComponentEffect(instance)) { + if (process.env.VUE_APP_DEBUG) { + const mpInstance = ctx.$scope + console.log( + '[' + + +new Date() + + '][' + + (mpInstance.is || mpInstance.route) + + '][' + + instance.uid + + ']:nextVueTick' + ) + } + return nextTick(fn && fn.bind(instance.proxy)) + } + if (process.env.VUE_APP_DEBUG) { + const mpInstance = ctx.$scope + console.log( + '[' + + +new Date() + + '][' + + (mpInstance.is || mpInstance.route) + + '][' + + instance.uid + + ']:nextMPTick' + ) + } + let _resolve + if (!ctx.__next_tick_callbacks) { + ctx.__next_tick_callbacks = [] + } + ctx.__next_tick_callbacks.push(() => { + if (fn) { + callWithErrorHandling( + fn.bind(instance.proxy), + instance, + 14 /* SCHEDULER */ + ) + } else if (_resolve) { + _resolve(instance.proxy) + } + }) + return new Promise(resolve => { + _resolve = resolve + }) +} + +function getMPInstanceData(instance, keys) { + const data = instance.data + const ret = Object.create(null) + //仅同步 data 中有的数据 + keys.forEach(key => { + ret[key] = data[key] + }) + return ret +} +function getVueInstanceData(instance) { + const { data, setupState, ctx } = instance + const keys = new Set() + const ret = Object.create(null) + Object.keys(setupState).forEach(key => { + keys.add(key) + ret[key] = setupState[key] + }) + if (data) { + Object.keys(data).forEach(key => { + if (!keys.has(key)) { + keys.add(key) + ret[key] = data[key] + } + }) + } + if (__VUE_OPTIONS_API__) { + if (ctx.$computedKeys) { + ctx.$computedKeys.forEach(key => { + if (!keys.has(key)) { + keys.add(key) + ret[key] = ctx[key] + } + }) + } + } + if (ctx.$mp) { + // TODO + extend(ret, ctx.$mp.data || {}) + } + // TODO form-field + // track + return { keys, data: JSON.parse(JSON.stringify(ret)) } +} +function patch(instance) { + const ctx = instance.ctx + const mpType = ctx.mpType + if (mpType === 'page' || mpType === 'component') { + const start = Date.now() + const mpInstance = ctx.$scope + const { keys, data } = getVueInstanceData(instance) + // data.__webviewId__ = mpInstance.data.__webviewId__ + const diffData = diff(data, getMPInstanceData(mpInstance, keys)) + if (Object.keys(diffData).length) { + if (process.env.VUE_APP_DEBUG) { + console.log( + '[' + + +new Date() + + '][' + + (mpInstance.is || mpInstance.route) + + '][' + + instance.uid + + '][耗时' + + (Date.now() - start) + + ']差量更新', + JSON.stringify(diffData) + ) + } + ctx.__next_tick_pending = true + mpInstance.setData(diffData, () => { + ctx.__next_tick_pending = false + flushCallbacks(instance) + }) + } else { + flushCallbacks(instance) + } + } +} + +function initAppConfig(appConfig) { + appConfig.globalProperties.$nextTick = function $nextTick(fn) { + return nextTick$1(this.$, fn) + } +} + +function onApplyOptions(options, instance, publicThis) { + instance.appContext.config.globalProperties.$applyOptions( + options, + instance, + publicThis + ) + const computedOptions = options.computed + if (computedOptions) { + const keys = Object.keys(computedOptions) + if (keys.length) { + const ctx = instance.ctx + if (!ctx.$computedKeys) { + ctx.$computedKeys = [] + } + ctx.$computedKeys.push(...keys) + } + } + // remove + delete instance.ctx.$onApplyOptions +} + +var MPType +;(function(MPType) { + MPType['APP'] = 'app' + MPType['PAGE'] = 'page' + MPType['COMPONENT'] = 'component' +})(MPType || (MPType = {})) +const queuePostRenderEffect$1 = queuePostFlushCb +function mountComponent(initialVNode, options) { + const instance = (initialVNode.component = createComponentInstance( + initialVNode, + options.parentComponent, + null + )) + if (__VUE_OPTIONS_API__) { + instance.ctx.$onApplyOptions = onApplyOptions + instance.ctx.$children = [] + } + if (options.mpType === 'app') { + instance.render = NOOP + } + if (options.onBeforeSetup) { + options.onBeforeSetup(instance, options) + } + if (process.env.NODE_ENV !== 'production') { + pushWarningContext(initialVNode) + } + setupComponent(instance) + if (__VUE_OPTIONS_API__) { + // $children + if (options.parentComponent && instance.proxy) { + options.parentComponent.ctx.$children.push(instance.proxy) + } + } + setupRenderEffect(instance) + if (process.env.NODE_ENV !== 'production') { + popWarningContext() + } + return instance.proxy +} +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 + } +} +function setupRenderEffect(instance) { + // create reactive effect for rendering + instance.update = effect(function componentEffect() { + if (!instance.isMounted) { + instance.render && instance.render.call(instance.proxy) + patch(instance) + } else { + instance.render && instance.render.call(instance.proxy) + // updateComponent + const { bu, u } = instance + // beforeUpdate hook + if (bu) { + invokeArrayFns(bu) + } + patch(instance) + // updated hook + if (u) { + queuePostRenderEffect$1(u) + } + } + }, process.env.NODE_ENV !== 'production' + ? createDevEffectOptions(instance) + : prodEffectOptions) +} +function unmountComponent(instance) { + const { bum, effects, update, um } = instance + // beforeUnmount hook + if (bum) { + invokeArrayFns(bum) + } + if (effects) { + for (let i = 0; i < effects.length; i++) { + stop(effects[i]) + } + } + // update may be null if a component is unmounted before its async + // setup has resolved. + if (update) { + stop(update) + } + // unmounted hook + if (um) { + queuePostRenderEffect$1(um) + } + queuePostRenderEffect$1(() => { + instance.isUnmounted = true + }) +} +const oldCreateApp = createAppAPI() +function createVueApp(rootComponent, rootProps = null) { + const app = oldCreateApp(rootComponent, rootProps) + const appContext = app._context + initAppConfig(appContext.config) + const createVNode = initialVNode => { + initialVNode.appContext = appContext + initialVNode.shapeFlag = 6 /* COMPONENT */ + return initialVNode + } + const createComponent = function createComponent(initialVNode, options) { + return mountComponent(createVNode(initialVNode), options) + } + const destroyComponent = function destroyComponent(component) { + return component && unmountComponent(component.$) + } + app.mount = function mount() { + rootComponent.render = NOOP + const instance = mountComponent(createVNode({ type: rootComponent }), { + mpType: MPType.APP, + mpInstance: null, + parentComponent: null, + slots: [], + props: null + }) + instance.$app = app + instance.$createComponent = createComponent + instance.$destroyComponent = destroyComponent + appContext.$appInstance = instance + return instance + } + app.unmount = function unmount() { + warn(`Cannot unmount an app.`) + } + return app +} + +function applyOptions$1(options, instance, publicThis) { + Object.keys(options).forEach(name => { + if (name.indexOf('on') === 0) { + const hook = options[name] + if (isFunction(hook)) { + injectHook(name, hook.bind(publicThis), instance) + } + } + }) +} + +function set$2(target, key, val) { + return (target[key] = val) +} +function hasHook(name) { + const hooks = this.$[name] + if (hooks && hooks.length) { + return true + } + return false +} +function callHook(name, args) { + const hooks = this.$[name] + let ret + if (hooks) { + for (let i = 0; i < hooks.length; i++) { + ret = hooks[i](args) + } + } + return ret +} + +function errorHandler(err, instance, info) { + if (!instance) { + throw err + } + const appInstance = instance.$.appContext.$appInstance + if (!appInstance) { + throw err + } + appInstance.$callHook('onError', err, info) +} + +function initApp(app) { + const appConfig = app._context.config + if (isFunction(app._component.onError)) { + appConfig.errorHandler = errorHandler + } + appConfig.isCustomElement = isCustomElement + const globalProperties = appConfig.globalProperties + globalProperties.$hasHook = hasHook + globalProperties.$callHook = callHook + if (__VUE_OPTIONS_API__) { + globalProperties.$set = set$2 + globalProperties.$applyOptions = applyOptions$1 + } +} + +var plugin = { + install(app) { + initApp(app) + const globalProperties = app._context.config.globalProperties + const oldCallHook = globalProperties.$callHook + globalProperties.$callHook = function callHook(name, args) { + if (name === 'mounted') { + oldCallHook.call(this, 'bm') // beforeMount + this.$.isMounted = true + name = 'm' + } + return oldCallHook.call(this, name, args) + } + const oldMount = app.mount + app.mount = function mount(rootContainer) { + const instance = oldMount.call(app, rootContainer) + // @ts-ignore + createMiniProgramApp(instance) + return instance + } + } +} + +// @ts-ignore +const createHook$1 = lifecycle => (hook, target) => + // post-create lifecycle registrations are noops during SSR + !isInSSRComponentSetup && injectHook(lifecycle, hook, target) +const onShow = /*#__PURE__*/ createHook$1('onShow' /* ON_SHOW */) +const onHide = /*#__PURE__*/ createHook$1('onHide' /* ON_HIDE */) +const onLaunch = /*#__PURE__*/ createHook$1('onLaunch' /* ON_LAUCH */) +const onError = /*#__PURE__*/ createHook$1('onError' /* ON_ERROR */) +const onThemeChange = /*#__PURE__*/ createHook$1( + 'onThemeChange' /* ON_THEME_CHANGE */ +) +const onPageNotFound = /*#__PURE__*/ createHook$1( + 'onPageNotFound' /* ON_PAGE_NOT_FOUND */ +) +const onUnhandledRejection = /*#__PURE__*/ createHook$1( + 'onUnhandledRejection' /* ON_UNHANDLE_REJECTION */ +) +const onLoad = /*#__PURE__*/ createHook$1('onLoad' /* ON_LOAD */) +const onReady = /*#__PURE__*/ createHook$1('onReady' /* ON_READY */) +const onUnload = /*#__PURE__*/ createHook$1('onUnload' /* ON_UNLOAD */) +const onResize = /*#__PURE__*/ createHook$1('onResize' /* ON_RESIZE */) +const onBackPress = /*#__PURE__*/ createHook$1( + 'onBackPress' /* ON_BACK_PRESS */ +) +const onPageScroll = /*#__PURE__*/ createHook$1( + 'onPageScroll' /* ON_PAGE_SCROLL */ +) +const onTabItemTap = /*#__PURE__*/ createHook$1( + 'onTabItemTap' /* ON_TAB_ITEM_TAP */ +) +const onReachBottom = /*#__PURE__*/ createHook$1( + 'onReachBottom' /* ON_REACH_BOTTOM */ +) +const onPullDownRefresh = /*#__PURE__*/ createHook$1( + 'onPullDownRefresh' /* ON_PULL_DOWN_REFRESH */ +) +const onShareTimeline = /*#__PURE__*/ createHook$1( + 'onShareTimeline' /* ON_SHARE_TIMELINE */ +) +const onAddToFavorites = /*#__PURE__*/ createHook$1( + 'onAddToFavorites' /* ON_ADD_TO_FAVORITES */ +) +const onShareAppMessage = /*#__PURE__*/ createHook$1( + 'onShareAppMessage' /* ON_SHARE_APP_MESSAGE */ +) +const onNavigationBarButtonTap = /*#__PURE__*/ createHook$1( + 'onNavigationBarButtonTap' /* ON_NAVIGATION_BAR_BUTTON_TAP */ +) +const onNavigationBarSearchInputChanged = /*#__PURE__*/ createHook$1( + 'onNavigationBarSearchInputChanged' /* ON_NAVIGATION_BAR_SEARCH_INPUT_CHANGED */ +) +const onNavigationBarSearchInputClicked = /*#__PURE__*/ createHook$1( + 'onNavigationBarSearchInputClicked' /* ON_NAVIGATION_BAR_SEARCH_INPUT_CLICKED */ +) +const onNavigationBarSearchInputConfirmed = /*#__PURE__*/ createHook$1( + 'onNavigationBarSearchInputConfirmed' /* ON_NAVIGATION_BAR_SEARCH_INPUT_CONFIRMED */ +) +const onNavigationBarSearchInputFocusChanged = /*#__PURE__*/ createHook$1( + 'onNavigationBarSearchInputFocusChanged' /* ON_NAVIGATION_BAR_SEARCH_INPUT_FOCUS_CHANGED */ +) + +function createApp(rootComponent, rootProps = null) { + return createVueApp(rootComponent, rootProps).use(plugin) +} + +export { + callWithAsyncErrorHandling, + callWithErrorHandling, + computed$1 as computed, + createApp, + createHook$1 as createHook, + createVueApp, + customRef, + inject, + injectHook, + isInSSRComponentSetup, + isProxy, + isReactive, + isReadonly, + isRef, + logError, + markRaw, + nextTick, + onActivated, + onAddToFavorites, + onBackPress, + onBeforeMount, + onBeforeUnmount, + onBeforeUpdate, + onDeactivated, + onError, + onErrorCaptured, + onHide, + onLaunch, + onLoad, + onMounted, + onNavigationBarButtonTap, + onNavigationBarSearchInputChanged, + onNavigationBarSearchInputClicked, + onNavigationBarSearchInputConfirmed, + onNavigationBarSearchInputFocusChanged, + onPageNotFound, + onPageScroll, + onPullDownRefresh, + onReachBottom, + onReady, + onRenderTracked, + onRenderTriggered, + onResize, + onShareAppMessage, + onShareTimeline, + onShow, + onTabItemTap, + onThemeChange, + onUnhandledRejection, + onUnload, + onUnmounted, + onUpdated, + provide, + reactive, + readonly, + ref, + shallowReactive, + shallowReadonly, + shallowRef, + toRaw, + toRef, + toRefs, + triggerRef, + unref, + version, + warn, + watch, + watchEffect +} diff --git a/packages/uni-mp-vue/lib/vue.runtime.esm.js b/packages/uni-mp-vue/lib/vue.runtime.esm.js index 36b196d85f56f4bd448980db04dd542b021c6c9c..ef400f16e7dc458311bc49855cedfff1e6edb8c8 100644 --- a/packages/uni-mp-vue/lib/vue.runtime.esm.js +++ b/packages/uni-mp-vue/lib/vue.runtime.esm.js @@ -329,8 +329,6 @@ const mutableHandlers = { } const readonlyHandlers = { get: readonlyGet, - has, - ownKeys, set(target, key) { if (process.env.NODE_ENV !== 'production') { console.warn( @@ -1321,10 +1319,12 @@ function markAttrsAccessed() {} function emit(instance, event, ...args) { const props = instance.vnode.props || EMPTY_OBJ if (process.env.NODE_ENV !== 'production') { - const options = normalizeEmitsOptions(instance.type) - if (options) { - if (!(event in options)) { - const propsOptions = normalizePropsOptions(instance.type)[0] + 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 ` + @@ -1332,7 +1332,7 @@ function emit(instance, event, ...args) { ) } } else { - const validator = options[event] + const validator = emitsOptions[event] if (isFunction(validator)) { const isValid = validator(...args) if (!isValid) { @@ -1370,46 +1370,53 @@ function emit(instance, event, ...args) { ) } } -function normalizeEmitsOptions(comp) { - if (hasOwn(comp, '__emits')) { - return comp.__emits +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)) { - if (comp.extends) { + const extendEmits = raw => { hasExtends = true - extend(normalized, normalizeEmitsOptions(comp.extends)) + extend(normalized, normalizeEmitsOptions(raw, appContext, true)) + } + if (!asMixin && appContext.mixins.length) { + appContext.mixins.forEach(extendEmits) + } + if (comp.extends) { + extendEmits(comp.extends) } if (comp.mixins) { - hasExtends = true - comp.mixins.forEach(m => extend(normalized, normalizeEmitsOptions(m))) + comp.mixins.forEach(extendEmits) } } if (!raw && !hasExtends) { - return (comp.__emits = undefined) + return (cache[appId] = null) } if (isArray(raw)) { raw.forEach(key => (normalized[key] = null)) } else { extend(normalized, raw) } - return (comp.__emits = normalized) + 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(comp, key) { - let emits - if (!isOn(key) || !(emits = normalizeEmitsOptions(comp))) { +function isEmitListener(options, key) { + if (!options || !isOn(key)) { return false } key = key.replace(/Once$/, '') return ( - hasOwn(emits, key[2].toLowerCase() + key.slice(3)) || - hasOwn(emits, key.slice(2)) + hasOwn(options, key[2].toLowerCase() + key.slice(3)) || + hasOwn(options, key.slice(2)) ) } @@ -1421,12 +1428,12 @@ function initProps( ) { const props = {} const attrs = {} - // def(attrs, InternalObjectKey, 1) // fixed by xxxxx + // def(attrs, InternalObjectKey, 1) // fixed by xxxxxx def(attrs, '__vInternal', 1) setFullProps(instance, rawProps, props, attrs) // validation if (process.env.NODE_ENV !== 'production') { - validateProps(props, instance.type) + validateProps(props, instance) } if (isStateful) { // stateful @@ -1443,7 +1450,7 @@ function initProps( instance.attrs = attrs } function setFullProps(instance, rawProps, props, attrs) { - const [options, needCastKeys] = normalizePropsOptions(instance.type) + const [options, needCastKeys] = instance.propsOptions if (rawProps) { for (const key in rawProps) { const value = rawProps[key] @@ -1456,7 +1463,7 @@ function setFullProps(instance, rawProps, props, attrs) { let camelKey if (options && hasOwn(options, (camelKey = camelize(key)))) { props[camelKey] = value - } else if (!isEmitListener(instance.type, key)) { + } 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 @@ -1503,9 +1510,12 @@ function resolvePropValue(options, props, key, value) { } return value } -function normalizePropsOptions(comp) { - if (comp.__props) { - return comp.__props +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 = {} @@ -1514,21 +1524,23 @@ function normalizePropsOptions(comp) { let hasExtends = false if (__VUE_OPTIONS_API__ && !isFunction(comp)) { const extendProps = raw => { - const [props, keys] = normalizePropsOptions(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) { - hasExtends = true extendProps(comp.extends) } if (comp.mixins) { - hasExtends = true comp.mixins.forEach(extendProps) } } if (!raw && !hasExtends) { - return (comp.__props = EMPTY_ARR) + return (cache[appId] = EMPTY_ARR) } if (isArray(raw)) { for (let i = 0; i < raw.length; i++) { @@ -1564,9 +1576,7 @@ function normalizePropsOptions(comp) { } } } - const normalizedEntry = [normalized, needCastKeys] - comp.__props = normalizedEntry - return normalizedEntry + return (cache[appId] = [normalized, needCastKeys]) } // use function string name to check type constructors // so that it works across vms / iframes. @@ -1592,9 +1602,9 @@ function getTypeIndex(type, expectedTypes) { /** * dev only */ -function validateProps(props, comp) { +function validateProps(props, instance) { const rawValues = toRaw(props) - const options = normalizePropsOptions(comp)[0] + const options = instance.propsOptions[0] for (const key in options) { let opt = options[key] if (opt == null) continue @@ -1872,10 +1882,9 @@ function createAppContext() { provides: Object.create(null) } } +let uid$1 = 0 // fixed by xxxxxx function createAppAPI() { -// render: RootRenderFunction, -// hydrate?: RootHydrateFunction return function createApp(rootComponent, rootProps = null) { if (rootProps != null && !isObject(rootProps)) { process.env.NODE_ENV !== 'production' && @@ -1887,6 +1896,7 @@ function createAppAPI() { // fixed by xxxxxx // let isMounted = false const app = (context.app = { + _uid: uid$1++, _component: rootComponent, _props: rootProps, _container: null, @@ -2300,7 +2310,7 @@ function applyOptions( const checkDuplicateProperties = process.env.NODE_ENV !== 'production' ? createDuplicateChecker() : null if (process.env.NODE_ENV !== 'production') { - const propsOptions = normalizePropsOptions(options)[0] + const [propsOptions] = instance.propsOptions if (propsOptions) { for (const key in propsOptions) { checkDuplicateProperties('Props' /* PROPS */, key) @@ -2601,17 +2611,18 @@ function resolveMergedOptions(instance) { if (!globalMixins.length && !mixins && !extendsOptions) return raw const options = {} globalMixins.forEach(m => mergeOptions(options, m, instance)) - extendsOptions && mergeOptions(options, extendsOptions, instance) - mixins && mixins.forEach(m => mergeOptions(options, m, instance)) mergeOptions(options, raw, instance) return (raw.__merged = options) } function mergeOptions(to, from, instance) { const strats = instance.appContext.config.optionMergeStrategies + const { mixins, extends: extendsOptions } = from + extendsOptions && mergeOptions(to, extendsOptions, instance) + mixins && mixins.forEach(m => mergeOptions(to, m, instance)) for (const key in from) { if (strats && hasOwn(strats, key)) { to[key] = strats[key](to[key], from[key], instance.proxy, key) - } else if (!hasOwn(to, key)) { + } else { to[key] = from[key] } } @@ -2682,7 +2693,7 @@ const PublicInstanceProxyHandlers = { } else if ( // only cache other properties when instance has declared (thus stable) // props - (normalizedProps = normalizePropsOptions(type)[0]) && + (normalizedProps = instance.propsOptions[0]) && hasOwn(normalizedProps, key) ) { accessCache[key] = 2 /* PROPS */ @@ -2727,12 +2738,16 @@ const PublicInstanceProxyHandlers = { // to infinite warning loop key.indexOf('__v') !== 0) ) { - if (data !== EMPTY_OBJ && key[0] === '$' && hasOwn(data, key)) { + if ( + data !== EMPTY_OBJ && + (key[0] === '$' || key[0] === '_') && + hasOwn(data, key) + ) { warn( `Property ${JSON.stringify( key )} must be accessed via $data because it starts with a reserved ` + - `character and is not proxied on the render context.` + `character ("$" or "_") and is not proxied on the render context.` ) } else { warn( @@ -2782,7 +2797,7 @@ const PublicInstanceProxyHandlers = { }, has( { - _: { data, setupState, accessCache, ctx, type, appContext } + _: { data, setupState, accessCache, ctx, appContext, propsOptions } }, key ) { @@ -2791,8 +2806,7 @@ const PublicInstanceProxyHandlers = { accessCache[key] !== undefined || (data !== EMPTY_OBJ && hasOwn(data, key)) || (setupState !== EMPTY_OBJ && hasOwn(setupState, key)) || - ((normalizedProps = normalizePropsOptions(type)[0]) && - hasOwn(normalizedProps, key)) || + ((normalizedProps = propsOptions[0]) && hasOwn(normalizedProps, key)) || hasOwn(ctx, key) || hasOwn(publicPropertiesMap, key) || hasOwn(appContext.config.globalProperties, key) @@ -2872,8 +2886,10 @@ function createRenderContext(instance) { } // dev only function exposePropsOnRenderContext(instance) { - const { ctx, type } = instance - const propsOptions = normalizePropsOptions(type)[0] + const { + ctx, + propsOptions: [propsOptions] + } = instance if (propsOptions) { Object.keys(propsOptions).forEach(key => { Object.defineProperty(ctx, key, { @@ -2889,6 +2905,15 @@ function exposePropsOnRenderContext(instance) { function exposeSetupStateOnRenderContext(instance) { const { ctx, setupState } = instance Object.keys(toRaw(setupState)).forEach(key => { + if (key[0] === '$' || key[0] === '_') { + warn( + `setup() return property ${JSON.stringify( + key + )} should not start with "$" or "_" ` + + `which are reserved prefixes for Vue internals.` + ) + return + } Object.defineProperty(ctx, key, { enumerable: true, configurable: true, @@ -2899,14 +2924,14 @@ function exposeSetupStateOnRenderContext(instance) { } const emptyAppContext = createAppContext() -let uid$1 = 0 +let uid$2 = 0 function createComponentInstance(vnode, parent, suspense) { const type = vnode.type // inherit parent app context - or - if root, adopt from root vnode const appContext = (parent ? parent.appContext : vnode.appContext) || emptyAppContext const instance = { - uid: uid$1++, + uid: uid$2++, vnode, type, parent, @@ -2925,6 +2950,12 @@ function createComponentInstance(vnode, parent, suspense) { // local resovled assets components: null, directives: null, + // resolved props and emits options + propsOptions: normalizePropsOptions(type, appContext), + emitsOptions: normalizeEmitsOptions(type, appContext), + // emit + emit: null, + emitted: null, // state ctx: EMPTY_OBJ, data: EMPTY_OBJ, @@ -2955,9 +2986,7 @@ function createComponentInstance(vnode, parent, suspense) { a: null, rtg: null, rtc: null, - ec: null, - emit: null, - emitted: null + ec: null } if (process.env.NODE_ENV !== 'production') { instance.ctx = createRenderContext(instance) @@ -3214,7 +3243,7 @@ function computed$1(getterOrOptions) { } // Core API ------------------------------------------------------------------ -const version = '3.0.0-rc.9' +const version = '3.0.0-rc.10' // import deepCopy from './deepCopy' /** diff --git a/packages/uni-mp-weixin/dist/uni.api.esm.js b/packages/uni-mp-weixin/dist/uni.api.esm.js new file mode 100644 index 0000000000000000000000000000000000000000..55c797bf0b90bb86f92528bd3416af143800a354 --- /dev/null +++ b/packages/uni-mp-weixin/dist/uni.api.esm.js @@ -0,0 +1,535 @@ +import { + isArray, + isPromise, + isFunction, + isPlainObject, + hasOwn, + isString +} from '@vue/shared' + +function createApi(fn, validate) { + if (process.env.NODE_ENV !== 'production' && validate); + return fn +} + +const Upx2pxProtocol = [ + { + name: 'upx', + type: [Number, String], + required: true + } +] + +const EPS = 1e-4 +const BASE_DEVICE_WIDTH = 750 +let isIOS = false +let deviceWidth = 0 +let deviceDPR = 0 +function checkDeviceWidth() { + const { platform, pixelRatio, windowWidth } = wx.getSystemInfoSync() + deviceWidth = windowWidth + deviceDPR = pixelRatio + isIOS = platform === 'ios' +} +const upx2px = createApi((number, newDeviceWidth) => { + if (deviceWidth === 0) { + checkDeviceWidth() + } + number = Number(number) + if (number === 0) { + return 0 + } + let result = (number / BASE_DEVICE_WIDTH) * (newDeviceWidth || deviceWidth) + if (result < 0) { + result = -result + } + result = Math.floor(result + EPS) + if (result === 0) { + if (deviceDPR === 1 || !isIOS) { + result = 1 + } else { + result = 0.5 + } + } + return number < 0 ? -result : result +}, Upx2pxProtocol) + +var HOOKS +;(function(HOOKS) { + HOOKS['INVOKE'] = 'invoke' + HOOKS['SUCCESS'] = 'success' + HOOKS['FAIL'] = 'fail' + HOOKS['COMPLETE'] = 'complete' + HOOKS['RETURN_VALUE'] = 'returnValue' +})(HOOKS || (HOOKS = {})) +const globalInterceptors = {} +const scopedInterceptors = {} +function wrapperHook(hook) { + return function(data) { + return hook(data) || data + } +} +function queue(hooks, data) { + let promise = false + for (let i = 0; i < hooks.length; i++) { + const hook = hooks[i] + if (promise) { + promise = Promise.resolve(wrapperHook(hook)) + } else { + const res = hook(data) + if (isPromise(res)) { + promise = Promise.resolve(res) + } + if (res === false) { + return { + then() {}, + catch() {} + } + } + } + } + return ( + promise || { + then(callback) { + return callback(data) + }, + catch() {} + } + ) +} +function wrapperOptions(interceptors, options = {}) { + ;[HOOKS.SUCCESS, HOOKS.FAIL, HOOKS.COMPLETE].forEach(name => { + const hooks = interceptors[name] + if (!isArray(hooks)) { + return + } + const oldCallback = options[name] + options[name] = function callbackInterceptor(res) { + queue(hooks, res).then(res => { + return (isFunction(oldCallback) && oldCallback(res)) || res + }) + } + }) + return options +} +function wrapperReturnValue(method, returnValue) { + const returnValueHooks = [] + if (isArray(globalInterceptors.returnValue)) { + returnValueHooks.push(...globalInterceptors.returnValue) + } + const interceptor = scopedInterceptors[method] + if (interceptor && isArray(interceptor.returnValue)) { + returnValueHooks.push(...interceptor.returnValue) + } + returnValueHooks.forEach(hook => { + returnValue = hook(returnValue) || returnValue + }) + return returnValue +} +function getApiInterceptorHooks(method) { + const interceptor = Object.create(null) + Object.keys(globalInterceptors).forEach(hook => { + if (hook !== 'returnValue') { + interceptor[hook] = globalInterceptors[hook].slice() + } + }) + const scopedInterceptor = scopedInterceptors[method] + if (scopedInterceptor) { + Object.keys(scopedInterceptor).forEach(hook => { + if (hook !== 'returnValue') { + interceptor[hook] = (interceptor[hook] || []).concat( + scopedInterceptor[hook] + ) + } + }) + } + return interceptor +} +function invokeApi(method, api, options, ...params) { + const interceptor = getApiInterceptorHooks(method) + if (interceptor && Object.keys(interceptor).length) { + if (isArray(interceptor.invoke)) { + const res = queue(interceptor.invoke, options) + return res.then(options => { + return api(wrapperOptions(interceptor, options), ...params) + }) + } else { + return api(wrapperOptions(interceptor, options), ...params) + } + } + return api(options, ...params) +} + +const AddInterceptorProtocol = [ + { + name: 'method', + type: [String, Object], + required: true + } +] +const RemoveInterceptorProtocol = AddInterceptorProtocol + +function mergeInterceptorHook(interceptors, interceptor) { + Object.keys(interceptor).forEach(hook => { + if (isFunction(interceptor[hook])) { + interceptors[hook] = mergeHook(interceptors[hook], interceptor[hook]) + } + }) +} +function removeInterceptorHook(interceptors, interceptor) { + if (!interceptors || !interceptor) { + return + } + Object.keys(interceptor).forEach(hook => { + if (isFunction(interceptor[hook])) { + removeHook(interceptors[hook], interceptor[hook]) + } + }) +} +function mergeHook(parentVal, childVal) { + const res = childVal + ? parentVal + ? parentVal.concat(childVal) + : isArray(childVal) + ? childVal + : [childVal] + : parentVal + return res ? dedupeHooks(res) : res +} +function dedupeHooks(hooks) { + const res = [] + for (let i = 0; i < hooks.length; i++) { + if (res.indexOf(hooks[i]) === -1) { + res.push(hooks[i]) + } + } + return res +} +function removeHook(hooks, hook) { + if (!hooks) { + return + } + const index = hooks.indexOf(hook) + if (index !== -1) { + hooks.splice(index, 1) + } +} +const addInterceptor = createApi((method, interceptor) => { + if (typeof method === 'string' && isPlainObject(interceptor)) { + mergeInterceptorHook( + scopedInterceptors[method] || (scopedInterceptors[method] = {}), + interceptor + ) + } else if (isPlainObject(method)) { + mergeInterceptorHook(globalInterceptors, method) + } +}, AddInterceptorProtocol) +const removeInterceptor = createApi((method, interceptor) => { + if (typeof method === 'string') { + if (isPlainObject(interceptor)) { + removeInterceptorHook(scopedInterceptors[method], interceptor) + } else { + delete scopedInterceptors[method] + } + } else if (isPlainObject(method)) { + removeInterceptorHook(globalInterceptors, method) + } +}, RemoveInterceptorProtocol) + +const SYNC_API_RE = /^\$|sendNativeEvent|restoreGlobal|getCurrentSubNVue|getMenuButtonBoundingClientRect|^report|interceptors|Interceptor$|getSubNVueById|requireNativePlugin|upx2px|hideKeyboard|canIUse|^create|Sync$|Manager$|base64ToArrayBuffer|arrayBufferToBase64/ +const CONTEXT_API_RE = /^create|Manager$/ +// Context例外情况 +const CONTEXT_API_RE_EXC = ['createBLEConnection'] +// 同步例外情况 +const ASYNC_API = ['createBLEConnection'] +const CALLBACK_API_RE = /^on|^off/ +function isContextApi(name) { + return CONTEXT_API_RE.test(name) && CONTEXT_API_RE_EXC.indexOf(name) === -1 +} +function isSyncApi(name) { + return SYNC_API_RE.test(name) && ASYNC_API.indexOf(name) === -1 +} +function isCallbackApi(name) { + return CALLBACK_API_RE.test(name) && name !== 'onPush' +} +function handlePromise(promise) { + if (!__UNI_PROMISE_API__) { + return promise + } + return promise + .then(data => { + return [null, data] + }) + .catch(err => [err]) +} +function shouldPromise(name) { + if (isContextApi(name) || isSyncApi(name) || isCallbackApi(name)) { + return false + } + return true +} +/* eslint-disable no-extend-native */ +if (!Promise.prototype.finally) { + Promise.prototype.finally = function(onfinally) { + const promise = this.constructor + return this.then( + value => promise.resolve(onfinally && onfinally()).then(() => value), + reason => + promise.resolve(onfinally && onfinally()).then(() => { + throw reason + }) + ) + } +} +function promisify(name, api) { + if (!shouldPromise(name)) { + return api + } + if (!isFunction(api)) { + return api + } + return function promiseApi(options = {}, ...params) { + if ( + isFunction(options.success) || + isFunction(options.fail) || + isFunction(options.complete) + ) { + return wrapperReturnValue(name, invokeApi(name, api, options, ...params)) + } + return wrapperReturnValue( + name, + handlePromise( + new Promise((resolve, reject) => { + invokeApi( + name, + api, + Object.assign({}, options, { + success: resolve, + fail: reject + }), + ...params + ) + }) + ) + ) + } +} + +const CALLBACKS = ['success', 'fail', 'cancel', 'complete'] +function initWrapper(protocols) { + function processCallback(methodName, method, returnValue) { + return function(res) { + return method(processReturnValue(methodName, res, returnValue)) + } + } + function processArgs( + methodName, + fromArgs, + argsOption = {}, + returnValue = {}, + keepFromArgs = false + ) { + if (isPlainObject(fromArgs)) { + // 一般 api 的参数解析 + const toArgs = keepFromArgs === true ? fromArgs : {} // returnValue 为 false 时,说明是格式化返回值,直接在返回值对象上修改赋值 + if (isFunction(argsOption)) { + argsOption = argsOption(fromArgs, toArgs) || {} + } + for (const key in fromArgs) { + if (hasOwn(argsOption, key)) { + let keyOption = argsOption[key] + if (isFunction(keyOption)) { + keyOption = keyOption(fromArgs[key], fromArgs, toArgs) + } + if (!keyOption) { + // 不支持的参数 + console.warn(`微信小程序 ${methodName} 暂不支持 ${key}`) + } else if (isString(keyOption)) { + // 重写参数 key + toArgs[keyOption] = fromArgs[key] + } else if (isPlainObject(keyOption)) { + // {name:newName,value:value}可重新指定参数 key:value + toArgs[keyOption.name ? keyOption.name : key] = keyOption.value + } + } else if (CALLBACKS.indexOf(key) !== -1) { + const callback = fromArgs[key] + if (isFunction(callback)) { + toArgs[key] = processCallback(methodName, callback, returnValue) + } + } else { + if (!keepFromArgs && !hasOwn(toArgs, key)) { + toArgs[key] = fromArgs[key] + } + } + } + return toArgs + } else if (isFunction(fromArgs)) { + fromArgs = processCallback(methodName, fromArgs, returnValue) + } + return fromArgs + } + function processReturnValue( + methodName, + res, + returnValue, + keepReturnValue = false + ) { + if (isFunction(protocols.returnValue)) { + // 处理通用 returnValue + res = protocols.returnValue(methodName, res) + } + return processArgs(methodName, res, returnValue, {}, keepReturnValue) + } + return function wrapper(methodName, method) { + if (!hasOwn(protocols, methodName)) { + return method + } + const protocol = protocols[methodName] + if (!protocol) { + // 暂不支持的 api + return function() { + console.error(`微信小程序 暂不支持${methodName}`) + } + } + return function(arg1, arg2) { + // 目前 api 最多两个参数 + let options = protocol + if (isFunction(protocol)) { + options = protocol(arg1) + } + arg1 = processArgs(methodName, arg1, options.args, options.returnValue) + const args = [arg1] + if (typeof arg2 !== 'undefined') { + args.push(arg2) + } + const returnValue = wx[options.name || methodName].apply(wx, args) + if (isSyncApi(methodName)) { + // 同步 api + return processReturnValue( + methodName, + returnValue, + options.returnValue, + isContextApi(methodName) + ) + } + return returnValue + } + } +} + +const baseApis = { upx2px, addInterceptor, removeInterceptor } +function initUni(api, protocols) { + const wrapper = initWrapper(protocols) + const UniProxyHandlers = { + get(target, key) { + if (hasOwn(target, key)) { + return target[key] + } + if (hasOwn(api, key)) { + return promisify(key, api[key]) + } + if (hasOwn(baseApis, key)) { + return promisify(key, baseApis[key]) + } + // event-api + // provider-api? + return promisify(key, wrapper(key, wx[key])) + } + } + return new Proxy({}, UniProxyHandlers) +} + +function initGetProvider(providers) { + return function getProvider({ service, success, fail, complete }) { + let res + if (providers[service]) { + res = { + errMsg: 'getProvider:ok', + service, + provider: providers[service] + } + isFunction(success) && success(res) + } else { + res = { + errMsg: 'getProvider:fail:服务[' + service + ']不存在' + } + isFunction(fail) && fail(res) + } + isFunction(complete) && complete(res) + } +} + +const previewImage = { + args(fromArgs, toArgs) { + let currentIndex = parseInt(fromArgs.current) + if (isNaN(currentIndex)) { + return + } + const urls = fromArgs.urls + if (!isArray(urls)) { + return + } + const len = urls.length + if (!len) { + return + } + if (currentIndex < 0) { + currentIndex = 0 + } else if (currentIndex >= len) { + currentIndex = len - 1 + } + if (currentIndex > 0) { + toArgs.current = urls[currentIndex] + toArgs.urls = urls.filter( + (item, index) => + index < currentIndex ? item !== urls[currentIndex] : true + ) + } else { + toArgs.current = urls[0] + } + return { + indicator: false, + loop: false + } + } +} +function addSafeAreaInsets(fromRes, toRes) { + if (fromRes.safeArea) { + const safeArea = fromRes.safeArea + toRes.safeAreaInsets = { + top: safeArea.top, + left: safeArea.left, + right: fromRes.windowWidth - safeArea.right, + bottom: fromRes.windowHeight - safeArea.bottom + } + } +} +const getSystemInfo = { + returnValue: addSafeAreaInsets +} +const getSystemInfoSync = getSystemInfo +const redirectTo = {} + +const getProvider = initGetProvider({ + oauth: ['weixin'], + share: ['weixin'], + payment: ['wxpay'], + push: ['weixin'] +}) + +var shims = /*#__PURE__*/ Object.freeze({ + __proto__: null, + getProvider: getProvider +}) + +var protocols = /*#__PURE__*/ Object.freeze({ + __proto__: null, + redirectTo: redirectTo, + previewImage: previewImage, + getSystemInfo: getSystemInfo, + getSystemInfoSync: getSystemInfoSync +}) + +var index = initUni(shims, protocols) + +export default index diff --git a/packages/uni-mp-weixin/dist/uni.mp.esm.js b/packages/uni-mp-weixin/dist/uni.mp.esm.js new file mode 100644 index 0000000000000000000000000000000000000000..23526112bd24bc30ec0e69ebd43c2909cc60c26d --- /dev/null +++ b/packages/uni-mp-weixin/dist/uni.mp.esm.js @@ -0,0 +1,929 @@ +import { + isArray, + hasOwn, + toNumber, + isPlainObject, + isObject, + isFunction, + extend, + NOOP, + camelize +} from '@vue/shared' +import { stringifyQuery } from '@dcloudio/uni-shared' + +function setModel(target, key, value, modifiers) { + if (isArray(modifiers)) { + if (modifiers.indexOf('trim') !== -1) { + value = value.trim() + } + if (modifiers.indexOf('number') !== -1) { + value = toNumber(value) + } + } + if (!target) { + target = this + } + target[key] = value +} +function setSync(target, key, value) { + if (!target) { + target = this + } + target[key] = value +} +function getOrig(data) { + if (isPlainObject(data)) { + return data.$orig || data + } + return data +} +function map(val, iteratee) { + let ret, i, l, keys, key + if (isArray(val)) { + ret = new Array(val.length) + for (i = 0, l = val.length; i < l; i++) { + ret[i] = iteratee(val[i], i) + } + return ret + } else if (isObject(val)) { + keys = Object.keys(val) + ret = Object.create(null) + for (i = 0, l = keys.length; i < l; i++) { + key = keys[i] + ret[key] = iteratee(val[key], key, i) + } + return ret + } + return [] +} +const MP_METHODS = [ + 'createSelectorQuery', + 'createIntersectionObserver', + 'selectAllComponents', + 'selectComponent' +] +function createEmitFn(oldEmit, ctx) { + return function emit(event, ...args) { + if (ctx.$scope && event) { + ctx.$scope.triggerEvent(event, { __args__: args }) + } + return oldEmit.apply(this, [event, ...args]) + } +} +function initBaseInstance(instance, options) { + const ctx = instance.ctx + // mp + ctx.mpType = options.mpType // @deprecated + ctx.$mpType = options.mpType + ctx.$scope = options.mpInstance + // TODO @deprecated + ctx.$mp = {} + if (__VUE_OPTIONS_API__) { + ctx._self = {} + } + // $vm + ctx.$scope.$vm = instance.proxy + // slots + { + instance.slots = {} + if (isArray(options.slots) && options.slots.length) { + options.slots.forEach(name => { + instance.slots[name] = true + }) + } + } + // $emit + instance.emit = createEmitFn(instance.emit, ctx) +} +function initComponentInstance(instance, options) { + initBaseInstance(instance, options) + const ctx = instance.ctx + MP_METHODS.forEach(method => { + ctx[method] = function(...args) { + const mpInstance = ctx.$scope + if (mpInstance && mpInstance[method]) { + return mpInstance[method].apply(mpInstance, args) + } + } + }) + // TODO other + ctx.__set_model = setModel + ctx.__set_sync = setSync + ctx.__get_orig = getOrig + // TODO + // ctx.__get_style = getStyle + ctx.__map = map +} +function initMocks(instance, mpInstance, mocks) { + const ctx = instance.ctx + mocks.forEach(mock => { + if (hasOwn(mpInstance, mock)) { + ctx[mock] = mpInstance[mock] + } + }) +} + +const PAGE_HOOKS = [ + 'onLoad', + 'onShow', + // 'onReady', // lifetimes.ready + 'onHide', + 'onUnload', + 'onResize', + // 'onPageScroll', // 影响性能,开发者手动注册 + 'onTabItemTap', + 'onReachBottom', + 'onPullDownRefresh', + // 'onShareTimeline', // 右上角菜单,开发者手动注册 + 'onAddToFavorites' + // 'onShareAppMessage' // 右上角菜单,开发者手动注册 +] +function findHooks(vueOptions, hooks = new Set()) { + if (vueOptions) { + Object.keys(vueOptions).forEach(name => { + if (name.indexOf('on') === 0 && isFunction(vueOptions[name])) { + hooks.add(name) + } + }) + if (__VUE_OPTIONS_API__) { + const { extends: extendsOptions, mixins } = vueOptions + if (mixins) { + mixins.forEach(mixin => findHooks(mixin, hooks)) + } + if (extendsOptions) { + findHooks(extendsOptions, hooks) + } + } + } + return hooks +} +function initHook(mpOptions, hook, excludes) { + if (excludes.indexOf(hook) === -1 && !hasOwn(mpOptions, hook)) { + mpOptions[hook] = function(args) { + return this.$vm && this.$vm.$callHook(hook, args) + } + } +} +const EXCLUDE_HOOKS = ['onReady'] +function initHooks(mpOptions, hooks, excludes = EXCLUDE_HOOKS) { + hooks.forEach(hook => initHook(mpOptions, hook, excludes)) +} +function initUnknownHooks(mpOptions, vueOptions, excludes = EXCLUDE_HOOKS) { + findHooks(vueOptions).forEach(hook => initHook(mpOptions, hook, excludes)) +} + +const HOOKS = [ + 'onShow', + 'onHide', + 'onError', + 'onThemeChange', + 'onPageNotFound', + 'onUnhandledRejection' +] +function parseApp(instance, parseAppOptions) { + const internalInstance = instance.$ + const appOptions = { + globalData: (instance.$options && instance.$options.globalData) || {}, + $vm: instance, + onLaunch(options) { + const ctx = internalInstance.ctx + if (this.$vm && ctx.$scope) { + // 已经初始化过了,主要是为了百度,百度 onShow 在 onLaunch 之前 + return + } + initBaseInstance(internalInstance, { + mpType: 'app', + mpInstance: this, + slots: [] + }) + ctx.globalData = this.globalData + instance.$callHook('onLaunch', options) + } + } + const vueOptions = instance.$.type + initHooks(appOptions, HOOKS) + initUnknownHooks(appOptions, vueOptions) + if (__VUE_OPTIONS_API__) { + const methods = vueOptions.methods + methods && extend(appOptions, methods) + } + if (parseAppOptions) { + parseAppOptions.parse(appOptions) + } + return appOptions +} +function initCreateApp(parseAppOptions) { + return function createApp(vm) { + return App(parseApp(vm, parseAppOptions)) + } +} + +function initBehavior(options) { + return Behavior(options) +} +function initVueIds(vueIds, mpInstance) { + if (!vueIds) { + return + } + const ids = vueIds.split(',') + const len = ids.length + if (len === 1) { + mpInstance._$vueId = ids[0] + } else if (len === 2) { + mpInstance._$vueId = ids[0] + mpInstance._$vuePid = ids[1] + } +} +const EXTRAS = ['externalClasses'] +function initExtraOptions(miniProgramComponentOptions, vueOptions) { + EXTRAS.forEach(name => { + if (hasOwn(vueOptions, name)) { + miniProgramComponentOptions[name] = vueOptions[name] + } + }) +} +function initWxsCallMethods(methods, wxsCallMethods) { + if (!isArray(wxsCallMethods)) { + return + } + wxsCallMethods.forEach(callMethod => { + methods[callMethod] = function(args) { + return this.$vm[callMethod](args) + } + }) +} +function initRefs(instance, mpInstance) { + Object.defineProperty(instance, 'refs', { + get() { + const $refs = {} + const components = mpInstance.selectAllComponents('.vue-ref') + components.forEach(component => { + const ref = component.dataset.ref + $refs[ref] = component.$vm || component + }) + const forComponents = mpInstance.selectAllComponents('.vue-ref-in-for') + forComponents.forEach(component => { + const ref = component.dataset.ref + if (!$refs[ref]) { + $refs[ref] = [] + } + $refs[ref].push(component.$vm || component) + }) + return $refs + } + }) +} +function findVmByVueId(instance, vuePid) { + // TODO vue3 中 没有 $children + const $children = instance.$children + // 优先查找直属(反向查找:https://github.com/dcloudio/uni-app/issues/1200) + for (let i = $children.length - 1; i >= 0; i--) { + const childVm = $children[i] + if (childVm.$scope._$vueId === vuePid) { + return childVm + } + } + // 反向递归查找 + let parentVm + for (let i = $children.length - 1; i >= 0; i--) { + parentVm = findVmByVueId($children[i], vuePid) + if (parentVm) { + return parentVm + } + } +} + +const PROP_TYPES = [String, Number, Boolean, Object, Array, null] +function createObserver(name) { + return function observer(newVal) { + if (this.$vm) { + this.$vm.$.props[name] = newVal // 为了触发其他非 render watcher + } + } +} +function parsePropType(key, type, defaultValue) { + // [String]=>String + if (isArray(type) && type.length === 1) { + return type[0] + } + return type +} +function initDefaultProps(isBehavior = false) { + const properties = {} + if (!isBehavior) { + properties.vueId = { + type: String, + value: '' + } + // 小程序不能直接定义 $slots 的 props,所以通过 vueSlots 转换到 $slots + properties.vueSlots = { + type: null, + value: [], + observer: function(newVal) { + const $slots = Object.create(null) + newVal.forEach(slotName => { + $slots[slotName] = true + }) + this.setData({ + $slots + }) + } + } + } + return properties +} +function createProperty(key, prop) { + prop.observer = createObserver(key) + return prop +} +function initProps(mpComponentOptions, rawProps, isBehavior = false) { + const properties = initDefaultProps(isBehavior) + if (isArray(rawProps)) { + rawProps.forEach(key => { + properties[key] = createProperty(key, { + type: null + }) + }) + } else if (isPlainObject(rawProps)) { + Object.keys(rawProps).forEach(key => { + const opts = rawProps[key] + if (isPlainObject(opts)) { + // title:{type:String,default:''} + let value = opts.default + if (isFunction(value)) { + value = value() + } + const type = opts.type + opts.type = parsePropType(key, type) + properties[key] = createProperty(key, { + type: PROP_TYPES.indexOf(type) !== -1 ? type : null, + value + }) + } else { + // content:String + const type = parsePropType(key, opts) + properties[key] = createProperty(key, { + type: PROP_TYPES.indexOf(type) !== -1 ? type : null + }) + } + }) + } + mpComponentOptions.properties = properties +} + +function initData(vueOptions) { + let data = vueOptions.data || {} + if (typeof data === 'function') { + try { + const appConfig = getApp().$vm.$.appContext.config + data = data.call(appConfig.globalProperties) + } catch (e) { + if (process.env.VUE_APP_DEBUG) { + console.warn( + '根据 Vue 的 data 函数初始化小程序 data 失败,请尽量确保 data 函数中不访问 vm 对象,否则可能影响首次数据渲染速度。', + data, + e + ) + } + } + } else { + try { + // 对 data 格式化 + data = JSON.parse(JSON.stringify(data)) + } catch (e) {} + } + if (!isPlainObject(data)) { + data = {} + } + return data +} +function initBehaviors(vueOptions, initBehavior) { + const vueBehaviors = vueOptions.behaviors + const vueExtends = vueOptions.extends + const vueMixins = vueOptions.mixins + let vueProps = vueOptions.props + if (!vueProps) { + vueOptions.props = vueProps = [] + } + const behaviors = [] + if (isArray(vueBehaviors)) { + vueBehaviors.forEach(behavior => { + behaviors.push(behavior.replace('uni://', `${__PLATFORM_PREFIX__}://`)) + if (behavior === 'uni://form-field') { + if (isArray(vueProps)) { + vueProps.push('name') + vueProps.push('value') + } else { + vueProps.name = { + type: String, + default: '' + } + vueProps.value = { + type: [String, Number, Boolean, Array, Object, Date], + default: '' + } + } + } + }) + } + if (isPlainObject(vueExtends) && vueExtends.props) { + const behavior = {} + initProps(behavior, vueExtends.props, true) + behaviors.push(initBehavior(behavior)) + } + if (isArray(vueMixins)) { + vueMixins.forEach(vueMixin => { + if (isPlainObject(vueMixin) && vueMixin.props) { + const behavior = {} + initProps(behavior, vueMixin.props, true) + behaviors.push(initBehavior(behavior)) + } + }) + } + return behaviors +} +function applyOptions(componentOptions, vueOptions, initBehavior) { + componentOptions.data = initData(vueOptions) + componentOptions.behaviors = initBehaviors(vueOptions, initBehavior) +} + +function getValue(obj, path) { + const parts = path.split('.') + let key = parts[0] + if (key.indexOf('__$n') === 0) { + //number index + key = parseInt(key.replace('__$n', '')) + } + if (parts.length === 1) { + return obj[key] + } + return getValue(obj[key], parts.slice(1).join('.')) +} +function getExtraValue(instance, dataPathsArray) { + let context = instance + dataPathsArray.forEach(dataPathArray => { + const dataPath = dataPathArray[0] + const value = dataPathArray[2] + if (dataPath || typeof value !== 'undefined') { + // ['','',index,'disable'] + const propPath = dataPathArray[1] + const valuePath = dataPathArray[3] + let vFor + if (Number.isInteger(dataPath)) { + vFor = dataPath + } else if (!dataPath) { + vFor = context + } else if (typeof dataPath === 'string' && dataPath) { + if (dataPath.indexOf('#s#') === 0) { + vFor = dataPath.substr(3) + } else { + vFor = getValue(context, dataPath) + } + } + if (Number.isInteger(vFor)) { + context = value + } else if (!propPath) { + context = vFor[value] + } else { + if (isArray(vFor)) { + context = vFor.find(vForItem => { + return getValue(vForItem, propPath) === value + }) + } else if (isPlainObject(vFor)) { + context = Object.keys(vFor).find(vForKey => { + return getValue(vFor[vForKey], propPath) === value + }) + } else { + console.error('v-for 暂不支持循环数据:', vFor) + } + } + if (valuePath) { + context = getValue(context, valuePath) + } + } + }) + return context +} +function processEventExtra(instance, extra, event) { + const extraObj = {} + if (isArray(extra) && extra.length) { + /** + *[ + * ['data.items', 'data.id', item.data.id], + * ['metas', 'id', meta.id] + *], + *[ + * ['data.items', 'data.id', item.data.id], + * ['metas', 'id', meta.id] + *], + *'test' + */ + extra.forEach((dataPath, index) => { + if (typeof dataPath === 'string') { + if (!dataPath) { + // model,prop.sync + extraObj['$' + index] = instance + } else { + if (dataPath === '$event') { + // $event + extraObj['$' + index] = event + } else if (dataPath === 'arguments') { + if (event.detail && event.detail.__args__) { + extraObj['$' + index] = event.detail.__args__ + } else { + extraObj['$' + index] = [event] + } + } else if (dataPath.indexOf('$event.') === 0) { + // $event.target.value + extraObj['$' + index] = getValue( + event, + dataPath.replace('$event.', '') + ) + } else { + extraObj['$' + index] = getValue(instance, dataPath) + } + } + } else { + extraObj['$' + index] = getExtraValue(instance, dataPath) + } + }) + } + return extraObj +} +function getObjByArray(arr) { + const obj = {} + for (let i = 1; i < arr.length; i++) { + const element = arr[i] + obj[element[0]] = element[1] + } + return obj +} +function processEventArgs( + instance, + event, + args = [], + extra = [], + isCustom, + methodName +) { + let isCustomMPEvent = false // wxcomponent 组件,传递原始 event 对象 + if (isCustom) { + // 自定义事件 + isCustomMPEvent = + event.currentTarget && + event.currentTarget.dataset && + event.currentTarget.dataset.comType === 'wx' + if (!args.length) { + // 无参数,直接传入 event 或 detail 数组 + if (isCustomMPEvent) { + return [event] + } + return event.detail.__args__ || event.detail + } + } + const extraObj = processEventExtra(instance, extra, event) + const ret = [] + args.forEach(arg => { + if (arg === '$event') { + if (methodName === '__set_model' && !isCustom) { + // input v-model value + ret.push(event.target.value) + } else { + if (isCustom && !isCustomMPEvent) { + ret.push(event.detail.__args__[0]) + } else { + // wxcomponent 组件或内置组件 + ret.push(event) + } + } + } else { + if (isArray(arg) && arg[0] === 'o') { + ret.push(getObjByArray(arg)) + } else if (typeof arg === 'string' && hasOwn(extraObj, arg)) { + ret.push(extraObj[arg]) + } else { + ret.push(arg) + } + } + }) + return ret +} +function wrapper(event) { + event.stopPropagation = NOOP + event.preventDefault = NOOP + event.target = event.target || {} + if (!hasOwn(event, 'detail')) { + event.detail = {} + } + if (hasOwn(event, 'markerId')) { + event.detail = typeof event.detail === 'object' ? event.detail : {} + event.detail.markerId = event.markerId + } + if (isPlainObject(event.detail)) { + event.target = Object.assign({}, event.target, event.detail) + } + return event +} +const ONCE = '~' +const CUSTOM = '^' +function matchEventType(eventType, optType) { + return ( + eventType === optType || + (optType === 'regionchange' && + (eventType === 'begin' || eventType === 'end')) + ) +} +function handleEvent(event) { + event = wrapper(event) + // [['tap',[['handle',[1,2,a]],['handle1',[1,2,a]]]]] + const dataset = (event.currentTarget || event.target).dataset + if (!dataset) { + return console.warn('事件信息不存在') + } + const eventOpts = dataset.eventOpts || dataset['event-opts'] // 支付宝 web-view 组件 dataset 非驼峰 + if (!eventOpts) { + return console.warn('事件信息不存在') + } + // [['handle',[1,2,a]],['handle1',[1,2,a]]] + const eventType = event.type + const ret = [] + eventOpts.forEach(eventOpt => { + let type = eventOpt[0] + const eventsArray = eventOpt[1] + const isCustom = type.charAt(0) === CUSTOM + type = isCustom ? type.slice(1) : type + const isOnce = type.charAt(0) === ONCE + type = isOnce ? type.slice(1) : type + if (eventsArray && matchEventType(eventType, type)) { + eventsArray.forEach(eventArray => { + const methodName = eventArray[0] + if (methodName) { + let handlerCtx = this.$vm + if ( + handlerCtx.$options.generic && + handlerCtx.$parent && + handlerCtx.$parent.$parent + ) { + // mp-weixin,mp-toutiao 抽象节点模拟 scoped slots + handlerCtx = handlerCtx.$parent.$parent + } + if (methodName === '$emit') { + handlerCtx.$emit.apply( + handlerCtx, + processEventArgs( + this.$vm, + event, + eventArray[1], + eventArray[2], + isCustom, + methodName + ) + ) + return + } + const handler = handlerCtx[methodName] + if (!isFunction(handler)) { + throw new Error(` _vm.${methodName} is not a function`) + } + if (isOnce) { + if (handler.once) { + return + } + handler.once = true + } + ret.push( + handler.apply( + handlerCtx, + processEventArgs( + this.$vm, + event, + eventArray[1], + eventArray[2], + isCustom, + methodName + ) + ) + ) + } + }) + } + }) + if ( + eventType === 'input' && + ret.length === 1 && + typeof ret[0] !== 'undefined' + ) { + return ret[0] + } +} + +function parseComponent( + vueOptions, + { parse, mocks, isPage, initRelation, handleLink, initLifetimes } +) { + vueOptions = vueOptions.default || vueOptions + const options = { + multipleSlots: true, + addGlobalClass: true + } + if (vueOptions.options) { + extend(options, vueOptions.options) + } + const mpComponentOptions = { + options, + lifetimes: initLifetimes({ mocks, isPage, initRelation, vueOptions }), + pageLifetimes: { + show() { + this.$vm && this.$vm.$callHook('onPageShow') + }, + hide() { + this.$vm && this.$vm.$callHook('onPageHide') + }, + resize(size) { + this.$vm && this.$vm.$callHook('onPageResize', size) + } + }, + methods: { + __l: handleLink, + __e: handleEvent + } + } + if (__VUE_OPTIONS_API__) { + applyOptions(mpComponentOptions, vueOptions, initBehavior) + } + initProps(mpComponentOptions, vueOptions.props, false) + initExtraOptions(mpComponentOptions, vueOptions) + initWxsCallMethods(mpComponentOptions.methods, vueOptions.wxsCallMethods) + if (parse) { + parse(mpComponentOptions, { handleLink }) + } + return mpComponentOptions +} +function initCreateComponent(parseOptions) { + return function createComponent(vueComponentOptions) { + return Component(parseComponent(vueComponentOptions, parseOptions)) + } +} +let $createComponentFn +let $destroyComponentFn +function $createComponent(initialVNode, options) { + if (!$createComponentFn) { + $createComponentFn = getApp().$vm.$createComponent + } + return $createComponentFn(initialVNode, options) +} +function $destroyComponent(instance) { + if (!$destroyComponentFn) { + $destroyComponentFn = getApp().$vm.$destroyComponent + } + return $destroyComponentFn(instance) +} + +function parsePage(vueOptions, parseOptions) { + const { + parse, + mocks, + isPage, + initRelation, + handleLink, + initLifetimes + } = parseOptions + const miniProgramPageOptions = parseComponent(vueOptions, { + mocks, + isPage, + initRelation, + handleLink, + initLifetimes + }) + const methods = miniProgramPageOptions.methods + methods.onLoad = function(query) { + this.options = query + this.$page = { + fullPath: '/' + this.route + stringifyQuery(query) + } + return this.$vm && this.$vm.$callHook('onLoad', query) + } + initHooks(methods, PAGE_HOOKS) + initUnknownHooks(methods, vueOptions) + parse && parse(miniProgramPageOptions, { handleLink }) + return miniProgramPageOptions +} +function initCreatePage(parseOptions) { + return function createPage(vuePageOptions) { + return Component(parsePage(vuePageOptions, parseOptions)) + } +} + +const MPPage = Page +const MPComponent = Component +const customizeRE = /:/g +function customize(str) { + return camelize(str.replace(customizeRE, '-')) +} +function initTriggerEvent(mpInstance) { + const oldTriggerEvent = mpInstance.triggerEvent + mpInstance.triggerEvent = function(event, ...args) { + return oldTriggerEvent.apply(mpInstance, [customize(event), ...args]) + } +} +function initHook$1(name, options) { + const oldHook = options[name] + if (!oldHook) { + options[name] = function() { + initTriggerEvent(this) + } + } else { + options[name] = function(...args) { + initTriggerEvent(this) + return oldHook.apply(this, args) + } + } +} +Page = function(options) { + initHook$1('onLoad', options) + return MPPage(options) +} +Component = function(options) { + initHook$1('created', options) + return MPComponent(options) +} + +function initLifetimes({ mocks, isPage, initRelation, vueOptions }) { + return { + attached() { + const properties = this.properties + initVueIds(properties.vueId, this) + const relationOptions = { + vuePid: this._$vuePid + } + // 处理父子关系 + initRelation(this, relationOptions) + // 初始化 vue 实例 + const mpInstance = this + this.$vm = $createComponent( + { + type: vueOptions, + props: properties + }, + { + mpType: isPage(mpInstance) ? 'page' : 'component', + mpInstance, + slots: properties.vueSlots, + parentComponent: relationOptions.parent && relationOptions.parent.$, + onBeforeSetup(instance, options) { + initRefs(instance, mpInstance) + initMocks(instance, mpInstance, mocks) + initComponentInstance(instance, options) + } + } + ) + }, + ready() { + // 当组件 props 默认值为 true,初始化时传入 false 会导致 created,ready 触发, 但 attached 不触发 + // https://developers.weixin.qq.com/community/develop/doc/00066ae2844cc0f8eb883e2a557800 + if (this.$vm) { + this.$vm.$callHook('mounted') + this.$vm.$callHook('onReady') + } + }, + detached() { + this.$vm && $destroyComponent(this.$vm) + } + } +} + +const mocks = ['__route__', '__wxExparserNodeId__', '__wxWebviewId__'] +function isPage(mpInstance) { + return !!mpInstance.route +} +function initRelation(mpInstance, detail) { + mpInstance.triggerEvent('__l', detail) +} +function handleLink(event) { + // detail 是微信,value 是百度(dipatch) + const detail = event.detail || event.value + const vuePid = detail.vuePid + let parentVm + if (vuePid) { + parentVm = findVmByVueId(this.$vm, vuePid) + } + if (!parentVm) { + parentVm = this.$vm + } + detail.parent = parentVm +} + +var parseOptions = /*#__PURE__*/ Object.freeze({ + __proto__: null, + mocks: mocks, + isPage: isPage, + initRelation: initRelation, + handleLink: handleLink, + initLifetimes: initLifetimes +}) + +const createApp = initCreateApp() +const createPage = initCreatePage(parseOptions) +const createComponent = initCreateComponent(parseOptions) + +export { createApp, createComponent, createPage } diff --git a/packages/uni-quickapp-webview/dist/uni.api.esm.js b/packages/uni-quickapp-webview/dist/uni.api.esm.js new file mode 100644 index 0000000000000000000000000000000000000000..db4cebca42161b7408df2b210710067db763f503 --- /dev/null +++ b/packages/uni-quickapp-webview/dist/uni.api.esm.js @@ -0,0 +1,542 @@ +import { + isArray, + isPromise, + isFunction, + isPlainObject, + hasOwn, + isString +} from '@vue/shared' + +function createApi(fn, validate) { + if (process.env.NODE_ENV !== 'production' && validate); + return fn +} + +const Upx2pxProtocol = [ + { + name: 'upx', + type: [Number, String], + required: true + } +] + +const EPS = 1e-4 +const BASE_DEVICE_WIDTH = 750 +let isIOS = false +let deviceWidth = 0 +let deviceDPR = 0 +function checkDeviceWidth() { + const { platform, pixelRatio, windowWidth } = qa.getSystemInfoSync() + deviceWidth = windowWidth + deviceDPR = pixelRatio + isIOS = platform === 'ios' +} +const upx2px = createApi((number, newDeviceWidth) => { + if (deviceWidth === 0) { + checkDeviceWidth() + } + number = Number(number) + if (number === 0) { + return 0 + } + let result = (number / BASE_DEVICE_WIDTH) * (newDeviceWidth || deviceWidth) + if (result < 0) { + result = -result + } + result = Math.floor(result + EPS) + if (result === 0) { + if (deviceDPR === 1 || !isIOS) { + result = 1 + } else { + result = 0.5 + } + } + return number < 0 ? -result : result +}, Upx2pxProtocol) + +var HOOKS +;(function(HOOKS) { + HOOKS['INVOKE'] = 'invoke' + HOOKS['SUCCESS'] = 'success' + HOOKS['FAIL'] = 'fail' + HOOKS['COMPLETE'] = 'complete' + HOOKS['RETURN_VALUE'] = 'returnValue' +})(HOOKS || (HOOKS = {})) +const globalInterceptors = {} +const scopedInterceptors = {} +function wrapperHook(hook) { + return function(data) { + return hook(data) || data + } +} +function queue(hooks, data) { + let promise = false + for (let i = 0; i < hooks.length; i++) { + const hook = hooks[i] + if (promise) { + promise = Promise.resolve(wrapperHook(hook)) + } else { + const res = hook(data) + if (isPromise(res)) { + promise = Promise.resolve(res) + } + if (res === false) { + return { + then() {}, + catch() {} + } + } + } + } + return ( + promise || { + then(callback) { + return callback(data) + }, + catch() {} + } + ) +} +function wrapperOptions(interceptors, options = {}) { + ;[HOOKS.SUCCESS, HOOKS.FAIL, HOOKS.COMPLETE].forEach(name => { + const hooks = interceptors[name] + if (!isArray(hooks)) { + return + } + const oldCallback = options[name] + options[name] = function callbackInterceptor(res) { + queue(hooks, res).then(res => { + return (isFunction(oldCallback) && oldCallback(res)) || res + }) + } + }) + return options +} +function wrapperReturnValue(method, returnValue) { + const returnValueHooks = [] + if (isArray(globalInterceptors.returnValue)) { + returnValueHooks.push(...globalInterceptors.returnValue) + } + const interceptor = scopedInterceptors[method] + if (interceptor && isArray(interceptor.returnValue)) { + returnValueHooks.push(...interceptor.returnValue) + } + returnValueHooks.forEach(hook => { + returnValue = hook(returnValue) || returnValue + }) + return returnValue +} +function getApiInterceptorHooks(method) { + const interceptor = Object.create(null) + Object.keys(globalInterceptors).forEach(hook => { + if (hook !== 'returnValue') { + interceptor[hook] = globalInterceptors[hook].slice() + } + }) + const scopedInterceptor = scopedInterceptors[method] + if (scopedInterceptor) { + Object.keys(scopedInterceptor).forEach(hook => { + if (hook !== 'returnValue') { + interceptor[hook] = (interceptor[hook] || []).concat( + scopedInterceptor[hook] + ) + } + }) + } + return interceptor +} +function invokeApi(method, api, options, ...params) { + const interceptor = getApiInterceptorHooks(method) + if (interceptor && Object.keys(interceptor).length) { + if (isArray(interceptor.invoke)) { + const res = queue(interceptor.invoke, options) + return res.then(options => { + return api(wrapperOptions(interceptor, options), ...params) + }) + } else { + return api(wrapperOptions(interceptor, options), ...params) + } + } + return api(options, ...params) +} + +const AddInterceptorProtocol = [ + { + name: 'method', + type: [String, Object], + required: true + } +] +const RemoveInterceptorProtocol = AddInterceptorProtocol + +function mergeInterceptorHook(interceptors, interceptor) { + Object.keys(interceptor).forEach(hook => { + if (isFunction(interceptor[hook])) { + interceptors[hook] = mergeHook(interceptors[hook], interceptor[hook]) + } + }) +} +function removeInterceptorHook(interceptors, interceptor) { + if (!interceptors || !interceptor) { + return + } + Object.keys(interceptor).forEach(hook => { + if (isFunction(interceptor[hook])) { + removeHook(interceptors[hook], interceptor[hook]) + } + }) +} +function mergeHook(parentVal, childVal) { + const res = childVal + ? parentVal + ? parentVal.concat(childVal) + : isArray(childVal) + ? childVal + : [childVal] + : parentVal + return res ? dedupeHooks(res) : res +} +function dedupeHooks(hooks) { + const res = [] + for (let i = 0; i < hooks.length; i++) { + if (res.indexOf(hooks[i]) === -1) { + res.push(hooks[i]) + } + } + return res +} +function removeHook(hooks, hook) { + if (!hooks) { + return + } + const index = hooks.indexOf(hook) + if (index !== -1) { + hooks.splice(index, 1) + } +} +const addInterceptor = createApi((method, interceptor) => { + if (typeof method === 'string' && isPlainObject(interceptor)) { + mergeInterceptorHook( + scopedInterceptors[method] || (scopedInterceptors[method] = {}), + interceptor + ) + } else if (isPlainObject(method)) { + mergeInterceptorHook(globalInterceptors, method) + } +}, AddInterceptorProtocol) +const removeInterceptor = createApi((method, interceptor) => { + if (typeof method === 'string') { + if (isPlainObject(interceptor)) { + removeInterceptorHook(scopedInterceptors[method], interceptor) + } else { + delete scopedInterceptors[method] + } + } else if (isPlainObject(method)) { + removeInterceptorHook(globalInterceptors, method) + } +}, RemoveInterceptorProtocol) + +const SYNC_API_RE = /^\$|sendNativeEvent|restoreGlobal|getCurrentSubNVue|getMenuButtonBoundingClientRect|^report|interceptors|Interceptor$|getSubNVueById|requireNativePlugin|upx2px|hideKeyboard|canIUse|^create|Sync$|Manager$|base64ToArrayBuffer|arrayBufferToBase64/ +const CONTEXT_API_RE = /^create|Manager$/ +// Context例外情况 +const CONTEXT_API_RE_EXC = ['createBLEConnection'] +// 同步例外情况 +const ASYNC_API = ['createBLEConnection'] +const CALLBACK_API_RE = /^on|^off/ +function isContextApi(name) { + return CONTEXT_API_RE.test(name) && CONTEXT_API_RE_EXC.indexOf(name) === -1 +} +function isSyncApi(name) { + return SYNC_API_RE.test(name) && ASYNC_API.indexOf(name) === -1 +} +function isCallbackApi(name) { + return CALLBACK_API_RE.test(name) && name !== 'onPush' +} +function handlePromise(promise) { + if (!__UNI_PROMISE_API__) { + return promise + } + return promise + .then(data => { + return [null, data] + }) + .catch(err => [err]) +} +function shouldPromise(name) { + if (isContextApi(name) || isSyncApi(name) || isCallbackApi(name)) { + return false + } + return true +} +/* eslint-disable no-extend-native */ +if (!Promise.prototype.finally) { + Promise.prototype.finally = function(onfinally) { + const promise = this.constructor + return this.then( + value => promise.resolve(onfinally && onfinally()).then(() => value), + reason => + promise.resolve(onfinally && onfinally()).then(() => { + throw reason + }) + ) + } +} +function promisify(name, api) { + if (!shouldPromise(name)) { + return api + } + if (!isFunction(api)) { + return api + } + return function promiseApi(options = {}, ...params) { + if ( + isFunction(options.success) || + isFunction(options.fail) || + isFunction(options.complete) + ) { + return wrapperReturnValue(name, invokeApi(name, api, options, ...params)) + } + return wrapperReturnValue( + name, + handlePromise( + new Promise((resolve, reject) => { + invokeApi( + name, + api, + Object.assign({}, options, { + success: resolve, + fail: reject + }), + ...params + ) + }) + ) + ) + } +} + +const CALLBACKS = ['success', 'fail', 'cancel', 'complete'] +function initWrapper(protocols) { + function processCallback(methodName, method, returnValue) { + return function(res) { + return method(processReturnValue(methodName, res, returnValue)) + } + } + function processArgs( + methodName, + fromArgs, + argsOption = {}, + returnValue = {}, + keepFromArgs = false + ) { + if (isPlainObject(fromArgs)) { + // 一般 api 的参数解析 + const toArgs = keepFromArgs === true ? fromArgs : {} // returnValue 为 false 时,说明是格式化返回值,直接在返回值对象上修改赋值 + if (isFunction(argsOption)) { + argsOption = argsOption(fromArgs, toArgs) || {} + } + for (const key in fromArgs) { + if (hasOwn(argsOption, key)) { + let keyOption = argsOption[key] + if (isFunction(keyOption)) { + keyOption = keyOption(fromArgs[key], fromArgs, toArgs) + } + if (!keyOption) { + // 不支持的参数 + console.warn(`快应用(Webview)版 ${methodName} 暂不支持 ${key}`) + } else if (isString(keyOption)) { + // 重写参数 key + toArgs[keyOption] = fromArgs[key] + } else if (isPlainObject(keyOption)) { + // {name:newName,value:value}可重新指定参数 key:value + toArgs[keyOption.name ? keyOption.name : key] = keyOption.value + } + } else if (CALLBACKS.indexOf(key) !== -1) { + const callback = fromArgs[key] + if (isFunction(callback)) { + toArgs[key] = processCallback(methodName, callback, returnValue) + } + } else { + if (!keepFromArgs && !hasOwn(toArgs, key)) { + toArgs[key] = fromArgs[key] + } + } + } + return toArgs + } else if (isFunction(fromArgs)) { + fromArgs = processCallback(methodName, fromArgs, returnValue) + } + return fromArgs + } + function processReturnValue( + methodName, + res, + returnValue, + keepReturnValue = false + ) { + if (isFunction(protocols.returnValue)) { + // 处理通用 returnValue + res = protocols.returnValue(methodName, res) + } + return processArgs(methodName, res, returnValue, {}, keepReturnValue) + } + return function wrapper(methodName, method) { + if (!hasOwn(protocols, methodName)) { + return method + } + const protocol = protocols[methodName] + if (!protocol) { + // 暂不支持的 api + return function() { + console.error(`快应用(Webview)版 暂不支持${methodName}`) + } + } + return function(arg1, arg2) { + // 目前 api 最多两个参数 + let options = protocol + if (isFunction(protocol)) { + options = protocol(arg1) + } + arg1 = processArgs(methodName, arg1, options.args, options.returnValue) + const args = [arg1] + if (typeof arg2 !== 'undefined') { + args.push(arg2) + } + const returnValue = qa[options.name || methodName].apply(qa, args) + if (isSyncApi(methodName)) { + // 同步 api + return processReturnValue( + methodName, + returnValue, + options.returnValue, + isContextApi(methodName) + ) + } + return returnValue + } + } +} + +const baseApis = { upx2px, addInterceptor, removeInterceptor } +function initUni(api, protocols) { + const wrapper = initWrapper(protocols) + const UniProxyHandlers = { + get(target, key) { + if (hasOwn(target, key)) { + return target[key] + } + if (hasOwn(api, key)) { + return promisify(key, api[key]) + } + if (hasOwn(baseApis, key)) { + return promisify(key, baseApis[key]) + } + // event-api + // provider-api? + return promisify(key, wrapper(key, qa[key])) + } + } + return new Proxy({}, UniProxyHandlers) +} + +function initGetProvider(providers) { + return function getProvider({ service, success, fail, complete }) { + let res + if (providers[service]) { + res = { + errMsg: 'getProvider:ok', + service, + provider: providers[service] + } + isFunction(success) && success(res) + } else { + res = { + errMsg: 'getProvider:fail:服务[' + service + ']不存在' + } + isFunction(fail) && fail(res) + } + isFunction(complete) && complete(res) + } +} + +const previewImage = { + args(fromArgs, toArgs) { + let currentIndex = parseInt(fromArgs.current) + if (isNaN(currentIndex)) { + return + } + const urls = fromArgs.urls + if (!isArray(urls)) { + return + } + const len = urls.length + if (!len) { + return + } + if (currentIndex < 0) { + currentIndex = 0 + } else if (currentIndex >= len) { + currentIndex = len - 1 + } + if (currentIndex > 0) { + toArgs.current = urls[currentIndex] + toArgs.urls = urls.filter( + (item, index) => + index < currentIndex ? item !== urls[currentIndex] : true + ) + } else { + toArgs.current = urls[0] + } + return { + indicator: false, + loop: false + } + } +} +function addSafeAreaInsets(fromRes, toRes) { + if (fromRes.safeArea) { + const safeArea = fromRes.safeArea + toRes.safeAreaInsets = { + top: safeArea.top, + left: safeArea.left, + right: fromRes.windowWidth - safeArea.right, + bottom: fromRes.windowHeight - safeArea.bottom + } + } +} +const getSystemInfo = { + returnValue: addSafeAreaInsets +} +const getSystemInfoSync = getSystemInfo +const redirectTo = {} + +const providers = { + oauth: [], + share: [], + payment: [], + push: [] +} +if (qa.canIUse('getAccountProvider')) { + providers.oauth.push(qa.getAccountProvider()) +} +if (qa.canIUse('getVendorPaymentProvider')) { + providers.payment.push(qa.getVendorPaymentProvider()) +} +const getProvider = initGetProvider(providers) + +var shims = /*#__PURE__*/ Object.freeze({ + __proto__: null, + getProvider: getProvider +}) + +var protocols = /*#__PURE__*/ Object.freeze({ + __proto__: null, + redirectTo: redirectTo, + previewImage: previewImage, + getSystemInfo: getSystemInfo, + getSystemInfoSync: getSystemInfoSync +}) + +var index = initUni(shims, protocols) + +export default index diff --git a/packages/uni-quickapp-webview/dist/uni.mp.esm.js b/packages/uni-quickapp-webview/dist/uni.mp.esm.js new file mode 100644 index 0000000000000000000000000000000000000000..4446cb15be6783499031a71e90596ea324d3c1f4 --- /dev/null +++ b/packages/uni-quickapp-webview/dist/uni.mp.esm.js @@ -0,0 +1,1062 @@ +import { + isArray, + hasOwn, + toNumber, + isPlainObject, + isObject, + isFunction, + extend, + NOOP, + camelize +} from '@vue/shared' +import { stringifyQuery } from '@dcloudio/uni-shared' + +function setModel(target, key, value, modifiers) { + if (isArray(modifiers)) { + if (modifiers.indexOf('trim') !== -1) { + value = value.trim() + } + if (modifiers.indexOf('number') !== -1) { + value = toNumber(value) + } + } + if (!target) { + target = this + } + target[key] = value +} +function setSync(target, key, value) { + if (!target) { + target = this + } + target[key] = value +} +function getOrig(data) { + if (isPlainObject(data)) { + return data.$orig || data + } + return data +} +function map(val, iteratee) { + let ret, i, l, keys, key + if (isArray(val)) { + ret = new Array(val.length) + for (i = 0, l = val.length; i < l; i++) { + ret[i] = iteratee(val[i], i) + } + return ret + } else if (isObject(val)) { + keys = Object.keys(val) + ret = Object.create(null) + for (i = 0, l = keys.length; i < l; i++) { + key = keys[i] + ret[key] = iteratee(val[key], key, i) + } + return ret + } + return [] +} +const MP_METHODS = [ + 'createSelectorQuery', + 'createIntersectionObserver', + 'selectAllComponents', + 'selectComponent' +] +function createEmitFn(oldEmit, ctx) { + return function emit(event, ...args) { + if (ctx.$scope && event) { + ctx.$scope.triggerEvent(event, { __args__: args }) + } + return oldEmit.apply(this, [event, ...args]) + } +} +function initBaseInstance(instance, options) { + const ctx = instance.ctx + // mp + ctx.mpType = options.mpType // @deprecated + ctx.$mpType = options.mpType + ctx.$scope = options.mpInstance + // TODO @deprecated + ctx.$mp = {} + if (__VUE_OPTIONS_API__) { + ctx._self = {} + } + // $vm + ctx.$scope.$vm = instance.proxy + // slots + { + instance.slots = {} + if (isArray(options.slots) && options.slots.length) { + options.slots.forEach(name => { + instance.slots[name] = true + }) + } + } + // $emit + instance.emit = createEmitFn(instance.emit, ctx) +} +function initComponentInstance(instance, options) { + initBaseInstance(instance, options) + const ctx = instance.ctx + MP_METHODS.forEach(method => { + ctx[method] = function(...args) { + const mpInstance = ctx.$scope + if (mpInstance && mpInstance[method]) { + return mpInstance[method].apply(mpInstance, args) + } + } + }) + // TODO other + ctx.__set_model = setModel + ctx.__set_sync = setSync + ctx.__get_orig = getOrig + // TODO + // ctx.__get_style = getStyle + ctx.__map = map +} +function initMocks(instance, mpInstance, mocks) { + const ctx = instance.ctx + mocks.forEach(mock => { + if (hasOwn(mpInstance, mock)) { + ctx[mock] = mpInstance[mock] + } + }) +} + +const PAGE_HOOKS = [ + 'onLoad', + 'onShow', + // 'onReady', // lifetimes.ready + 'onHide', + 'onUnload', + 'onResize', + // 'onPageScroll', // 影响性能,开发者手动注册 + 'onTabItemTap', + 'onReachBottom', + 'onPullDownRefresh', + // 'onShareTimeline', // 右上角菜单,开发者手动注册 + 'onAddToFavorites' + // 'onShareAppMessage' // 右上角菜单,开发者手动注册 +] +function findHooks(vueOptions, hooks = new Set()) { + if (vueOptions) { + Object.keys(vueOptions).forEach(name => { + if (name.indexOf('on') === 0 && isFunction(vueOptions[name])) { + hooks.add(name) + } + }) + if (__VUE_OPTIONS_API__) { + const { extends: extendsOptions, mixins } = vueOptions + if (mixins) { + mixins.forEach(mixin => findHooks(mixin, hooks)) + } + if (extendsOptions) { + findHooks(extendsOptions, hooks) + } + } + } + return hooks +} +function initHook(mpOptions, hook, excludes) { + if (excludes.indexOf(hook) === -1 && !hasOwn(mpOptions, hook)) { + mpOptions[hook] = function(args) { + return this.$vm && this.$vm.$callHook(hook, args) + } + } +} +const EXCLUDE_HOOKS = ['onReady'] +function initHooks(mpOptions, hooks, excludes = EXCLUDE_HOOKS) { + hooks.forEach(hook => initHook(mpOptions, hook, excludes)) +} +function initUnknownHooks(mpOptions, vueOptions, excludes = EXCLUDE_HOOKS) { + findHooks(vueOptions).forEach(hook => initHook(mpOptions, hook, excludes)) +} + +const HOOKS = [ + 'onShow', + 'onHide', + 'onError', + 'onThemeChange', + 'onPageNotFound', + 'onUnhandledRejection' +] +function parseApp(instance, parseAppOptions) { + const internalInstance = instance.$ + const appOptions = { + globalData: (instance.$options && instance.$options.globalData) || {}, + $vm: instance, + onLaunch(options) { + const ctx = internalInstance.ctx + if (this.$vm && ctx.$scope) { + // 已经初始化过了,主要是为了百度,百度 onShow 在 onLaunch 之前 + return + } + initBaseInstance(internalInstance, { + mpType: 'app', + mpInstance: this, + slots: [] + }) + ctx.globalData = this.globalData + instance.$callHook('onLaunch', options) + } + } + const vueOptions = instance.$.type + initHooks(appOptions, HOOKS) + initUnknownHooks(appOptions, vueOptions) + if (__VUE_OPTIONS_API__) { + const methods = vueOptions.methods + methods && extend(appOptions, methods) + } + if (parseAppOptions) { + parseAppOptions.parse(appOptions) + } + return appOptions +} +function initCreateApp(parseAppOptions) { + return function createApp(vm) { + return App(parseApp(vm, parseAppOptions)) + } +} + +function initBehavior(options) { + return Behavior(options) +} +function initVueIds(vueIds, mpInstance) { + if (!vueIds) { + return + } + const ids = vueIds.split(',') + const len = ids.length + if (len === 1) { + mpInstance._$vueId = ids[0] + } else if (len === 2) { + mpInstance._$vueId = ids[0] + mpInstance._$vuePid = ids[1] + } +} +const EXTRAS = ['externalClasses'] +function initExtraOptions(miniProgramComponentOptions, vueOptions) { + EXTRAS.forEach(name => { + if (hasOwn(vueOptions, name)) { + miniProgramComponentOptions[name] = vueOptions[name] + } + }) +} +function initWxsCallMethods(methods, wxsCallMethods) { + if (!isArray(wxsCallMethods)) { + return + } + wxsCallMethods.forEach(callMethod => { + methods[callMethod] = function(args) { + return this.$vm[callMethod](args) + } + }) +} +function initRefs(instance, mpInstance) { + Object.defineProperty(instance, 'refs', { + get() { + const $refs = {} + const components = mpInstance.selectAllComponents('.vue-ref') + components.forEach(component => { + const ref = component.dataset.ref + $refs[ref] = component.$vm || component + }) + const forComponents = mpInstance.selectAllComponents('.vue-ref-in-for') + forComponents.forEach(component => { + const ref = component.dataset.ref + if (!$refs[ref]) { + $refs[ref] = [] + } + $refs[ref].push(component.$vm || component) + }) + return $refs + } + }) +} + +const PROP_TYPES = [String, Number, Boolean, Object, Array, null] +function createObserver(name) { + return function observer(newVal) { + if (this.$vm) { + this.$vm.$.props[name] = newVal // 为了触发其他非 render watcher + } + } +} +function parsePropType(key, type, defaultValue) { + // [String]=>String + if (isArray(type) && type.length === 1) { + return type[0] + } + return type +} +function initDefaultProps(isBehavior = false) { + const properties = {} + if (!isBehavior) { + properties.vueId = { + type: String, + value: '' + } + // 小程序不能直接定义 $slots 的 props,所以通过 vueSlots 转换到 $slots + properties.vueSlots = { + type: null, + value: [], + observer: function(newVal) { + const $slots = Object.create(null) + newVal.forEach(slotName => { + $slots[slotName] = true + }) + this.setData({ + $slots + }) + } + } + } + return properties +} +function createProperty(key, prop) { + prop.observer = createObserver(key) + return prop +} +function initProps(mpComponentOptions, rawProps, isBehavior = false) { + const properties = initDefaultProps(isBehavior) + if (isArray(rawProps)) { + rawProps.forEach(key => { + properties[key] = createProperty(key, { + type: null + }) + }) + } else if (isPlainObject(rawProps)) { + Object.keys(rawProps).forEach(key => { + const opts = rawProps[key] + if (isPlainObject(opts)) { + // title:{type:String,default:''} + let value = opts.default + if (isFunction(value)) { + value = value() + } + const type = opts.type + opts.type = parsePropType(key, type) + properties[key] = createProperty(key, { + type: PROP_TYPES.indexOf(type) !== -1 ? type : null, + value + }) + } else { + // content:String + const type = parsePropType(key, opts) + properties[key] = createProperty(key, { + type: PROP_TYPES.indexOf(type) !== -1 ? type : null + }) + } + }) + } + mpComponentOptions.properties = properties +} + +function initData(vueOptions) { + let data = vueOptions.data || {} + if (typeof data === 'function') { + try { + const appConfig = getApp().$vm.$.appContext.config + data = data.call(appConfig.globalProperties) + } catch (e) { + if (process.env.VUE_APP_DEBUG) { + console.warn( + '根据 Vue 的 data 函数初始化小程序 data 失败,请尽量确保 data 函数中不访问 vm 对象,否则可能影响首次数据渲染速度。', + data, + e + ) + } + } + } else { + try { + // 对 data 格式化 + data = JSON.parse(JSON.stringify(data)) + } catch (e) {} + } + if (!isPlainObject(data)) { + data = {} + } + return data +} +function initBehaviors(vueOptions, initBehavior) { + const vueBehaviors = vueOptions.behaviors + const vueExtends = vueOptions.extends + const vueMixins = vueOptions.mixins + let vueProps = vueOptions.props + if (!vueProps) { + vueOptions.props = vueProps = [] + } + const behaviors = [] + if (isArray(vueBehaviors)) { + vueBehaviors.forEach(behavior => { + behaviors.push(behavior.replace('uni://', `${__PLATFORM_PREFIX__}://`)) + if (behavior === 'uni://form-field') { + if (isArray(vueProps)) { + vueProps.push('name') + vueProps.push('value') + } else { + vueProps.name = { + type: String, + default: '' + } + vueProps.value = { + type: [String, Number, Boolean, Array, Object, Date], + default: '' + } + } + } + }) + } + if (isPlainObject(vueExtends) && vueExtends.props) { + const behavior = {} + initProps(behavior, vueExtends.props, true) + behaviors.push(initBehavior(behavior)) + } + if (isArray(vueMixins)) { + vueMixins.forEach(vueMixin => { + if (isPlainObject(vueMixin) && vueMixin.props) { + const behavior = {} + initProps(behavior, vueMixin.props, true) + behaviors.push(initBehavior(behavior)) + } + }) + } + return behaviors +} +function applyOptions(componentOptions, vueOptions, initBehavior) { + componentOptions.data = initData(vueOptions) + componentOptions.behaviors = initBehaviors(vueOptions, initBehavior) +} + +function getValue(obj, path) { + const parts = path.split('.') + let key = parts[0] + if (key.indexOf('__$n') === 0) { + //number index + key = parseInt(key.replace('__$n', '')) + } + if (parts.length === 1) { + return obj[key] + } + return getValue(obj[key], parts.slice(1).join('.')) +} +function getExtraValue(instance, dataPathsArray) { + let context = instance + dataPathsArray.forEach(dataPathArray => { + const dataPath = dataPathArray[0] + const value = dataPathArray[2] + if (dataPath || typeof value !== 'undefined') { + // ['','',index,'disable'] + const propPath = dataPathArray[1] + const valuePath = dataPathArray[3] + let vFor + if (Number.isInteger(dataPath)) { + vFor = dataPath + } else if (!dataPath) { + vFor = context + } else if (typeof dataPath === 'string' && dataPath) { + if (dataPath.indexOf('#s#') === 0) { + vFor = dataPath.substr(3) + } else { + vFor = getValue(context, dataPath) + } + } + if (Number.isInteger(vFor)) { + context = value + } else if (!propPath) { + context = vFor[value] + } else { + if (isArray(vFor)) { + context = vFor.find(vForItem => { + return getValue(vForItem, propPath) === value + }) + } else if (isPlainObject(vFor)) { + context = Object.keys(vFor).find(vForKey => { + return getValue(vFor[vForKey], propPath) === value + }) + } else { + console.error('v-for 暂不支持循环数据:', vFor) + } + } + if (valuePath) { + context = getValue(context, valuePath) + } + } + }) + return context +} +function processEventExtra(instance, extra, event) { + const extraObj = {} + if (isArray(extra) && extra.length) { + /** + *[ + * ['data.items', 'data.id', item.data.id], + * ['metas', 'id', meta.id] + *], + *[ + * ['data.items', 'data.id', item.data.id], + * ['metas', 'id', meta.id] + *], + *'test' + */ + extra.forEach((dataPath, index) => { + if (typeof dataPath === 'string') { + if (!dataPath) { + // model,prop.sync + extraObj['$' + index] = instance + } else { + if (dataPath === '$event') { + // $event + extraObj['$' + index] = event + } else if (dataPath === 'arguments') { + if (event.detail && event.detail.__args__) { + extraObj['$' + index] = event.detail.__args__ + } else { + extraObj['$' + index] = [event] + } + } else if (dataPath.indexOf('$event.') === 0) { + // $event.target.value + extraObj['$' + index] = getValue( + event, + dataPath.replace('$event.', '') + ) + } else { + extraObj['$' + index] = getValue(instance, dataPath) + } + } + } else { + extraObj['$' + index] = getExtraValue(instance, dataPath) + } + }) + } + return extraObj +} +function getObjByArray(arr) { + const obj = {} + for (let i = 1; i < arr.length; i++) { + const element = arr[i] + obj[element[0]] = element[1] + } + return obj +} +function processEventArgs( + instance, + event, + args = [], + extra = [], + isCustom, + methodName +) { + let isCustomMPEvent = false // wxcomponent 组件,传递原始 event 对象 + if (isCustom) { + // 自定义事件 + isCustomMPEvent = + event.currentTarget && + event.currentTarget.dataset && + event.currentTarget.dataset.comType === 'wx' + if (!args.length) { + // 无参数,直接传入 event 或 detail 数组 + if (isCustomMPEvent) { + return [event] + } + return event.detail.__args__ || event.detail + } + } + const extraObj = processEventExtra(instance, extra, event) + const ret = [] + args.forEach(arg => { + if (arg === '$event') { + if (methodName === '__set_model' && !isCustom) { + // input v-model value + ret.push(event.target.value) + } else { + if (isCustom && !isCustomMPEvent) { + ret.push(event.detail.__args__[0]) + } else { + // wxcomponent 组件或内置组件 + ret.push(event) + } + } + } else { + if (isArray(arg) && arg[0] === 'o') { + ret.push(getObjByArray(arg)) + } else if (typeof arg === 'string' && hasOwn(extraObj, arg)) { + ret.push(extraObj[arg]) + } else { + ret.push(arg) + } + } + }) + return ret +} +function wrapper(event) { + event.stopPropagation = NOOP + event.preventDefault = NOOP + event.target = event.target || {} + if (!hasOwn(event, 'detail')) { + event.detail = {} + } + if (hasOwn(event, 'markerId')) { + event.detail = typeof event.detail === 'object' ? event.detail : {} + event.detail.markerId = event.markerId + } + if (isPlainObject(event.detail)) { + event.target = Object.assign({}, event.target, event.detail) + } + return event +} +const ONCE = '~' +const CUSTOM = '^' +function matchEventType(eventType, optType) { + return ( + eventType === optType || + (optType === 'regionchange' && + (eventType === 'begin' || eventType === 'end')) + ) +} +function handleEvent(event) { + event = wrapper(event) + // [['tap',[['handle',[1,2,a]],['handle1',[1,2,a]]]]] + const dataset = (event.currentTarget || event.target).dataset + if (!dataset) { + return console.warn('事件信息不存在') + } + const eventOpts = dataset.eventOpts || dataset['event-opts'] // 支付宝 web-view 组件 dataset 非驼峰 + if (!eventOpts) { + return console.warn('事件信息不存在') + } + // [['handle',[1,2,a]],['handle1',[1,2,a]]] + const eventType = event.type + const ret = [] + eventOpts.forEach(eventOpt => { + let type = eventOpt[0] + const eventsArray = eventOpt[1] + const isCustom = type.charAt(0) === CUSTOM + type = isCustom ? type.slice(1) : type + const isOnce = type.charAt(0) === ONCE + type = isOnce ? type.slice(1) : type + if (eventsArray && matchEventType(eventType, type)) { + eventsArray.forEach(eventArray => { + const methodName = eventArray[0] + if (methodName) { + let handlerCtx = this.$vm + if ( + handlerCtx.$options.generic && + handlerCtx.$parent && + handlerCtx.$parent.$parent + ) { + // mp-weixin,mp-toutiao 抽象节点模拟 scoped slots + handlerCtx = handlerCtx.$parent.$parent + } + if (methodName === '$emit') { + handlerCtx.$emit.apply( + handlerCtx, + processEventArgs( + this.$vm, + event, + eventArray[1], + eventArray[2], + isCustom, + methodName + ) + ) + return + } + const handler = handlerCtx[methodName] + if (!isFunction(handler)) { + throw new Error(` _vm.${methodName} is not a function`) + } + if (isOnce) { + if (handler.once) { + return + } + handler.once = true + } + ret.push( + handler.apply( + handlerCtx, + processEventArgs( + this.$vm, + event, + eventArray[1], + eventArray[2], + isCustom, + methodName + ) + ) + ) + } + }) + } + }) + if ( + eventType === 'input' && + ret.length === 1 && + typeof ret[0] !== 'undefined' + ) { + return ret[0] + } +} + +function parseComponent( + vueOptions, + { parse, mocks, isPage, initRelation, handleLink, initLifetimes } +) { + vueOptions = vueOptions.default || vueOptions + const options = { + multipleSlots: true, + addGlobalClass: true + } + if (vueOptions.options) { + extend(options, vueOptions.options) + } + const mpComponentOptions = { + options, + lifetimes: initLifetimes({ mocks, isPage, initRelation, vueOptions }), + pageLifetimes: { + show() { + this.$vm && this.$vm.$callHook('onPageShow') + }, + hide() { + this.$vm && this.$vm.$callHook('onPageHide') + }, + resize(size) { + this.$vm && this.$vm.$callHook('onPageResize', size) + } + }, + methods: { + __l: handleLink, + __e: handleEvent + } + } + if (__VUE_OPTIONS_API__) { + applyOptions(mpComponentOptions, vueOptions, initBehavior) + } + initProps(mpComponentOptions, vueOptions.props, false) + initExtraOptions(mpComponentOptions, vueOptions) + initWxsCallMethods(mpComponentOptions.methods, vueOptions.wxsCallMethods) + if (parse) { + parse(mpComponentOptions, { handleLink }) + } + return mpComponentOptions +} +function initCreateComponent(parseOptions) { + return function createComponent(vueComponentOptions) { + return Component(parseComponent(vueComponentOptions, parseOptions)) + } +} +let $createComponentFn +let $destroyComponentFn +function $createComponent(initialVNode, options) { + if (!$createComponentFn) { + $createComponentFn = getApp().$vm.$createComponent + } + return $createComponentFn(initialVNode, options) +} +function $destroyComponent(instance) { + if (!$destroyComponentFn) { + $destroyComponentFn = getApp().$vm.$destroyComponent + } + return $destroyComponentFn(instance) +} + +function parsePage(vueOptions, parseOptions) { + const { + parse, + mocks, + isPage, + initRelation, + handleLink, + initLifetimes + } = parseOptions + const miniProgramPageOptions = parseComponent(vueOptions, { + mocks, + isPage, + initRelation, + handleLink, + initLifetimes + }) + const methods = miniProgramPageOptions.methods + methods.onLoad = function(query) { + this.options = query + this.$page = { + fullPath: '/' + this.route + stringifyQuery(query) + } + return this.$vm && this.$vm.$callHook('onLoad', query) + } + initHooks(methods, PAGE_HOOKS) + initUnknownHooks(methods, vueOptions) + parse && parse(miniProgramPageOptions, { handleLink }) + return miniProgramPageOptions +} +function initCreatePage(parseOptions) { + return function createPage(vuePageOptions) { + return Component(parsePage(vuePageOptions, parseOptions)) + } +} + +const MPPage = Page +const MPComponent = Component +const customizeRE = /:/g +function customize(str) { + return camelize(str.replace(customizeRE, '-')) +} +function initTriggerEvent(mpInstance) { + const oldTriggerEvent = mpInstance.triggerEvent + mpInstance.triggerEvent = function(event, ...args) { + return oldTriggerEvent.apply(mpInstance, [customize(event), ...args]) + } +} +function initHook$1(name, options) { + const oldHook = options[name] + if (!oldHook) { + options[name] = function() { + initTriggerEvent(this) + } + } else { + options[name] = function(...args) { + initTriggerEvent(this) + return oldHook.apply(this, args) + } + } +} +Page = function(options) { + initHook$1('onLoad', options) + return MPPage(options) +} +Component = function(options) { + initHook$1('created', options) + return MPComponent(options) +} + +function provide(instance, key, value) { + if (!instance) { + if (process.env.NODE_ENV !== 'production') { + console.warn(`provide() can only be used inside setup().`) + } + } else { + let provides = instance.provides + // by default an instance inherits its parent's provides object + // but when it needs to provide values of its own, it creates its + // own provides object using parent provides object as prototype. + // this way in `inject` we can simply look up injections from direct + // parent and let the prototype chain do the work. + const parentProvides = instance.parent && instance.parent.provides + if (parentProvides === provides) { + provides = instance.provides = Object.create(parentProvides) + } + // TS doesn't allow symbol as index type + provides[key] = value + } +} +function initProvide(instance) { + const provideOptions = instance.$options.provide + if (!provideOptions) { + return + } + const provides = isFunction(provideOptions) + ? provideOptions.call(instance) + : provideOptions + const internalInstance = instance.$ + for (const key in provides) { + provide(internalInstance, key, provides[key]) + } +} +function inject(instance, key, defaultValue) { + if (instance) { + const provides = instance.provides + if (key in provides) { + // TS doesn't allow symbol as index type + return provides[key] + } else if (arguments.length > 1) { + return defaultValue + } else if (process.env.NODE_ENV !== 'production') { + console.warn(`injection "${String(key)}" not found.`) + } + } else if (process.env.NODE_ENV !== 'production') { + console.warn( + `inject() can only be used inside setup() or functional components.` + ) + } +} +function initInjections(instance) { + const injectOptions = instance.$options.inject + if (!injectOptions) { + return + } + const internalInstance = instance.$ + const ctx = internalInstance.ctx + if (isArray(injectOptions)) { + for (let i = 0; i < injectOptions.length; i++) { + const key = injectOptions[i] + ctx[key] = inject(internalInstance, key) + } + } else { + for (const key in injectOptions) { + const opt = injectOptions[key] + if (isObject(opt)) { + ctx[key] = inject(internalInstance, opt.from, opt.default) + } else { + ctx[key] = inject(internalInstance, opt) + } + } + } +} + +function initLifetimes({ mocks, isPage, initRelation, vueOptions }) { + return { + attached() { + const properties = this.properties + initVueIds(properties.vueId, this) + const relationOptions = { + vuePid: this._$vuePid + } + // 初始化 vue 实例 + const mpInstance = this + const mpType = isPage(mpInstance) ? 'page' : 'component' + if (mpType === 'page' && !mpInstance.route && mpInstance.__route__) { + mpInstance.route = mpInstance.__route__ + } + this.$vm = $createComponent( + { + type: vueOptions, + props: properties + }, + { + mpType, + mpInstance, + slots: properties.vueSlots, + parentComponent: relationOptions.parent && relationOptions.parent.$, + onBeforeSetup(instance, options) { + initRefs(instance, mpInstance) + initMocks(instance, mpInstance, mocks) + initComponentInstance(instance, options) + } + } + ) + // 处理父子关系 + initRelation(this, relationOptions) + }, + detached() { + this.$vm && $destroyComponent(this.$vm) + } + } +} + +const instances = Object.create(null) +function parse(componentOptions, { handleLink }) { + componentOptions.methods.__l = handleLink +} + +function initLifetimes$1(lifetimesOptions) { + return extend(initLifetimes(lifetimesOptions), { + ready() { + if (this.$vm && lifetimesOptions.isPage(this)) { + if (this.pageinstance) { + this.__webviewId__ = this.pageinstance.__pageId__ + } + this.$vm.$callSyncHook('created') + this.$vm.$callHook('mounted') + this.$vm.$callHook('onReady') + } else { + this.is && console.warn(this.is + ' is not ready') + } + }, + detached() { + this.$vm && $destroyComponent(this.$vm) + // 清理 + const webviewId = this.__webviewId__ + webviewId && + Object.keys(instances).forEach(key => { + if (key.indexOf(webviewId + '_') === 0) { + delete instances[key] + } + }) + } + }) +} + +const mocks = ['nodeId', 'componentName', '_componentId', 'uniquePrefix'] +function isPage(mpInstance) { + return !hasOwn(mpInstance, 'ownerId') +} + +function initRelation(mpInstance) { + // triggerEvent 后,接收事件时机特别晚,已经到了 ready 之后 + const nodeId = mpInstance.nodeId + '' + const webviewId = mpInstance.pageinstance.__pageId__ + '' + instances[webviewId + '_' + nodeId] = mpInstance.$vm + mpInstance.triggerEvent('__l', { + nodeId, + webviewId + }) +} +function handleLink({ detail: { nodeId, webviewId } }) { + const vm = instances[webviewId + '_' + nodeId] + if (!vm) { + return + } + let parentVm = instances[webviewId + '_' + vm.$scope.ownerId] + if (!parentVm) { + parentVm = this.$vm + } + vm.$.parent = parentVm.$ + const createdVm = function() { + if (__VUE_OPTIONS_API__) { + parentVm.$children.push(vm) + const parent = parentVm.$ + vm.$.provides = parent + ? parent.provides + : Object.create(parent.appContext.provides) + initInjections(vm) + initProvide(vm) + } + vm.$callSyncHook('created') + } + const mountedVm = function() { + // 处理当前 vm 子 + if (vm._$childVues) { + vm._$childVues.forEach(([createdVm]) => createdVm()) + vm._$childVues.forEach(([, mountedVm]) => mountedVm()) + delete vm._$childVues + } + vm.$callHook('mounted') + vm.$callHook('onReady') + } + // 当 parentVm 已经 mounted 时,直接触发,否则延迟 + if (!parentVm || parentVm.$.isMounted) { + createdVm() + mountedVm() + } else { + ;(parentVm._$childVues || (parentVm._$childVues = [])).push([ + createdVm, + mountedVm + ]) + } +} + +var parseComponentOptions = /*#__PURE__*/ Object.freeze({ + __proto__: null, + initRelation: initRelation, + handleLink: handleLink, + mocks: mocks, + isPage: isPage, + parse: parse, + initLifetimes: initLifetimes +}) + +var parsePageOptions = /*#__PURE__*/ Object.freeze({ + __proto__: null, + mocks: mocks, + isPage: isPage, + initRelation: initRelation, + handleLink: handleLink, + parse: parse, + initLifetimes: initLifetimes$1 +}) + +const createApp = initCreateApp() +const createPage = initCreatePage(parsePageOptions) +const createComponent = initCreateComponent(parseComponentOptions) + +export { createApp, createComponent, createPage } diff --git a/packages/uni-shared/dist/uni.shared.esm.js b/packages/uni-shared/dist/uni.shared.esm.js new file mode 100644 index 0000000000000000000000000000000000000000..74729a0ccc98073af1793b403c6704a541e4642b --- /dev/null +++ b/packages/uni-shared/dist/uni.shared.esm.js @@ -0,0 +1,122 @@ +import { isPlainObject } from '@vue/shared' + +const NAVBAR_HEIGHT = 44 +const TABBAR_HEIGHT = 50 +const COMPONENT_NAME_PREFIX = 'VUni' + +function debounce(fn, delay) { + let timeout + const newFn = function() { + clearTimeout(timeout) + const timerFn = () => fn.apply(this, arguments) + timeout = setTimeout(timerFn, delay) + } + newFn.cancel = function() { + clearTimeout(timeout) + } + return newFn +} + +function plusReady(callback) { + if (typeof callback !== 'function') { + return + } + if (window.plus) { + return callback() + } + document.addEventListener('plusready', callback) +} + +const encode = encodeURIComponent +function stringifyQuery(obj, encodeStr = encode) { + const res = obj + ? Object.keys(obj) + .map(key => { + let val = obj[key] + if (typeof val === undefined || val === null) { + val = '' + } else if (isPlainObject(val)) { + val = JSON.stringify(val) + } + return encodeStr(key) + '=' + encodeStr(val) + }) + .filter(x => x.length > 0) + .join('&') + : null + return res ? `?${res}` : '' +} + +const TAGS = [ + 'uni-app', + 'uni-layout', + 'uni-content', + 'uni-main', + 'uni-left-window', + 'uni-right-window', + 'uni-tabbar', + 'uni-page', + 'uni-page-head', + 'uni-page-wrapper', + 'uni-page-body', + 'uni-page-refresh', + 'uni-actionsheet', + 'uni-modal', + 'uni-toast', + 'uni-resize-sensor', + 'uni-shadow-root', + 'uni-ad', + 'uni-audio', + 'uni-button', + 'uni-camera', + 'uni-canvas', + 'uni-checkbox', + 'uni-checkbox-group', + 'uni-cover-image', + 'uni-cover-view', + 'uni-editor', + 'uni-form', + 'uni-functional-page-navigator', + 'uni-icon', + 'uni-image', + 'uni-input', + 'uni-label', + 'uni-live-player', + 'uni-live-pusher', + 'uni-map', + 'uni-movable-area', + 'uni-movable-view', + 'uni-navigator', + 'uni-official-account', + 'uni-open-data', + 'uni-picker', + 'uni-picker-view', + 'uni-picker-view-column', + 'uni-progress', + 'uni-radio', + 'uni-radio-group', + 'uni-rich-text', + 'uni-scroll-view', + 'uni-slider', + 'uni-swiper', + 'uni-swiper-item', + 'uni-switch', + 'uni-text', + 'uni-textarea', + 'uni-video', + 'uni-view', + 'uni-web-view' +] +function isCustomElement(tag) { + return TAGS.indexOf(tag) !== -1 +} + +export { + COMPONENT_NAME_PREFIX, + NAVBAR_HEIGHT, + TABBAR_HEIGHT, + TAGS, + debounce, + isCustomElement, + plusReady, + stringifyQuery +}