@opentiny/vue-renderless 3.9.2 → 3.10.0

package/time-spinner/vue.js

@@ -19,7 +19,16 @@ import {
   emitSelectRange
 } from "./index";
 import { getRangeHours, getRangeMinutes } from "../common/deps/date-util";
-const api = ["state", "emitSelectRange", "adjustCurrentSpinner", "handleClick", "decrease", "increase", "amPm", "adjustSpinners"];
+const api = [
+  "state",
+  "emitSelectRange",
+  "adjustCurrentSpinner",
+  "handleClick",
+  "decrease",
+  "increase",
+  "amPm",
+  "adjustSpinners"
+];
 const initState = ({ reactive, computed, props, api: api2 }) => {
   const state = reactive({
     selectableRange: [],
@@ -27,16 +36,28 @@ const initState = ({ reactive, computed, props, api: api2 }) => {
     hours: computed(() => props.date.getHours()),
     minutes: computed(() => props.date.getMinutes()),
     seconds: computed(() => props.date.getSeconds()),
-    hoursList: computed(() => getRangeHours(state.selectableRange)),
-    minutesList: computed(() => getRangeMinutes(state.selectableRange, state.hours)),
+    hoursList: computed(
+      () => Array.from(getRangeHours(state.selectableRange)).map((disabled, hour) => ({ disabled, hour })).filter(({ hour }) => !(hour % state.step.hours))
+    ),
+    minutesList: computed(
+      () => Array.from(getRangeMinutes(state.selectableRange, state.hours)).map((disabled, minute) => ({ disabled, minute })).filter(({ minute }) => !(minute % state.step.minutes))
+    ),
+    secondsList: computed(
+      () => Array.from(new Array(60)).map((item, second) => ({ second })).filter(({ second }) => !(second % state.step.seconds))
+    ),
     arrowHourList: computed(() => api2.getArrowHourList()),
     arrowMinuteList: computed(() => api2.getArrowMinuteList()),
     arrowSecondList: computed(() => api2.getArrowSecondList()),
-    animationName: ""
+    animationName: "",
+    step: computed(() => ({
+      hours: props.step.hour * 1 || 1,
+      minutes: props.step.minute * 1 || 1,
+      seconds: props.step.second * 1 || 1
+    }))
   });
   return state;
 };
-const renderless = (props, { computed, onMounted, reactive, watch, nextTick }, { emit, refs, constants }) => {
+const renderless = (props, { computed, onMounted, reactive, watch, nextTick }, { emit, vm, constants }) => {
   const api2 = {};
   const state = initState({ reactive, computed, props, api: api2 });
   onMounted(() => {
@@ -45,26 +66,30 @@ const renderless = (props, { computed, onMounted, reactive, watch, nextTick }, {
   Object.assign(api2, {
     state,
     amPm: amPm(props),
-    typeItemHeight: typeItemHeight({ refs }),
-    scrollBarHeight: scrollBarHeight(refs),
+    typeItemHeight: typeItemHeight({ vm }),
+    scrollBarHeight: scrollBarHeight(vm),
     getArrowHourList: getArrowHourList(state),
     getArrowSecondList: getArrowSecondList(state),
     getArrowMinuteList: getArrowMinuteList(state),
     emitSelectRange: emitSelectRange({ emit, state }),
     modifyDateField: modifyDateField({ emit, props, state }),
-    bindScrollEvent: bindScrollEvent({ api: api2, refs }),
+    bindScrollEvent: bindScrollEvent({ api: api2, vm }),
     adjustSpinners: adjustSpinners({ api: api2, state }),
-    adjustSpinner: adjustSpinner({ api: api2, props, refs }),
-    increase: increase(api2),
-    decrease: decrease(api2),
+    adjustSpinner: adjustSpinner({ api: api2, props, vm, state }),
+    increase: increase(api2, state),
+    decrease: decrease(api2, state),
     handleClick: handleClick(api2),
     scrollDown: scrollDown({ api: api2, state }),
-    handleScroll: handleScroll({ api: api2, refs }),
+    handleScroll: handleScroll({ api: api2, vm, state }),
     adjustCurrentSpinner: adjustCurrentSpinner({ api: api2, state })
   });
   watch(
     () => props.date,
     () => {
+      const timeType = ["hours", "minutes", "seconds"];
+      timeType.forEach((type) => {
+        api2.modifyDateField(type, Math.round(state[type] / state.step[type]) * state.step[type]);
+      });
       nextTick(api2.adjustSpinners);
     },
     { immediate: true }

package/timeline-item/index.js

@@ -0,0 +1,77 @@
+import "../chunk-PKUHTIDK.js";
+import { format } from "../common/date";
+const getDate = (dateTime) => ({
+  date: format(dateTime, "yyyy-MM-dd"),
+  time: format(dateTime, "hh:mm")
+});
+const getStatus = ({ state, t }) => (value) => {
+  const status = state.current - value;
+  return status > 0 ? t("ui.steps.done") : status === 0 ? t("ui.steps.doing") : t("ui.steps.wait");
+};
+const computedSpace = ({ props, api }) => () => {
+  const space = props.space || api.rootProps.space;
+  if (/^\d+$/.test(space)) {
+    return `${space}px`;
+  }
+  return space;
+};
+const handleClick = ({ emit, state }) => (node) => {
+  const { index } = node || {};
+  if (!node.disabled) {
+    emit("click", state.isReverse ? state.nodesLength - index - 1 : index, node);
+  }
+};
+const getStatusCls = ({ constants, state }) => (node) => {
+  const { index } = node || {};
+  const { PROCESS_DONE_CLS, PROCESS_CUR_CLS, PROCESS_WAIT_CLS, PROCESS_DISABLED_CLS, PROCESS_ERROR_CLS } = constants;
+  const cls = {};
+  const reverse = state.isReverse;
+  if (node == null ? void 0 : node.disabled) {
+    cls[PROCESS_DISABLED_CLS] = true;
+  } else if (node == null ? void 0 : node.error) {
+    cls[PROCESS_ERROR_CLS] = true;
+  } else {
+    cls[PROCESS_DONE_CLS] = reverse ? index > state.current : index < state.current;
+    cls[PROCESS_CUR_CLS] = index === state.current;
+    cls[PROCESS_WAIT_CLS] = reverse ? index < state.current : index > state.current;
+  }
+  return cls;
+};
+const computedCurrent = ({ state, api }) => () => state.isReverse ? state.nodesLength - api.rootProps.active - 1 : api.rootProps.active;
+const computedIsReverse = (api) => () => api.rootProps.reverse && api.rootProps.vertical;
+const computedItemCls = ({ props, api }) => () => {
+  const itemClass = [];
+  if (api.rootProps.vertical) {
+    itemClass.push("timeline");
+  } else {
+    itemClass.push("normal");
+  }
+  itemClass.push(api.getStatusCls(props.node));
+  return itemClass;
+};
+const computedItemStyle = ({ props, state, api }) => () => {
+  const { index } = props.node;
+  const { computedSpace: computedSpace2, nodesLength } = state;
+  const { textPosition, vertical } = api.rootProps;
+  if (vertical) {
+    return { height: index === nodesLength - 1 ? "" : computedSpace2 || "88px" };
+  }
+  if (textPosition === "right") {
+    if (computedSpace2) {
+      return { flex: `0 0 ${computedSpace2}` };
+    }
+    return null;
+  }
+  return { width: computedSpace2 || 100 / nodesLength + "%" };
+};
+export {
+  computedCurrent,
+  computedIsReverse,
+  computedItemCls,
+  computedItemStyle,
+  computedSpace,
+  getDate,
+  getStatus,
+  getStatusCls,
+  handleClick
+};

package/timeline-item/vue.js

@@ -0,0 +1,44 @@
+import "../chunk-PKUHTIDK.js";
+import {
+  handleClick,
+  getStatusCls,
+  computedItemCls,
+  getStatus,
+  getDate,
+  computedCurrent,
+  computedIsReverse,
+  computedSpace,
+  computedItemStyle
+} from "./index";
+const api = ["state", "handleClick", "getStatusCls", "getStatus", "getDate", "rootProps"];
+const renderless = (props, { computed, reactive, inject }, { t, emit, constants }) => {
+  const api2 = {};
+  const { timelineItems, nodes, props: rootProps } = inject("nodesInject");
+  timelineItems.push(props.node);
+  const state = reactive({
+    nodesLength: computed(() => nodes.length),
+    current: computed(() => api2.computedCurrent()),
+    isReverse: computed(() => api2.computedIsReverse()),
+    computedSpace: computed(() => api2.computedSpace()),
+    computedItemCls: computed(() => api2.computedItemCls()),
+    computedItemStyle: computed(() => api2.computedItemStyle())
+  });
+  Object.assign(api2, {
+    state,
+    rootProps,
+    getDate,
+    computedCurrent: computedCurrent({ state, api: api2 }),
+    computedIsReverse: computedIsReverse(api2),
+    computedItemCls: computedItemCls({ props, api: api2 }),
+    computedItemStyle: computedItemStyle({ props, state, api: api2 }),
+    computedSpace: computedSpace({ props, api: api2 }),
+    getStatus: getStatus({ state, t }),
+    handleClick: handleClick({ emit, state }),
+    getStatusCls: getStatusCls({ constants, state })
+  });
+  return api2;
+};
+export {
+  api,
+  renderless
+};

package/toggle-menu/vue.js

@@ -47,7 +47,6 @@ const renderless = (props, { reactive, watch, computed, onMounted }, { t, servic
   service = service || { base: {} };
   service = {
     getMenuDataSync: props.getMenuDataSync || service.base.getMenuDataSync,
-    // deprecated v3.4.0废弃, v3.16.0移除；移除原因：如果是同步数据则和:data功能重复
     getMenuDataAsync: props.getMenuDataAsync
   };
   Object.assign(api2, {

package/tooltip/index.js

@@ -144,19 +144,18 @@ const observeCallback = ({ state, popperVmRef }) => (mutationsList) => {
 };
 const bindPopper = ({ vm, refs, nextTick, popperVmRef }) => (el) => {
   nextTick(() => vm.bindEvent(el));
-  if (vm.popperVM) {
-    if (!vm.$refs.popper) {
-      popperVmRef.popper = vm.popperVM.$el;
-    } else {
-      popperVmRef.popper = vm.$refs.popper;
-    }
-    refs.popper || (refs.popper = vm.popperVM.$el);
-    nextTick(() => {
-      if (vm.modelValue) {
-        vm.updatePopper();
-      }
-    });
+  let popperVM = vm.popperVM;
+  if (!vm.$refs.popper) {
+    popperVmRef.popper = popperVM.$el;
+  } else {
+    popperVmRef.popper = vm.$refs.popper;
   }
+  refs.popper || (refs.popper = popperVM.$el);
+  nextTick(() => {
+    if (vm.modelValue) {
+      vm.updatePopper();
+    }
+  });
 };
 export {
   bindEvent,

package/tooltip/vue.js

@@ -49,7 +49,17 @@ const initState = ({ reactive, showPopper, popperElm, referenceElm, props, markR
   showContent: inject("showContent", null),
   tipsMaxWidth: inject("tips-max-width", null)
 });
-const renderless = (props, { watch, toRefs, reactive, onBeforeUnmount, onDeactivated, onMounted, onUnmounted, markRaw, inject }, { vm, emit, refs, slots, nextTick, parent }) => {
+const renderless = (props, {
+  watch,
+  toRefs,
+  reactive,
+  onBeforeUnmount,
+  onDeactivated,
+  onMounted,
+  onUnmounted,
+  markRaw,
+  inject
+}, { vm, emit, refs, slots, nextTick, parent }) => {
   const api2 = {};
   const popperParam = { emit, props, nextTick, toRefs, reactive, parent: parent.$parent, refs };
   const popperVmRef = {};

package/top-box/vue.js

@@ -1,5 +1,17 @@
 import "../chunk-PKUHTIDK.js";
-import { clearTimer, startTimer, close, handleAfterLeave, bindEvent, unBindEvent, destroy, watchClosed, getTypeClass, getOffsetStyle, getZindex } from "./index";
+import {
+  clearTimer,
+  startTimer,
+  close,
+  handleAfterLeave,
+  bindEvent,
+  unBindEvent,
+  destroy,
+  watchClosed,
+  getTypeClass,
+  getOffsetStyle,
+  getZindex
+} from "./index";
 const api = ["state", "handleAfterLeave", "clearTimer", "startTimer", "close", "getZindex"];
 const renderless = (props, { computed, onBeforeUnmount, onMounted, reactive, watch }, { vm, parent, constants }) => {
   const api2 = {};

package/tree/index.js

@@ -5,13 +5,14 @@ import TreeStore from "../common/deps/tree-model/tree-store";
 import { addClass, removeClass } from "../common/deps/dom";
 import { on, off } from "../common/deps/dom";
 import { getDataset } from "../common/dataset";
+import { copyArray } from "../common/object";
 const setChildren = (props) => (data) => props.data = data;
 const getChildren = () => (props) => props.data;
 const computedTreeItemArray = () => (props, state) => Array.prototype.slice.call(state.treeItems);
 const computedShowEmptyText = ({ constants, t }) => (props) => props.emptyText || t(constants.EMPTY_TEXT_LOCAL);
 const computedIsEmpty = () => (props, state) => {
   const { childNodes } = state.root;
-  return !childNodes || childNodes.length === 0 || childNodes.every(({ visible }) => !visible);
+  return !childNodes || childNodes.length === 0 || childNodes.every(({ visible }) => !visible) || props.viewType === "plain" && state.plainNodeStore.filteredNodes.length === 0;
 };
 const watchDefaultCheckedKeys = (state) => (value) => {
   state.store.setDefaultCheckedKey(value);
@@ -24,8 +25,8 @@ const watchDefaultExpandedKeys = ({ state, api, nextTick }) => (value) => {
     api.initIsCurrent();
   });
 };
-const watchData = (state) => (value) => {
-  state.store.setData(value);
+const watchData = ({ state }) => (data) => {
+  state.store.setData(data);
 };
 const watchCheckboxItems = () => (value) => {
   Array.prototype.forEach.call(value, (checkbox) => {
@@ -68,8 +69,9 @@ const getDropType = (dropPrev, dropInner, dropNext, dropNode) => {
   }
   return dropType;
 };
-const setDropIndicatorTop = (dropNode, dropIndicator, parent, dropType) => {
+const setDropIndicatorTop = (dropNode, parent, dropType) => {
   const iconElement = dropNode.$el.querySelector(".tiny-tree-node");
+  const dropIndicator = parent.$refs.dropIndicator;
   if (iconElement) {
     const treePosition = parent.$el.getBoundingClientRect();
     const iconPosition = iconElement.getBoundingClientRect();
@@ -118,7 +120,7 @@ const getDragDir = ({ draggingNode, dropNode, allowDrop, emit, dragState }) => {
   }
   return { dropPrev, dropInner, dropNext, userAllowDropInner };
 };
-const dragOver = ({ state, emit, props, refs, vm }) => (event2, dropNode) => {
+const dragOver = ({ state, emit, props, vm }) => (event2, dropNode) => {
   const dragState = state.dragState;
   const oldDropNode = dragState.dropNode;
   if (oldDropNode && oldDropNode !== dropNode) {
@@ -136,7 +138,7 @@ const dragOver = ({ state, emit, props, refs, vm }) => (event2, dropNode) => {
     dragState
   });
   const dropType = getDropType(dropPrev, dropInner, dropNext, dropNode);
-  setDropIndicatorTop(dropNode, refs.dropIndicator, vm, dropType);
+  setDropIndicatorTop(dropNode, vm, dropType);
   dragState.showDropIndicator = dropType === "before" || dropType === "after";
   dragState.allowDrop = dragState.showDropIndicator || userAllowDropInner;
   dragState.dropType = dropType;
@@ -174,9 +176,8 @@ const dragEnd = ({ state, emit }) => (event2) => {
   dragState.allowDrop = true;
   dragState.showDropIndicator = false;
 };
-const created = ({ api, props, state }) => () => {
-  state.isTree = true;
-  const { nodeKey, data, lazy, load, currentNodeKey, checkStrictly, checkDescendants } = props;
+const initTreeStore = ({ api, props, state, emit }) => () => {
+  const { nodeKey, data, lazy, load, afterLoad, currentNodeKey, checkStrictly, checkDescendants } = props;
   const { defaultCheckedKeys, defaultExpandedKeys, autoExpandParent, defaultExpandAll, filterNodeMethod } = props;
   state.store = new TreeStore({
     key: nodeKey,
@@ -184,6 +185,11 @@ const created = ({ api, props, state }) => () => {
     lazy,
     props: props.props,
     load,
+    afterLoad(params) {
+      !state.loaded && (state.loaded = true);
+      emit("load-data", params);
+      afterLoad && afterLoad(params);
+    },
     currentNodeKey,
     checkStrictly,
     checkDescendants,
@@ -195,9 +201,18 @@ const created = ({ api, props, state }) => () => {
   });
   state.root = state.store.root;
   api.initIsCurrent();
+  api.initPlainNodeStore();
+};
+const created = ({ api, state }) => () => {
+  state.isTree = true;
+  api.initTreeStore();
   state.emitter.on("tree-node-drag-start", api.dragStart);
   state.emitter.on("tree-node-drag-over", api.dragOver);
   state.emitter.on("tree-node-drag-end", api.dragEnd);
+  state.emitter.on("tree-node-save", api.saveNode);
+  state.emitter.on("tree-node-edit", api.editNode);
+  state.emitter.on("tree-node-delete", api.deleteConfirm);
+  state.emitter.on("tree-node-add", api.addNode);
 };
 const doClearCurrentStore = (state) => {
   if (state.currentStore.node) {
@@ -228,15 +243,22 @@ const initIsCurrent = ({ props, state }) => () => {
   if (state.store.getCurrentNode() && props.defaultExpandedKeysHighlight) {
     state.store.setCurrentNode(null);
   }
-  if (props.defaultExpandedKeysHighlight && Array.isArray(props.defaultExpandedKeys) && ~props.defaultExpandedKeys.indexOf(props.defaultExpandedKeysHighlight)) {
-    setIsCurrent(state.root, props.defaultExpandedKeys, props.defaultExpandedKeysHighlight, state.currentStore, props.nodeKey);
+  if (props.defaultExpandedKeysHighlight && Array.isArray(props.defaultExpandedKeys) && (~props.defaultExpandedKeys.indexOf(props.defaultExpandedKeysHighlight) || props.lazyCurrent)) {
+    setIsCurrent(
+      state.root,
+      props.defaultExpandedKeys,
+      props.defaultExpandedKeysHighlight,
+      state.currentStore,
+      props.nodeKey
+    );
   }
 };
 const mounted = ({ api, vm }) => () => {
   api.initTabIndex();
   on(vm.$el, "keydown", api.handleKeydown);
 };
-const beforeUnmount = ({ api, vm }) => () => {
+const beforeUnmount = ({ api, vm, state }) => () => {
+  state.action.popoverVisible = false;
   off(vm.$el, "keydown", api.handleKeydown);
 };
 const wrapMounted = ({ api, props, service }) => () => {
@@ -321,11 +343,11 @@ const setCurrentKey = ({ props, state }) => (key) => {
   state.store.setCurrentNodeKey(key);
 };
 const getNode = (state) => (data) => state.store.getNode(data);
-const remove = (state) => (data) => {
-  state.store.remove(data);
+const remove = (state) => (data, isSaveChildNode, isNode) => {
+  state.store.remove(data, isSaveChildNode, isNode);
 };
 const append = (state) => (data, parentNode) => {
-  state.store.append(data, parentNode);
+  state.store.append(data, parentNode, 0);
 };
 const insertBefore = (state) => (data, refNode) => {
   state.store.insertBefore(data, refNode);
@@ -459,18 +481,195 @@ const expandAllNodes = ({ state }) => (expandFlag) => {
     });
   }
 };
+const switchToggle = ({ state }) => (val) => {
+  state.checkEasily = val;
+};
+const getSameDataIndex = (list, data, key = "$treeNodeId") => {
+  let index = -1;
+  list.forEach((item, i) => {
+    if (item[key] === data[key]) {
+      index = i;
+    }
+  });
+  return index;
+};
+const editNode = ({ state }) => (node) => {
+  state.action.type = "edit";
+  state.action.label = node && node.data.label || "";
+  state.action.node = node;
+  state.action.popoverVisible = false;
+};
+const saveNode = ({ state, emit, api }) => () => {
+  const node = state.action.node;
+  if (!node) {
+    return;
+  } else if (state.action.label) {
+    node.data.label = state.action.label;
+    if (node.data._isNewNode) {
+      const index = api.getSameDataIndex(state.treeEdit.addData, node.data);
+      index === -1 ? state.treeEdit.addData.push(node.data) : state.treeEdit.addData.splice(index, 1, node.data);
+      emit("add-node", node);
+    } else {
+      const index = api.getSameDataIndex(state.treeEdit.editData, node.data);
+      index === -1 ? state.treeEdit.editData.push(node.data) : state.treeEdit.editData.splice(index, 1, node.data);
+      emit("edit-node", node);
+    }
+  } else if (node && node.data && node.data._isNewNode) {
+    api.remove(node, false, true);
+  }
+  state.action.node = null;
+};
+const addNode = ({ api }) => (node) => {
+  const newNode = { label: "" };
+  Object.defineProperty(newNode, "_isNewNode", {
+    value: true,
+    enumerable: false,
+    configurable: false,
+    writable: false
+  });
+  api.append(newNode, node.data);
+  setTimeout(() => {
+    const childs = node.childNodes;
+    const child = childs[0];
+    api.editNode(child);
+  }, 100);
+};
+const cancelDelete = ({ state }) => () => {
+  state.action.referenceElm = null;
+  state.action.popoverVisible = false;
+};
+const loopGetTreeData = (result = [], nodes = [], childKey = "childNodes") => {
+  nodes.forEach((node) => {
+    const index = getSameDataIndex(result, node.data);
+    index === -1 && result.push(node.data);
+    if (node[childKey] && node[childKey].length) {
+      result = loopGetTreeData(result, node[childKey]);
+    }
+  });
+  return result;
+};
+const deleteAction = ({ state, api, emit }) => () => {
+  const { node, isSaveChildNode } = state.action;
+  state.action.referenceElm = null;
+  state.action.popoverVisible = false;
+  if (!node.data._isNewNode) {
+    state.treeEdit.deleteData.push(node.data);
+    if (!isSaveChildNode) {
+      state.treeEdit.deleteData = loopGetTreeData(state.treeEdit.deleteData, node.childNodes);
+    }
+  }
+  emit("delete-node", node);
+  api.remove(state.action.node, isSaveChildNode, true);
+};
+const deleteConfirm = ({ state }) => (event2, node) => {
+  state.action.type = "delete";
+  state.action.node = node;
+  state.action.isLeaf = !node.childNodes || !node.childNodes.length;
+  state.action.referenceElm = event2.currentTarget;
+  state.action.popoverVisible = false;
+  state.action.isSaveChildNode = false;
+  setTimeout(() => {
+    state.action.popoverVisible = true;
+  }, 300);
+};
+const openEdit = ({ props, state, api, emit }) => () => {
+  state.action.show = true;
+  state.action.data = copyArray(props.data);
+  api.watchData(state.action.data);
+  emit("open-edit");
+};
+const closeEdit = ({ props, state, api, emit }) => () => {
+  state.action.show = false;
+  state.action.popoverVisible = false;
+  api.watchData(props.data);
+  emit("close-edit");
+  state.treeEdit = { addData: [], deleteData: [], editData: [] };
+};
+const saveEdit = ({ state, emit, props }) => () => {
+  const data = copyArray(state.action.show ? state.action.data : props.data);
+  state.action.show = false;
+  state.action.popoverVisible = false;
+  emit("save-edit", state.treeEdit, data);
+  state.treeEdit = { addData: [], deleteData: [], editData: [] };
+  return data;
+};
+const setAddDisabledKeys = ({ state }) => (data) => {
+  state.action.addDisabled = data || [];
+};
+const setEditDisabledKeys = ({ state }) => (data) => {
+  state.action.editDisabled = data || [];
+};
+const setDeleteDisabledKeys = ({ state }) => (data) => {
+  state.action.deleteDisabled = data || [];
+};
+const initPlainNodeStore = ({ props, state }) => () => {
+  const { nodeKey, pathSplit, filterPlainMethod } = props;
+  const prefixReg = new RegExp(`^\\${pathSplit}+`);
+  const plainNodeStore = { nodes: [], filteredNodes: [] };
+  const walkTree = (node, labelPath, nodeKeyPath) => {
+    if (node && node.data) {
+      labelPath += `${pathSplit}${node.data.label || ""}`;
+      nodeKeyPath += `${pathSplit}${node.data[nodeKey] || ""}`;
+      labelPath = labelPath.replace(prefixReg, "");
+      nodeKeyPath = nodeKeyPath.replace(prefixReg, "");
+      if (labelPath) {
+        const plainNode = { labelPath, nodeKeyPath, node };
+        const paths = labelPath.split(pathSplit);
+        const nodeKeyType = typeof node.data[nodeKey];
+        const nodeKeys = nodeKeyPath.split(pathSplit).map(nodeKeyType === "number" ? Number : String);
+        plainNode.title = paths[paths.length - 1];
+        plainNode.auxi = paths.slice(0, paths.length - 1).join(pathSplit);
+        plainNode.nodeKeyType = nodeKeyType;
+        plainNode.nodeKey = node.data[nodeKey];
+        plainNode.nodeKeys = nodeKeys;
+        plainNode.parentNodeKeys = nodeKeys.slice(0, nodeKeys.length - 1);
+        plainNodeStore.nodes.push(plainNode);
+      }
+    }
+    if (node.childNodes && node.childNodes.length) {
+      node.childNodes.forEach((n) => walkTree(n, labelPath, nodeKeyPath));
+    }
+  };
+  walkTree(state.root, "", "");
+  const filterPlainNode = (data) => !filterPlainMethod || typeof filterPlainMethod === "function" && filterPlainMethod(data);
+  plainNodeStore.filteredNodes = plainNodeStore.nodes.filter(
+    (plainNode) => plainNode.node.visible && filterPlainNode(plainNode.node.data)
+  );
+  state.plainNodeStore = plainNodeStore;
+};
+const handleCheckPlainNode = ({ props, emit }) => (e, plainNode) => {
+  plainNode.node.setChecked(e, !props.checkStrictly);
+  emit("check-plain", plainNode, e);
+};
+const handleClickPlainNode = (emit) => (e, plainNode) => {
+  emit("leave-plain-view", plainNode, e);
+};
+const setCheckedByNodeKey = ({ props, state }) => (key, checked) => {
+  const { nodeKey, checkStrictly } = props;
+  const { nodes: plainNodes } = state.plainNodeStore;
+  const plainNode = plainNodes.find((plainNode2) => plainNode2.node.data[nodeKey] === key);
+  if (plainNode) {
+    plainNode.node.setChecked(checked, !checkStrictly);
+  }
+};
 export {
+  addNode,
   append,
   beforeUnmount,
+  cancelDelete,
   clearCurrentStore,
+  closeEdit,
   closeMenu,
   computedIsEmpty,
   computedShowEmptyText,
   computedTreeItemArray,
   created,
+  deleteAction,
+  deleteConfirm,
   dragEnd,
   dragOver,
   dragStart,
+  editNode,
   expandAllNodes,
   filter,
   getCheckedKeys,
@@ -483,21 +682,35 @@ export {
   getNode,
   getNodeKey,
   getNodePath,
+  getSameDataIndex,
+  handleCheckPlainNode,
+  handleClickPlainNode,
   handleKeydown,
   handleNodeExpand,
   initIsCurrent,
+  initPlainNodeStore,
   initTabIndex,
+  initTreeStore,
   insertAfter,
   insertBefore,
+  loopGetTreeData,
   mounted,
+  openEdit,
   remove,
+  saveEdit,
+  saveNode,
+  setAddDisabledKeys,
   setChecked,
+  setCheckedByNodeKey,
   setCheckedKeys,
   setCheckedNodes,
   setChildren,
   setCurrentKey,
   setCurrentNode,
   setCurrentRadio,
+  setDeleteDisabledKeys,
+  setEditDisabledKeys,
+  switchToggle,
   updateKeyChildren,
   updated,
   watchCheckStrictly,