@opentiny/vue-renderless 3.21.2 → 3.22.0

package/common/deps/ResizeObserver.js

@@ -1,456 +0,0 @@
-import "../../chunk-G2ADBYYC.js";
-import { on, off } from "./dom";
-import { isBrowser } from "../browser";
-const MapShim = function() {
-  if (typeof Map !== "undefined") {
-    return Map;
-  }
-  const getIndex = (arr, key) => {
-    let result = -1;
-    arr.some((entry, index2) => {
-      if (entry[0] === key) {
-        result = index2;
-        return true;
-      }
-      return false;
-    });
-    return result;
-  };
-  return function() {
-    function obClass() {
-      this.__entries__ = [];
-    }
-    Object.defineProperty(obClass.prototype, "size", {
-      get() {
-        return this.__entries__.length;
-      },
-      enumerable: true,
-      configurable: true
-    });
-    obClass.prototype.get = function(key) {
-      const index2 = getIndex(this.__entries__, key);
-      const entry = this.__entries__[index2];
-      return entry && entry[1];
-    };
-    obClass.prototype.set = function(key, value) {
-      const index2 = getIndex(this.__entries__, key);
-      if (~index2) {
-        this.__entries__[index2][1] = value;
-      } else {
-        this.__entries__.push([key, value]);
-      }
-    };
-    obClass.prototype.delete = function(key) {
-      const entries = this.__entries__;
-      const index2 = getIndex(entries, key);
-      if (~index2) {
-        entries.splice(index2, 1);
-      }
-    };
-    obClass.prototype.clear = function() {
-      this.__entries__.splice(0);
-    };
-    obClass.prototype.has = function(key) {
-      return !!~getIndex(this.__entries__, key);
-    };
-    obClass.prototype.forEach = function(callback, ctx) {
-      if (ctx === void 0) {
-        ctx = null;
-      }
-      for (let _i = 0, _a = this.__entries__; _i < _a.length; _i++) {
-        const entry = _a[_i];
-        callback.call(ctx, entry[1], entry[0]);
-      }
-    };
-    return obClass;
-  }();
-}();
-const func = isBrowser ? window.Function : global.Function;
-const global$1 = function() {
-  const isMath = (val) => val.Math === Math;
-  if (typeof global !== "undefined" && isMath(global)) {
-    return global;
-  }
-  if (typeof self !== "undefined" && isMath(self)) {
-    return self;
-  }
-  if (typeof window !== "undefined" && isMath(window)) {
-    return window;
-  }
-  return func("return this")();
-}();
-const requestAnimationFrame$1 = function() {
-  if (typeof requestAnimationFrame === "function") {
-    return requestAnimationFrame.bind(global$1);
-  }
-  return function(callback) {
-    return setTimeout(() => callback(Date.now()), 1e3 / 60);
-  };
-}();
-let trailingTimeout = 2;
-function throttle(callback, delayTime) {
-  let leading = false;
-  let trailing = false;
-  let lastCallTime = 0;
-  let proxy;
-  const resolvePending = () => {
-    if (leading) {
-      leading = false;
-      callback();
-    }
-    trailing && proxy();
-  };
-  const timeoutCallback = () => {
-    requestAnimationFrame$1(resolvePending);
-  };
-  proxy = () => {
-    const timeStamps = Date.now();
-    if (leading) {
-      if (timeStamps - lastCallTime < trailingTimeout) {
-        return;
-      }
-      trailing = true;
-    } else {
-      leading = true;
-      trailing = false;
-      setTimeout(timeoutCallback, delayTime);
-    }
-    lastCallTime = timeStamps;
-  };
-  return proxy;
-}
-const REFRESH_DELAY = 20;
-const transitionKeys = ["top", "right", "bottom", "left", "width", "height", "size", "weight"];
-const mutationObserverSupported = typeof MutationObserver !== "undefined";
-const ResizeObserverController = function() {
-  function ResizeObserverController2() {
-    this.observers_ = [];
-    this.connected_ = false;
-    this.mutationEventsAdded_ = false;
-    this.mutationsObserver_ = null;
-    this.onTransitionEnd_ = this.onTransitionEnd_.bind(this);
-    this.refresh = throttle(this.refresh.bind(this), REFRESH_DELAY);
-  }
-  ResizeObserverController2.prototype.addObserver = function(observer) {
-    !~this.observers_.indexOf(observer) && this.observers_.push(observer);
-    !this.connected_ && this.connect_();
-  };
-  ResizeObserverController2.prototype.removeObserver = function(observer) {
-    const observers2 = this.observers_;
-    const index2 = observers2.indexOf(observer);
-    ~index2 && observers2.splice(index2, 1);
-    if (!observers2.length && this.connected_) {
-      this.disconnect_();
-    }
-  };
-  ResizeObserverController2.prototype.refresh = function() {
-    const changesDetected = this.updateObservers_();
-    changesDetected && this.refresh();
-  };
-  ResizeObserverController2.prototype.updateObservers_ = function() {
-    const activeObservers = this.observers_.filter((observer) => {
-      observer.gatherActive();
-      return observer.hasActive();
-    });
-    activeObservers.forEach((observer) => observer.broadcastActive());
-    return activeObservers.length > 0;
-  };
-  ResizeObserverController2.prototype.connect_ = function() {
-    if (!isBrowser || this.connected_) {
-      return;
-    }
-    on(document, "transitionend", this.onTransitionEnd_);
-    on(window, "resize", this.refresh);
-    if (mutationObserverSupported) {
-      this.mutationsObserver_ = new MutationObserver(this.refresh);
-      const options = {
-        attributes: true,
-        childList: true,
-        characterData: true,
-        subtree: true
-      };
-      this.mutationsObserver_.observe(document, options);
-    } else {
-      on(document, "DOMSubtreeModified", this.refresh);
-      this.mutationEventsAdded_ = true;
-    }
-    this.connected_ = true;
-  };
-  ResizeObserverController2.prototype.disconnect_ = function() {
-    if (!isBrowser || !this.connected_) {
-      return;
-    }
-    off(document, "transitionend", this.onTransitionEnd_);
-    off(window, "resize", this.refresh);
-    this.mutationsObserver_ && this.mutationsObserver_.disconnect();
-    if (this.mutationEventsAdded_) {
-      off(document, "DOMSubtreeModified", this.refresh);
-    }
-    this.mutationsObserver_ = null;
-    this.mutationEventsAdded_ = false;
-    this.connected_ = false;
-  };
-  ResizeObserverController2.prototype.onTransitionEnd_ = function(_a) {
-    const _b = _a.propertyName;
-    const propertyName = _b === void 0 ? "" : _b;
-    const isReflowProperty = transitionKeys.some((key) => !!~propertyName.indexOf(key));
-    isReflowProperty && this.refresh();
-  };
-  ResizeObserverController2.getInstance = function() {
-    if (!this._instance) {
-      this._instance = new ResizeObserverController2();
-    }
-    return this._instance;
-  };
-  ResizeObserverController2._instance = null;
-  return ResizeObserverController2;
-}();
-const defineConfigurable = function(target, props) {
-  for (let i = 0, a = Object.keys(props); i < a.length; i++) {
-    const key = a[i];
-    Object.defineProperty(target, key, {
-      value: props[key],
-      configurable: true,
-      writable: false,
-      enumerable: false
-    });
-  }
-  return target;
-};
-const createRectInit = function(x, y, width, height) {
-  return { x, y, width, height };
-};
-const getWindowOf = function(target) {
-  const ownerGlobal = target && target.ownerDocument && target.ownerDocument.defaultView;
-  return ownerGlobal || global$1;
-};
-const emptyRect = createRectInit(0, 0, 0, 0);
-const toFloat = (value) => parseFloat(value) || 0;
-const getBordersSize = function(styles) {
-  let positions = [];
-  for (let i = 1; i < arguments.length; i++) {
-    positions[i - 1] = arguments[i];
-  }
-  return positions.reduce((size, position) => {
-    const value = styles[`border-${position}-width`];
-    return size + toFloat(value);
-  }, 0);
-};
-const getPaddings = function(styles) {
-  const positions = ["top", "right", "bottom", "left"];
-  let paddings = {};
-  for (let i = 0, pos = positions; i < pos.length; i++) {
-    const position = pos[i];
-    const value = styles[`padding-${position}`];
-    paddings[position] = toFloat(value);
-  }
-  return paddings;
-};
-const getSVGContentRect = function(target) {
-  const bbox = target.getBBox();
-  return createRectInit(0, 0, bbox.width, bbox.height);
-};
-const isDocumentElement = function(target) {
-  return target === getWindowOf(target).document.documentElement;
-};
-const getHTMLElementContentRect = function(target) {
-  const clientWidth = target.clientWidth;
-  const clientHeight = target.clientHeight;
-  if (!clientHeight && !clientWidth) {
-    return emptyRect;
-  }
-  const styles = getWindowOf(target).getComputedStyle(target);
-  const paddings = getPaddings(styles);
-  const vertPad = paddings.top + paddings.bottom;
-  const horizPad = paddings.left + paddings.right;
-  let width = toFloat(styles.width);
-  let height = toFloat(styles.height);
-  if (styles.boxSizing === "border-box") {
-    if (Math.round(height + vertPad) !== clientHeight) {
-      height -= getBordersSize(styles, "top", "bottom") + vertPad;
-    }
-    if (Math.round(width + horizPad) !== clientWidth) {
-      width -= getBordersSize(styles, "left", "right") + horizPad;
-    }
-  }
-  if (!isDocumentElement(target)) {
-    const horizScrollbar = Math.round(height + vertPad) - clientHeight;
-    const vertScrollbar = Math.round(width + horizPad) - clientWidth;
-    if (Math.abs(horizScrollbar) !== 1) {
-      height -= horizScrollbar;
-    }
-    if (Math.abs(vertScrollbar) !== 1) {
-      width -= vertScrollbar;
-    }
-  }
-  return createRectInit(paddings.left, paddings.top, width, height);
-};
-const isSVGGraphicsElement = function() {
-  if (typeof SVGGraphicsElement !== "undefined") {
-    return (target) => target instanceof getWindowOf(target).SVGGraphicsElement;
-  }
-  return (target) => target instanceof getWindowOf(target).SVGElement && typeof target.getBBox === "function";
-}();
-const getContentRect = function(target) {
-  if (!isBrowser) {
-    return emptyRect;
-  }
-  if (isSVGGraphicsElement(target)) {
-    return getSVGContentRect(target);
-  }
-  return getHTMLElementContentRect(target);
-};
-const createReadOnlyRect = function(_a) {
-  const x = _a.x;
-  const y = _a.y;
-  const width = _a.width;
-  const height = _a.height;
-  const Constr = typeof DOMRectReadOnly !== "undefined" ? DOMRectReadOnly : Object;
-  const rect = Object.create(Constr.prototype);
-  defineConfigurable(rect, {
-    x,
-    y,
-    width,
-    height,
-    top: y,
-    right: x + width,
-    bottom: height + y,
-    left: x
-  });
-  return rect;
-};
-const ResizeObservation = function() {
-  function ResizeObservation2(target) {
-    this.broadcastWidth = 0;
-    this.broadcastHeight = 0;
-    this.contentRect_ = createRectInit(0, 0, 0, 0);
-    this.target = target;
-  }
-  ResizeObservation2.prototype.broadcastRect = function() {
-    const rect = this.contentRect_;
-    this.broadcastWidth = rect.width;
-    this.broadcastHeight = rect.height;
-    return rect;
-  };
-  ResizeObservation2.prototype.isActive = function() {
-    const rect = getContentRect(this.target);
-    this.contentRect_ = rect;
-    return rect.width !== this.broadcastWidth || rect.height !== this.broadcastHeight;
-  };
-  return ResizeObservation2;
-}();
-const ResizeObserverEntry = function() {
-  function ResizeObserverEntry2(target, rectInit) {
-    const contentRect = createReadOnlyRect(rectInit);
-    defineConfigurable(this, { target, contentRect });
-  }
-  return ResizeObserverEntry2;
-}();
-const ResizeObserverSPI = function() {
-  function ResizeObserverSPI2(callback, controller, callbackCtx) {
-    this.observations_ = new MapShim();
-    this.activeObservations_ = [];
-    if (typeof callback !== "function") {
-      throw new TypeError("[TINY-Resize] The callback provided as parameter 1 is not a function.");
-    }
-    this.callback_ = callback;
-    this.controller_ = controller;
-    this.callbackCtx_ = callbackCtx;
-  }
-  ResizeObserverSPI2.prototype.observe = function(target) {
-    if (!arguments.length) {
-      throw new TypeError("[TINY-Resize] 1 argument required, but only 0 present.");
-    }
-    if (typeof Element === "undefined" || !(Element instanceof Object)) {
-      return;
-    }
-    if (!(target instanceof getWindowOf(target).Element)) {
-      throw new TypeError('[TINY-Resize] parameter 1 is not of type "Element".');
-    }
-    const obserVations = this.observations_;
-    if (obserVations.has(target)) {
-      return;
-    }
-    obserVations.set(target, new ResizeObservation(target));
-    this.controller_.addObserver(this);
-    this.controller_.refresh();
-  };
-  ResizeObserverSPI2.prototype.unobserve = function(target) {
-    if (!arguments.length) {
-      throw new TypeError("[TINY-Resize]1 argument required, but only 0 present.");
-    }
-    if (typeof Element === "undefined" || !(Element instanceof Object)) {
-      return;
-    }
-    if (!(target instanceof getWindowOf(target).Element)) {
-      throw new TypeError('[TINY-Resize] parameter 1 is not of type "Element".');
-    }
-    const obserVations = this.observations_;
-    if (!obserVations.has(target)) {
-      return;
-    }
-    obserVations.delete(target);
-    !obserVations.size && this.controller_.removeObserver(this);
-  };
-  ResizeObserverSPI2.prototype.gatherActive = function() {
-    const me = this;
-    this.clearActive();
-    this.observations_.forEach((observation) => {
-      observation.isActive() && me.activeObservations_.push(observation);
-    });
-  };
-  ResizeObserverSPI2.prototype.disconnect = function() {
-    this.clearActive();
-    this.observations_.clear();
-    this.controller_.removeObserver(this);
-  };
-  ResizeObserverSPI2.prototype.broadcastActive = function() {
-    if (!this.hasActive()) {
-      return;
-    }
-    const ctx = this.callbackCtx_;
-    const entries = this.activeObservations_.map(
-      (observation) => new ResizeObserverEntry(observation.target, observation.broadcastRect())
-    );
-    this.callback_.call(ctx, entries, ctx);
-    this.clearActive();
-  };
-  ResizeObserverSPI2.prototype.hasActive = function() {
-    return this.activeObservations_.length > 0;
-  };
-  ResizeObserverSPI2.prototype.clearActive = function() {
-    this.activeObservations_.splice(0);
-  };
-  return ResizeObserverSPI2;
-}();
-const observers = typeof WeakMap !== "undefined" ? /* @__PURE__ */ new WeakMap() : new MapShim();
-const ResizeObserver = function() {
-  function ResizeObserver2(callback) {
-    if (!(this instanceof ResizeObserver2)) {
-      throw new TypeError("[TINY-Resize] Cannot call a class as a function.");
-    }
-    if (!arguments.length) {
-      throw new TypeError("[TINY-Resize] 1 argument required, but only 0 present.");
-    }
-    const controller = ResizeObserverController.getInstance();
-    const observer = new ResizeObserverSPI(callback, controller, this);
-    observers.set(this, observer);
-  }
-  return ResizeObserver2;
-}();
-["observe", "unobserve", "disconnect"].forEach((method) => {
-  ResizeObserver.prototype[method] = function() {
-    let _a;
-    return (_a = observers.get(this))[method].apply(_a, arguments);
-  };
-});
-const index = function() {
-  if (typeof global$1.ResizeObserver !== "undefined") {
-    return global$1.ResizeObserver;
-  }
-  return ResizeObserver;
-}();
-var ResizeObserver_default = index;
-export {
-  ResizeObserver_default as default
-};

