Skip to content

U
uni-app

qianlong66 / uni-app
与 Fork 源项目一致

Fork自 DCloud / uni-app

通知 1
Star 1
Fork 0
U
uni-app

体验新版 GitCode，发现更多精彩内容 >>

提交 a3b5033a 编写于 作者: fxy060608's avatar fxy060608
浏览文件
操作

fix: make video tree-shakeable

上级 34941693
隐藏空白更改
内联 并排
Showing with 114 addition and 1515 deletion
packages/uni-h5/dist/uni-h5.esm.js
浏览文件 @ a3b5033a
import {isFunction, extend, isPlainObject, isString, isArray, hasOwn as hasOwn$1, isObject as isObject$1, capitalize, toRawType, makeMap as makeMap$1, isPromise, invokeArrayFns as invokeArrayFns$1, hyphenate, isSymbol, isMap, isGloballyWhitelisted, isIntegerKey, hasChanged, remove, EMPTY_OBJ, isOn, isModelListener, camelize, isSpecialBooleanAttr, NOOP, isSet} from "@vue/shared";
import {injectHook as injectHook$1, createVNode, inject, provide, reactive as reactive$1, computed, nextTick as nextTick$1, getCurrentInstance, onBeforeMount, onMounted, onBeforeActivate, onBeforeDeactivate, openBlock, createBlock, mergeProps, toDisplayString, ref, defineComponent, resolveComponent, toHandlers, renderSlot, watch, onActivated, onBeforeUnmount as onBeforeUnmount$1, withModifiers, withDirectives, vShow, vModelDynamic, createTextVNode, createCommentVNode, Fragment, renderList, vModelText, watchEffect, withCtx, KeepAlive, resolveDynamicComponent} from "vue";
import {isFunction, extend, isPlainObject, isString, isArray, hasOwn as hasOwn$1, isObject as isObject$1, capitalize, toRawType, makeMap as makeMap$1, isPromise, invokeArrayFns as invokeArrayFns$1, hyphenate} from "@vue/shared";
import {injectHook, createVNode, inject, provide, reactive, computed, nextTick, getCurrentInstance, onBeforeMount, onMounted, onBeforeActivate, onBeforeDeactivate, openBlock, createBlock, mergeProps, toDisplayString, ref, defineComponent, resolveComponent, toHandlers, renderSlot, watch, onActivated, onBeforeUnmount, withModifiers, withDirectives, vShow, vModelDynamic, createTextVNode, createCommentVNode, Fragment, renderList, vModelText, watchEffect, withCtx, KeepAlive, resolveDynamicComponent} from "vue";
import {once, passive, normalizeTarget, invokeArrayFns, NAVBAR_HEIGHT, removeLeadingSlash, getLen, parseQuery, decodedQuery, plusReady, debounce, PRIMARY_COLOR as PRIMARY_COLOR$1, updateElementStyle, addFont, scrollTo} from "@dcloudio/uni-shared";
import {useRoute, createRouter, createWebHistory, createWebHashHistory, useRouter, isNavigationFailure, RouterView} from "vue-router";
function applyOptions(options, instance2, publicThis) {
......@@ -7,12 +7,12 @@ function applyOptions(options, instance2, publicThis) {
if (name.indexOf("on") === 0) {
const hook = options[name];
if (isFunction(hook)) {
injectHook$1(name, hook.bind(publicThis), instance2);
injectHook(name, hook.bind(publicThis), instance2);
}
}
});
}
function set$2(target, key, val) {
function set(target, key, val) {
return target[key] = val;
}
const isObject = (val) => val !== null && typeof val === "object";
......@@ -461,7 +461,7 @@ function init() {
});
return;
}
function setStyle2(el, style2) {
function setStyle(el, style2) {
var elStyle = el.style;
Object.keys(style2).forEach(function(key) {
var val = style2[key];
......@@ -503,15 +503,15 @@ function init() {
overflow: "hidden",
paddingBottom: support + "(safe-area-inset-" + attr2 + ")"
};
setStyle2(a1, aStyle);
setStyle2(a2, aStyle);
setStyle2(a1Children, {
setStyle(a1, aStyle);
setStyle(a2, aStyle);
setStyle(a1Children, {
transition: "0s",
animation: "none",
width: "400px",
height: "400px"
});
setStyle2(a2Children, {
setStyle(a2Children, {
transition: "0s",
animation: "none",
width: "250%",
......@@ -546,7 +546,7 @@ function init() {
});
}
var parentDiv = document.createElement("div");
setStyle2(parentDiv, {
setStyle(parentDiv, {
position: "absolute",
left: "0",
top: "0",
......@@ -1009,7 +1009,7 @@ function initService(app) {
function PolySymbol(name) {
return Symbol(process.env.NODE_ENV !== "production" ? "[uni-app]: " + name : name);
}
function rpx2px$1(str) {
function rpx2px(str) {
if (typeof str === "string") {
const res = parseInt(str) || 0;
if (str.indexOf("rpx") !== -1 || str.indexOf("upx") !== -1) {
......@@ -1028,10 +1028,10 @@ const ICON_PATH_SUCCESS_NO_CIRCLE = "M1.952 18.080q-0.32-0.352-0.416-0.88t0.128-
const ICON_PATH_SUCCESS = "M15.808 0.16q-4.224 0-7.872 2.176-3.552 2.112-5.632 5.728-2.144 3.744-2.144 8.128 0 4.192 2.144 7.872 2.112 3.52 5.632 5.632 3.68 2.144 7.872 2.144 4.384 0 8.128-2.144 3.616-2.080 5.728-5.632 2.176-3.648 2.176-7.872 0-4.384-2.176-8.128-2.112-3.616-5.728-5.728-3.744-2.176-8.128-2.176zM24.832 11.328l-11.264 11.104q-0.032 0.032-0.112 0.032t-0.112-0.032l-5.216-5.376q-0.096-0.128 0-0.288l0.704-0.96q0.032-0.064 0.112-0.064t0.112 0.032l4.256 3.264q0.064 0.032 0.144 0.032t0.112-0.032l10.336-8.608q0.064-0.064 0.144-0.064t0.112 0.064l0.672 0.672q0.128 0.128 0 0.224z";
const ICON_PATH_WAITING = "M15.84 0.096q-4.224 0-7.872 2.176-3.552 2.112-5.632 5.728-2.144 3.744-2.144 8.128 0 4.192 2.144 7.872 2.112 3.52 5.632 5.632 3.68 2.144 7.872 2.144 4.384 0 8.128-2.144 3.616-2.080 5.728-5.632 2.176-3.648 2.176-7.872 0-4.384-2.176-8.128-2.112-3.616-5.728-5.728-3.744-2.176-8.128-2.176zM23.008 21.92l-0.512 0.896q-0.096 0.128-0.224 0.064l-8-3.808q-0.096-0.064-0.16-0.128-0.128-0.096-0.128-0.288l0.512-12.096q0-0.064 0.048-0.112t0.112-0.048h1.376q0.064 0 0.112 0.048t0.048 0.112l0.448 10.848 6.304 4.256q0.064 0.064 0.080 0.128t-0.016 0.128z";
const ICON_PATH_WARN = "M15.808 0.16q-4.224 0-7.872 2.176-3.552 2.112-5.632 5.728-2.144 3.744-2.144 8.128 0 4.192 2.144 7.872 2.112 3.52 5.632 5.632 3.68 2.144 7.872 2.144 4.384 0 8.128-2.144 3.616-2.080 5.728-5.632 2.176-3.648 2.176-7.872 0-4.384-2.176-8.128-2.112-3.616-5.728-5.728-3.744-2.176-8.128-2.176zM15.136 8.672h1.728q0.128 0 0.224 0.096t0.096 0.256l-0.384 10.24q0 0.064-0.048 0.112t-0.112 0.048h-1.248q-0.096 0-0.144-0.048t-0.048-0.112l-0.384-10.24q0-0.16 0.096-0.256t0.224-0.096zM16 23.328q-0.48 0-0.832-0.352t-0.352-0.848 0.352-0.848 0.832-0.352 0.832 0.352 0.352 0.848-0.352 0.848-0.832 0.352z";
function createSvgIconVNode(path, color = "#000", size2 = 27) {
function createSvgIconVNode(path, color = "#000", size = 27) {
return createVNode("svg", {
width: size2,
height: size2,
width: size,
height: size,
viewBox: "0 0 32 32"
}, [
createVNode("path", {
......@@ -1099,7 +1099,7 @@ function initApp$1(app) {
}
const globalProperties = appConfig.globalProperties;
{
globalProperties.$set = set$2;
globalProperties.$set = set;
globalProperties.$applyOptions = applyOptions;
}
}
......@@ -1114,9 +1114,9 @@ function providePageMeta(id2) {
}
function initPageMeta(id2) {
if (__UNI_FEATURE_PAGES__) {
return reactive$1(normalizePageMeta(JSON.parse(JSON.stringify(mergePageMeta(id2, useRoute().meta)))));
return reactive(normalizePageMeta(JSON.parse(JSON.stringify(mergePageMeta(id2, useRoute().meta)))));
}
return reactive$1(normalizePageMeta(JSON.parse(JSON.stringify(mergePageMeta(id2, __uniRoutes[0].meta)))));
return reactive(normalizePageMeta(JSON.parse(JSON.stringify(mergePageMeta(id2, __uniRoutes[0].meta)))));
}
const PAGE_META_KEYS = [
"navigationBar",
......@@ -1141,14 +1141,14 @@ function normalizePageMeta(pageMeta) {
range: 150,
offset: 0
}, pageMeta.refreshOptions || {});
let offset = rpx2px$1(refreshOptions.offset);
let offset = rpx2px(refreshOptions.offset);
const {type} = navigationBar;
if (type !== "transparent" && type !== "none") {
offset += NAVBAR_HEIGHT + out.top;
}
refreshOptions.offset = offset;
refreshOptions.height = rpx2px$1(refreshOptions.height);
refreshOptions.range = rpx2px$1(refreshOptions.range);
refreshOptions.height = rpx2px(refreshOptions.height);
refreshOptions.range = rpx2px(refreshOptions.range);
pageMeta.refreshOptions = refreshOptions;
}
}
......@@ -1329,7 +1329,7 @@ function pruneRouteCache(key) {
}
routeCache.delete(key2);
routeCache.pruneCacheEntry(vnode);
nextTick$1(() => pruneCurrentPages());
nextTick(() => pruneCurrentPages());
}
});
}
......@@ -1392,7 +1392,7 @@ function initApp(vm) {
let tabBar;
function useTabBar() {
if (!tabBar) {
tabBar = __uniConfig.tabBar && reactive$1(__uniConfig.tabBar);
tabBar = __uniConfig.tabBar && reactive(__uniConfig.tabBar);
}
return tabBar;
}
......@@ -2972,21 +2972,21 @@ const initIntersectionObserverPolyfill = function() {
}
return;
}
function getFrameElement(doc2) {
function getFrameElement(doc) {
try {
return doc2.defaultView && doc2.defaultView.frameElement || null;
return doc.defaultView && doc.defaultView.frameElement || null;
} catch (e2) {
return null;
}
}
var document2 = function(startDoc) {
var doc2 = startDoc;
var frame = getFrameElement(doc2);
var doc = startDoc;
var frame = getFrameElement(doc);
while (frame) {
doc2 = frame.ownerDocument;
frame = getFrameElement(doc2);
doc = frame.ownerDocument;
frame = getFrameElement(doc);
}
return doc2;
return doc;
}(window.document);
var registry = [];
var crossOriginUpdater = null;
......@@ -3110,12 +3110,12 @@ const initIntersectionObserverPolyfill = function() {
margins[3] = margins[3] || margins[1];
return margins;
};
IntersectionObserver2.prototype._monitorIntersections = function(doc2) {
var win = doc2.defaultView;
IntersectionObserver2.prototype._monitorIntersections = function(doc) {
var win = doc.defaultView;
if (!win) {
return;
}
if (this._monitoringDocuments.indexOf(doc2) != -1) {
if (this._monitoringDocuments.indexOf(doc) != -1) {
return;
}
var callback = this._checkForIntersections;
......@@ -3125,10 +3125,10 @@ const initIntersectionObserverPolyfill = function() {
monitoringInterval = win.setInterval(callback, this.POLL_INTERVAL);
} else {
addEvent(win, "resize", callback, true);
addEvent(doc2, "scroll", callback, true);
addEvent(doc, "scroll", callback, true);
if (this.USE_MUTATION_OBSERVER && "MutationObserver" in win) {
domObserver = new win.MutationObserver(callback);
domObserver.observe(doc2, {
domObserver.observe(doc, {
attributes: true,
childList: true,
characterData: true,
......@@ -3136,43 +3136,43 @@ const initIntersectionObserverPolyfill = function() {
});
}
}
this._monitoringDocuments.push(doc2);
this._monitoringDocuments.push(doc);
this._monitoringUnsubscribes.push(function() {
var win2 = doc2.defaultView;
var win2 = doc.defaultView;
if (win2) {
if (monitoringInterval) {
win2.clearInterval(monitoringInterval);
}
removeEvent(win2, "resize", callback, true);
}
removeEvent(doc2, "scroll", callback, true);
removeEvent(doc, "scroll", callback, true);
if (domObserver) {
domObserver.disconnect();
}
});
var rootDoc = this.root && (this.root.ownerDocument || this.root) || document2;
if (doc2 != rootDoc) {
var frame = getFrameElement(doc2);
if (doc != rootDoc) {
var frame = getFrameElement(doc);
if (frame) {
this._monitorIntersections(frame.ownerDocument);
}
}
};
IntersectionObserver2.prototype._unmonitorIntersections = function(doc2) {
var index2 = this._monitoringDocuments.indexOf(doc2);
IntersectionObserver2.prototype._unmonitorIntersections = function(doc) {
var index2 = this._monitoringDocuments.indexOf(doc);
if (index2 == -1) {
return;
}
var rootDoc = this.root && (this.root.ownerDocument || this.root) || document2;
var hasDependentTargets = this._observationTargets.some(function(item) {
var itemDoc = item.element.ownerDocument;
if (itemDoc == doc2) {
if (itemDoc == doc) {
return true;
}
while (itemDoc && itemDoc != rootDoc) {
var frame2 = getFrameElement(itemDoc);
itemDoc = frame2 && frame2.ownerDocument;
if (itemDoc == doc2) {
if (itemDoc == doc) {
return true;
}
}
......@@ -3185,8 +3185,8 @@ const initIntersectionObserverPolyfill = function() {
this._monitoringDocuments.splice(index2, 1);
this._monitoringUnsubscribes.splice(index2, 1);
unsubscribe();
if (doc2 != rootDoc) {
var frame = getFrameElement(doc2);
if (doc != rootDoc) {
var frame = getFrameElement(doc);
if (frame) {
this._unmonitorIntersections(frame.ownerDocument);
}
......@@ -3279,8 +3279,8 @@ const initIntersectionObserverPolyfill = function() {
}
}
} else {
var doc2 = parent.ownerDocument;
if (parent != doc2.body && parent != doc2.documentElement && parentComputedStyle.overflow != "visible") {
var doc = parent.ownerDocument;
if (parent != doc.body && parent != doc.documentElement && parentComputedStyle.overflow != "visible") {
parentRect = getBoundingClientRect(parent);
}
}
......@@ -3298,9 +3298,9 @@ const initIntersectionObserverPolyfill = function() {
if (this.root && !isDoc(this.root)) {
rootRect = getBoundingClientRect(this.root);
} else {
var doc2 = isDoc(this.root) ? this.root : document2;
var html = doc2.documentElement;
var body = doc2.body;
var doc = isDoc(this.root) ? this.root : document2;
var html = doc.documentElement;
var body = doc.body;
rootRect = {
top: 0,
left: 0,
......@@ -5902,7 +5902,7 @@ var index$6 = /* @__PURE__ */ defineComponent({
},
setup(props2) {
const path = computed(() => ICONS[props2.type]);
return () => createVNode("uni-icon", null, [path.value.d && createSvgIconVNode(path.value.d, props2.color || path.value.c, rpx2px$1(props2.size))]);
return () => createVNode("uni-icon", null, [path.value.d && createSvgIconVNode(path.value.d, props2.color || path.value.c, rpx2px(props2.size))]);
}
});
function useCustomEvent(ref2, emit) {
......@@ -5933,9 +5933,9 @@ var ResizeSensor = /* @__PURE__ */ defineComponent({
emit
}) {
const rootRef = ref(null);
const reset2 = useResizeSensorReset(rootRef);
const update = useResizeSensorUpdate(rootRef, emit, reset2);
useResizeSensorLifecycle(rootRef, props2, update, reset2);
const reset = useResizeSensorReset(rootRef);
const update = useResizeSensorUpdate(rootRef, emit, reset);
useResizeSensorLifecycle(rootRef, props2, update, reset);
return () => createVNode("uni-resize-sensor", {
ref: rootRef,
onAnimationstartOnce: update
......@@ -5946,20 +5946,20 @@ var ResizeSensor = /* @__PURE__ */ defineComponent({
}, [createVNode("div", null, null)], 40, ["onScroll"])], 40, ["onAnimationstartOnce"]);
}
});
function useResizeSensorUpdate(rootRef, emit, reset2) {
const size2 = reactive$1({
function useResizeSensorUpdate(rootRef, emit, reset) {
const size = reactive({
width: -1,
height: -1
});
watch(() => extend({}, size2), (value) => emit("resize", value));
watch(() => extend({}, size), (value) => emit("resize", value));
return () => {
const {
offsetWidth,
offsetHeight
} = rootRef.value;
size2.width = offsetWidth;
size2.height = offsetHeight;
reset2();
size.width = offsetWidth;
size.height = offsetHeight;
reset();
};
}
function useResizeSensorReset(rootRef) {
......@@ -5974,18 +5974,18 @@ function useResizeSensorReset(rootRef) {
lastElementChild.scrollTop = 1e5;
};
}
function useResizeSensorLifecycle(rootRef, props2, update, reset2) {
onActivated(reset2);
function useResizeSensorLifecycle(rootRef, props2, update, reset) {
onActivated(reset);
onMounted(() => {
if (props2.initial) {
nextTick$1(update);
nextTick(update);
}
const rootEl = rootRef.value;
if (rootEl.offsetParent !== rootEl.parentElement) {
rootEl.parentElement.style.position = "relative";
}
if (!("AnimationEvent" in window)) {
reset2();
reset();
}
});
}
......@@ -6034,12 +6034,12 @@ var index$5 = /* @__PURE__ */ defineComponent({
}) {
const rootRef = ref(null);
const state = useImageState(rootRef, props2);
const trigger2 = useCustomEvent(rootRef, emit);
const trigger = useCustomEvent(rootRef, emit);
const {
fixSize
} = useImageSize(rootRef, props2, state);
useImageLoader(state, {
trigger: trigger2,
trigger,
fixSize
});
return () => {
......@@ -6066,20 +6066,20 @@ var index$5 = /* @__PURE__ */ defineComponent({
function useImageState(rootRef, props2) {
const imgSrc = ref("");
const modeStyleRef = computed(() => {
let size2 = "auto";
let size = "auto";
let position = "";
const opts = IMAGE_MODES[props2.mode];
if (!opts) {
position = "0% 0%";
size2 = "100% 100%";
size = "100% 100%";
} else {
opts[0] && (position = opts[0]);
opts[1] && (size2 = opts[1]);
opts[1] && (size = opts[1]);
}
const srcVal = imgSrc.value;
return `background-image:${srcVal ? 'url("' + srcVal + '")' : "none"};background-position:${position};background-size:${size2};background-repeat:no-repeat;`;
return `background-image:${srcVal ? 'url("' + srcVal + '")' : "none"};background-position:${position};background-size:${size};background-repeat:no-repeat;`;
});
const state = reactive$1({
const state = reactive({
rootEl: rootRef,
src: computed(() => props2.src ? getRealPath(props2.src) : ""),
origWidth: 0,
......@@ -6100,7 +6100,7 @@ function useImageState(rootRef, props2) {
return state;
}
function useImageLoader(state, {
trigger: trigger2,
trigger,
fixSize
}) {
let img;
......@@ -6126,7 +6126,7 @@ function useImageLoader(state, {
setState(width, height, src);
fixSize();
resetImage();
trigger2("load", evt, {
trigger("load", evt, {
width,
height
});
......@@ -6134,7 +6134,7 @@ function useImageLoader(state, {
img.onerror = (evt) => {
setState();
resetImage();
trigger2("error", evt, {
trigger("error", evt, {
errMsg: `GET ${state.src} 404 (Not Found)`
});
};
......@@ -6149,7 +6149,7 @@ function useImageLoader(state, {
};
watch(() => state.src, (value) => loadImage(value));
onMounted(() => loadImage(state.src));
onBeforeUnmount$1(() => resetImage());
onBeforeUnmount(() => resetImage());
}
const isChrome = navigator.vendor === "Google Inc.";
function fixNumber(num) {
......@@ -6224,7 +6224,7 @@ function useFormField(nameKey, valueKey) {
}
};
uniForm.addField(ctx);
onBeforeUnmount$1(() => {
onBeforeUnmount(() => {
uniForm.removeField(ctx);
});
}
......@@ -6892,12 +6892,12 @@ function _requestAnimationFrame(e2) {
});
}
}
function p$1(t2, n) {
function p(t2, n) {
if (t2 === n) {
return 0;
}
var i2 = t2.offsetLeft;
return t2.offsetParent ? i2 += p$1(t2.offsetParent, n) : 0;
return t2.offsetParent ? i2 += p(t2.offsetParent, n) : 0;
}
function f(t2, n) {
if (t2 === n) {
......@@ -7338,7 +7338,7 @@ const _sfc_main$c = {
this._updateOldScale(scale);
},
_updateOffset: function() {
this._offset.x = p$1(this.$el, this.$parent.$el);
this._offset.x = p(this.$el, this.$parent.$el);
this._offset.y = f(this.$el, this.$parent.$el);
},
_updateWH: function(scale) {
......@@ -7699,7 +7699,7 @@ function useProgressState(props2) {
realValue > 100 && (realValue = 100);
return realValue;
});
const state = reactive$1({
const state = reactive({
outerBarStyle,
innerBarStyle,
realPercent,
......@@ -10037,13 +10037,13 @@ function useSubscribe(callback, name) {
});
}
});
onBeforeUnmount$1(() => {
onBeforeUnmount(() => {
removeSubscribe(name || normalizeEvent(pageId, vm));
});
}
function useOn(name, callback) {
onMounted(() => UniViewJSBridge.on(name, callback));
onBeforeUnmount$1(() => UniViewJSBridge.off(name));
onBeforeUnmount(() => UniViewJSBridge.off(name));
}
const passiveOptions = passive(true);
const states = [];
......@@ -10083,1420 +10083,19 @@ function removeInteractListener(vm) {
}
}
function useUserAction() {
const state = reactive$1({
const state = reactive({
userAction: false
});
onMounted(() => {
addInteractListener(state);
});
onBeforeUnmount$1(() => {
onBeforeUnmount(() => {
removeInteractListener(state);
});
return {
state
};
}
const targetMap = new WeakMap();
const effectStack = [];
let activeEffect;
const ITERATE_KEY = Symbol("");
const MAP_KEY_ITERATE_KEY = Symbol("");
function isEffect(fn) {
return fn && fn._isEffect === true;
}
function effect(fn, options = EMPTY_OBJ) {
if (isEffect(fn)) {
fn = fn.raw;
}
const effect2 = createReactiveEffect(fn, options);
if (!options.lazy) {
effect2();
}
return effect2;
}
function stop(effect2) {
if (effect2.active) {
cleanup(effect2);
if (effect2.options.onStop) {
effect2.options.onStop();
}
effect2.active = false;
}
}
let uid = 0;
function createReactiveEffect(fn, options) {
const effect2 = function reactiveEffect() {
if (!effect2.active) {
return options.scheduler ? void 0 : fn();
}
if (!effectStack.includes(effect2)) {
cleanup(effect2);
try {
enableTracking();
effectStack.push(effect2);
activeEffect = effect2;
return fn();
} finally {
effectStack.pop();
resetTracking();
activeEffect = effectStack[effectStack.length - 1];
}
}
};
effect2.id = uid++;
effect2.allowRecurse = !!options.allowRecurse;
effect2._isEffect = true;
effect2.active = true;
effect2.raw = fn;
effect2.deps = [];
effect2.options = options;
return effect2;
}
function cleanup(effect2) {
const {deps} = effect2;
if (deps.length) {
for (let i2 = 0; i2 < deps.length; i2++) {
deps[i2].delete(effect2);
}
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 === void 0 ? true : last;
}
function track(target, type, key) {
if (!shouldTrack || activeEffect === void 0) {
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);
}
}
function trigger(target, type, key, newValue, oldValue, oldTarget) {
const depsMap = targetMap.get(target);
if (!depsMap) {
return;
}
const effects = new Set();
const add2 = (effectsToAdd) => {
if (effectsToAdd) {
effectsToAdd.forEach((effect2) => {
if (effect2 !== activeEffect || effect2.allowRecurse) {
effects.add(effect2);
}
});
}
};
if (type === "clear") {
depsMap.forEach(add2);
} else if (key === "length" && isArray(target)) {
depsMap.forEach((dep, key2) => {
if (key2 === "length" || key2 >= newValue) {
add2(dep);
}
});
} else {
if (key !== void 0) {
add2(depsMap.get(key));
}
switch (type) {
case "add":
if (!isArray(target)) {
add2(depsMap.get(ITERATE_KEY));
if (isMap(target)) {
add2(depsMap.get(MAP_KEY_ITERATE_KEY));
}
} else if (isIntegerKey(key)) {
add2(depsMap.get("length"));
}
break;
case "delete":
if (!isArray(target)) {
add2(depsMap.get(ITERATE_KEY));
if (isMap(target)) {
add2(depsMap.get(MAP_KEY_ITERATE_KEY));
}
}
break;
case "set":
if (isMap(target)) {
add2(depsMap.get(ITERATE_KEY));
}
break;
}
}
const run = (effect2) => {
if (effect2.options.scheduler) {
effect2.options.scheduler(effect2);
} else {
effect2();
}
};
effects.forEach(run);
}
const isNonTrackableKeys = /* @__PURE__ */ makeMap$1(`__proto__,__v_isRef,__isVue`);
const builtInSymbols = new Set(Object.getOwnPropertyNames(Symbol).map((key) => Symbol[key]).filter(isSymbol));
const get = /* @__PURE__ */ createGetter();
const shallowGet = /* @__PURE__ */ createGetter(false, true);
const readonlyGet = /* @__PURE__ */ createGetter(true);
const shallowReadonlyGet = /* @__PURE__ */ createGetter(true, true);
const arrayInstrumentations = {};
["includes", "indexOf", "lastIndexOf"].forEach((key) => {
const method = Array.prototype[key];
arrayInstrumentations[key] = function(...args) {
const arr = toRaw(this);
for (let i2 = 0, l = this.length; i2 < l; i2++) {
track(arr, "get", i2 + "");
}
const res = method.apply(arr, args);
if (res === -1 || res === false) {
return method.apply(arr, args.map(toRaw));
} else {
return res;
}
};
});
["push", "pop", "shift", "unshift", "splice"].forEach((key) => {
const method = Array.prototype[key];
arrayInstrumentations[key] = function(...args) {
pauseTracking();
const res = method.apply(this, args);
resetTracking();
return res;
};
});
function createGetter(isReadonly2 = false, shallow = false) {
return function get2(target, key, receiver) {
if (key === "__v_isReactive") {
return !isReadonly2;
} else if (key === "__v_isReadonly") {
return isReadonly2;
} else if (key === "__v_raw" && receiver === (isReadonly2 ? shallow ? shallowReadonlyMap : readonlyMap : shallow ? shallowReactiveMap : reactiveMap).get(target)) {
return target;
}
const targetIsArray = isArray(target);
if (!isReadonly2 && targetIsArray && hasOwn$1(arrayInstrumentations, key)) {
return Reflect.get(arrayInstrumentations, key, receiver);
}
const res = Reflect.get(target, key, receiver);
if (isSymbol(key) ? builtInSymbols.has(key) : isNonTrackableKeys(key)) {
return res;
}
if (!isReadonly2) {
track(target, "get", key);
}
if (shallow) {
return res;
}
if (isRef(res)) {
const shouldUnwrap = !targetIsArray || !isIntegerKey(key);
return shouldUnwrap ? res.value : res;
}
if (isObject$1(res)) {
return isReadonly2 ? readonly(res) : reactive(res);
}
return res;
};
}
const set = /* @__PURE__ */ createSetter();
const shallowSet = /* @__PURE__ */ createSetter(true);
function createSetter(shallow = false) {
return function set2(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$1(target, key);
const result = Reflect.set(target, key, value, receiver);
if (target === toRaw(receiver)) {
if (!hadKey) {
trigger(target, "add", key, value);
} else if (hasChanged(value, oldValue)) {
trigger(target, "set", key, value);
}
}
return result;
};
}
function deleteProperty(target, key) {
const hadKey = hasOwn$1(target, key);
target[key];
const result = Reflect.deleteProperty(target, key);
if (result && hadKey) {
trigger(target, "delete", key, void 0);
}
return result;
}
function has(target, key) {
const result = Reflect.has(target, key);
if (!isSymbol(key) || !builtInSymbols.has(key)) {
track(target, "has", key);
}
return result;
}
function ownKeys(target) {
track(target, "iterate", isArray(target) ? "length" : ITERATE_KEY);
return Reflect.ownKeys(target);
}
const mutableHandlers = {
get,
set,
deleteProperty,
has,
ownKeys
};
const readonlyHandlers = {
get: readonlyGet,
set(target, key) {
return true;
},
deleteProperty(target, key) {
return true;
}
};
extend({}, mutableHandlers, {
get: shallowGet,
set: shallowSet
});
extend({}, readonlyHandlers, {
get: shallowReadonlyGet
});
const toReactive = (value) => isObject$1(value) ? reactive(value) : value;
const toReadonly = (value) => isObject$1(value) ? readonly(value) : value;
const toShallow = (value) => value;
const getProto = (v2) => Reflect.getPrototypeOf(v2);
function get$1(target, key, isReadonly2 = false, isShallow = false) {
target = target["__v_raw"];
const rawTarget = toRaw(target);
const rawKey = toRaw(key);
if (key !== rawKey) {
!isReadonly2 && track(rawTarget, "get", key);
}
!isReadonly2 && track(rawTarget, "get", rawKey);
const {has: has2} = getProto(rawTarget);
const wrap = isShallow ? toShallow : isReadonly2 ? toReadonly : toReactive;
if (has2.call(rawTarget, key)) {
return wrap(target.get(key));
} else if (has2.call(rawTarget, rawKey)) {
return wrap(target.get(rawKey));
}
}
function has$1(key, isReadonly2 = false) {
const target = this["__v_raw"];
const rawTarget = toRaw(target);
const rawKey = toRaw(key);
if (key !== rawKey) {
!isReadonly2 && track(rawTarget, "has", key);
}
!isReadonly2 && track(rawTarget, "has", rawKey);
return key === rawKey ? target.has(key) : target.has(key) || target.has(rawKey);
}
function size(target, isReadonly2 = false) {
target = target["__v_raw"];
!isReadonly2 && track(toRaw(target), "iterate", ITERATE_KEY);
return Reflect.get(target, "size", target);
}
function add(value) {
value = toRaw(value);
const target = toRaw(this);
const proto = getProto(target);
const hadKey = proto.has.call(target, value);
if (!hadKey) {
target.add(value);
trigger(target, "add", value, value);
}
return this;
}
function set$1(key, value) {
value = toRaw(value);
const target = toRaw(this);
const {has: has2, get: get2} = getProto(target);
let hadKey = has2.call(target, key);
if (!hadKey) {
key = toRaw(key);
hadKey = has2.call(target, key);
}
const oldValue = get2.call(target, key);
target.set(key, value);
if (!hadKey) {
trigger(target, "add", key, value);
} else if (hasChanged(value, oldValue)) {
trigger(target, "set", key, value);
}
return this;
}
function deleteEntry(key) {
const target = toRaw(this);
const {has: has2, get: get2} = getProto(target);
let hadKey = has2.call(target, key);
if (!hadKey) {
key = toRaw(key);
hadKey = has2.call(target, key);
}
get2 ? get2.call(target, key) : void 0;
const result = target.delete(key);
if (hadKey) {
trigger(target, "delete", key, void 0);
}
return result;
}
function clear() {
const target = toRaw(this);
const hadItems = target.size !== 0;
const result = target.clear();
if (hadItems) {
trigger(target, "clear", void 0, void 0);
}
return result;
}
function createForEach(isReadonly2, isShallow) {
return function forEach(callback, thisArg) {
const observed = this;
const target = observed["__v_raw"];
const rawTarget = toRaw(target);
const wrap = isShallow ? toShallow : isReadonly2 ? toReadonly : toReactive;
!isReadonly2 && track(rawTarget, "iterate", ITERATE_KEY);
return target.forEach((value, key) => {
return callback.call(thisArg, wrap(value), wrap(key), observed);
});
};
}
function createIterableMethod(method, isReadonly2, isShallow) {
return function(...args) {
const target = this["__v_raw"];
const rawTarget = toRaw(target);
const targetIsMap = isMap(rawTarget);
const isPair = method === "entries" || method === Symbol.iterator && targetIsMap;
const isKeyOnly = method === "keys" && targetIsMap;
const innerIterator = target[method](...args);
const wrap = isShallow ? toShallow : isReadonly2 ? toReadonly : toReactive;
!isReadonly2 && track(rawTarget, "iterate", isKeyOnly ? MAP_KEY_ITERATE_KEY : ITERATE_KEY);
return {
next() {
const {value, done} = innerIterator.next();
return done ? {value, done} : {
value: isPair ? [wrap(value[0]), wrap(value[1])] : wrap(value),
done
};
},
[Symbol.iterator]() {
return this;
}
};
};
}
function createReadonlyMethod(type) {
return function(...args) {
return type === "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"),
set: createReadonlyMethod("set"),
delete: createReadonlyMethod("delete"),
clear: createReadonlyMethod("clear"),
forEach: createForEach(true, false)
};
const shallowReadonlyInstrumentations = {
get(key) {
return get$1(this, key, true, true);
},
get size() {
return size(this, true);
},
has(key) {
return has$1.call(this, key, true);
},
add: createReadonlyMethod("add"),
set: createReadonlyMethod("set"),
delete: createReadonlyMethod("delete"),
clear: createReadonlyMethod("clear"),
forEach: createForEach(true, true)
};
const iteratorMethods = ["keys", "values", "entries", Symbol.iterator];
iteratorMethods.forEach((method) => {
mutableInstrumentations[method] = createIterableMethod(method, false, false);
readonlyInstrumentations[method] = createIterableMethod(method, true, false);
shallowInstrumentations[method] = createIterableMethod(method, false, true);
shallowReadonlyInstrumentations[method] = createIterableMethod(method, true, true);
});
function createInstrumentationGetter(isReadonly2, shallow) {
const instrumentations = shallow ? isReadonly2 ? shallowReadonlyInstrumentations : shallowInstrumentations : isReadonly2 ? readonlyInstrumentations : mutableInstrumentations;
return (target, key, receiver) => {
if (key === "__v_isReactive") {
return !isReadonly2;
} else if (key === "__v_isReadonly") {
return isReadonly2;
} else if (key === "__v_raw") {
return target;
}
return Reflect.get(hasOwn$1(instrumentations, key) && key in target ? instrumentations : target, key, receiver);
};
}
const mutableCollectionHandlers = {
get: createInstrumentationGetter(false, false)
};
const readonlyCollectionHandlers = {
get: createInstrumentationGetter(true, false)
};
const reactiveMap = new WeakMap();
const shallowReactiveMap = new WeakMap();
const readonlyMap = new WeakMap();
const shallowReadonlyMap = new WeakMap();
function targetTypeMap(rawType) {
switch (rawType) {
case "Object":
case "Array":
return 1;
case "Map":
case "Set":
case "WeakMap":
case "WeakSet":
return 2;
default:
return 0;
}
}
function getTargetType(value) {
return value["__v_skip"] || !Object.isExtensible(value) ? 0 : targetTypeMap(toRawType(value));
}
function reactive(target) {
if (target && target["__v_isReadonly"]) {
return target;
}
return createReactiveObject(target, false, mutableHandlers, mutableCollectionHandlers, reactiveMap);
}
function readonly(target) {
return createReactiveObject(target, true, readonlyHandlers, readonlyCollectionHandlers, readonlyMap);
}
function createReactiveObject(target, isReadonly2, baseHandlers, collectionHandlers, proxyMap) {
if (!isObject$1(target)) {
return target;
}
if (target["__v_raw"] && !(isReadonly2 && target["__v_isReactive"])) {
return target;
}
const existingProxy = proxyMap.get(target);
if (existingProxy) {
return existingProxy;
}
const targetType = getTargetType(target);
if (targetType === 0) {
return target;
}
const proxy = new Proxy(target, targetType === 2 ? collectionHandlers : baseHandlers);
proxyMap.set(target, proxy);
return proxy;
}
function isReactive(value) {
if (isReadonly(value)) {
return isReactive(value["__v_raw"]);
}
return !!(value && value["__v_isReactive"]);
}
function isReadonly(value) {
return !!(value && value["__v_isReadonly"]);
}
function toRaw(observed) {
return observed && toRaw(observed["__v_raw"]) || observed;
}
function isRef(r) {
return Boolean(r && r.__v_isRef === true);
}
function callWithErrorHandling(fn, instance2, type, args) {
let res;
try {
res = args ? fn(...args) : fn();
} catch (err) {
handleError(err, instance2, type);
}
return res;
}
function callWithAsyncErrorHandling(fn, instance2, type, args) {
if (isFunction(fn)) {
const res = callWithErrorHandling(fn, instance2, type, args);
if (res && isPromise(res)) {
res.catch((err) => {
handleError(err, instance2, type);
});
}
return res;
}
const values = [];
for (let i2 = 0; i2 < fn.length; i2++) {
values.push(callWithAsyncErrorHandling(fn[i2], instance2, type, args));
}
return values;
}
function handleError(err, instance2, type, throwInDev = true) {
const contextVNode = instance2 ? instance2.vnode : null;
if (instance2) {
let cur = instance2.parent;
const exposedInstance = instance2.proxy;
const errorInfo = type;
while (cur) {
const errorCapturedHooks = cur.ec;
if (errorCapturedHooks) {
for (let i2 = 0; i2 < errorCapturedHooks.length; i2++) {
if (errorCapturedHooks[i2](err, exposedInstance, errorInfo) === false) {
return;
}
}
}
cur = cur.parent;
}
const appErrorHandler = instance2.appContext.config.errorHandler;
if (appErrorHandler) {
callWithErrorHandling(appErrorHandler, null, 10, [err, exposedInstance, errorInfo]);
return;
}
}
logError(err, type, contextVNode, throwInDev);
}
function logError(err, type, contextVNode, throwInDev = true) {
{
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 p2 = currentFlushPromise || resolvedPromise;
return fn ? p2.then(this ? fn.bind(this) : fn) : p2;
}
function findInsertionIndex(job) {
let start = flushIndex + 1;
let end = queue.length;
const jobId = getId(job);
while (start < end) {
const middle = start + end >>> 1;
const middleJobId = getId(queue[middle]);
middleJobId < jobId ? start = middle + 1 : end = middle;
}
return start;
}
function queueJob(job) {
if ((!queue.length || !queue.includes(job, isFlushing && job.allowRecurse ? flushIndex + 1 : flushIndex)) && job !== currentPreFlushParentJob) {
const pos = findInsertionIndex(job);
if (pos > -1) {
queue.splice(pos, 0, job);
} else {
queue.push(job);
}
queueFlush();
}
}
function queueFlush() {
if (!isFlushing && !isFlushPending) {
isFlushPending = true;
currentFlushPromise = resolvedPromise.then(flushJobs);
}
}
function queueCb(cb, activeQueue, pendingQueue, index2) {
if (!isArray(cb)) {
if (!activeQueue || !activeQueue.includes(cb, cb.allowRecurse ? index2 + 1 : index2)) {
pendingQueue.push(cb);
}
} else {
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;
for (preFlushIndex = 0; preFlushIndex < activePreFlushCbs.length; preFlushIndex++) {
activePreFlushCbs[preFlushIndex]();
}
activePreFlushCbs = null;
preFlushIndex = 0;
currentPreFlushParentJob = null;
flushPreFlushCbs(seen, parentJob);
}
}
function flushPostFlushCbs(seen) {
if (pendingPostFlushCbs.length) {
const deduped = [...new Set(pendingPostFlushCbs)];
pendingPostFlushCbs.length = 0;
if (activePostFlushCbs) {
activePostFlushCbs.push(...deduped);
return;
}
activePostFlushCbs = deduped;
activePostFlushCbs.sort((a2, b) => getId(a2) - getId(b));
for (postFlushIndex = 0; postFlushIndex < activePostFlushCbs.length; postFlushIndex++) {
activePostFlushCbs[postFlushIndex]();
}
activePostFlushCbs = null;
postFlushIndex = 0;
}
}
const getId = (job) => job.id == null ? Infinity : job.id;
function flushJobs(seen) {
isFlushPending = false;
isFlushing = true;
flushPreFlushCbs(seen);
queue.sort((a2, b) => getId(a2) - getId(b));
try {
for (flushIndex = 0; flushIndex < queue.length; flushIndex++) {
const job = queue[flushIndex];
if (job) {
if (false)
;
callWithErrorHandling(job, null, 14);
}
}
} finally {
flushIndex = 0;
queue.length = 0;
flushPostFlushCbs();
isFlushing = false;
currentFlushPromise = null;
if (queue.length || pendingPostFlushCbs.length) {
flushJobs(seen);
}
}
}
function checkRecursiveUpdates(seen, fn) {
if (!seen.has(fn)) {
seen.set(fn, 1);
} else {
const count = seen.get(fn);
if (count > RECURSION_LIMIT) {
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);
}
}
}
function queueEffectWithSuspense(fn, suspense) {
if (suspense && suspense.pendingBranch) {
if (isArray(fn)) {
suspense.effects.push(...fn);
} else {
suspense.effects.push(fn);
}
} else {
queuePostFlushCb(fn);
}
}
function injectHook(type, hook, target = currentInstance, prepend = false) {
if (target) {
const hooks = target[type] || (target[type] = []);
const wrappedHook = hook.__weh || (hook.__weh = (...args) => {
if (target.isUnmounted) {
return;
}
pauseTracking();
setCurrentInstance(target);
const res = callWithAsyncErrorHandling(hook, target, type, args);
setCurrentInstance(null);
resetTracking();
return res;
});
if (prepend) {
hooks.unshift(wrappedHook);
} else {
hooks.push(wrappedHook);
}
return wrappedHook;
}
}
const createHook = (lifecycle) => (hook, target = currentInstance) => injectHook(lifecycle, hook, target);
const onBeforeUnmount = createHook("bum");
const INITIAL_WATCHER_VALUE = {};
function doWatch(source, cb, {immediate, deep, flush, onTrack, onTrigger} = EMPTY_OBJ, instance2 = currentInstance) {
let getter;
let forceTrigger = false;
if (isRef(source)) {
getter = () => source.value;
forceTrigger = !!source._shallow;
} 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, instance2, 2, [
instance2 && instance2.proxy
]);
} else
;
});
} else if (isFunction(source)) {
if (cb) {
getter = () => callWithErrorHandling(source, instance2, 2, [
instance2 && instance2.proxy
]);
} else {
getter = () => {
if (instance2 && instance2.isUnmounted) {
return;
}
if (cleanup2) {
cleanup2();
}
return callWithAsyncErrorHandling(source, instance2, 3, [onInvalidate]);
};
}
} else {
getter = NOOP;
}
if (cb && deep) {
const baseGetter = getter;
getter = () => traverse(baseGetter());
}
let cleanup2;
let onInvalidate = (fn) => {
cleanup2 = runner.options.onStop = () => {
callWithErrorHandling(fn, instance2, 4);
};
};
let oldValue = isArray(source) ? [] : INITIAL_WATCHER_VALUE;
const job = () => {
if (!runner.active) {
return;
}
if (cb) {
const newValue = runner();
if (deep || forceTrigger || hasChanged(newValue, oldValue)) {
if (cleanup2) {
cleanup2();
}
callWithAsyncErrorHandling(cb, instance2, 3, [
newValue,
oldValue === INITIAL_WATCHER_VALUE ? void 0 : oldValue,
onInvalidate
]);
oldValue = newValue;
}
} else {
runner();
}
};
job.allowRecurse = !!cb;
let scheduler;
if (flush === "sync") {
scheduler = job;
} else if (flush === "post") {
scheduler = () => queuePostRenderEffect(job, instance2 && instance2.suspense);
} else {
scheduler = () => {
if (!instance2 || instance2.isMounted) {
queuePreFlushCb(job);
} else {
job();
}
};
}
const runner = effect(getter, {
lazy: true,
onTrack,
onTrigger,
scheduler
});
recordInstanceBoundEffect(runner, instance2);
if (cb) {
if (immediate) {
job();
} else {
oldValue = runner();
}
} else if (flush === "post") {
queuePostRenderEffect(runner, instance2 && instance2.suspense);
} else {
runner();
}
return () => {
stop(runner);
if (instance2) {
remove(instance2.effects, runner);
}
};
}
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$1(value) || seen.has(value)) {
return value;
}
seen.add(value);
if (isRef(value)) {
traverse(value.value, seen);
} else if (isArray(value)) {
for (let i2 = 0; i2 < value.length; i2++) {
traverse(value[i2], seen);
}
} else if (isSet(value) || isMap(value)) {
value.forEach((v2) => {
traverse(v2, seen);
});
} else {
for (const key in value) {
traverse(value[key], seen);
}
}
return value;
}
const queuePostRenderEffect = queueEffectWithSuspense;
function resolveMergedOptions(instance2) {
const raw = instance2.type;
const {__merged, mixins, extends: extendsOptions} = raw;
if (__merged)
return __merged;
const globalMixins = instance2.appContext.mixins;
if (!globalMixins.length && !mixins && !extendsOptions)
return raw;
const options = {};
globalMixins.forEach((m) => mergeOptions(options, m, instance2));
mergeOptions(options, raw, instance2);
return raw.__merged = options;
}
function mergeOptions(to, from, instance2) {
const strats = instance2.appContext.config.optionMergeStrategies;
const {mixins, extends: extendsOptions} = from;
extendsOptions && mergeOptions(to, extendsOptions, instance2);
mixins && mixins.forEach((m) => mergeOptions(to, m, instance2));
for (const key in from) {
if (strats && hasOwn$1(strats, key)) {
to[key] = strats[key](to[key], from[key], instance2.proxy, key);
} else {
to[key] = from[key];
}
}
}
const getPublicInstance = (i2) => {
if (!i2)
return null;
if (isStatefulComponent(i2))
return i2.exposed ? i2.exposed : i2.proxy;
return getPublicInstance(i2.parent);
};
const publicPropertiesMap = extend(Object.create(null), {
$: (i2) => i2,
$el: (i2) => i2.vnode.el,
$data: (i2) => i2.data,
$props: (i2) => i2.props,
$attrs: (i2) => i2.attrs,
$slots: (i2) => i2.slots,
$refs: (i2) => i2.refs,
$parent: (i2) => getPublicInstance(i2.parent),
$root: (i2) => getPublicInstance(i2.root),
$emit: (i2) => i2.emit,
$options: (i2) => resolveMergedOptions(i2),
$forceUpdate: (i2) => () => queueJob(i2.update),
$nextTick: (i2) => nextTick.bind(i2.proxy),
$watch: (i2) => instanceWatch.bind(i2)
});
const PublicInstanceProxyHandlers = {
get({_: instance2}, key) {
const {ctx, setupState, data, props: props2, accessCache, type, appContext} = instance2;
if (key === "__v_skip") {
return true;
}
let normalizedProps;
if (key[0] !== "$") {
const n = accessCache[key];
if (n !== void 0) {
switch (n) {
case 0:
return setupState[key];
case 1:
return data[key];
case 3:
return ctx[key];
case 2:
return props2[key];
}
} else if (setupState !== EMPTY_OBJ && hasOwn$1(setupState, key)) {
accessCache[key] = 0;
return setupState[key];
} else if (data !== EMPTY_OBJ && hasOwn$1(data, key)) {
accessCache[key] = 1;
return data[key];
} else if ((normalizedProps = instance2.propsOptions[0]) && hasOwn$1(normalizedProps, key)) {
accessCache[key] = 2;
return props2[key];
} else if (ctx !== EMPTY_OBJ && hasOwn$1(ctx, key)) {
accessCache[key] = 3;
return ctx[key];
} else {
accessCache[key] = 4;
}
}
const publicGetter = publicPropertiesMap[key];
let cssModule, globalProperties;
if (publicGetter) {
if (key === "$attrs") {
track(instance2, "get", key);
}
return publicGetter(instance2);
} else if ((cssModule = type.__cssModules) && (cssModule = cssModule[key])) {
return cssModule;
} else if (ctx !== EMPTY_OBJ && hasOwn$1(ctx, key)) {
accessCache[key] = 3;
return ctx[key];
} else if (globalProperties = appContext.config.globalProperties, hasOwn$1(globalProperties, key)) {
return globalProperties[key];
} else
;
},
set({_: instance2}, key, value) {
const {data, setupState, ctx} = instance2;
if (setupState !== EMPTY_OBJ && hasOwn$1(setupState, key)) {
setupState[key] = value;
} else if (data !== EMPTY_OBJ && hasOwn$1(data, key)) {
data[key] = value;
} else if (hasOwn$1(instance2.props, key)) {
return false;
}
if (key[0] === "$" && key.slice(1) in instance2) {
return false;
} else {
{
ctx[key] = value;
}
}
return true;
},
has({_: {data, setupState, accessCache, ctx, appContext, propsOptions}}, key) {
let normalizedProps;
return accessCache[key] !== void 0 || data !== EMPTY_OBJ && hasOwn$1(data, key) || setupState !== EMPTY_OBJ && hasOwn$1(setupState, key) || (normalizedProps = propsOptions[0]) && hasOwn$1(normalizedProps, key) || hasOwn$1(ctx, key) || hasOwn$1(publicPropertiesMap, key) || hasOwn$1(appContext.config.globalProperties, key);
}
};
extend({}, PublicInstanceProxyHandlers, {
get(target, key) {
if (key === Symbol.unscopables) {
return;
}
return PublicInstanceProxyHandlers.get(target, key, target);
},
has(_, key) {
const has2 = key[0] !== "_" && !isGloballyWhitelisted(key);
return has2;
}
});
let currentInstance = null;
const setCurrentInstance = (instance2) => {
currentInstance = instance2;
};
function isStatefulComponent(instance2) {
return instance2.vnode.shapeFlag & 4;
}
function recordInstanceBoundEffect(effect2, instance2 = currentInstance) {
if (instance2) {
(instance2.effects || (instance2.effects = [])).push(effect2);
}
}
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, props2) => {
const el = isSVG ? doc.createElementNS(svgNS, tag) : doc.createElement(tag, is ? {is} : void 0);
if (tag === "select" && props2 && props2.multiple != null) {
el.setAttribute("multiple", props2.multiple);
}
return el;
},
createText: (text2) => doc.createTextNode(text2),
createComment: (text2) => doc.createComment(text2),
setText: (node, text2) => {
node.nodeValue = text2;
},
setElementText: (el, text2) => {
el.textContent = text2;
},
parentNode: (node) => node.parentNode,
nextSibling: (node) => node.nextSibling,
querySelector: (selector) => doc.querySelector(selector),
setScopeId(el, id2) {
el.setAttribute(id2, "");
},
cloneNode(el) {
const cloned = el.cloneNode(true);
if (`_value` in el) {
cloned._value = el._value;
}
return cloned;
},
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];
}
};
function patchClass(el, value, isSVG) {
if (value == null) {
value = "";
}
if (isSVG) {
el.setAttribute("class", value);
} else {
const transitionClasses = el._vtc;
if (transitionClasses) {
value = (value ? [value, ...transitionClasses] : [...transitionClasses]).join(" ");
}
el.className = value;
}
}
function patchStyle(el, prev, next) {
const style2 = el.style;
if (!next) {
el.removeAttribute("style");
} else if (isString(next)) {
if (prev !== next) {
const current = style2.display;
style2.cssText = normalizeRpx(next);
if ("_vod" in el) {
style2.display = current;
}
}
} else {
for (const key in next) {
setStyle(style2, key, next[key]);
}
if (prev && !isString(prev)) {
for (const key in prev) {
if (next[key] == null) {
setStyle(style2, key, "");
}
}
}
}
}
const importantRE = /\s*!important$/;
function setStyle(style2, name, val) {
if (isArray(val)) {
val.forEach((v2) => setStyle(style2, name, v2));
} else {
val = normalizeRpx(val);
if (name.startsWith("--")) {
style2.setProperty(name, val);
} else {
const prefixed = autoPrefix(style2, name);
if (importantRE.test(val)) {
style2.setProperty(hyphenate(prefixed), val.replace(importantRE, ""), "important");
} else {
style2[prefixed] = val;
}
}
}
}
const prefixes = ["Webkit", "Moz", "ms"];
const prefixCache = {};
function autoPrefix(style2, rawName) {
const cached = prefixCache[rawName];
if (cached) {
return cached;
}
let name = camelize(rawName);
if (name !== "filter" && name in style2) {
return prefixCache[rawName] = name;
}
name = capitalize(name);
for (let i2 = 0; i2 < prefixes.length; i2++) {
const prefixed = prefixes[i2] + name;
if (prefixed in style2) {
return prefixCache[rawName] = prefixed;
}
}
return rawName;
}
const rpxRE = /\b([+-]?\d+(\.\d+)?)[r|u]px\b/g;
const normalizeRpx = (val) => {
if (isString(val)) {
return val.replace(rpxRE, (a2, b) => {
return rpx2px(b) + "px";
});
}
return val;
};
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 {
const isBoolean2 = isSpecialBooleanAttr(key);
if (value == null || isBoolean2 && value === false) {
el.removeAttribute(key);
} else {
el.setAttribute(key, isBoolean2 ? "" : value);
}
}
}
function patchDOMProp(el, key, value, 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") {
el._value = value;
const newValue = value == null ? "" : value;
if (el.value !== newValue) {
el.value = newValue;
}
return;
}
if (value === "" || value == null) {
const type = typeof el[key];
if (value === "" && type === "boolean") {
el[key] = true;
return;
} else if (value == null && type === "string") {
el[key] = "";
el.removeAttribute(key);
return;
} else if (type === "number") {
el[key] = 0;
el.removeAttribute(key);
return;
}
}
try {
el[key] = value;
} catch (e2) {
}
}
let _getNow = Date.now;
if (typeof document !== "undefined" && _getNow() > document.createEvent("Event").timeStamp) {
_getNow = () => performance.now();
}
let cachedNow = 0;
const p = Promise.resolve();
const reset = () => {
cachedNow = 0;
};
const getNow = () => cachedNow || (p.then(reset), cachedNow = _getNow());
function addEventListener(el, event2, handler, options) {
el.addEventListener(event2, handler, options);
}
function removeEventListener(el, event2, handler, options) {
el.removeEventListener(event2, handler, options);
}
function patchEvent(el, rawName, prevValue, nextValue, instance2 = null) {
const invokers = el._vei || (el._vei = {});
const existingInvoker = invokers[rawName];
if (nextValue && existingInvoker) {
existingInvoker.value = nextValue;
} else {
const [name, options] = parseName(rawName);
if (nextValue) {
const invoker = invokers[rawName] = createInvoker(nextValue, instance2);
addEventListener(el, name, invoker, options);
} else if (existingInvoker) {
removeEventListener(el, name, existingInvoker, options);
invokers[rawName] = void 0;
}
}
}
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 [hyphenate(name.slice(2)), options];
}
function createInvoker(initialValue, instance2) {
const invoker = (e2) => {
const timeStamp = e2.timeStamp || _getNow();
if (timeStamp >= invoker.attached - 1) {
const proxy = instance2 && instance2.proxy;
const normalizeNativeEvent = proxy && proxy.$normalizeNativeEvent;
callWithAsyncErrorHandling(patchStopImmediatePropagation(e2, invoker.value), instance2, 5, [normalizeNativeEvent ? normalizeNativeEvent(e2) : e2]);
}
};
invoker.value = initialValue;
invoker.attached = getNow();
return invoker;
}
function patchStopImmediatePropagation(e2, value) {
if (isArray(value)) {
const originalStop = e2.stopImmediatePropagation;
e2.stopImmediatePropagation = () => {
originalStop.call(e2);
e2._stopped = true;
};
return value.map((fn) => (e3) => !e3._stopped && fn(e3));
} 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) {
case "class":
patchClass(el, nextValue, isSVG);
break;
case "style":
patchStyle(el, prevValue, nextValue);
break;
default:
if (isOn(key)) {
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 {
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) {
if (key === "innerHTML") {
return true;
}
if (key in el && nativeOnRE.test(key) && isFunction(value)) {
return true;
}
return false;
}
if (key === "spellcheck" || key === "draggable") {
return false;
}
if (key === "form") {
return false;
}
if (key === "list" && el.tagName === "INPUT") {
return false;
}
if (key === "type" && el.tagName === "TEXTAREA") {
return false;
}
if (nativeOnRE.test(key) && isString(value)) {
return false;
}
return key in el;
}
extend({patchProp, forcePatchProp}, nodeOps);
function formatTime(val) {
val = val > 0 && val < Infinity ? val : 0;
const h = Math.floor(val / 3600);
......@@ -11512,7 +10111,7 @@ function formatTime(val) {
return str;
}
function useGesture(props2, videoRef, fullscreenState) {
const state = reactive$1({
const state = reactive({
gestureType: "none",
volumeOld: 0,
volumeNew: 0,
......@@ -11532,12 +10131,12 @@ function useGesture(props2, videoRef, fullscreenState) {
state.currentTimeOld = state.currentTimeNew = 0;
}
function onTouchmove(event2) {
function stop2() {
function stop() {
event2.stopPropagation();
event2.preventDefault();
}
if (fullscreenState.fullscreen) {
stop2();
stop();
}
const gestureType = state.gestureType;
if (gestureType === "stop") {
......@@ -11564,7 +10163,7 @@ function useGesture(props2, videoRef, fullscreenState) {
state.gestureType = "progress";
state.currentTimeOld = state.currentTimeNew = video.currentTime;
if (!fullscreenState.fullscreen) {
stop2();
stop();
}
} else {
if (!props2.pageGesture) {
......@@ -11574,7 +10173,7 @@ function useGesture(props2, videoRef, fullscreenState) {
state.gestureType = "volume";
state.volumeOld = video.volume;
if (!fullscreenState.fullscreen) {
stop2();
stop();
}
}
}
......@@ -11622,8 +10221,8 @@ function useGesture(props2, videoRef, fullscreenState) {
onTouchend
};
}
function useFullscreen(trigger2, containerRef, videoRef, userActionState, rootRef) {
const state = reactive$1({
function useFullscreen(trigger, containerRef, videoRef, userActionState, rootRef) {
const state = reactive({
fullscreen: false
});
const isSafari = /^Apple/.test(navigator.vendor);
......@@ -11635,7 +10234,7 @@ function useFullscreen(trigger2, containerRef, videoRef, userActionState, rootRe
}
function emitFullscreenChange(val) {
state.fullscreen = val;
trigger2("fullscreenchange", {}, {
trigger("fullscreenchange", {}, {
fullScreen: val,
direction: "vertical"
});
......@@ -11692,10 +10291,10 @@ function useFullscreen(trigger2, containerRef, videoRef, userActionState, rootRe
exitFullScreen
};
}
function useVideo(props2, attrs2, trigger2) {
function useVideo(props2, attrs2, trigger) {
const videoRef = ref(null);
const src = computed(() => getRealPath(props2.src));
const state = reactive$1({
const state = reactive({
start: false,
src,
playing: false,
......@@ -11709,7 +10308,7 @@ function useVideo(props2, attrs2, trigger2) {
state.currentTime = 0;
});
watch(() => state.buffered, (buffered) => {
trigger2("progress", {}, {
trigger("progress", {}, {
buffered
});
});
......@@ -11734,7 +10333,7 @@ function useVideo(props2, attrs2, trigger2) {
if (initialTime > 0) {
video.currentTime = initialTime;
}
trigger2("loadedmetadata", $event, {
trigger("loadedmetadata", $event, {
width: video.videoWidth,
height: video.videoHeight,
duration: video.duration
......@@ -11749,29 +10348,29 @@ function useVideo(props2, attrs2, trigger2) {
}
}
function onWaiting($event) {
trigger2("waiting", $event, {});
trigger("waiting", $event, {});
}
function onVideoError($event) {
state.playing = false;
trigger2("error", $event, {});
trigger("error", $event, {});
}
function onPlay($event) {
state.start = true;
state.playing = true;
trigger2("play", $event, {});
trigger("play", $event, {});
}
function onPause($event) {
state.playing = false;
trigger2("pause", $event, {});
trigger("pause", $event, {});
}
function onEnded($event) {
state.playing = false;
trigger2("ended", $event, {});
trigger("ended", $event, {});
}
function onTimeUpdate($event) {
const video = $event.target;
const currentTime = state.currentTime = video.currentTime;
trigger2("timeupdate", $event, {
trigger("timeupdate", $event, {
currentTime,
duration: video.duration
});
......@@ -11830,7 +10429,7 @@ function useControls(props2, videoState, seek) {
const centerPlayBtnShow = computed(() => props2.showCenterPlayBtn && !videoState.start);
const controlsVisible = ref(true);
const controlsShow = computed(() => !centerPlayBtnShow.value && props2.controls && controlsVisible.value);
const state = reactive$1({
const state = reactive({
touching: false,
controlsTouching: false,
centerPlayBtnShow,
......@@ -11951,7 +10550,7 @@ function useControls(props2, videoState, seek) {
}
function useDanmu(props2, videoState) {
const danmuRef = ref(null);
const state = reactive$1({
const state = reactive({
enable: Boolean(props2.enableDanmu)
});
let danmuIndex = {
......@@ -12151,7 +10750,7 @@ var index$1 = /* @__PURE__ */ defineComponent({
}) {
const rootRef = ref(null);
const containerRef = ref(null);
const trigger2 = useCustomEvent(rootRef, emit);
const trigger = useCustomEvent(rootRef, emit);
const {
state: userActionState
} = useUserAction();
......@@ -12177,7 +10776,7 @@ var index$1 = /* @__PURE__ */ defineComponent({
onPause,
onEnded,
onTimeUpdate
} = useVideo(props2, attrs2, trigger2);
} = useVideo(props2, attrs2, trigger);
const {
state: danmuState,
danmuRef,
......@@ -12192,7 +10791,7 @@ var index$1 = /* @__PURE__ */ defineComponent({
toggleFullscreen,
requestFullScreen,
exitFullScreen
} = useFullscreen(trigger2, containerRef, videoRef, userActionState, rootRef);
} = useFullscreen(trigger, containerRef, videoRef, userActionState, rootRef);
const {
state: gestureState,
onTouchstart,
......@@ -12724,7 +11323,7 @@ const startAccelerometer = defineAsyncApi(API_START_ACCELEROMETER, (_, {resolve,
reject();
return;
}
function addEventListener2() {
function addEventListener() {
listener$1 = function(event2) {
const acceleration = event2.acceleration || event2.accelerationIncludingGravity;
UniServiceJSBridge.invokeOnCallback(API_ON_ACCELEROMETER, {
......@@ -12739,7 +11338,7 @@ const startAccelerometer = defineAsyncApi(API_START_ACCELEROMETER, (_, {resolve,
if (DeviceMotionEvent.requestPermission) {
DeviceMotionEvent.requestPermission().then((res) => {
if (res === "granted") {
addEventListener2();
addEventListener();
resolve();
} else {
reject(`${res}`);
......@@ -12749,7 +11348,7 @@ const startAccelerometer = defineAsyncApi(API_START_ACCELEROMETER, (_, {resolve,
});
return;
}
addEventListener2();
addEventListener();
}
resolve();
});
......@@ -12772,7 +11371,7 @@ const startCompass = defineAsyncApi(API_START_COMPASS, (_, {resolve, reject}) =>
reject();
return;
}
function addEventListener2() {
function addEventListener() {
listener = function(event2) {
const direction2 = 360 - (event2.alpha !== null ? event2.alpha : 360);
UniServiceJSBridge.invokeOnCallback(API_ON_COMPASS, {
......@@ -12785,7 +11384,7 @@ const startCompass = defineAsyncApi(API_START_COMPASS, (_, {resolve, reject}) =>
if (DeviceOrientationEvent.requestPermission) {
DeviceOrientationEvent.requestPermission().then((res) => {
if (res === "granted") {
addEventListener2();
addEventListener();
resolve();
} else {
reject(`${res}`);
......@@ -12795,7 +11394,7 @@ const startCompass = defineAsyncApi(API_START_COMPASS, (_, {resolve, reject}) =>
});
return;
}
addEventListener2();
addEventListener();
}
resolve();
});
......
packages/uni-h5/src/view/components/video/index.tsx
浏览文件 @ a3b5033a
......@@ -9,6 +9,7 @@ import {
onMounted,
SetupContext,
renderList,
onBeforeUnmount,
} from 'vue'
import { passive } from '@dcloudio/uni-shared'
import { useI18n, initI18nVideoMsgsOnce } from '@dcloudio/uni-core'
......@@ -16,7 +17,6 @@ import { getRealPath } from '@dcloudio/uni-platform'
import { useSubscribe } from '@dcloudio/uni-components'
import { useCustomEvent } from '@dcloudio/uni-components'
import { useUserAction } from '@dcloudio/uni-components'
import { onBeforeUnmount } from '@dcloudio/uni-h5-vue/src'
type CustomEventTrigger = ReturnType<typeof useCustomEvent>
type UserActionState = ReturnType<typeof useUserAction>['state']
......
Markdown is supported
0% 或 .
You are about to add 0 people to the discussion. Proceed with caution.
先完成此消息的编辑！
想要评论请 注册 或