@opentiny/vue-renderless 3.21.1 → 3.22.0

package/common/deps/tree-model/tree-store.js

@@ -1,312 +0,0 @@
-import {
-  __spreadProps,
-  __spreadValues
-} from "../../../chunk-G2ADBYYC.js";
-import { hasOwn, isNull } from "../../type";
-import { getNodeKey } from "./util";
-import Node from "./node";
-class TreeStore {
-  constructor(options) {
-    this.currentNode = null;
-    this.currentNodeKey = null;
-    for (let option in options) {
-      if (hasOwn.call(options, option)) {
-        this[option] = options[option];
-      }
-    }
-    this.nodesMap = {};
-    this.root = new Node({ data: this.data, store: this });
-    if (this.lazy && this.load) {
-      this.load(this.root, (data) => {
-        this.root.doCreateChildren(data);
-        this._initDefaultCheckedNodes();
-        typeof this.afterLoad === "function" && this.afterLoad({ data, init: true });
-      });
-    } else {
-      this._initDefaultCheckedNodes();
-    }
-  }
-  getMappingData(data) {
-    const props = this.props || {};
-    const mapping = {};
-    for (let key in props) {
-      if (hasOwn.call(props, key)) {
-        mapping[key] = data[props[key]];
-      }
-    }
-    return __spreadValues(__spreadValues({}, data), mapping);
-  }
-  filter(value) {
-    const { lazy, filterNodeMethod, getMappingData } = this;
-    const walkTree = (node) => {
-      const childNodes = node.root ? node.root.childNodes : node.childNodes;
-      childNodes.forEach((child) => {
-        const mappingData = getMappingData.call(this, child.data);
-        child.visible = filterNodeMethod.call(child, value, mappingData, child);
-        walkTree(child);
-      });
-      if (!node.visible && childNodes.length) {
-        let allHidden = !childNodes.some(({ visible }) => visible);
-        if (node.root) {
-          node.root.visible = allHidden === false;
-        } else {
-          node.visible = allHidden === false;
-        }
-      }
-      if (!value) {
-        return;
-      }
-      if (node.visible && !node.isLeaf && !lazy) {
-        node.expand();
-      }
-    };
-    walkTree(this);
-  }
-  setData(newVal) {
-    if (newVal !== this.root.data) {
-      this.root.setData(newVal);
-      this._initDefaultCheckedNodes();
-    } else {
-      this.root.updateChildren();
-    }
-  }
-  getNode(data) {
-    if (data instanceof Node) {
-      return data;
-    }
-    const nodeKey = typeof data !== "object" ? data : getNodeKey(this.key, data);
-    return this.nodesMap[nodeKey] || null;
-  }
-  insertBefore(data, insertData) {
-    const refNode = this.getNode(insertData);
-    refNode.parent.insertBefore({ data }, refNode);
-  }
-  insertAfter(data, insertData) {
-    const refNode = this.getNode(insertData);
-    refNode.parent.insertAfter({ data }, refNode);
-  }
-  remove(data, isSaveChildNode, isNode) {
-    const treeNode = isNode ? data : this.getNode(data);
-    if (treeNode && treeNode.parent) {
-      if (treeNode === this.currentNode) {
-        this.currentNode = null;
-      }
-      if (isSaveChildNode && treeNode.childNodes) {
-        treeNode.childNodes.forEach((child) => {
-          treeNode.parent.insertChild({ data: child.data });
-        });
-      }
-      treeNode.parent.removeChild(treeNode);
-    }
-  }
-  append(data, parentData, index) {
-    const parentNode = parentData ? this.getNode(parentData) : this.root;
-    if (parentNode) {
-      const child = parentNode.insertChild({ data }, index);
-      data._isNewNode && this.registerNode(child);
-    }
-  }
-  setDefaultCheckedKey(newValue) {
-    if (newValue !== this.defaultCheckedKeys) {
-      this.defaultCheckedKeys = newValue;
-      this._initDefaultCheckedNodes();
-    }
-  }
-  _initDefaultCheckedNodes() {
-    const defaultCheckedKeys = this.defaultCheckedKeys || [];
-    const nodesMap = this.nodesMap;
-    defaultCheckedKeys.forEach((checkedKey) => {
-      const node = nodesMap[checkedKey];
-      node && node.setChecked(true, !this.checkStrictly);
-    });
-  }
-  _initDefaultCheckedNode(node) {
-    const defaultCheckedKeys = this.defaultCheckedKeys || [];
-    ~defaultCheckedKeys.indexOf(node.key) && node.setChecked(true, !this.checkStrictly);
-  }
-  getCheckedKeys(leafOnly = false) {
-    return this.getCheckedNodes(leafOnly).map((node) => (node || {})[this.key]);
-  }
-  getHalfCheckedKeys() {
-    return this.getHalfCheckedNodes().map((node) => (node || {})[this.key]);
-  }
-  deregisterNode(node) {
-    const key = this.key;
-    if (!key || !node || !node.data) {
-      return;
-    }
-    node.childNodes.forEach((child) => {
-      this.deregisterNode(child);
-    });
-    delete this.nodesMap[node.key];
-  }
-  registerNode(node) {
-    const key = this.key;
-    if (!key || !node || !node.data) {
-      return;
-    }
-    const nodeKey = node.key;
-    if (nodeKey !== void 0) {
-      this.nodesMap[nodeKey] = node;
-    }
-  }
-  getCheckedNodes(leafOnly = false, includeHalfChecked = false, isNode = false) {
-    const checkedNodes = [];
-    const walkTree = (node) => {
-      const childNodes = node.root ? node.root.childNodes : node.childNodes;
-      childNodes.forEach((child) => {
-        const { checked, indeterminate, isLeaf, data } = child;
-        if ((checked || includeHalfChecked && indeterminate) && (!leafOnly || leafOnly && isLeaf)) {
-          checkedNodes.push(isNode ? child : data);
-        }
-        walkTree(child);
-      });
-    };
-    walkTree(this);
-    return checkedNodes;
-  }
-  getHalfCheckedNodes() {
-    const nodes = [];
-    const walkTree = (node) => {
-      const childNodes = node.root ? node.root.childNodes : node.childNodes;
-      childNodes.forEach((child) => {
-        const { indeterminate, data } = child;
-        indeterminate && nodes.push(data);
-        walkTree(child);
-      });
-    };
-    walkTree(this);
-    return nodes;
-  }
-  _getAllNodes() {
-    const allNodes = [];
-    const nodesMap = this.nodesMap;
-    Object.keys(nodesMap).forEach((nodeKey) => {
-      hasOwn.call(nodesMap, nodeKey) && allNodes.push(nodesMap[nodeKey]);
-    });
-    return allNodes;
-  }
-  updateChildren(key, data) {
-    const node = this.nodesMap[key];
-    if (!node) {
-      return;
-    }
-    const childNodes = node.childNodes;
-    for (let i = childNodes.length - 1; i >= 0; i--) {
-      this.remove(childNodes[i].data);
-    }
-    for (let i = 0, len = data.length; i < len; i++) {
-      const child = data[i];
-      this.append(child, node.data);
-    }
-  }
-  _setCheckedKeys(key, leafOnly = false, checkedKeys = {}) {
-    const nodes = this._getAllNodes().sort((prevNode, nextNode) => nextNode.level - prevNode.level);
-    const cache = /* @__PURE__ */ Object.create(null);
-    const keys = Object.keys(checkedKeys);
-    nodes.forEach((node) => {
-      node.setChecked(false, false);
-    });
-    for (let i = 0, len = nodes.length; i < len; i++) {
-      const node = nodes[i];
-      const nodeKey = node.data[key].toString();
-      let checked = ~keys.indexOf(nodeKey);
-      if (!checked) {
-        if (node.checked && !cache[nodeKey]) {
-          node.setChecked(false, false);
-        }
-      } else {
-        let parentNode = node.parent;
-        while (parentNode && parentNode.level > 0) {
-          cache[parentNode.data[key]] = true;
-          parentNode = parentNode.parent;
-        }
-        if (node.isLeaf || this.checkStrictly) {
-          node.setChecked(true, false);
-        } else if (leafOnly) {
-          node.setChecked(false, false);
-          const walkTree = (node2) => {
-            const childNodes = node2.childNodes;
-            childNodes.forEach((child) => {
-              !child.isLeaf && child.setChecked(false, false);
-              walkTree(child);
-            });
-          };
-          walkTree(node);
-        } else {
-          node.setChecked(true, true);
-        }
-      }
-    }
-  }
-  setDefaultExpandedKeys(keys) {
-    keys = keys || [];
-    this.defaultExpandedKeys = keys;
-    keys.forEach((key) => {
-      const node = this.getNode(key);
-      node && node.expand(null, this.autoExpandParent);
-    });
-  }
-  setCheckedKeys(keys, leafOnly = false) {
-    this.defaultCheckedKeys = keys;
-    const checkedKeys = {};
-    keys.forEach((key) => {
-      checkedKeys[key] = true;
-    });
-    this._setCheckedKeys(this.key, leafOnly, checkedKeys);
-  }
-  setCheckedNodes(array, leafOnly = false) {
-    const key = this.key;
-    const checkedKeys = {};
-    array.forEach((item) => {
-      checkedKeys[(item || {})[key]] = true;
-    });
-    this._setCheckedKeys(key, leafOnly, checkedKeys);
-  }
-  setChecked(data, checked, deep) {
-    const node = this.getNode(data);
-    node && node.setChecked(!!checked, deep);
-  }
-  setCurrentNode(currentNode) {
-    const prevNode = this.currentNode;
-    if (prevNode) {
-      prevNode.isCurrent = false;
-    }
-    this.currentNode = currentNode;
-    if (currentNode) {
-      this.currentNode.isCurrent = true;
-    }
-  }
-  getCurrentNode() {
-    return this.currentNode;
-  }
-  setCurrentNodeKey(key) {
-    if (isNull(key)) {
-      this.currentNode && (this.currentNode.isCurrent = false);
-      this.currentNode = null;
-      return;
-    }
-    const node = this.getNode(key);
-    node && this.setCurrentNode(node);
-  }
-  setUserCurrentNode(node) {
-    const key = node[this.key];
-    const currNode = this.nodesMap[key];
-    this.setCurrentNode(currNode);
-  }
-  getData(data) {
-    return (this.getNode(data) || {}).data;
-  }
-  getAllData() {
-    const children = this.props.children;
-    const walkTree = (nodes) => {
-      return nodes.map((node) => {
-        return __spreadProps(__spreadValues({}, node.data), { [children]: walkTree(node.childNodes) });
-      });
-    };
-    return walkTree(this.root.childNodes);
-  }
-}
-export {
-  TreeStore as default
-};