package/common/deps/after-leave.js

@@ -1,27 +0,0 @@
-import "../../chunk-G2ADBYYC.js";
-const AfterLave = "after-leave";
-const Speed = 300;
-var after_leave_default = (instance, callback, speed = Speed, once = false) => {
-  if (!instance || !callback) {
-    throw new Error("instance & callback is required");
-  }
-  let called = false;
-  const eventCallback = function() {
-    if (called) {
-      return;
-    }
-    called = true;
-    if (typeof callback === "function") {
-      callback.apply(null, arguments);
-    }
-  };
-  if (once) {
-    instance.$once(AfterLave, eventCallback);
-  } else {
-    instance.$on(AfterLave, eventCallback);
-  }
-  setTimeout(eventCallback, speed + 100);
-};
-export {
-  after_leave_default as default
-};

package/common/deps/clickoutside.js

@@ -1,75 +0,0 @@
-import "../../chunk-G2ADBYYC.js";
-import { on } from "./dom";
-const isServer = typeof window === "undefined";
-const nodeList = [];
-const nameSpace = "@@clickoutsideContext";
-let startClick;
-let seed = 0;
-if (!isServer) {
-  on(document, "mousedown", (event) => {
-    startClick = event;
-    nodeList.filter((node) => node[nameSpace].mousedownTrigger).forEach((node) => node[nameSpace].documentHandler(event, startClick));
-  });
-  on(document, "mouseup", (event) => {
-    nodeList.filter((node) => !node[nameSpace].mousedownTrigger).forEach((node) => {
-      var _a;
-      return node[nameSpace].documentHandler(event, ((_a = node[nameSpace]) == null ? void 0 : _a.mouseupTrigger) ? event : startClick);
-    });
-    startClick = null;
-  });
-}
-const createDocumentHandler = (el, binding, vnode) => function(mouseup = {}, mousedown = {}) {
-  let popperElm = vnode.context.popperElm || vnode.context.state && vnode.context.state.popperElm;
-  if (!(mouseup == null ? void 0 : mouseup.target) || !(mousedown == null ? void 0 : mousedown.target) || el.contains(mouseup.target) || el.contains(mousedown.target) || el === mouseup.target || popperElm && (popperElm.contains(mouseup.target) || popperElm.contains(mousedown.target))) {
-    return;
-  }
-  if (binding.expression && el[nameSpace].methodName && vnode.context[el[nameSpace].methodName]) {
-    vnode.context[el[nameSpace].methodName]();
-  } else {
-    el[nameSpace].bindingFn && el[nameSpace].bindingFn();
-  }
-};
-var clickoutside_default = {
-  bind: (el, binding, vnode) => {
-    nodeList.push(el);
-    const id = seed++;
-    const { modifiers, expression, value } = binding;
-    const { mousedown = false, mouseup = false } = modifiers || {};
-    el[nameSpace] = {
-      id,
-      documentHandler: createDocumentHandler(el, binding, vnode),
-      methodName: expression,
-      bindingFn: value,
-      mousedownTrigger: mousedown,
-      mouseupTrigger: mouseup
-    };
-  },
-  update: (el, binding, vnode) => {
-    const { modifiers, expression, value } = binding;
-    const { mousedown = false, mouseup = false } = modifiers || {};
-    el[nameSpace].documentHandler = createDocumentHandler(el, binding, vnode);
-    el[nameSpace].methodName = expression;
-    el[nameSpace].bindingFn = value;
-    el[nameSpace].mousedownTrigger = mousedown;
-    el[nameSpace].mouseupTrigger = mouseup;
-  },
-  unbind: (el) => {
-    if (el.nodeType !== Node.ELEMENT_NODE) {
-      return;
-    }
-    let len = nodeList.length;
-    for (let i = 0; i < len; i++) {
-      if (nodeList[i][nameSpace].id === el[nameSpace].id) {
-        nodeList.splice(i, 1);
-        break;
-      }
-    }
-    if (nodeList.length === 0 && startClick) {
-      startClick = null;
-    }
-    delete el[nameSpace];
-  }
-};
-export {
-  clickoutside_default as default
-};