@opentiny/vue-renderless 3.21.2 → 3.22.0

package/common/deps/fullscreen/screenfull.js

@@ -1,165 +0,0 @@
-import "../../../chunk-G2ADBYYC.js";
-import { on, off } from "../dom";
-import { isBrowser } from "../../browser";
-const fullscreenApi = [
-  "fullscreenElement",
-  "fullscreenEnabled",
-  "requestFullscreen",
-  "exitFullscreen",
-  "fullscreenchange",
-  "fullscreenerror"
-];
-const fullscreenApiMoz = [
-  "mozFullScreenElement",
-  "mozFullScreenEnabled",
-  "mozRequestFullScreen",
-  "mozCancelFullScreen",
-  "mozfullscreenchange",
-  "mozfullscreenerror"
-];
-const fullscreenApiWebkit = [
-  "webkitFullscreenElement",
-  "webkitFullscreenEnabled",
-  "webkitRequestFullscreen",
-  "webkitExitFullscreen",
-  "webkitfullscreenchange",
-  "webkitfullscreenerror"
-];
-const fullscreenApiMs = [
-  "msFullscreenElement",
-  "msFullscreenEnabled",
-  "msRequestFullscreen",
-  "msExitFullscreen",
-  "MSFullscreenChange",
-  "MSFullscreenError"
-];
-const fullscreenApiMap = [fullscreenApi, fullscreenApiWebkit, fullscreenApiMoz, fullscreenApiMs];
-const document = typeof window !== "undefined" && typeof window.document !== "undefined" ? window.document : {};
-let fullscreenEvents = null;
-const getFullScreenEvents = () => {
-  if (!isBrowser)
-    return;
-  for (let i = 0, len = fullscreenApiMap.length; i < len; i++) {
-    let eventName = fullscreenApiMap[i];
-    if (eventName && eventName[1] in document) {
-      fullscreenEvents = {};
-      for (i = 0; i < eventName.length; i++) {
-        fullscreenEvents[fullscreenApiMap[0][i]] = eventName[i];
-      }
-      return;
-    }
-  }
-};
-getFullScreenEvents();
-const eventNameMap = {
-  change: fullscreenEvents && fullscreenEvents.fullscreenchange,
-  error: fullscreenEvents && fullscreenEvents.fullscreenerror
-};
-const screenfull = {
-  request(element, options) {
-    return new Promise((resolve, reject) => {
-      const onFullscreenEntered = () => {
-        this.off("change", onFullscreenEntered);
-        resolve();
-      };
-      this.on("change", onFullscreenEntered);
-      element = element || (isBrowser ? document.documentElement : null);
-      if (element && fullscreenEvents && element[fullscreenEvents.requestFullscreen]) {
-        const promiseReturn = element[fullscreenEvents.requestFullscreen](options);
-        if (promiseReturn instanceof Promise) {
-          promiseReturn.then(onFullscreenEntered).catch(reject);
-        }
-      } else {
-        reject(new Error("Fullscreen API not supported or element is null."));
-      }
-    });
-  },
-  exit() {
-    return new Promise((resolve, reject) => {
-      if (!this.isFullscreen) {
-        resolve();
-        return;
-      }
-      const onFullscreenExit = () => {
-        this.off("change", onFullscreenExit);
-        resolve();
-      };
-      this.on("change", onFullscreenExit);
-      if (isBrowser && fullscreenEvents && document[fullscreenEvents.exitFullscreen]) {
-        const promiseReturn = document[fullscreenEvents.exitFullscreen]();
-        if (promiseReturn instanceof Promise) {
-          promiseReturn.then(onFullscreenExit).catch(reject);
-        }
-      } else {
-        reject(new Error("Fullscreen API not supported."));
-      }
-    });
-  },
-  toggle(element, options) {
-    return this.isFullscreen ? this.exit() : this.request(element, options);
-  },
-  onchange(callback) {
-    this.on("change", callback);
-  },
-  onerror(callback) {
-    this.on("error", callback);
-  },
-  on(event, callback) {
-    const eventName = eventNameMap[event];
-    if (eventName && isBrowser) {
-      on(document, eventName, callback);
-    }
-  },
-  off(event, callback) {
-    const eventName = eventNameMap[event];
-    if (eventName && isBrowser) {
-      off(document, eventName, callback);
-    }
-  },
-  raw: fullscreenEvents || {}
-};
-if (isBrowser) {
-  Object.defineProperties(screenfull, {
-    isFullscreen: {
-      get() {
-        return !!document[fullscreenEvents && fullscreenEvents.fullscreenElement];
-      }
-    },
-    element: {
-      enumerable: true,
-      get() {
-        return document[fullscreenEvents && fullscreenEvents.fullscreenElement];
-      }
-    },
-    isEnabled: {
-      enumerable: true,
-      get() {
-        return !!document[fullscreenEvents && fullscreenEvents.fullscreenEnabled];
-      }
-    }
-  });
-} else {
-  Object.defineProperties(screenfull, {
-    isFullscreen: {
-      get() {
-        return false;
-      }
-    },
-    element: {
-      enumerable: true,
-      get() {
-        return null;
-      }
-    },
-    isEnabled: {
-      enumerable: true,
-      get() {
-        return false;
-      }
-    }
-  });
-}
-var screenfull_default = screenfull;
-export {
-  screenfull_default as default
-};