package/common/deps/tree-model/util.js

@@ -1,24 +0,0 @@
-import "../../../chunk-G2ADBYYC.js";
-const NODE_KEY = "$treeNodeId";
-const getNodeKey = function(key, data) {
-  if (!key) {
-    return data[NODE_KEY];
-  }
-  return data[key];
-};
-const markNodeData = function(node, data) {
-  if (!data || data[NODE_KEY]) {
-    return;
-  }
-  Object.defineProperty(data, NODE_KEY, {
-    value: node.id,
-    enumerable: false,
-    configurable: false,
-    writable: false
-  });
-};
-export {
-  NODE_KEY,
-  getNodeKey,
-  markNodeData
-};

package/common/deps/upload-ajax.js

@@ -1,81 +0,0 @@
-import "../../chunk-G2ADBYYC.js";
-import { hasOwn } from "../type";
-import { xss } from "@opentiny/utils";
-const getBody = (xhr) => {
-  const text = xhr.responseText || xhr.response;
-  if (!text) {
-    return text;
-  }
-  try {
-    return JSON.parse(text);
-  } catch (e) {
-    return text;
-  }
-};
-const getError = (action, option, xhr) => {
-  let errorText;
-  if (xhr.response) {
-    errorText = xhr.response.error || xhr.response;
-  } else if (xhr.responseText) {
-    errorText = xhr.responseText;
-  } else {
-    errorText = `fail to post ${action} ${xhr.status}`;
-  }
-  const error = new Error(errorText);
-  error.status = xhr.status;
-  error.method = "post";
-  error.url = action;
-  return error;
-};
-var upload_ajax_default = (option) => {
-  if (typeof XMLHttpRequest === "undefined") {
-    return;
-  }
-  const xhr = new XMLHttpRequest();
-  const action = xss.filterUrl(option.action);
-  if (xhr.upload) {
-    xhr.upload.onprogress = (event) => {
-      if (event.total > 0) {
-        event.percent = event.loaded / event.total * 100;
-      }
-      option.onProgress(event);
-    };
-  }
-  const formData = new FormData();
-  if (option.data) {
-    Object.keys(option.data).forEach((key) => {
-      formData.append(key, option.data[key]);
-    });
-  }
-  if (Array.isArray(option.file)) {
-    option.file.forEach((file) => {
-      formData.append(option.filename, file, file.name);
-    });
-  } else {
-    formData.append(option.filename, option.file, option.file.name);
-  }
-  xhr.onerror = (event) => {
-    option.onError(event);
-  };
-  xhr.onload = () => {
-    if (xhr.status < 200 || xhr.status >= 300) {
-      return option.onError(getError(action, option, xhr));
-    }
-    option.onSuccess(getBody(xhr));
-  };
-  xhr.open("post", action, true);
-  if (option.withCredentials && "withCredentials" in xhr) {
-    xhr.withCredentials = true;
-  }
-  const headers = option.headers || {};
-  for (let header in headers) {
-    if (hasOwn.call(headers, header) && headers[header] !== null) {
-      xhr.setRequestHeader(header, headers[header]);
-    }
-  }
-  xhr.send(formData);
-  return xhr;
-};
-export {
-  upload_ajax_default as default
-};

