@koi-design/uxd-ui 12.1.36-beta.0

package/es/components/Transfer/index.mjs

@@ -0,0 +1,8 @@
+import { withInstall } from '../../utils/install.mjs';
+import Transfer from './Transfer.mjs';
+export { transferEmits, transferProps, transferSide } from './Transfer.type.mjs';
+
+const UTransfer = withInstall(Transfer);
+
+export { UTransfer, UTransfer as default };
+//# sourceMappingURL=index.mjs.map

package/es/components/Transfer/index.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.mjs","sources":["../../../../src/components/Transfer/index.ts"],"sourcesContent":["import { withInstall } from '../../utils/install';\nimport Transfer from './Transfer.vue';\n\nexport const UTransfer = withInstall(Transfer);\n\nexport default UTransfer;\n\nexport * from './Transfer.type';\n"],"names":[],"mappings":";;;;MAGa,YAAY,YAAY,QAAQ;;;;"}

package/es/components/Transfer/style/index.d.ts

@@ -0,0 +1 @@
+import '@koi-design/uxd-ui/styles/components/transfer/index.less';

package/es/components/Transfer/style/index.mjs

@@ -0,0 +1,2 @@
+import '@koi-design/uxd-ui/styles/components/transfer/index.less';
+//# sourceMappingURL=index.mjs.map

package/es/components/Transfer/style/index.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.mjs","sources":[],"sourcesContent":[],"names":[],"mappings":""}

package/es/components/Transfer/util.d.ts

@@ -0,0 +1 @@
+export declare function changeKeys(source: string[], key: string, isAdd: boolean): string[];

package/es/components/Transfer/util.mjs

@@ -0,0 +1,15 @@
+function changeKeys(source, key, isAdd) {
+  const sourceKeys = [...source];
+  if (isAdd) {
+    if (!sourceKeys.includes(key)) {
+      sourceKeys.push(key);
+    }
+  } else {
+    const indexOfKey = sourceKeys.indexOf(key);
+    sourceKeys.splice(indexOfKey, 1);
+  }
+  return sourceKeys;
+}
+
+export { changeKeys };
+//# sourceMappingURL=util.mjs.map

package/es/components/Transfer/util.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"util.mjs","sources":["../../../../src/components/Transfer/util.ts"],"sourcesContent":["export function changeKeys(source: string[], key: string, isAdd: boolean) {\n  const sourceKeys = [...source];\n\n  if (isAdd) {\n    if (!sourceKeys.includes(key)) {\n      sourceKeys.push(key);\n    }\n  } else {\n    const indexOfKey = sourceKeys.indexOf(key);\n    sourceKeys.splice(indexOfKey, 1);\n  }\n\n  return sourceKeys;\n}\n"],"names":[],"mappings":"SAAgB,WAAW,QAAkB,KAAa,OAAgB;AACxE,QAAM,aAAa,CAAC,GAAG,MAAM;AAE7B,MAAI,OAAO;AACT,QAAI,CAAC,WAAW,SAAS,GAAG,GAAG;AAC7B,iBAAW,KAAK,GAAG;AAAA;AACrB,SACK;AACL,UAAM,aAAa,WAAW,QAAQ,GAAG;AACzC,eAAW,OAAO,YAAY,CAAC;AAAA;AAGjC,SAAO;AACT;;;;"}

package/es/components/Tree/SubTree.mjs

@@ -0,0 +1,44 @@
+import { defineComponent, inject, resolveComponent, openBlock, createElementBlock, Fragment, renderList, createBlock, withCtx, createVNode } from 'vue';
+import TreeNode from './TreeNode.mjs';
+import { TREE_CONTEXT_INJECTION_KEY } from './Tree.type.mjs';
+import _export_sfc from '../../_virtual/plugin-vue_export-helper.mjs';
+
+const _sfc_main = defineComponent({
+  name: "SubTree",
+  components: {
+    TreeNode
+  },
+  props: {
+    data: {
+      type: Array
+    }
+  },
+  setup() {
+    const tree = inject(TREE_CONTEXT_INJECTION_KEY);
+    const prefixCls = tree.prefixCls || "";
+    return {
+      prefixCls
+    };
+  }
+});
+function _sfc_render(_ctx, _cache, $props, $setup, $data, $options) {
+  const _component_SubTree = resolveComponent("SubTree", true);
+  const _component_TreeNode = resolveComponent("TreeNode");
+  return openBlock(true), createElementBlock(Fragment, null, renderList(_ctx.data, (item) => {
+    return openBlock(), createBlock(_component_TreeNode, {
+      key: item.componentKey,
+      data: item
+    }, {
+      list: withCtx(() => [
+        createVNode(_component_SubTree, {
+          data: item.children
+        }, null, 8, ["data"])
+      ]),
+      _: 2
+    }, 1032, ["data"]);
+  }), 128);
+}
+var SubTree = /* @__PURE__ */ _export_sfc(_sfc_main, [["render", _sfc_render], ["__file", "E:\\br-fe\\uxd-ui\\src\\components\\Tree\\SubTree.vue"]]);
+
+export { SubTree as default };
+//# sourceMappingURL=SubTree.mjs.map

