@opentiny/vue-renderless 3.1.0-alpha.0

package/common/deps/ResizeObserver.js

@@ -0,0 +1,474 @@
+import { on, off } from '@opentiny/vue-renderless/common/deps/dom';
+var MapShim = function () {
+  if (typeof Map !== 'undefined') {
+    return Map;
+  }
+  var getIndex = function getIndex(arr, key) {
+    var result = -1;
+    arr.some(function (entry, index) {
+      if (entry[0] === key) {
+        result = index;
+        return true;
+      }
+      return false;
+    });
+    return result;
+  };
+  return function () {
+    function obClass() {
+      this.__entries__ = [];
+    }
+    Object.defineProperty(obClass.prototype, 'size', {
+      get: function get() {
+        return this.__entries__.length;
+      },
+      enumerable: true,
+      configurable: true
+    });
+    obClass.prototype.get = function (key) {
+      var index = getIndex(this.__entries__, key);
+      var entry = this.__entries__[index];
+      return entry && entry[1];
+    };
+    obClass.prototype.set = function (key, value) {
+      var index = getIndex(this.__entries__, key);
+      if (~index) {
+        this.__entries__[index][1] = value;
+      } else {
+        this.__entries__.push([key, value]);
+      }
+    };
+    obClass.prototype["delete"] = function (key) {
+      var entries = this.__entries__;
+      var index = getIndex(entries, key);
+      if (~index) {
+        entries.splice(index, 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 (var _i = 0, _a = this.__entries__; _i < _a.length; _i++) {
+        var entry = _a[_i];
+        callback.call(ctx, entry[1], entry[0]);
+      }
+    };
+    return obClass;
+  }();
+}();
+var func = window.Function;
+var isBrowser = window !== 'undefined' && document !== 'undefined' && window.document === document;
+var global$1 = function () {
+  var isMath = function isMath(val) {
+    return 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')();
+}();
+var requestAnimationFrame$1 = function () {
+  if (typeof requestAnimationFrame === 'function') {
+    return requestAnimationFrame.bind(global$1);
+  }
+  return function (callback) {
+    return setTimeout(function () {
+      return callback(Date.now());
+    }, 1000 / 60);
+  };
+}();
+var trailingTimeout = 2;
+function throttle(callback, delayTime) {
+  var leading = false;
+  var trailing = false;
+  var lastCallTime = 0;
+  var proxy;
+  var resolvePending = function resolvePending() {
+    if (leading) {
+      leading = false;
+      callback();
+    }
+    trailing && proxy();
+  };
+  var timeoutCallback = function timeoutCallback() {
+    requestAnimationFrame$1(resolvePending);
+  };
+  proxy = function proxy() {
+    var timeStamps = Date.now();
+    if (leading) {
+      if (timeStamps - lastCallTime < trailingTimeout) {
+        return;
+      }
+      trailing = true;
+    } else {
+      leading = true;
+      trailing = false;
+      setTimeout(timeoutCallback, delayTime);
+    }
+    lastCallTime = timeStamps;
+  };
+  return proxy;
+}
+var REFRESH_DELAY = 20;
+var transitionKeys = ['top', 'right', 'bottom', 'left', 'width', 'height', 'size', 'weight'];
+var mutationObserverSupported = typeof MutationObserver !== 'undefined';
+var ResizeObserverController = function () {
+  function ResizeObserverController() {
+    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);
+  }
+  ResizeObserverController.prototype.addObserver = function (observer) {
+    !~this.observers_.indexOf(observer) && this.observers_.push(observer);
+    !this.connected_ && this.connect_();
+  };
+  ResizeObserverController.prototype.removeObserver = function (observer) {
+    var observers = this.observers_;
+    var index = observers.indexOf(observer);
+    ~index && observers.splice(index, 1);
+    if (!observers.length && this.connected_) {
+      this.disconnect_();
+    }
+  };
+  ResizeObserverController.prototype.refresh = function () {
+    var changesDetected = this.updateObservers_();
+    changesDetected && this.refresh();
+  };
+  ResizeObserverController.prototype.updateObservers_ = function () {
+    var activeObservers = this.observers_.filter(function (observer) {
+      observer.gatherActive();
+      return observer.hasActive();
+    });
+    activeObservers.forEach(function (observer) {
+      return observer.broadcastActive();
+    });
+    return activeObservers.length > 0;
+  };
+  ResizeObserverController.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);
+      var 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;
+  };
+  ResizeObserverController.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;
+  };
+  ResizeObserverController.prototype.onTransitionEnd_ = function (_a) {
+    var _b = _a.propertyName;
+    var propertyName = _b === void 0 ? '' : _b;
+    var isReflowProperty = transitionKeys.some(function (key) {
+      return !!~propertyName.indexOf(key);
+    });
+    isReflowProperty && this.refresh();
+  };
+  ResizeObserverController.getInstance = function () {
+    if (!this._instance) {
+      this._instance = new ResizeObserverController();
+    }
+    return this._instance;
+  };
+  ResizeObserverController._instance = null;
+  return ResizeObserverController;
+}();
+var defineConfigurable = function defineConfigurable(target, props) {
+  for (var i = 0, a = Object.keys(props); i < a.length; i++) {
+    var key = a[i];
+    Object.defineProperty(target, key, {
+      value: props[key],
+      configurable: true,
+      writable: false,
+      enumerable: false
+    });
+  }
+  return target;
+};
+var createRectInit = function createRectInit(x, y, width, height) {
+  return {
+    x: x,
+    y: y,
+    width: width,
+    height: height
+  };
+};
+var getWindowOf = function getWindowOf(target) {
+  var ownerGlobal = target && target.ownerDocument && target.ownerDocument.defaultView;
+  return ownerGlobal || global$1;
+};
+var emptyRect = createRectInit(0, 0, 0, 0);
+var toFloat = function toFloat(value) {
+  return parseFloat(value) || 0;
+};
+var getBordersSize = function getBordersSize(styles) {
+  var positions = [];
+  for (var i = 1; i < arguments.length; i++) {
+    positions[i - 1] = arguments[i];
+  }
+  return positions.reduce(function (size, position) {
+    var value = styles["border-".concat(position, "-width")];
+    return size + toFloat(value);
+  }, 0);
+};
+var getPaddings = function getPaddings(styles) {
+  var positions = ['top', 'right', 'bottom', 'left'];
+  var paddings = {};
+  for (var i = 0, pos = positions; i < pos.length; i++) {
+    var position = pos[i];
+    var value = styles["padding-".concat(position)];
+    paddings[position] = toFloat(value);
+  }
+  return paddings;
+};
+var getSVGContentRect = function getSVGContentRect(target) {
+  var bbox = target.getBBox();
+  return createRectInit(0, 0, bbox.width, bbox.height);
+};
+var isDocumentElement = function isDocumentElement(target) {
+  return target === getWindowOf(target).document.documentElement;
+};
+var getHTMLElementContentRect = function getHTMLElementContentRect(target) {
+  var clientWidth = target.clientWidth;
+  var clientHeight = target.clientHeight;
+  if (!clientHeight && !clientWidth) {
+    return emptyRect;
+  }
+  var styles = getWindowOf(target).getComputedStyle(target);
+  var paddings = getPaddings(styles);
+  var vertPad = paddings.top + paddings.bottom;
+  var horizPad = paddings.left + paddings.right;
+  var width = toFloat(styles.width);
+  var 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)) {
+    var horizScrollbar = Math.round(height + vertPad) - clientHeight;
+    var 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);
+};
+var isSVGGraphicsElement = function () {
+  if (typeof SVGGraphicsElement !== 'undefined') {
+    return function (target) {
+      return target instanceof getWindowOf(target).SVGGraphicsElement;
+    };
+  }
+  return function (target) {
+    return target instanceof getWindowOf(target).SVGElement && typeof target.getBBox === 'function';
+  };
+}();
+var getContentRect = function getContentRect(target) {
+  if (!isBrowser) {
+    return emptyRect;
+  }
+  if (isSVGGraphicsElement(target)) {
+    return getSVGContentRect(target);
+  }
+  return getHTMLElementContentRect(target);
+};
+var createReadOnlyRect = function createReadOnlyRect(_a) {
+  var x = _a.x;
+  var y = _a.y;
+  var width = _a.width;
+  var height = _a.height;
+  var Constr = typeof DOMRectReadOnly !== 'undefined' ? DOMRectReadOnly : Object;
+  var rect = Object.create(Constr.prototype);
+  defineConfigurable(rect, {
+    x: x,
+    y: y,
+    width: width,
+    height: height,
+    top: y,
+    right: x + width,
+    bottom: height + y,
+    left: x
+  });
+  return rect;
+};
+var ResizeObservation = function () {
+  function ResizeObservation(target) {
+    this.broadcastWidth = 0;
+    this.broadcastHeight = 0;
+    this.contentRect_ = createRectInit(0, 0, 0, 0);
+    this.target = target;
+  }
+  ResizeObservation.prototype.broadcastRect = function () {
+    var rect = this.contentRect_;
+    this.broadcastWidth = rect.width;
+    this.broadcastHeight = rect.height;
+    return rect;
+  };
+  ResizeObservation.prototype.isActive = function () {
+    var rect = getContentRect(this.target);
+    this.contentRect_ = rect;
+    return rect.width !== this.broadcastWidth || rect.height !== this.broadcastHeight;
+  };
+  return ResizeObservation;
+}();
+var ResizeObserverEntry = function () {
+  function ResizeObserverEntry(target, rectInit) {
+    var contentRect = createReadOnlyRect(rectInit);
+    defineConfigurable(this, {
+      target: target,
+      contentRect: contentRect
+    });
+  }
+  return ResizeObserverEntry;
+}();
+var ResizeObserverSPI = function () {
+  function ResizeObserverSPI(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;
+  }
+  ResizeObserverSPI.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".');
+    }
+    var obserVations = this.observations_;
+    if (obserVations.has(target)) {
+      return;
+    }
+    obserVations.set(target, new ResizeObservation(target));
+    this.controller_.addObserver(this);
+    this.controller_.refresh();
+  };
+  ResizeObserverSPI.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".');
+    }
+    var obserVations = this.observations_;
+    if (!obserVations.has(target)) {
+      return;
+    }
+    obserVations["delete"](target);
+    !obserVations.size && this.controller_.removeObserver(this);
+  };
+  ResizeObserverSPI.prototype.gatherActive = function () {
+    var me = this;
+    this.clearActive();
+    this.observations_.forEach(function (observation) {
+      observation.isActive() && me.activeObservations_.push(observation);
+    });
+  };
+  ResizeObserverSPI.prototype.disconnect = function () {
+    this.clearActive();
+    this.observations_.clear();
+    this.controller_.removeObserver(this);
+  };
+  ResizeObserverSPI.prototype.broadcastActive = function () {
+    if (!this.hasActive()) {
+      return;
+    }
+    var ctx = this.callbackCtx_;
+    var entries = this.activeObservations_.map(function (observation) {
+      return new ResizeObserverEntry(observation.target, observation.broadcastRect());
+    });
+    this.callback_.call(ctx, entries, ctx);
+    this.clearActive();
+  };
+  ResizeObserverSPI.prototype.hasActive = function () {
+    return this.activeObservations_.length > 0;
+  };
+  ResizeObserverSPI.prototype.clearActive = function () {
+    this.activeObservations_.splice(0);
+  };
+  return ResizeObserverSPI;
+}();
+var observers = typeof WeakMap !== 'undefined' ? new WeakMap() : new MapShim();
+var ResizeObserver = function () {
+  function ResizeObserver(callback) {
+    if (!(this instanceof ResizeObserver)) {
+      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.');
+    }
+    var controller = ResizeObserverController.getInstance();
+    var observer = new ResizeObserverSPI(callback, controller, this);
+    observers.set(this, observer);
+  }
+  return ResizeObserver;
+}();
+['observe', 'unobserve', 'disconnect'].forEach(function (method) {
+  ResizeObserver.prototype[method] = function () {
+    var _a;
+    return (_a = observers.get(this))[method].apply(_a, arguments);
+  };
+});
+var index = function () {
+  if (typeof global$1.ResizeObserver !== 'undefined') {
+    return global$1.ResizeObserver;
+  }
+  return ResizeObserver;
+}();
+export default index;