package/common/deps/useEventListener.js

@@ -1,54 +0,0 @@
-import "../../chunk-G2ADBYYC.js";
-import { on, off, isServer } from "./dom";
-const onMountedOrActivated = ({ onMounted, onActivated, nextTick }) => (hook) => {
-  let mounted;
-  onMounted(() => {
-    hook();
-    nextTick(() => mounted = true);
-  });
-  onActivated(() => mounted && hook());
-};
-const useEventListener = ({ unref, isRef, watch, nextTick, onMounted, onUnmounted, onActivated, onDeactivated }) => (type, listener, options = {}) => {
-  if (isServer)
-    return;
-  const { target = window, passive = false, capture = false } = options;
-  let cleaned = false;
-  let attached;
-  const add = (target2) => {
-    if (cleaned)
-      return;
-    const element = unref(target2);
-    if (element && !attached) {
-      on(element, type, listener, { capture, passive });
-      attached = true;
-    }
-  };
-  const remove = (target2) => {
-    if (cleaned)
-      return;
-    const element = unref(target2);
-    if (element && attached) {
-      off(element, type, listener, { capture, passive });
-      attached = false;
-    }
-  };
-  onUnmounted(() => remove(target));
-  onDeactivated(() => remove(target));
-  onMountedOrActivated({ onMounted, onActivated, nextTick })(() => add(target));
-  let stopWatch;
-  if (isRef(target)) {
-    stopWatch = watch(target, (val, oldVal) => {
-      remove(oldVal);
-      add(val);
-    });
-  }
-  return () => {
-    stopWatch && stopWatch();
-    remove(target);
-    cleaned = true;
-  };
-};
-export {
-  onMountedOrActivated,
-  useEventListener
-};