package/es/components/Tree/SubTree.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"SubTree.mjs","sources":["../../../../src/components/Tree/SubTree.vue"],"sourcesContent":["<template>\n  <TreeNode v-for=\"item in data\" :key=\"item.componentKey\" :data=\"item\">\n    <template #list>\n      <SubTree :data=\"item.children\" />\n    </template>\n  </TreeNode>\n</template>\n\n<script lang=\"ts\">\nimport { defineComponent, inject, type PropType } from 'vue';\nimport TreeNode from './TreeNode.vue';\nimport { TREE_CONTEXT_INJECTION_KEY, type InnerTreeItem } from './Tree.type';\n\nexport default defineComponent({\n  name: 'SubTree',\n  components: {\n    TreeNode\n  },\n  props: {\n    data: {\n      type: Array as PropType<InnerTreeItem[]>\n    }\n  },\n  setup() {\n    const tree = inject(TREE_CONTEXT_INJECTION_KEY)!;\n    const prefixCls = tree.prefixCls || '';\n    return {\n      prefixCls\n    };\n  }\n});\n</script>\n"],"names":["_createElementBlock","_Fragment","_createBlock","_withCtx","_createVNode"],"mappings":";;;;;AAaA,MAAK,YAAa,gBAAa;AAAA,EAC7B,MAAM;AAAA,EACN,YAAY;AAAA,IACV;AAAA;AACF,EACA,OAAO;AAAA,IACL,MAAM;AAAA,MACJ,MAAM;AAAA;AACR;AACF,EACA,QAAQ;UACA,OAAO,OAAO,0BAA0B;UACxC,YAAY,KAAK,aAAa;WAC7B;AAAA,MACL;AAAA;AACF;AAEJ,CAAC;;;;0BA7BCA,mBAIWC,2BAJc,WAAI,CAAZ,SAAI;wBAArBC,YAIW;MAJqB,KAAK,KAAK;AAAA,MAAe,MAAM;AAAA;MAClD,MAAIC,QACb,MAAiC;AAAA,QAAjCC,YAAiC;UAAvB,MAAM,KAAK;AAAA;;;;;;;;;;"}

package/es/components/Tree/SubTree.vue.d.ts

@@ -0,0 +1,14 @@
+import { type PropType } from 'vue';
+import { type InnerTreeItem } from './Tree.type';
+declare const _default: import("vue").DefineComponent<{
+    data: {
+        type: PropType<InnerTreeItem[]>;
+    };
+}, {
+    prefixCls: string;
+}, unknown, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
+    data: {
+        type: PropType<InnerTreeItem[]>;
+    };
+}>>, {}, {}>;
+export default _default;

package/es/components/Tree/Tree.mjs

