@opentinyvue/vue-renderless 3.21.0

package/common/deps/popup-manager.js

@@ -0,0 +1,205 @@
+import "../../chunk-G2ADBYYC.js";
+import { KEY_CODE } from "../index";
+import { addClass, removeClass, on } from "./dom";
+const isServer = typeof window === "undefined";
+const instances = {};
+const classes = {
+  leave: "v-modal-leave",
+  enter: "v-modal-enter",
+  modal: "v-modal"
+};
+const removeStack = (modalStack, id) => {
+  for (let i = modalStack.length - 1; i >= 0; i--) {
+    if (modalStack[i].id === id) {
+      modalStack.splice(i, 1);
+      break;
+    }
+  }
+};
+let getModal;
+const PopupManager = {
+  step: 2,
+  zIndex: 2e3,
+  globalScroll: false,
+  // 是否打开全局滚动监听
+  modalFade: true,
+  modalStack: [],
+  modalDom: null,
+  // 当前model挂载的div.
+  hasModal: false,
+  // 当前是否有Modal
+  popLockClass: "popup-parent--hidden",
+  oldBodyBorder: "",
+  viewportWindow: null,
+  fixBodyBorder() {
+    const barWidth = window.innerWidth - document.documentElement.clientWidth;
+    if (barWidth) {
+      this.oldBodyBorder = document.documentElement.style.borderRight;
+      document.body.style.borderRight = `${barWidth}px solid transparent`;
+    }
+  },
+  resetBodyBorder() {
+    document.body.style.borderRight = this.oldBodyBorder;
+    this.oldBodyBorder = "";
+  },
+  /** 全局反注册 */
+  deregister: (id) => {
+    if (id) {
+      instances[id] = null;
+      delete instances[id];
+    }
+  },
+  /** 返回全局实例 */
+  getInstance: (id) => instances[id],
+  /** 全局注册   仅vue-popup.ts中使用，instance就是vm, 把vm注册到 vm._popupId 这个键值上 */
+  register: (id, instance) => {
+    if (id && instance) {
+      instances[id] = instance;
+    }
+  },
+  nextZIndex: () => {
+    const zIndex = PopupManager.zIndex;
+    PopupManager.zIndex += PopupManager.step;
+    return zIndex;
+  },
+  /** 打开遮罩层， 仅vue-popup.ts中使用。 dom = vm.$el 或者 undefined (appendtoBody时)  */
+  openModal(id, zIndex, dom, modalClass, modalFade) {
+    if (isServer) {
+      return;
+    }
+    if (!id || zIndex === void 0) {
+      return;
+    }
+    this.modalFade = modalFade;
+    for (let i = 0, len = this.modalStack.length; i < len; i++) {
+      const modal = this.modalStack[i];
+      if (modal.id === id) {
+        return;
+      }
+    }
+    const modalDom = getModal();
+    addClass(modalDom, classes.modal);
+    if (this.modalFade && !PopupManager.hasModal) {
+      addClass(modalDom, classes.enter);
+    }
+    if (modalClass) {
+      const classArr = modalClass.trim().split(/\s+/);
+      classArr.forEach((cls) => addClass(modalDom, cls));
+    }
+    setTimeout(() => {
+      removeClass(modalDom, classes.enter);
+    }, 200);
+    if (zIndex) {
+      modalDom.style.zIndex = zIndex.toString();
+    }
+    modalDom.style.display = "";
+    modalDom.tabIndex = 0;
+    let parentNode;
+    if (dom && dom.parentNode && dom.parentNode.nodeType !== 11) {
+      parentNode = dom.parentNode;
+    } else {
+      parentNode = document.body;
+    }
+    parentNode.appendChild(modalDom);
+    this.modalStack.push({ id, zIndex, modalClass });
+  },
+  /** 点击背景遮罩层时，调用栈顶的popup，调用它的close() */
+  doOnModalClick: () => {
+    const modalStack = PopupManager.modalStack;
+    const topPopup = modalStack[modalStack.length - 1];
+    if (!topPopup) {
+      return;
+    }
+    const instance = PopupManager.getInstance(topPopup.id);
+    if (instance && instance.closeOnClickModal) {
+      typeof instance.close === "function" && instance.close();
+    }
+  },
+  closeModal(id) {
+    const modalStack = this.modalStack;
+    const modalDom = getModal();
+    if (modalStack.length > 0) {
+      const topPopup = modalStack[modalStack.length - 1];
+      if (topPopup.id === id) {
+        if (topPopup.modalClass) {
+          const classArr = topPopup.modalClass.trim().split(/\s+/);
+          classArr.forEach((cls) => removeClass(modalDom, cls));
+        }
+        modalStack.pop();
+        const stackSize = modalStack.length;
+        if (stackSize > 0) {
+          modalDom.style.zIndex = modalStack[stackSize - 1].zIndex.toString();
+        }
+      } else {
+        removeStack(modalStack, id);
+      }
+    }
+    if (modalStack.length === 0) {
+      this.modalFade && addClass(modalDom, classes.leave);
+      removeClass(document.body, this.popLockClass);
+      this.resetBodyBorder();
+      setTimeout(() => {
+        if (modalStack.length === 0) {
+          if (modalDom.parentNode) {
+            modalDom.parentNode.removeChild(modalDom);
+          }
+          modalDom.style.display = "none";
+          PopupManager.modalDom = null;
+        }
+        removeClass(modalDom, classes.leave);
+      }, 200);
+    }
+  }
+};
+getModal = () => {
+  if (isServer) {
+    return null;
+  }
+  let modalDom = PopupManager.modalDom;
+  if (modalDom) {
+    PopupManager.hasModal = true;
+  } else {
+    PopupManager.hasModal = false;
+    modalDom = document.createElement("div");
+    PopupManager.modalDom = modalDom;
+    modalDom.addEventListener(
+      "touchmove",
+      (event) => {
+        event.preventDefault();
+        event.stopPropagation();
+      },
+      { passive: true }
+    );
+    on(modalDom, "click", () => {
+      PopupManager.doOnModalClick();
+    });
+  }
+  return modalDom;
+};
+if (!isServer) {
+  on(window, "keydown", (event) => {
+    if (event.keyCode === KEY_CODE.Escape) {
+      const modalStack = PopupManager.modalStack;
+      if (modalStack.length > 0) {
+        const topPopup = modalStack[modalStack.length - 1];
+        if (!topPopup) {
+          return;
+        }
+        const topPopupVm = PopupManager.getInstance(topPopup.id);
+        if (topPopupVm && topPopupVm.closeOnPressEscape) {
+          if (topPopupVm.handleClose) {
+            topPopupVm.handleClose("esc");
+          } else if (topPopupVm.handleAction) {
+            topPopupVm.handleAction("cancel");
+          } else {
+            topPopupVm.close();
+          }
+        }
+      }
+    }
+  });
+}
+var popup_manager_default = PopupManager;
+export {
+  popup_manager_default as default
+};

