@opentinyvue/vue-renderless 3.21.0

package/common/deps/dom.js

@@ -0,0 +1,217 @@
+import "../../chunk-G2ADBYYC.js";
+import { hasOwn, isNull } from "../type";
+import globalConfig from "../global";
+const isServer = typeof window === "undefined";
+const SPECIAL_CHARS_REGEXP = /([:\-_]+(.))/g;
+const MOZ_HACK_REGEXP = /^moz([A-Z])/;
+const camelCase = (name) => name.replace(SPECIAL_CHARS_REGEXP, (_, separator, letter, offset) => offset ? letter.toUpperCase() : letter).replace(MOZ_HACK_REGEXP, "Moz$1");
+const on = (el, event, handler, options = false) => {
+  if (el && event && handler) {
+    el.addEventListener(event, handler, options);
+  }
+};
+const off = (el, event, handler, options = false) => {
+  if (el && event) {
+    el.removeEventListener(event, handler, options);
+  }
+};
+const once = (el, event, fn) => {
+  const listener = function() {
+    if (fn) {
+      fn.apply(this, arguments);
+    }
+    off(el, event, listener);
+  };
+  on(el, event, listener);
+};
+const hasClass = (el, clazz) => {
+  if (!el || !clazz) {
+    return false;
+  }
+  if (clazz.includes(" ")) {
+    throw new Error("className should not contain space.");
+  }
+  if (el.classList) {
+    return el.classList.contains(clazz);
+  }
+};
+const addClass = (el, clazz = "") => {
+  if (!el) {
+    return;
+  }
+  const classes = clazz.split(" ").filter((name) => name);
+  classes.forEach((clsName) => el.classList.add(clsName));
+};
+const removeClass = (el, clazz) => {
+  if (!el || !clazz) {
+    return;
+  }
+  const classes = clazz.split(" ").filter((name) => name);
+  classes.forEach((clsName) => el.classList.remove(clsName));
+};
+const getStyle = (el, styleName) => {
+  if (isServer) {
+    return;
+  }
+  if (!el || !styleName) {
+    return null;
+  }
+  styleName = camelCase(styleName);
+  if (styleName === "float") {
+    styleName = "cssFloat";
+  }
+  try {
+    if (el.style[styleName]) {
+      return el.style[styleName];
+    }
+    const computed = window.getComputedStyle(el);
+    return computed ? computed[styleName] : null;
+  } catch (e) {
+    return el.style[styleName];
+  }
+};
+const setStyle = (el, name, value) => {
+  if (!el || !name) {
+    return;
+  }
+  if (typeof name === "object") {
+    for (const prop in name) {
+      if (hasOwn.call(name, prop)) {
+        setStyle(el, prop, name[prop]);
+      }
+    }
+  } else {
+    name = camelCase(name);
+    el.style[name] = value;
+  }
+};
+const isScroll = (el, vertical) => {
+  if (isServer) {
+    return;
+  }
+  const determinedDirection = !isNull(vertical);
+  let overflow;
+  if (determinedDirection) {
+    overflow = vertical ? getStyle(el, "overflow-y") : getStyle(el, "overflow-x");
+  } else {
+    overflow = getStyle(el, "overflow");
+  }
+  return overflow.match(/(scroll|auto)/);
+};
+const getScrollContainer = (el, vertical) => {
+  if (isServer) {
+    return;
+  }
+  let parent = el;
+  while (parent) {
+    if (~[window, document, document.documentElement].indexOf(parent)) {
+      return window;
+    }
+    if (isScroll(parent, vertical)) {
+      return parent;
+    }
+    parent = parent.parentNode;
+  }
+  return parent;
+};
+const isInContainer = (el, container) => {
+  if (isServer || !el || !container) {
+    return false;
+  }
+  const elRect = el.getBoundingClientRect();
+  let containerRect;
+  if (~[window, document, document.documentElement].indexOf(container) || isNull(container)) {
+    containerRect = {
+      top: 0,
+      right: window.innerWidth,
+      bottom: window.innerHeight,
+      left: 0
+    };
+  } else {
+    containerRect = container.getBoundingClientRect();
+  }
+  return elRect.top < containerRect.bottom && elRect.bottom > containerRect.top && elRect.right > containerRect.left && elRect.left < containerRect.right;
+};
+const getDomNode = () => {
+  const viewportWindow = globalConfig.viewportWindow || window;
+  let documentElement = viewportWindow.document.documentElement;
+  let bodyElem = viewportWindow.document.body;
+  return {
+    scrollTop: documentElement.scrollTop || bodyElem.scrollTop,
+    scrollLeft: documentElement.scrollLeft || bodyElem.scrollLeft,
+    visibleHeight: documentElement.clientHeight || bodyElem.clientHeight,
+    visibleWidth: documentElement.clientWidth || bodyElem.clientWidth
+  };
+};
+const getScrollTop = (el) => {
+  const top = "scrollTop" in el ? el.scrollTop : el.pageYOffset;
+  return Math.max(top, 0);
+};
+const stopPropagation = (event) => event.stopPropagation();
+const preventDefault = (event, isStopPropagation) => {
+  if (typeof event.cancelable !== "boolean" || event.cancelable) {
+    event.preventDefault();
+  }
+  if (isStopPropagation) {
+    stopPropagation(event);
+  }
+};
+const overflowScrollReg = /scroll|auto|overlay/i;
+const defaultRoot = isServer ? void 0 : window;
+const isElement = (node) => node.tagName !== "HTML" && node.tagName !== "BODY" && node.nodeType === 1;
+const getScrollParent = (el, root = defaultRoot) => {
+  let node = el;
+  while (node && node !== root && isElement(node)) {
+    const { overflowY } = window.getComputedStyle(node);
+    if (overflowScrollReg.test(overflowY)) {
+      return node;
+    }
+    node = node.parentNode;
+  }
+  return root;
+};
+const useScrollParent = ({ onMounted, ref, watch }) => (elRef, root = defaultRoot) => {
+  const scrollParent = ref();
+  const setScrollParent = () => scrollParent.value = getScrollParent(elRef.value, root);
+  watch(elRef, setScrollParent);
+  onMounted(() => elRef.value && setScrollParent());
+  return scrollParent;
+};
+const isDisplayNone = (elm) => {
+  if (isServer)
+    return false;
+  if (elm) {
+    const computedStyle = getComputedStyle(elm);
+    if (computedStyle.getPropertyValue("position") === "fixed") {
+      if (computedStyle.getPropertyValue("display") === "none") {
+        return true;
+      } else if (elm.parentNode !== document.body) {
+        return isDisplayNone(elm.parentNode);
+      }
+    } else {
+      return elm.offsetParent === null;
+    }
+  }
+  return false;
+};
+export {
+  addClass,
+  getDomNode,
+  getScrollContainer,
+  getScrollParent,
+  getScrollTop,
+  getStyle,
+  hasClass,
+  isDisplayNone,
+  isInContainer,
+  isScroll,
+  isServer,
+  off,
+  on,
+  once,
+  preventDefault,
+  removeClass,
+  setStyle,
+  stopPropagation,
+  useScrollParent
+};