@@ -0,0 +1,253 @@
+import { defineComponent, ref, watch, provide, reactive, resolveComponent, openBlock, createElementBlock, normalizeClass, createVNode } from 'vue';
+import { treeMap } from '../../utils/tools.mjs';
+import useGlobalConfig from '../base/hooks/useGlobalConfig.mjs';
+import useTransfer from './hooks/useTransfer.mjs';
+import { getDragNode, findNodeByLoop } from './utils/tools.mjs';
+import { generateCheck } from './utils/generateCheck.mjs';
+import SubTree from './SubTree.mjs';
+import { treeProps, treeEmits, TREE_CONTEXT_INJECTION_KEY } from './Tree.type.mjs';
+import _export_sfc from '../../_virtual/plugin-vue_export-helper.mjs';
+
+const _sfc_main = defineComponent({
+  name: "UTree",
+  components: {
+    SubTree
+  },
+  props: treeProps,
+  emits: treeEmits,
+  setup(props, { emit, slots }) {
+    const { prefixCls } = useGlobalConfig("tree");
+    const selectedKeys = ref([]);
+    const checkedKeys = ref([]);
+    const halfCheckedKeys = ref([]);
+    const loadingKeys = ref([]);
+    const dragKey = ref("");
+    const getDataKey = (data) => {
+      if (typeof props.dataKey === "function") {
+        return props.dataKey(data);
+      }
+      return data[props.dataKey];
+    };
+    const { expandedKeys, localTreeData, treeDataMap, initData } = useTransfer(props, slots, getDataKey);
+    const computedChecked = (keys, checked) => {
+      const checkedParams = {
+        oriCheckedKeys: checkedKeys.value,
+        oriHalfCheckedKeys: halfCheckedKeys.value
+      };
+      const checkResult = generateCheck(keys, checked, treeDataMap.value, checkedParams, getDataKey);
+      return checkResult;
+    };
+    const initChecked = () => {
+      if (props.checkStrictly)
+        return;
+      const checkResult = computedChecked(checkedKeys.value, true);
+      checkedKeys.value = checkResult.checkedKeys;
+      halfCheckedKeys.value = checkResult.halfCheckedKeys;
+      emit("check", checkResult.checkedKeys, checkResult.halfCheckedKeys);
+    };
+    watch(
+      () => props.treeData,
+      (nv) => {
+        initData(nv);
+      },
+      { immediate: true }
+    );
+    watch(
+      () => props.selectedKeys,
+      (nv) => {
+        selectedKeys.value = [...nv];
+      },
+      { immediate: true }
+    );
+    watch(
+      () => props.checkedKeys,
+      (nv) => {
+        if (checkedKeys.value !== nv && checkedKeys.value.length !== nv.length && props.checkable) {
+          checkedKeys.value = [...nv];
+          initChecked();
+        }
+      },
+      { immediate: true }
+    );
+    const updateDragKeys = (key) => {
+      dragKey.value = key;
+    };
+    const updateOriginData = (data) => {
+      if (props.treeSelect) {
+        emit("update-data", data);
+      }
+      emit("update:treeData", data);
+    };
+    const fireTreeDrop = (dropEvent) => {
+      const dropNode = treeDataMap.value.get(dropEvent.dropKey);
+      const data = treeMap(props.treeData, (x) => ({
+        ...x
+      }));
+      const dragNode = getDragNode(data, dropEvent.dragKey, getDataKey);
+      if (!dropEvent.dropToGap) {
+        findNodeByLoop(
+          data,
+          dropEvent.dropKey,
+          (item) => {
+            item.children = item.children || [];
+            item.children.push(dragNode);
+          },
+          getDataKey
+        );
+      } else if (((dropNode == null ? void 0 : dropNode.children) || []).length > 0 && dropEvent.dropPosition === 1) {
+        findNodeByLoop(
+          data,
+          dropEvent.dropKey,
+          (item) => {
+            item.children = item.children || [];
+            item.children.unshift(dragNode);
+          },
+          getDataKey
+        );
+      } else {
+        let tempArr = [];
+        let tempIndex = 0;
+        findNodeByLoop(
+          data,
+          dropEvent.dropKey,
+          (item, index, arr) => {
+            tempArr = arr;
+            tempIndex = index;
+          },
+          getDataKey
+        );
+        if (dropEvent.dropPosition === -1) {
+          tempArr.splice(tempIndex, 0, dragNode);
+        } else {
+          tempArr.splice(tempIndex + 1, 0, dragNode);
+        }
+      }
+      updateOriginData(data);
+    };
+    const fireTreeSelect = (e) => {
+      const selectItems = [];
+      selectedKeys.value.forEach((key) => {
+        if (treeDataMap.value.get(key)) {
+          selectItems.push(treeDataMap.value.get(key).dataRef);
+        }
+      });
+      emit("update:selectedKeys", selectedKeys.value);
+      emit("select", selectItems, e);
+    };
+    const fireTreeCheck = (e, key) => {
+      if (props.disabled)
+        return;
+      const keyIndex = checkedKeys.value.indexOf(key);
+      if (props.checkStrictly) {
+        if (keyIndex === -1) {
+          checkedKeys.value.push(key);
+        } else {
+          checkedKeys.value.splice(keyIndex, 1);
+        }
+      } else {
+        const checked = !(keyIndex >= 0);
+        const checkResult = computedChecked([key], checked);
+        checkedKeys.value = checkResult.checkedKeys;
+        halfCheckedKeys.value = checkResult.halfCheckedKeys;
+      }
+      emit("update:checkedKeys", checkedKeys.value);
+      emit("check", checkedKeys.value, props.checkStrictly ? [] : halfCheckedKeys.value, e);
+    };
+    const treeNodeOperate = (type, key, children) => {
+      const data = treeMap(props.treeData, (x) => ({ ...x }));
+      if (type === "add") {
+        findNodeByLoop(
+          data,
+          key,
+          (item) => {
+            item.children = [...item.children || [], ...children || []];
+          },
+          getDataKey
+        );
+      } else {
+        const currentNode = treeDataMap.value.get(key);
+        if (currentNode.parent === null) {
+          const index = data.findIndex((x) => getDataKey(x) === key);
+          data.splice(index, 1);
+        } else {
+          findNodeByLoop(
+            data,
+            getDataKey(currentNode.parent),
+            (item) => {
+              const index = item.children.findIndex((x) => getDataKey(x) === key);
+              item.children.splice(index, 1);
+            },
+            getDataKey
+          );
+        }
+      }
+      updateOriginData(data);
+    };
+    const asyncLoadData = (node) => {
+      const nodeKey = getDataKey(node);
+      loadingKeys.value.push(nodeKey);
+      return new Promise((resolve) => {
+        if (props.loadData) {
+          const promise = props.loadData(node);
+          promise.then((children) => {
+            if (children && Array.isArray(children)) {
+              treeNodeOperate("add", nodeKey, children);
+            }
+            loadingKeys.value = loadingKeys.value.filter((x) => x !== nodeKey);
+            resolve();
+          });
+        }
+        resolve();
+      });
+    };
+    const fireTreeExpand = (e) => {
+      emit("update:expandedKeys", expandedKeys.value);
+      emit("expand", expandedKeys.value, e);
+    };
+    provide(
+      TREE_CONTEXT_INJECTION_KEY,
+      reactive({
+        props,
+        emit,
+        prefixCls,
+        treeDataMap,
+        selectedKeys,
+        expandedKeys,
+        checkedKeys,
+        halfCheckedKeys,
+        dragKey,
+        loadingKeys,
+        asyncLoadData,
+        treeNodeOperate,
+        updateDragKeys,
+        fireTreeDrop,
+        fireTreeSelect,
+        fireTreeCheck,
+        fireTreeExpand,
+        getDataKey
+      })
+    );
+    return {
+      prefixCls,
+      localTreeData,
+      computedChecked
+    };
+  }
+});
+function _sfc_render(_ctx, _cache, $props, $setup, $data, $options) {
+  const _component_SubTree = resolveComponent("SubTree");
+  return openBlock(), createElementBlock("ul", {
+    class: normalizeClass([
+      _ctx.prefixCls,
+      {
+        [`${_ctx.prefixCls}-show-line`]: _ctx.showLine
+      }
+    ])
+  }, [
+    createVNode(_component_SubTree, { data: _ctx.localTreeData }, null, 8, ["data"])
+  ], 2);
+}
+var Tree = /* @__PURE__ */ _export_sfc(_sfc_main, [["render", _sfc_render], ["__file", "E:\\br-fe\\uxd-ui\\src\\components\\Tree\\Tree.vue"]]);
+
+export { Tree as default };
+//# sourceMappingURL=Tree.mjs.map