package/common/deps/after-leave.js

@@ -0,0 +1,25 @@
+var AfterLave = 'after-leave';
+var Speed = 300;
+export default (function (instance, callback) {
+  var speed = arguments.length > 2 && arguments[2] !== undefined ? arguments[2] : Speed;
+  var once = arguments.length > 3 && arguments[3] !== undefined ? arguments[3] : false;
+  if (!instance || !callback) {
+    throw new Error('instance & callback is required');
+  }
+  var called = false;
+  var eventCallback = function eventCallback() {
+    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);
+});

package/common/deps/clickoutside.js

@@ -0,0 +1,61 @@
+import { on } from '@opentiny/vue-renderless/common/deps/dom';
+var isServer = typeof window === 'undefined';
+var nodeList = [];
+var nameSpace = '@@clickoutsideContext';
+var startClick;
+var seed = 0;
+if (!isServer) {
+  on(document, 'mousedown', function (event) {
+    return startClick = event;
+  });
+  on(document, 'mouseup', function (event) {
+    nodeList.forEach(function (node) {
+      return node[nameSpace].documentHandler(event, startClick);
+    });
+  });
+}
+var createDocumentHandler = function createDocumentHandler(el, binding, vnode) {
+  return function () {
+    var mouseup = arguments.length > 0 && arguments[0] !== undefined ? arguments[0] : {};
+    var mousedown = arguments.length > 1 && arguments[1] !== undefined ? arguments[1] : {};
+    var popperElm = vnode.context.popperElm || vnode.context.state.popperElm;
+    if (!mouseup.target || !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();
+    }
+  };
+};
+export default {
+  bind: function bind(el, binding, vnode) {
+    nodeList.push(el);
+    var id = seed++;
+    el[nameSpace] = {
+      id: id,
+      documentHandler: createDocumentHandler(el, binding, vnode),
+      methodName: binding.expression,
+      bindingFn: binding.value
+    };
+  },
+  update: function update(el, binding, vnode) {
+    el[nameSpace].documentHandler = createDocumentHandler(el, binding, vnode);
+    el[nameSpace].methodName = binding.expression;
+    el[nameSpace].bindingFn = binding.value;
+  },
+  unbind: function unbind(el) {
+    if (el.nodeType !== Node.ELEMENT_NODE) {
+      return;
+    }
+    var len = nodeList.length;
+    for (var i = 0; i < len; i++) {
+      if (nodeList[i][nameSpace].id === el[nameSpace].id) {
+        nodeList.splice(i, 1);
+        break;
+      }
+    }
+    delete el[nameSpace];
+  }
+};