package/common/deps/memorize.js

@@ -1,124 +0,0 @@
-import "../../chunk-G2ADBYYC.js";
-class Memorize {
-  constructor(value, options = {}) {
-    if (value && typeof value === "object") {
-      options = value;
-    } else {
-      value = [];
-    }
-    if (typeof options.key !== "string" || !options.key) {
-      throw new Error("Memorize Initialization error.");
-    }
-    this._prefix = "tiny_memorize_";
-    this._customField1 = "frequency";
-    this._customField2 = "time";
-    this._sortBy = (options.sortBy || "frequency").toUpperCase();
-    this._sort = (options.sort || "desc").toUpperCase();
-    this._dataKey = options.dataKey || "value";
-    this._highlightClass = options.highlightClass || "memorize-highlight";
-    this._highlightNum = options.highlightNum || Infinity;
-    this._cacheNum = options.cacheNum || Infinity;
-    this._serialize = options.serialize || JSON.stringify;
-    this._deserialize = options.deserialize || JSON.parse;
-    this.setKey(options.key);
-    this.assemble(value);
-  }
-  setKey(storeKey) {
-    this._storeKey = this._prefix + (storeKey || Number(/* @__PURE__ */ new Date()));
-  }
-  getValue(isSort = true) {
-    const storeVlue = window.localStorage[this._storeKey] || "";
-    if (storeVlue) {
-      try {
-        const list = this._deserialize(storeVlue);
-        return isSort ? this.sort(list) : list;
-      } catch (e) {
-        return [];
-      }
-    }
-    return [];
-  }
-  setValue(value) {
-    try {
-      window.localStorage.setItem(this._storeKey, this._serialize(value));
-    } catch (e) {
-      throw new Error("Memorize set localStorage error.");
-    }
-  }
-  clear() {
-    window.localStorage.removeItem(this._storeKey);
-  }
-  add(dataKey) {
-    const list = this.getValue(false);
-    const newData = {
-      key: dataKey
-    };
-    newData[this._customField1] = 1;
-    newData[this._customField2] = Number(/* @__PURE__ */ new Date());
-    if (list.length < this._cacheNum) {
-      list.push(newData);
-      this.setValue(list);
-    }
-  }
-  updateByKey(dataKey) {
-    let isChanged = false;
-    const list = this.getValue(false);
-    list.some((item) => {
-      if (item.key === dataKey) {
-        item[this._customField1] = (item[this._customField1] || 0) + 1;
-        item[this._customField2] = Number(/* @__PURE__ */ new Date());
-        isChanged = true;
-        return true;
-      }
-      return false;
-    });
-    isChanged ? this.setValue(list) : this.add(dataKey);
-  }
-  sort(list) {
-    if (Array.isArray(list)) {
-      return list.sort((x, y) => {
-        const isDesc = this._sort === "DESC";
-        const compare = isDesc ? [-1, 1] : [1, -1];
-        const sortField = this._sortBy === "FREQUENCY" ? this._customField1 : this._customField2;
-        const xField = x[sortField];
-        const yField = y[sortField];
-        if (isNaN(xField)) {
-          return isDesc ? -1 : 1;
-        } else if (isNaN(yField)) {
-          return -1;
-        }
-        return xField > yField ? compare[0] : compare[1];
-      });
-    } else {
-      return list;
-    }
-  }
-  assemble(list) {
-    const storeValue = this.getValue(true);
-    if (!(Array.isArray(list) && list.length) || !storeValue.length) {
-      return list;
-    }
-    let matchCount = 0;
-    const handler = (storeItem) => (listItem, index) => {
-      if (listItem[this._dataKey] === storeItem.key) {
-        matchCount++;
-        list.splice(index, 1);
-        if (matchCount <= this._highlightNum) {
-          listItem._highlightClass = this._highlightClass;
-        }
-        list.unshift(listItem);
-        return true;
-      }
-      return false;
-    };
-    for (let i = storeValue.length - 1; i > -1; i--) {
-      const storeItem = storeValue[i];
-      list.some(handler(storeItem));
-    }
-    return list;
-  }
-}
-var memorize_default = Memorize;
-export {
-  memorize_default as default
-};