package/common/deps/useInstanceSlots.js

@@ -1,22 +0,0 @@
-import "../../chunk-G2ADBYYC.js";
-const useInstanceSlots = ({ getCurrentInstance, isVue2, nextTick, onUnmounted }) => () => {
-  const publicInstance = getCurrentInstance().proxy;
-  if (!isVue2) {
-    Object.defineProperty(publicInstance, "$scopedSlots", { configurable: true, value: null });
-  }
-  Object.defineProperty(publicInstance, "instanceSlots", {
-    configurable: true,
-    get: () => publicInstance.$scopedSlots || publicInstance.$slots
-  });
-  onUnmounted(() => {
-    nextTick(() => {
-      if (!isVue2) {
-        delete publicInstance.$scopedSlots;
-      }
-      delete publicInstance.instanceSlots;
-    });
-  });
-};
-export {
-  useInstanceSlots
-};

package/common/deps/useRect.js

@@ -1,25 +0,0 @@
-import "../../chunk-G2ADBYYC.js";
-const isWindow = (val) => val === window;
-const makeDOMRect = (width, height) => ({
-  top: 0,
-  left: 0,
-  width,
-  right: width,
-  height,
-  bottom: height
-});
-const useRect = (unref) => (elOrRef) => {
-  const el = unref(elOrRef);
-  if (isWindow(el)) {
-    const width = el.innerWidth;
-    const height = el.innerHeight;
-    return makeDOMRect(width, height);
-  }
-  if (el && el.getBoundingClientRect) {
-    return el.getBoundingClientRect();
-  }
-  return makeDOMRect(0, 0);
-};
-export {
-  useRect
-};