package/common/deps/repeat-click.js

@@ -0,0 +1,29 @@
+import "../../chunk-G2ADBYYC.js";
+import { on, once } from "./dom";
+var repeat_click_default = (el, binding) => {
+  const LONG_PRESS_INTERVAL = 200;
+  let interval = null;
+  let startTime;
+  const handler = () => {
+    typeof binding.value === "function" && binding.value.apply();
+  };
+  const clear = () => {
+    if (Date.now() - startTime < LONG_PRESS_INTERVAL) {
+      handler();
+    }
+    clearInterval(interval);
+    interval = null;
+  };
+  on(el, "mousedown", (e) => {
+    if (e.button !== 0) {
+      return;
+    }
+    startTime = Date.now();
+    once(document, "mouseup", clear);
+    clearInterval(interval);
+    interval = setInterval(handler, LONG_PRESS_INTERVAL);
+  });
+};
+export {
+  repeat_click_default as default
+};

package/common/deps/resize-event.js

@@ -0,0 +1,39 @@
+import "../../chunk-G2ADBYYC.js";
+import ResizeObserver from "./ResizeObserver";
+const isServer = typeof window === "undefined";
+const cacheKey = "__resizeListeners__";
+const resizeHandler = (entries) => {
+  entries.forEach((entry) => {
+    const listeners = entry.target[cacheKey] || [];
+    if (listeners.length) {
+      listeners.forEach((fn) => {
+        fn();
+      });
+    }
+  });
+};
+const addResizeListener = (el, fn) => {
+  if (isServer) {
+    return;
+  }
+  if (!el[cacheKey]) {
+    el[cacheKey] = [];
+    el.__ro__ = new ResizeObserver(resizeHandler);
+    el.__ro__.observe(el);
+  }
+  el[cacheKey].push(fn);
+};
+const removeResizeListener = (el, fn) => {
+  if (!el || !el[cacheKey]) {
+    return;
+  }
+  el[cacheKey].splice(el[cacheKey].indexOf(fn), 1);
+  if (!el[cacheKey].length) {
+    el.__ro__.disconnect();
+    delete el.__ro__;
+  }
+};
+export {
+  addResizeListener,
+  removeResizeListener
+};