package/common/deps/eSpaceCtrl.js

@@ -0,0 +1,304 @@
+import "../../chunk-G2ADBYYC.js";
+import { isBrowser } from "../browser";
+let ws = null;
+const url = "ws://localhost";
+const ports = [27197, 27198, 27199];
+let index = 0;
+let connected;
+let pollingInterval = 1e3;
+let timeout = 3e4;
+let cid = 0;
+let callbacks = {};
+let pollingTimer;
+let userStatus = {};
+const heartbeatInterval = 20 * 1e3;
+let heartbeatTimer = null;
+let connectTimer = null;
+let apiTimers = {};
+let events = {};
+let out = {};
+let error = () => void 0;
+let ready = () => void 0;
+const clearCallback = function(cid2) {
+  clearTimeout(apiTimers[cid2]);
+  delete callbacks[cid2];
+  delete apiTimers[cid2];
+};
+const onopen = function() {
+  connectTimer = setTimeout(() => {
+    ws.close();
+  }, 5e3);
+};
+const send = function(argv, cb) {
+  let id = cid++;
+  id = String(id);
+  argv.cid = id;
+  if (!connected) {
+    cb && setTimeout(cb, 0, { ok: false, message: "eSpace is not logged in." });
+    return;
+  }
+  if (typeof cb === "function") {
+    callbacks[id] = cb;
+    apiTimers[id] = setTimeout(() => {
+      cb({ ok: false, message: "time out" });
+      clearCallback(id);
+    }, timeout);
+  }
+  ws.send(JSON.stringify(argv));
+};
+const sendHeartbeat = function() {
+  heartbeatTimer = setTimeout(() => {
+    if (connected) {
+      send(
+        {
+          type: "heartbeat"
+        },
+        () => {
+          sendHeartbeat();
+        }
+      );
+    } else {
+      clearTimeout(heartbeatTimer);
+    }
+  }, heartbeatInterval);
+};
+const connectionSucceeded = function(data) {
+  connected = true;
+  sendHeartbeat();
+  clearTimeout(pollingTimer);
+  clearTimeout(connectTimer);
+  ready(data);
+};
+const onmessage = function(evt) {
+  let data = evt.data;
+  if (typeof data !== "string") {
+    return;
+  }
+  data = data.replace(/^\d+/, "");
+  if (!data) {
+    return;
+  }
+  try {
+    data = JSON.parse(data);
+  } catch (e) {
+    return !e;
+  }
+  if (connected) {
+    let event = events[data.type];
+    if (event) {
+      return event(data.data);
+    }
+    let cid2 = data.cid;
+    let cb = callbacks[cid2];
+    if (cb) {
+      if (data.ok) {
+        cb(null, data.data);
+      } else {
+        cb({ ok: data.ok });
+      }
+      clearCallback(cid2);
+    }
+  } else {
+    if (data.type === "eSpace-ctrl-connection-success") {
+      connectionSucceeded(data.data);
+    } else {
+      ws.close();
+    }
+  }
+};
+const bindEvents = function() {
+  ws.onopen = onopen;
+  ws.onclose = onclose;
+  ws.onmessage = onmessage;
+};
+const connect = function(interval) {
+  pollingTimer = setTimeout(() => {
+    if (index >= ports.length) {
+      index = 0;
+    }
+    ws = new WebSocket(url + ":" + ports[index++]);
+    bindEvents();
+  }, interval || 0);
+};
+const onclose = function() {
+  if (connected || typeof connected === "undefined") {
+    connected = false;
+    error();
+  }
+  connect(pollingInterval);
+};
+out.init = function(conf) {
+  if (conf) {
+    timeout = conf.timeout || 3e4;
+    pollingInterval = conf.pollingInterval || 0;
+  }
+  connect();
+};
+out.ready = function(cb) {
+  ready = cb;
+};
+out.error = function(cb) {
+  error = cb;
+};
+const attrToArr = function(name, total, object) {
+  let result = [];
+  for (let i = 0; i < total; i++) {
+    let attrName = name;
+    if (i) {
+      attrName += i;
+    }
+    let attrVal = object[attrName];
+    if (attrVal) {
+      result.push(attrVal);
+    }
+  }
+  return result;
+};
+out.on = function(event, hander) {
+  events[event] = hander;
+};
+out.getUserInfo = function(account, cb) {
+  const fn = function(err, data) {
+    if (err) {
+      return cb(err);
+    }
+    const formatInfo = function(user) {
+      return {
+        account: user.account,
+        name: user.name,
+        mobile: attrToArr("mobile", 6, user),
+        "office_phone": attrToArr("office_phone", 6, user),
+        "home_phone": user.home_phone,
+        "ip_phone": user.ip_phone,
+        "other_phone": user.other_phone
+      };
+    };
+    if (data.account) {
+      cb(null, formatInfo(data));
+    } else {
+      let result = {};
+      for (let p in data) {
+        if (Object.prototype.hasOwnProperty.call(data, p)) {
+          let user = data[p];
+          result[p] = user ? formatInfo(user) : user;
+        }
+      }
+      cb(null, result);
+    }
+  };
+  send(
+    {
+      type: "get-user-info",
+      param: account
+    },
+    fn
+  );
+};
+out.subscribeUserStatus = function(accounts, cb) {
+  if (Array.isArray(accounts)) {
+    accounts.forEach((account) => {
+      userStatus[account] = true;
+    });
+  }
+  send(
+    {
+      type: "subscribe-user-status",
+      param: accounts
+    },
+    cb
+  );
+};
+out.eSpaceCall = function(account, num, cb) {
+  send(
+    {
+      type: "espace-call",
+      param: {
+        account,
+        number: num
+      }
+    },
+    cb
+  );
+};
+out.eSpaceCallByAccount = function(account, cb) {
+  send(
+    {
+      type: "espace-call",
+      param: {
+        account
+      }
+    },
+    cb
+  );
+};
+out.eSpaceCallByNumber = function(number, cb) {
+  send(
+    {
+      type: "espace-call",
+      param: {
+        number
+      }
+    },
+    cb
+  );
+};
+out.showImDialog = function(account, cb) {
+  send(
+    {
+      type: "show-espace-im-dialog",
+      param: account
+    },
+    cb
+  );
+};
+out.showGroupDialog = function(gid, cb) {
+  send(
+    {
+      type: "show-espace-im-group-dialog",
+      param: gid
+    },
+    cb
+  );
+};
+out.addContactList = function(account, cb) {
+  send(
+    {
+      type: "add-contact-list",
+      param: account
+    },
+    cb
+  );
+};
+if (!isBrowser || !window.WebSocket) {
+  const notFn = function() {
+    return void 0;
+  };
+  for (let api in out) {
+    if (Object.prototype.hasOwnProperty.call(out, api)) {
+      let fn = out[api];
+      if (typeof fn === "function") {
+        out[api] = notFn;
+      }
+    }
+  }
+}
+let initialized = false;
+function init() {
+  if (!initialized && isBrowser) {
+    localStorage.setItem("eSpaceCtrl_initialized", 0);
+    out.init({ timeout: 3e3, pollingInterval: 1e3 });
+    out.ready(() => {
+      localStorage.setItem("eSpaceCtrl_initialized", 1);
+    });
+    out.error(() => {
+      localStorage.setItem("eSpaceCtrl_initialized", 0);
+    });
+    initialized = true;
+  }
+  return out;
+}
+var eSpaceCtrl_default = out;
+export {
+  eSpaceCtrl_default as default,
+  init
+};