package/es/components/Tree/Tree.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"Tree.mjs","sources":["../../../../src/components/Tree/Tree.vue"],"sourcesContent":["<template>\n  <ul\n    :class=\"[\n      prefixCls,\n      {\n        [`${prefixCls}-show-line`]: showLine\n      }\n    ]\"\n  >\n    <SubTree :data=\"localTreeData\" />\n  </ul>\n</template>\n\n<script lang=\"ts\">\nimport { provide, ref, watch, defineComponent, reactive } from 'vue';\nimport { treeMap } from '../../utils/tools';\nimport useGlobalConfig from '../base/hooks/useGlobalConfig';\nimport useTransfer from './hooks/useTransfer';\nimport { findNodeByLoop, getDragNode } from './utils/tools';\nimport { generateCheck } from './utils/generateCheck';\nimport SubTree from './SubTree.vue';\nimport { type TreeItem, treeProps, treeEmits, TREE_CONTEXT_INJECTION_KEY, type InnerTreeItem } from './Tree.type';\n\nexport default defineComponent({\n  name: 'UTree',\n  components: {\n    SubTree\n  },\n  props: treeProps,\n  emits: treeEmits,\n  setup(props, { emit, slots }) {\n    const { prefixCls } = useGlobalConfig('tree');\n    const selectedKeys = ref<(string | number)[]>([]);\n    const checkedKeys = ref<(string | number)[]>([]);\n    const halfCheckedKeys = ref<(string | number)[]>([]);\n    const loadingKeys = ref<(string | number)[]>([]);\n    const dragKey = ref<string | number>('');\n\n    const getDataKey = (data: InnerTreeItem): string | number => {\n      if (typeof props.dataKey === 'function') {\n        return props.dataKey(data);\n      }\n      return data[props.dataKey];\n    };\n\n    const { expandedKeys, localTreeData, treeDataMap, initData } = useTransfer(props, slots, getDataKey);\n\n    const computedChecked = (keys: (string | number)[], checked: boolean) => {\n      const checkedParams = {\n        oriCheckedKeys: checkedKeys.value,\n        oriHalfCheckedKeys: halfCheckedKeys.value\n      };\n      const checkResult = generateCheck(keys, checked, treeDataMap.value, checkedParams, getDataKey);\n      return checkResult;\n    };\n\n    // #region init halfCheckedKeys _checkedKeys\n    const initChecked = () => {\n      if (props.checkStrictly) return;\n      const checkResult = computedChecked(checkedKeys.value, true);\n      checkedKeys.value = checkResult.checkedKeys;\n      halfCheckedKeys.value = checkResult.halfCheckedKeys;\n      // emit('update:checkedKeys', checkResult.checkedKeys);\n      emit('check', checkResult.checkedKeys, checkResult.halfCheckedKeys);\n    };\n    // #endregion\n\n    // #region watch\n    watch(\n      () => props.treeData,\n      (nv) => {\n        initData(nv);\n      },\n      { immediate: true }\n    );\n    watch(\n      () => props.selectedKeys,\n      (nv) => {\n        selectedKeys.value = [...nv];\n      },\n      { immediate: true }\n    );\n    watch(\n      () => props.checkedKeys,\n      (nv) => {\n        if (checkedKeys.value !== nv && checkedKeys.value.length !== nv.length && props.checkable) {\n          checkedKeys.value = [...nv];\n          initChecked();\n        }\n      },\n      { immediate: true }\n    );\n    // #endregion\n\n    // methods\n    const updateDragKeys = (key: string | number) => {\n      dragKey.value = key;\n    };\n\n    const updateOriginData = (data: TreeItem[]) => {\n      if (props.treeSelect) {\n        emit('update-data', data);\n      }\n      emit('update:treeData', data);\n    };\n    // #region fireTreeDrop\n    const fireTreeDrop = (dropEvent: { dragKey: string | number; dropKey: string | number; dropPosition: number; dropToGap: boolean }) => {\n      // const dropPos = dropKey.split('-');\n      const dropNode = treeDataMap.value.get(dropEvent.dropKey);\n      // const _dropPosition = dropPosition - Number(dropPos[dropPos.length - 1]);\n      const data = treeMap<TreeItem, TreeItem>(props.treeData, (x) => ({\n        ...x\n      }));\n      const dragNode = getDragNode(data, dropEvent.dragKey, getDataKey);\n      if (!dropEvent.dropToGap) {\n        // Drop on the content\n        findNodeByLoop(\n          data,\n          dropEvent.dropKey,\n          (item: TreeItem) => {\n            item.children = item.children || [];\n\n            item.children.push(dragNode);\n          },\n          getDataKey\n        );\n      } else if ((dropNode?.children || []).length > 0 && dropEvent.dropPosition === 1) {\n        findNodeByLoop(\n          data,\n          dropEvent.dropKey,\n          (item) => {\n            item.children = item.children || [];\n\n            item.children.unshift(dragNode);\n          },\n          getDataKey\n        );\n      } else {\n        let tempArr: TreeItem[] = [];\n        let tempIndex = 0;\n        findNodeByLoop(\n          data,\n          dropEvent.dropKey,\n          (item, index, arr) => {\n            tempArr = arr;\n            tempIndex = index;\n          },\n          getDataKey\n        );\n        if (dropEvent.dropPosition === -1) {\n          tempArr.splice(tempIndex, 0, dragNode);\n        } else {\n          tempArr.splice(tempIndex + 1, 0, dragNode);\n        }\n      }\n      updateOriginData(data);\n    };\n    // #endregion\n\n    // #region treeSelect\n\n    const fireTreeSelect = (e: Event) => {\n      const selectItems = [] as TreeItem[];\n      selectedKeys.value.forEach((key) => {\n        if (treeDataMap.value.get(key)) {\n          selectItems.push(treeDataMap.value.get(key)!.dataRef);\n        }\n      });\n      emit('update:selectedKeys', selectedKeys.value);\n      emit('select', selectItems, e);\n    };\n\n    // #endregion\n\n    // #region treeCheck\n\n    const fireTreeCheck = (e: Event, key: string | number) => {\n      if (props.disabled) return;\n      const keyIndex = checkedKeys.value.indexOf(key);\n      if (props.checkStrictly) {\n        if (keyIndex === -1) {\n          checkedKeys.value.push(key);\n        } else {\n          checkedKeys.value.splice(keyIndex, 1);\n        }\n      } else {\n        const checked = !(keyIndex >= 0);\n        const checkResult = computedChecked([key], checked);\n        checkedKeys.value = checkResult.checkedKeys;\n        halfCheckedKeys.value = checkResult.halfCheckedKeys;\n        // emit('check', checkResult.checkedKeys, checkResult.halfCheckedKeys, e);\n      }\n      emit('update:checkedKeys', checkedKeys.value);\n      emit('check', checkedKeys.value, props.checkStrictly ? [] : halfCheckedKeys.value, e);\n    };\n\n    // #endregion\n\n    // #region tree Data operate\n    const treeNodeOperate = (type: 'add' | 'delete', key: string | number, children?: TreeItem[]) => {\n      const data = treeMap(props.treeData, (x) => ({ ...x }));\n      if (type === 'add') {\n        findNodeByLoop(\n          data,\n          key,\n          (item) => {\n            item.children = [...(item.children || []), ...(children || [])];\n          },\n          getDataKey\n        );\n      } else {\n        const currentNode = treeDataMap.value.get(key)!;\n\n        if (currentNode.parent === null) {\n          const index = data.findIndex((x) => getDataKey(x as InnerTreeItem) === key);\n          data.splice(index, 1);\n        } else {\n          findNodeByLoop(\n            data,\n            getDataKey(currentNode.parent),\n            (item) => {\n              const index = item.children!.findIndex((x) => getDataKey(x as InnerTreeItem) === key);\n              item.children!.splice(index, 1);\n            },\n            getDataKey\n          );\n        }\n      }\n\n      updateOriginData(data);\n    };\n\n    // #endregion\n\n    // #region async load data\n\n    const asyncLoadData = (node: InnerTreeItem) => {\n      const nodeKey = getDataKey(node);\n      loadingKeys.value.push(nodeKey);\n      return new Promise<void>((resolve) => {\n        if (props.loadData) {\n          const promise = props.loadData(node);\n          promise.then((children?: TreeItem[]) => {\n            if (children && Array.isArray(children)) {\n              treeNodeOperate('add', nodeKey, children);\n            }\n            loadingKeys.value = loadingKeys.value.filter((x) => x !== nodeKey);\n            resolve();\n          });\n        }\n        resolve();\n      });\n    };\n\n    // #endregion\n\n    const fireTreeExpand = (e: Event) => {\n      emit('update:expandedKeys', expandedKeys.value);\n      emit('expand', expandedKeys.value, e);\n    };\n\n    // #region provide\n    provide(\n      TREE_CONTEXT_INJECTION_KEY,\n      reactive({\n        props,\n        emit,\n        prefixCls,\n        treeDataMap,\n        selectedKeys,\n        expandedKeys,\n        checkedKeys,\n        halfCheckedKeys,\n        dragKey,\n        loadingKeys,\n        asyncLoadData,\n        treeNodeOperate,\n        updateDragKeys,\n        fireTreeDrop,\n        fireTreeSelect,\n        fireTreeCheck,\n        fireTreeExpand,\n        getDataKey\n      })\n    );\n    // #endregion\n\n    return {\n      prefixCls,\n      localTreeData,\n      computedChecked // treeSelect use\n    };\n  }\n});\n</script>\n"],"names":["_createElementBlock","_normalizeClass","_createVNode"],"mappings":"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"}