package/common/deps/scroll-into-view.js

@@ -0,0 +1,29 @@
+import "../../chunk-G2ADBYYC.js";
+const isServer = typeof window === "undefined";
+var scroll_into_view_default = (container, selected) => {
+  if (isServer) {
+    return;
+  }
+  if (!selected) {
+    container.scrollTop = 0;
+    return;
+  }
+  const offsetParents = [];
+  let { offsetParent, offsetTop, offsetHeight } = selected;
+  while (offsetParent && container !== offsetParent && container.contains(offsetParent)) {
+    offsetParents.push(offsetParent);
+    offsetParent = offsetParent.offsetParent;
+  }
+  const top = offsetTop + offsetParents.reduce((prev, curr) => prev + curr.offsetTop, 0);
+  const bottom = top + offsetHeight;
+  const viewRectTop = container.scrollTop;
+  const viewRectBottom = viewRectTop + container.clientHeight;
+  if (top < viewRectTop) {
+    container.scrollTop = top;
+  } else if (bottom > viewRectBottom) {
+    container.scrollTop = bottom - container.clientHeight;
+  }
+};
+export {
+  scroll_into_view_default as default
+};

package/common/deps/scrollbar-width.js

@@ -0,0 +1,33 @@
+import "../../chunk-G2ADBYYC.js";
+let scrollBarWidth;
+const isServer = typeof window === "undefined";
+function scrollbar_width_default() {
+  if (isServer) {
+    return 0;
+  }
+  if (scrollBarWidth !== void 0) {
+    return scrollBarWidth;
+  }
+  const container = document.createElement("div");
+  container.className = "tiny-scrollbar";
+  container.style.visibility = "hidden";
+  container.style.position = "absolute";
+  container.style.top = "-9999px";
+  const outer = document.createElement("div");
+  outer.className = "tiny-scrollbar__wrap";
+  outer.style.width = "100px";
+  container.appendChild(outer);
+  document.body.appendChild(container);
+  const widthNoScroll = outer.offsetWidth;
+  outer.style.overflow = "scroll";
+  const inner = document.createElement("div");
+  inner.style.width = "100%";
+  outer.appendChild(inner);
+  const widthWithScroll = inner.offsetWidth;
+  outer.parentNode.removeChild(outer);
+  scrollBarWidth = widthNoScroll - widthWithScroll;
+  return scrollBarWidth;
+}
+export {
+  scrollbar_width_default as default
+};

package/common/deps/throttle.js

@@ -0,0 +1,45 @@
+import "../../chunk-G2ADBYYC.js";
+function throttle_default(delay, noTrailing, callback, debounceMode) {
+  let timeoutID;
+  let lastExec = 0;
+  if (typeof noTrailing !== "boolean") {
+    debounceMode = callback;
+    callback = noTrailing;
+    noTrailing = void 0;
+  }
+  function wrapper() {
+    const me = this;
+    const elapsed = (/* @__PURE__ */ new Date()).valueOf() - lastExec;
+    const args = arguments;
+    function exec() {
+      lastExec = (/* @__PURE__ */ new Date()).valueOf();
+      callback.apply(me, args);
+    }
+    function clear() {
+      timeoutID = void 0;
+    }
+    if (debounceMode && !timeoutID) {
+      exec();
+    }
+    if (timeoutID) {
+      clearTimeout(timeoutID);
+    }
+    const isUndMode = debounceMode === void 0;
+    if (isUndMode && elapsed > delay) {
+      exec();
+    } else if (noTrailing !== true) {
+      timeoutID = setTimeout(debounceMode ? clear : exec, isUndMode ? delay - elapsed : delay);
+    }
+  }
+  function cancel() {
+    if (timeoutID) {
+      clearTimeout(timeoutID);
+      timeoutID = null;
+    }
+  }
+  wrapper._cancel = cancel;
+  return wrapper;
+}
+export {
+  throttle_default as default
+};

package/common/deps/touch-emulator.js