package/common/deps/fastdom/async.js

@@ -0,0 +1,41 @@
+import "../../../chunk-G2ADBYYC.js";
+import fastdomSingleton from "./singleton";
+const create = (promised, type, fn, ctx) => {
+  const tasks = promised._tasks;
+  const fastdom = promised.fastdom;
+  let task;
+  const promise = new Promise(function(resolve, reject) {
+    task = fastdom[type](function() {
+      tasks.delete(promise);
+      try {
+        resolve(ctx ? fn.call(ctx) : fn());
+      } catch (e) {
+        reject(e);
+      }
+    }, ctx);
+  });
+  tasks.set(promise, task);
+  return promise;
+};
+const exports = {
+  initialize() {
+    this._tasks = /* @__PURE__ */ new Map();
+  },
+  mutate(fn, ctx) {
+    return create(this, "mutate", fn, ctx);
+  },
+  measure(fn, ctx) {
+    return create(this, "measure", fn, ctx);
+  },
+  clear(promise) {
+    const tasks = this._tasks;
+    const task = tasks.get(promise);
+    this.fastdom.clear(task);
+    tasks.delete(promise);
+  }
+};
+const fastdomAsync = fastdomSingleton.extend(exports);
+var async_default = fastdomAsync;
+export {
+  async_default as default
+};