package/common/deps/observe-visibility.js

@@ -1,106 +0,0 @@
-import "../../chunk-G2ADBYYC.js";
-import throttle from "./throttle";
-import { isEqual } from "../object";
-const CONTEXT_KEY = "@@observevisibilityContext";
-const processOptions = (value) => {
-  let options;
-  if (typeof value === "function") {
-    options = { callback: value };
-  } else {
-    options = value;
-  }
-  return options;
-};
-const createObserver = ({ options, instance, state }) => {
-  if (state.observer) {
-    destroyObserver(state);
-  }
-  if (state.frozen)
-    return;
-  state.options = processOptions(options);
-  state.callback = (result, entry) => {
-    state.options.callback(result, entry);
-    if (result && state.options.once) {
-      state.frozen = true;
-      destroyObserver(state);
-    }
-  };
-  if (state.callback && state.options.throttle) {
-    state.callback = throttle(state.options.throttleDelay || 20, state.callback);
-  }
-  state.observer = new IntersectionObserver((entries) => {
-    let entry = entries[0];
-    if (entries.length > 1) {
-      const intersectingEntry = entries.find((e) => e.isIntersecting);
-      if (intersectingEntry) {
-        entry = intersectingEntry;
-      }
-    }
-    if (state.callback) {
-      state.callback(entry.isIntersecting, entry);
-    }
-  }, state.options.intersection);
-  instance.$nextTick(() => {
-    if (state.observer) {
-      state.observer.observe(state.el);
-    }
-  });
-};
-const destroyObserver = (state) => {
-  if (state.observer) {
-    state.observer.disconnect();
-    state.observer = null;
-  }
-  if (state.callback) {
-    state.callback = null;
-  }
-};
-const createVisibilityState = ({ el, options, instance }) => {
-  const state = { el, observer: null, frozen: false };
-  createObserver({ options, instance, state });
-  return state;
-};
-const bind = (el, { value, instance }, { context }) => {
-  if (!value)
-    return;
-  if (typeof IntersectionObserver === "undefined") {
-    throw new TypeError("[TINY Error][ObserveVisibility] IntersectionObserver API is not available in your browser");
-  } else {
-    instance = instance || context;
-    el[CONTEXT_KEY] = createVisibilityState({ el, options: value, instance });
-  }
-};
-const update = (el, { value, oldValue, instance }, { context }) => {
-  if (isEqual(value, oldValue))
-    return;
-  const state = el[CONTEXT_KEY];
-  if (!value) {
-    unbind(el);
-    return;
-  }
-  instance = instance || context;
-  if (state) {
-    createObserver({ options: value, instance, state });
-  } else {
-    bind(el, { value, instance }, { context });
-  }
-};
-const unbind = (el) => {
-  const state = el[CONTEXT_KEY];
-  if (state) {
-    destroyObserver(state);
-    delete el[CONTEXT_KEY];
-  }
-};
-const ObserveVisibility = {
-  bind,
-  update,
-  unbind,
-  beforeMount: bind,
-  updated: update,
-  unmounted: unbind
-};
-var observe_visibility_default = ObserveVisibility;
-export {
-  observe_visibility_default as default
-};