@@ -0,0 +1,103 @@
+import "../../chunk-G2ADBYYC.js";
+import { isBrowser } from "../browser";
+let emulated = false;
+let initiated = false;
+let eventTarget = null;
+let mouseTarget = null;
+const matches = isBrowser ? Element.prototype.matches : null;
+const closest = (el, s) => {
+  if (isBrowser) {
+    do {
+      if (matches.call(el, s))
+        return el;
+      el = el.parentElement || el.parentNode;
+    } while (el !== null && el.nodeType === 1);
+  }
+  return null;
+};
+class Touch {
+  constructor(target, identifier, pos, deltaX, deltaY) {
+    this.target = target;
+    this.identifier = identifier;
+    deltaX = deltaX || 0;
+    deltaY = deltaY || 0;
+    this.pageX = pos.pageX + deltaX;
+    this.pageY = pos.pageY + deltaY;
+    this.screenX = pos.screenX + deltaX;
+    this.screenY = pos.screenY + deltaY;
+    this.clientX = pos.clientX + deltaX;
+    this.clientY = pos.clientY + deltaY;
+    this.offsetX = pos.offsetX + deltaX;
+    this.offsetY = pos.offsetY + deltaY;
+  }
+}
+const TouchList = () => {
+  const touchList = [];
+  touchList.item = (index) => touchList[index] || null;
+  touchList.identifiedTouch = (id) => touchList[id + 1] || null;
+  return touchList;
+};
+const createTouchList = (mouseEv) => {
+  const touchList = TouchList();
+  touchList.push(new Touch(eventTarget, 1, mouseEv, 0, 0));
+  return touchList;
+};
+const getActiveTouches = (mouseEv) => {
+  if (mouseEv.type === "mouseup") {
+    return TouchList();
+  }
+  return createTouchList(mouseEv);
+};
+const triggerTouch = (eventName, mouseEv) => {
+  const touchEvent = document.createEvent("Event");
+  touchEvent.initEvent(eventName, true, true);
+  touchEvent.altKey = mouseEv.altKey;
+  touchEvent.metaKey = mouseEv.metaKey;
+  touchEvent.ctrlKey = mouseEv.ctrlKey;
+  touchEvent.shiftKey = mouseEv.shiftKey;
+  touchEvent.changedTouches = createTouchList(mouseEv);
+  touchEvent.targetTouches = getActiveTouches(mouseEv);
+  touchEvent.touches = getActiveTouches(mouseEv);
+  touchEvent.isTinySimulate = true;
+  eventTarget.dispatchEvent(touchEvent);
+};
+const onMouse = (touchType) => (ev) => {
+  if (ev.type === "mousedown") {
+    initiated = true;
+  }
+  if (ev.type === "mouseup") {
+    initiated = false;
+  }
+  if (ev.type === "mousemove" && !initiated) {
+    return;
+  }
+  if (ev.type === "mousedown" || !mouseTarget) {
+    mouseTarget = ev.target;
+  }
+  eventTarget = closest(mouseTarget, "[data-tiny-touch-simulate-container]");
+  if (eventTarget && eventTarget.dispatchEvent) {
+    triggerTouch(touchType, ev);
+  }
+  if (ev.type === "mouseup") {
+    eventTarget = null;
+    mouseTarget = null;
+  }
+};
+const touchEmulator = () => {
+  window.addEventListener("mousedown", onMouse("touchstart"), true);
+  window.addEventListener("mousemove", onMouse("touchmove"), true);
+  window.addEventListener("mouseup", onMouse("touchend"), true);
+};
+const emulate = () => {
+  if (isBrowser) {
+    const supportTouch = "ontouchstart" in window;
+    if (!emulated && !supportTouch) {
+      emulated = true;
+      touchEmulator();
+    }
+  }
+};
+var touch_emulator_default = emulate;
+export {
+  touch_emulator_default as default
+};

package/common/deps/touch.js

@@ -0,0 +1,37 @@
+import "../../chunk-G2ADBYYC.js";
+const MIN_DISTANCE = 10;
+const getDirection = (x, y) => {
+  if (x > y && x > MIN_DISTANCE) {
+    return "horizontal";
+  }
+  if (y > x && y > MIN_DISTANCE) {
+    return "vertical";
+  }
+  return "";
+};
+const touchStart = (state) => (event) => {
+  resetTouchStatus(state);
+  state.startX = event.touches[0].clientX;
+  state.startY = event.touches[0].clientY;
+};
+const touchMove = (state) => (event) => {
+  const touch = event.touches[0];
+  state.deltaX = touch.clientX - state.startX;
+  state.deltaY = touch.clientY - state.startY;
+  state.offsetX = Math.abs(state.deltaX);
+  state.offsetY = Math.abs(state.deltaY);
+  state.direction = state.direction || getDirection(state.offsetX, state.offsetY);
+};
+const resetTouchStatus = (state) => {
+  state.direction = "";
+  state.deltaX = 0;
+  state.deltaY = 0;
+  state.offsetX = 0;
+  state.offsetY = 0;
+};
+export {
+  getDirection,
+  resetTouchStatus,
+  touchMove,
+  touchStart
+};