package/es/components/Tree/Tree.type.d.ts

@@ -0,0 +1,155 @@
+import type { PropType, ExtractPropTypes, InjectionKey, VNode } from 'vue';
+import type { EmitFn, IconPropType } from '../../utils/globalType';
+export interface TreeItem {
+    title: string;
+    key?: string | number;
+    disabled?: boolean;
+    children?: TreeItem[];
+    isLeaf?: boolean;
+    checkable?: boolean;
+    [key: string]: any;
+}
+export interface TreeNodeSlotArgs {
+    node: InnerTreeItem;
+    origin: TreeItem;
+    operate: (type: 'add' | 'delete', key: string, children: TreeItem[]) => void;
+}
+export interface InnerTreeItem extends TreeItem {
+    key: string | number;
+    slot: (param: TreeNodeSlotArgs) => VNode[];
+    operateSlot: (param: TreeNodeSlotArgs) => VNode[];
+    componentKey: string;
+    dataRef: TreeItem;
+    parent: InnerTreeItem | null;
+    level: string;
+    children?: InnerTreeItem[];
+}
+export declare type TreeMap = Map<string | number, InnerTreeItem>;
+export declare type TreeLoadData = (node: InnerTreeItem) => Promise<TreeItem[] | undefined>;
+export declare type GetDataKey = (item: InnerTreeItem) => string | number;
+export declare const treeProps: {
+    treeData: {
+        type: PropType<TreeItem[]>;
+        default: () => TreeItem[];
+    };
+    dataKey: {
+        type: PropType<string | GetDataKey>;
+        default: string;
+    };
+    multiple: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    checkable: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    selectable: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    checkStrictly: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    disabled: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    switcherIcon: {
+        type: PropType<IconPropType>;
+        default: any;
+    };
+    showLine: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    showIcon: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    selectedKeys: {
+        type: PropType<(string | number)[]>;
+        default: () => string[];
+    };
+    expandedKeys: {
+        type: PropType<(string | number)[]>;
+        default: () => string[];
+    };
+    checkedKeys: {
+        type: PropType<(string | number)[]>;
+        default: () => string[];
+    };
+    defaultExpandAll: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    draggable: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    blockNode: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    loadData: {
+        type: PropType<TreeLoadData>;
+    };
+    loadedKeys: {
+        type: PropType<(string | number)[]>;
+    };
+    treeSelect: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+};
+export declare type TreeProps = ExtractPropTypes<typeof treeProps>;
+export declare const treeEmits: {
+    'update:treeData': (data: TreeItem[]) => boolean;
+    'update:selectedKeys': (keys: (string | number)[]) => boolean;
+    'update:expandedKeys': (keys: (string | number)[]) => boolean;
+    'update:checkedKeys': (keys: (string | number)[]) => boolean;
+    select: (item: TreeItem[], e: Event) => boolean;
+    check: (checkedkeys: (string | number)[], halfCheckedKeys: (string | number)[], e?: Event) => boolean;
+    expand: (keys: (string | number)[], e: Event) => boolean;
+    'update-data': (data: TreeItem[]) => boolean;
+    'drag-start': (node: TreeItem, e: Event) => boolean;
+};
+export declare type TreeEmits = typeof treeEmits;
+export declare const treeNodeProps: {
+    data: {
+        type: PropType<InnerTreeItem>;
+        default: () => InnerTreeItem;
+    };
+    appear: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+};
+export declare type TreeNodeProps = ExtractPropTypes<typeof treeNodeProps>;
+export interface TreeContext {
+    props: TreeProps;
+    prefixCls: string;
+    treeDataMap: TreeMap;
+    selectedKeys: (string | number)[];
+    expandedKeys: (string | number)[];
+    checkedKeys: (string | number)[];
+    halfCheckedKeys: (string | number)[];
+    dragKey: string | number;
+    loadingKeys: (string | number)[];
+    emit: EmitFn<TreeEmits>;
+    updateDragKeys: (key: string | number) => void;
+    fireTreeDrop: (params: {
+        dragKey: string | number;
+        dropKey: string | number;
+        dropPosition: number;
+        dropToGap: boolean;
+    }) => void;
+    treeNodeOperate: (type: 'add' | 'delete', key: string, children?: TreeItem[]) => void;
+    asyncLoadData: (node: InnerTreeItem) => Promise<void>;
+    fireTreeSelect: (e: Event) => void;
+    fireTreeCheck: (e: Event, key: string | number) => void;
+    fireTreeExpand: (e: Event) => void;
+    getDataKey: (data: InnerTreeItem) => string | number;
+}
+export declare const TREE_CONTEXT_INJECTION_KEY: InjectionKey<TreeContext>;