package/common/deps/useRelation.js

@@ -1,89 +0,0 @@
-import "../../chunk-G2ADBYYC.js";
-import { noop } from "../function";
-import { onMountedOrActivated as createHook } from "./useEventListener";
-const useRelation = ({
-  computed,
-  getCurrentInstance,
-  inject,
-  markRaw,
-  nextTick,
-  onMounted,
-  onActivated,
-  onUnmounted,
-  provide,
-  reactive,
-  toRef
-}) => ({ relationKey, relationContainer, onChange, childrenKey, delivery } = {}) => {
-  if (!relationKey) {
-    throw new Error("[TINY Error]<relationKey> must exist.");
-  }
-  const instance = getCurrentInstance();
-  const state = reactive({ children: [], indexInParent: -1 });
-  const injectValue = inject(relationKey, null);
-  let callbacks = [];
-  if (injectValue) {
-    const { link: link2, unlink: unlink2, callbacks: injectCbs, childrenKey: injectKey, delivery: injectDelivery } = injectValue;
-    callbacks = injectCbs;
-    childrenKey = childrenKey || injectKey || "instanceChildren";
-    delivery = injectDelivery;
-    state.indexInParent = link2(instance);
-    onUnmounted(() => unlink2(instance));
-  } else {
-    childrenKey = childrenKey || "instanceChildren";
-    const onMountedOrActivated = createHook({ onMounted, onActivated, nextTick });
-    const changeHandler = onChange ? () => nextTick(onChange) : noop;
-    let relationMO;
-    nextTick(() => {
-      const targetNode = typeof relationContainer === "function" ? relationContainer() : relationContainer;
-      if (targetNode) {
-        relationMO = new MutationObserver((mutationList, observer) => {
-          const flattenNodes = [];
-          flattenChildNodes(targetNode.childNodes, flattenNodes);
-          callbacks.forEach((callback) => callback(flattenNodes, mutationList, observer));
-          changeHandler();
-        });
-        relationMO.observe(targetNode, { attributes: true, childList: true, subtree: true });
-      }
-    });
-    onMountedOrActivated(() => changeHandler());
-    onUnmounted(() => {
-      if (relationMO) {
-        relationMO.disconnect();
-        relationMO = null;
-      }
-      callbacks = null;
-    });
-  }
-  const link = (child) => {
-    const childPublic = child.proxy;
-    state.children.push(markRaw(childPublic));
-    return computed(() => state.children.indexOf(childPublic));
-  };
-  const unlink = (child) => {
-    const index = state.children.indexOf(child.proxy);
-    if (index > -1) {
-      state.children.splice(index, 1);
-    }
-  };
-  callbacks.push((flattenNodes) => sortPublicInstances(state.children, flattenNodes));
-  provide(relationKey, { link, unlink, callbacks, childrenKey, delivery });
-  Object.defineProperty(instance.proxy, childrenKey, { configurable: true, get: () => state.children });
-  onUnmounted(() => delete instance.proxy[childrenKey]);
-  return { children: toRef(state, "children"), index: toRef(state, "indexInParent"), delivery };
-};
-const flattenChildNodes = (childNodes, result) => {
-  if (childNodes.length) {
-    childNodes.forEach((childNode) => {
-      result.push(childNode);
-      if (childNode.childNodes) {
-        flattenChildNodes(childNode.childNodes, result);
-      }
-    });
-  }
-};
-const sortPublicInstances = (instances, flattenNodes) => {
-  instances.sort((a, b) => flattenNodes.indexOf(a.$el) - flattenNodes.indexOf(b.$el));
-};
-export {
-  useRelation
-};