package/common/deps/fastdom/index.js

@@ -0,0 +1,9 @@
+import "../../../chunk-G2ADBYYC.js";
+import fastdom from "./singleton";
+import fastdomAsync from "./async";
+import fastdomSandbox from "./sandbox";
+export {
+  fastdom,
+  fastdomAsync,
+  fastdomSandbox
+};

package/common/deps/fastdom/sandbox.js

@@ -0,0 +1,53 @@
+import "../../../chunk-G2ADBYYC.js";
+import fastdomSingleton from "./singleton";
+const clearAll = (fastdom, tasks) => {
+  let i = tasks.length;
+  while (i--) {
+    fastdom.clear(tasks[i]);
+    tasks.splice(i, 1);
+  }
+};
+const remove = (array, item) => {
+  const index = array.indexOf(item);
+  return !!~index && !!array.splice(index, 1);
+};
+class Sandbox {
+  constructor(fastdom) {
+    this.fastdom = fastdom;
+    this.tasks = [];
+  }
+  measure(fn, ctx) {
+    const tasks = this.tasks;
+    const task = this.fastdom.measure(function() {
+      tasks.splice(tasks.indexOf(task));
+      return fn.call(ctx);
+    });
+    tasks.push(task);
+    return task;
+  }
+  mutate(fn, ctx) {
+    const tasks = this.tasks;
+    const task = this.fastdom.mutate(function() {
+      tasks.splice(tasks.indexOf(task));
+      return fn.call(ctx);
+    });
+    this.tasks.push(task);
+    return task;
+  }
+  clear(task) {
+    if (!arguments.length)
+      clearAll(this.fastdom, this.tasks);
+    remove(this.tasks, task);
+    return this.fastdom.clear(task);
+  }
+}
+const exports = {
+  sandbox() {
+    return new Sandbox(this.fastdom);
+  }
+};
+const fastdomSandbox = fastdomSingleton.extend(exports);
+var sandbox_default = fastdomSandbox;
+export {
+  sandbox_default as default
+};