package/es/components/Tree/Tree.type.mjs

@@ -0,0 +1,103 @@
+import { USolidCaretRight } from '@koi-design/uxd-icon';
+
+const treeProps = {
+  treeData: {
+    type: Array,
+    default: () => []
+  },
+  dataKey: {
+    type: [Function, String],
+    default: "key"
+  },
+  multiple: {
+    type: Boolean,
+    default: false
+  },
+  checkable: {
+    type: Boolean,
+    default: false
+  },
+  selectable: {
+    type: Boolean,
+    default: true
+  },
+  checkStrictly: {
+    type: Boolean,
+    default: false
+  },
+  disabled: {
+    type: Boolean,
+    default: false
+  },
+  switcherIcon: {
+    type: [String, Object],
+    default: USolidCaretRight
+  },
+  showLine: {
+    type: Boolean,
+    default: false
+  },
+  showIcon: {
+    type: Boolean,
+    default: false
+  },
+  selectedKeys: {
+    type: Array,
+    default: () => []
+  },
+  expandedKeys: {
+    type: Array,
+    default: () => []
+  },
+  checkedKeys: {
+    type: Array,
+    default: () => []
+  },
+  defaultExpandAll: {
+    type: Boolean,
+    default: false
+  },
+  draggable: {
+    type: Boolean,
+    default: false
+  },
+  blockNode: {
+    type: Boolean,
+    default: false
+  },
+  loadData: {
+    type: Function
+  },
+  loadedKeys: {
+    type: Array
+  },
+  treeSelect: {
+    type: Boolean,
+    default: false
+  }
+};
+const treeEmits = {
+  "update:treeData": (data) => Array.isArray(data),
+  "update:selectedKeys": (keys) => Array.isArray(keys),
+  "update:expandedKeys": (keys) => Array.isArray(keys),
+  "update:checkedKeys": (keys) => Array.isArray(keys),
+  select: (item, e) => Array.isArray(item) && e instanceof Event,
+  check: (checkedkeys, halfCheckedKeys, e) => Array.isArray(checkedkeys) && Array.isArray(halfCheckedKeys) && (e === void 0 || e instanceof Event),
+  expand: (keys, e) => Array.isArray(keys) && e instanceof Event,
+  "update-data": (data) => Array.isArray(data),
+  "drag-start": (node, e) => typeof node === "object" && e instanceof Event
+};
+const treeNodeProps = {
+  data: {
+    type: Object,
+    default: () => ({})
+  },
+  appear: {
+    type: Boolean,
+    default: false
+  }
+};
+const TREE_CONTEXT_INJECTION_KEY = Symbol("treeContext");
+
+export { TREE_CONTEXT_INJECTION_KEY, treeEmits, treeNodeProps, treeProps };
+//# sourceMappingURL=Tree.type.mjs.map