package/common/deps/useTouch.js

@@ -1,68 +0,0 @@
-import "../../chunk-G2ADBYYC.js";
-const TAP_OFFSET = 5;
-const getDirection = (x, y) => {
-  if (x > y)
-    return "horizontal";
-  if (y > x)
-    return "vertical";
-  return "";
-};
-const touchEvent = (event) => event.touches[0];
-const useTouch = (ref) => () => {
-  const startX = ref(0);
-  const startY = ref(0);
-  const deltaX = ref(0);
-  const deltaY = ref(0);
-  const offsetX = ref(0);
-  const offsetY = ref(0);
-  const direction = ref("");
-  const isTap = ref(true);
-  const isVertical = () => direction.value === "vertical";
-  const isHorizontal = () => direction.value === "horizontal";
-  const reset = () => {
-    deltaX.value = 0;
-    deltaY.value = 0;
-    offsetX.value = 0;
-    offsetY.value = 0;
-    direction.value = "";
-    isTap.value = true;
-  };
-  const start = (event) => {
-    reset();
-    const touch = touchEvent(event);
-    startX.value = touch.clientX;
-    startY.value = touch.clientY;
-  };
-  const move = (event) => {
-    const touch = touchEvent(event);
-    deltaX.value = (touch.clientX < 0 ? 0 : touch.clientX) - startX.value;
-    deltaY.value = touch.clientY - startY.value;
-    offsetX.value = Math.abs(deltaX.value);
-    offsetY.value = Math.abs(deltaY.value);
-    const LOCK_DIRECTION_DISTANCE = 10;
-    if (!direction.value || offsetX.value < LOCK_DIRECTION_DISTANCE && offsetY.value < LOCK_DIRECTION_DISTANCE) {
-      direction.value = getDirection(offsetX.value, offsetY.value);
-    }
-    if (isTap.value && (offsetX.value > TAP_OFFSET || offsetY.value > TAP_OFFSET)) {
-      isTap.value = false;
-    }
-  };
-  return {
-    move,
-    start,
-    reset,
-    isVertical,
-    isHorizontal,
-    startX,
-    startY,
-    deltaX,
-    deltaY,
-    offsetX,
-    offsetY,
-    direction,
-    isTap
-  };
-};
-export {
-  useTouch
-};

package/common/deps/useUserAgent.js

@@ -1,16 +0,0 @@
-import "../../chunk-G2ADBYYC.js";
-import { isServer } from "./dom";
-function getIsIOS() {
-  if (isServer)
-    return false;
-  return window.navigator && window.navigator.userAgent && (/iP(?:ad|hone|od)/.test(window.navigator.userAgent) || // The new iPad Pro Gen3 does not identify itself as iPad, but as Macintosh.
-  // https://github.com/vueuse/vueuse/issues/3577
-  window.navigator.maxTouchPoints > 2 && /iPad|Macintosh/.test(window.navigator.userAgent));
-}
-const useUserAgent = () => {
-  const isIOS = getIsIOS();
-  return { isIOS };
-};
-export {
-  useUserAgent
-};