package/common/deps/fastdom/singleton.js

@@ -0,0 +1,88 @@
+import "../../../chunk-G2ADBYYC.js";
+import { isBrowser } from "../../browser";
+const RAF = function() {
+  if (isBrowser) {
+    return window.requestAnimationFrame.bind(window);
+  }
+  return function(callback) {
+    setTimeout(() => callback(Date.now()), 1e3 / 60);
+  };
+}();
+const scheduleFlush = (fastdom) => {
+  if (!fastdom.scheduled) {
+    fastdom.scheduled = true;
+    fastdom.raf(flush.bind(null, fastdom));
+  }
+};
+const flush = (fastdom) => {
+  const { reads, writes } = fastdom;
+  let error;
+  try {
+    fastdom.runTasks(reads);
+    fastdom.runTasks(writes);
+  } catch (e) {
+    error = e;
+  }
+  fastdom.scheduled = false;
+  if (reads.length || writes.length)
+    scheduleFlush(fastdom);
+  if (error) {
+    if (fastdom.catch) {
+      fastdom.catch(error);
+    } else {
+      throw error;
+    }
+  }
+};
+const remove = (array, item) => {
+  const index = array.indexOf(item);
+  return !!~index && !!array.splice(index, 1);
+};
+const mixin = (target, source) => {
+  for (let key in source) {
+    if (Object.hasOwnProperty.call(source, key))
+      target[key] = source[key];
+  }
+};
+class FastDom {
+  constructor() {
+    this.reads = [];
+    this.writes = [];
+    this.raf = RAF.bind(window);
+  }
+  runTasks(tasks) {
+    let task;
+    while (task = tasks.shift())
+      task();
+  }
+  measure(fn, ctx) {
+    const task = !ctx ? fn : fn.bind(ctx);
+    this.reads.push(task);
+    scheduleFlush(this);
+    return task;
+  }
+  mutate(fn, ctx) {
+    const task = !ctx ? fn : fn.bind(ctx);
+    this.writes.push(task);
+    scheduleFlush(this);
+    return task;
+  }
+  clear(task) {
+    return remove(this.reads, task) || remove(this.writes, task);
+  }
+  extend(props) {
+    if (!props || typeof props !== "object")
+      throw new Error("[TINY][FastDom] expected object");
+    const child = Object.create(this);
+    mixin(child, props);
+    child.fastdom = this;
+    if (child.initialize)
+      child.initialize();
+    return child;
+  }
+}
+const fastdomSingleton = new FastDom();
+var singleton_default = fastdomSingleton;
+export {
+  singleton_default as default
+};