package/es/components/Tree/Tree.type.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"Tree.type.mjs","sources":["../../../../src/components/Tree/Tree.type.ts"],"sourcesContent":["import type { PropType, ExtractPropTypes, InjectionKey, VNode } from 'vue';\nimport { USolidCaretRight } from '@koi-design/uxd-icon';\nimport type { EmitFn, IconPropType } from '../../utils/globalType';\n\nexport interface TreeItem {\n  title: string;\n  key?: string | number;\n  disabled?: boolean;\n  children?: TreeItem[];\n  isLeaf?: boolean;\n  checkable?: boolean;\n  [key: string]: any;\n}\n\nexport interface TreeNodeSlotArgs {\n  node: InnerTreeItem;\n  origin: TreeItem;\n  operate: (type: 'add' | 'delete', key: string, children: TreeItem[]) => void;\n}\nexport interface InnerTreeItem extends TreeItem {\n  key: string | number;\n  slot: (param: TreeNodeSlotArgs) => VNode[];\n  operateSlot: (param: TreeNodeSlotArgs) => VNode[];\n  componentKey: string;\n  dataRef: TreeItem;\n  // & { parent: boolean | null };\n  parent: InnerTreeItem | null;\n  level: string;\n  children?: InnerTreeItem[];\n}\n\nexport type TreeMap = Map<string | number, InnerTreeItem>;\n\nexport type TreeLoadData = (node: InnerTreeItem) => Promise<TreeItem[] | undefined>;\n\nexport type GetDataKey = (item: InnerTreeItem) => string | number;\n\nexport const treeProps = {\n  treeData: {\n    type: Array as PropType<TreeItem[]>,\n    default: (): TreeItem[] => []\n  },\n  dataKey: {\n    type: [Function, String] as PropType<string | GetDataKey>,\n    default: 'key'\n  },\n  multiple: {\n    type: Boolean,\n    default: false\n  },\n  checkable: {\n    type: Boolean,\n    default: false\n  },\n  selectable: {\n    type: Boolean,\n    default: true\n  },\n  checkStrictly: {\n    type: Boolean,\n    default: false\n  },\n  disabled: {\n    type: Boolean,\n    default: false\n  },\n  switcherIcon: {\n    type: [String, Object] as PropType<IconPropType>,\n    default: USolidCaretRight\n  },\n  showLine: {\n    type: Boolean,\n    default: false\n  },\n  showIcon: {\n    type: Boolean,\n    default: false\n  },\n  selectedKeys: {\n    type: Array as PropType<(string | number)[]>,\n    default: (): string[] => []\n  },\n  expandedKeys: {\n    type: Array as PropType<(string | number)[]>,\n    default: (): string[] => []\n  },\n  checkedKeys: {\n    type: Array as PropType<(string | number)[]>,\n    default: (): string[] => []\n  },\n  defaultExpandAll: {\n    type: Boolean,\n    default: false\n  },\n  draggable: {\n    type: Boolean,\n    default: false\n  },\n  blockNode: {\n    type: Boolean,\n    default: false\n  },\n  loadData: {\n    type: Function as PropType<TreeLoadData>\n  },\n  loadedKeys: {\n    type: Array as PropType<(string | number)[]>\n  },\n  treeSelect: {\n    type: Boolean,\n    default: false\n  }\n};\nexport type TreeProps = ExtractPropTypes<typeof treeProps>;\n\nexport const treeEmits = {\n  'update:treeData': (data: TreeItem[]) => Array.isArray(data),\n  'update:selectedKeys': (keys: (string | number)[]) => Array.isArray(keys),\n  'update:expandedKeys': (keys: (string | number)[]) => Array.isArray(keys),\n  'update:checkedKeys': (keys: (string | number)[]) => Array.isArray(keys),\n\n  select: (item: TreeItem[], e: Event) => Array.isArray(item) && e instanceof Event,\n  check: (checkedkeys: (string | number)[], halfCheckedKeys: (string | number)[], e?: Event) =>\n    Array.isArray(checkedkeys) && Array.isArray(halfCheckedKeys) && (e === undefined || e instanceof Event),\n  expand: (keys: (string | number)[], e: Event) => Array.isArray(keys) && e instanceof Event,\n  'update-data': (data: TreeItem[]) => Array.isArray(data),\n  'drag-start': (node: TreeItem, e: Event) => typeof node === 'object' && e instanceof Event\n};\n\nexport type TreeEmits = typeof treeEmits;\n\nexport const treeNodeProps = {\n  data: {\n    type: Object as PropType<InnerTreeItem>,\n    default: () => ({} as InnerTreeItem)\n  },\n  appear: {\n    type: Boolean,\n    default: false\n  }\n};\n\nexport type TreeNodeProps = ExtractPropTypes<typeof treeNodeProps>;\n\nexport interface TreeContext {\n  props: TreeProps;\n  prefixCls: string;\n  treeDataMap: TreeMap;\n  selectedKeys: (string | number)[];\n  expandedKeys: (string | number)[];\n  checkedKeys: (string | number)[];\n  halfCheckedKeys: (string | number)[];\n  dragKey: string | number;\n  loadingKeys: (string | number)[];\n  emit: EmitFn<TreeEmits>;\n  updateDragKeys: (key: string | number) => void;\n  fireTreeDrop: (params: { dragKey: string | number; dropKey: string | number; dropPosition: number; dropToGap: boolean }) => void;\n  treeNodeOperate: (type: 'add' | 'delete', key: string, children?: TreeItem[]) => void;\n  asyncLoadData: (node: InnerTreeItem) => Promise<void>;\n  fireTreeSelect: (e: Event) => void;\n  fireTreeCheck: (e: Event, key: string | number) => void;\n  fireTreeExpand: (e: Event) => void;\n  getDataKey: (data: InnerTreeItem) => string | number;\n}\n\nexport const TREE_CONTEXT_INJECTION_KEY: InjectionKey<TreeContext> = Symbol('treeContext');\n"],"names":[],"mappings":";;MAqCa,YAAY;AAAA,EACvB,UAAU;AAAA,IACR,MAAM;AAAA,IACN,SAAS,MAAkB;AAAC;AAC9B,EACA,SAAS;AAAA,IACP,MAAM,CAAC,UAAU,MAAM;AAAA,IACvB,SAAS;AAAA;AACX,EACA,UAAU;AAAA,IACR,MAAM;AAAA,IACN,SAAS;AAAA;AACX,EACA,WAAW;AAAA,IACT,MAAM;AAAA,IACN,SAAS;AAAA;AACX,EACA,YAAY;AAAA,IACV,MAAM;AAAA,IACN,SAAS;AAAA;AACX,EACA,eAAe;AAAA,IACb,MAAM;AAAA,IACN,SAAS;AAAA;AACX,EACA,UAAU;AAAA,IACR,MAAM;AAAA,IACN,SAAS;AAAA;AACX,EACA,cAAc;AAAA,IACZ,MAAM,CAAC,QAAQ,MAAM;AAAA,IACrB,SAAS;AAAA;AACX,EACA,UAAU;AAAA,IACR,MAAM;AAAA,IACN,SAAS;AAAA;AACX,EACA,UAAU;AAAA,IACR,MAAM;AAAA,IACN,SAAS;AAAA;AACX,EACA,cAAc;AAAA,IACZ,MAAM;AAAA,IACN,SAAS,MAAgB;AAAC;AAC5B,EACA,cAAc;AAAA,IACZ,MAAM;AAAA,IACN,SAAS,MAAgB;AAAC;AAC5B,EACA,aAAa;AAAA,IACX,MAAM;AAAA,IACN,SAAS,MAAgB;AAAC;AAC5B,EACA,kBAAkB;AAAA,IAChB,MAAM;AAAA,IACN,SAAS;AAAA;AACX,EACA,WAAW;AAAA,IACT,MAAM;AAAA,IACN,SAAS;AAAA;AACX,EACA,WAAW;AAAA,IACT,MAAM;AAAA,IACN,SAAS;AAAA;AACX,EACA,UAAU;AAAA,IACR,MAAM;AAAA;AACR,EACA,YAAY;AAAA,IACV,MAAM;AAAA;AACR,EACA,YAAY;AAAA,IACV,MAAM;AAAA,IACN,SAAS;AAAA;AAEb;MAGa,YAAY;AAAA,EACvB,mBAAmB,CAAC,SAAqB,MAAM,QAAQ,IAAI;AAAA,EAC3D,uBAAuB,CAAC,SAA8B,MAAM,QAAQ,IAAI;AAAA,EACxE,uBAAuB,CAAC,SAA8B,MAAM,QAAQ,IAAI;AAAA,EACxE,sBAAsB,CAAC,SAA8B,MAAM,QAAQ,IAAI;AAAA,EAEvE,QAAQ,CAAC,MAAkB,MAAa,MAAM,QAAQ,IAAI,KAAK,aAAa;AAAA,EAC5E,OAAO,CAAC,aAAkC,iBAAsC,MAC9E,MAAM,QAAQ,WAAW,KAAK,MAAM,QAAQ,eAAe,MAAM,MAAM,UAAa,aAAa;AAAA,EACnG,QAAQ,CAAC,MAA2B,MAAa,MAAM,QAAQ,IAAI,KAAK,aAAa;AAAA,EACrF,eAAe,CAAC,SAAqB,MAAM,QAAQ,IAAI;AAAA,EACvD,cAAc,CAAC,MAAgB,MAAa,OAAO,SAAS,YAAY,aAAa;AACvF;MAIa,gBAAgB;AAAA,EAC3B,MAAM;AAAA,IACJ,MAAM;AAAA,IACN,SAAS,OAAO;AAAC;AACnB,EACA,QAAQ;AAAA,IACN,MAAM;AAAA,IACN,SAAS;AAAA;AAEb;MAyBa,6BAAwD,OAAO,aAAa;;;;"}