@opentiny/vue-renderless 3.10.7 → 3.11.0

package/calendar-view/vue.js

@@ -0,0 +1,289 @@
+import "../chunk-G2ADBYYC.js";
+import {
+  computedCalendar,
+  handleEvents,
+  selectDay,
+  getEventByTime,
+  isToday,
+  dateIsToday,
+  toToday,
+  getAllWednesdaysInYear,
+  getAllWednesdaysInMonth,
+  getAllDatesOfCurrWeek,
+  initWeeklyCalendar,
+  getDatesOfPreviousWeek,
+  getDatesOfNextWeek,
+  getPrevWeek,
+  getNextWeek,
+  goPrevMonth,
+  goNextMonth,
+  currentDateChange,
+  newSchedule,
+  handleMouseenter,
+  handleMouseleave,
+  isSelectedDate,
+  isStartOrEndDay,
+  getDayBgColor,
+  isShowNewSchedule,
+  genDayTimes,
+  isShowMark,
+  computeCascaderOptions,
+  handleCascaderChange,
+  setCascaderVisible,
+  getEventByMonth,
+  getEventByDate,
+  getWeekOfDate,
+  handleDropBtnClick,
+  getEventShowTime,
+  getCurWeekEvent,
+  touchstart,
+  touchmove,
+  touchend
+} from "./index";
+import throttle from "@opentiny/vue-renderless/common/deps/throttle";
+const api = [
+  "state",
+  "renderProxy",
+  "isToday",
+  "dateIsToday",
+  "getEventByTime",
+  "selectDay",
+  "toToday",
+  "getPrevWeek",
+  "getNextWeek",
+  "goPrevMonth",
+  "goNextMonth",
+  "currentDateChange",
+  "newSchedule",
+  "handleMouseenter",
+  "handleMouseleave",
+  "isSelectedDate",
+  "isStartOrEndDay",
+  "getDayBgColor",
+  "isShowNewSchedule",
+  "isShowMark",
+  "handleCascaderChange",
+  "setCascaderVisible",
+  "handleDropBtnClick",
+  "getEventShowTime",
+  "touchstart",
+  "touchmove",
+  "touchend"
+];
+const initState = ({ reactive, props, computed, api: api2, images, modesIcon }) => {
+  const state = reactive({
+    dayStartTime: props._constants.DAY_START_TIME,
+    dayEndTime: props._constants.DAY_END_TIME,
+    wednesday: props._constants.WEDNESDAY,
+    modesIcon,
+    images,
+    weekDays: [0, 1, 2, 3, 4, 5, 6],
+    dayTimes: computed(() => api2.genDayTimes()),
+    mode: props.mode,
+    events: [],
+    eventsChangeHash: 0,
+    weekDates: [],
+    prevWeekDates: [],
+    nextWeekDates: [],
+    monthEvents: [],
+    nextMonthEvents: [],
+    prevMonthEvents: [],
+    selectedDateEvents: [],
+    monthWednesdays: [],
+    wholeYearWednesdays: [],
+    index: 0,
+    delta: 0,
+    startPos: {
+      X: 0,
+      Y: 0
+    },
+    deltaPos: {
+      X: 0,
+      Y: 0
+    },
+    offsetPos: {
+      X: 0,
+      Y: 0
+    },
+    curWeekEvents: {},
+    scrollStartTime: 0,
+    debounceTime: 100,
+    touchTime: 0,
+    direction: "",
+    monthEventsLength: 0,
+    activedWeekIndex: -1,
+    selectedTip: "",
+    selectedDate: "",
+    selectedDates: [],
+    showYear: false,
+    showMonth: false,
+    showSelectedDateEvents: false,
+    multiSelect: computed(() => props.multiSelect),
+    eventTipVisible: false,
+    cascaderVisible: false,
+    eventTipContent: {},
+    activeYear: props.year,
+    displayMode: props.mode,
+    activeMonth: props.month,
+    currentDate: props.year + "-" + props.month,
+    cascaderCurrent: [props.year || (/* @__PURE__ */ new Date()).getFullYear(), props.month || (/* @__PURE__ */ new Date()).getMonth + 1],
+    cascaderOptions: computed(() => api2.computeCascaderOptions()),
+    calendar: computed(() => api2.computedCalendar("cur")),
+    prevCalendar: computed(() => api2.computedCalendar("prev")),
+    nextCalendar: computed(() => api2.computedCalendar("next"))
+  });
+  return state;
+};
+const initWatch = ({ watch, props, state, emit, api: api2, nextTick }) => {
+  watch(
+    () => props.mode,
+    () => {
+      state.mode = props.mode;
+    }
+  );
+  watch(
+    () => props.events,
+    () => {
+      api2.handleEvents();
+    },
+    { deep: true }
+  );
+  watch(
+    () => state.selectedDate,
+    () => {
+      if (state.mode === "month") {
+        api2.getEventByDate(state.selectedDate, state.selectedDateEvents);
+      }
+      emit("selected-date-change", state.selectedDate);
+    },
+    { deep: true }
+  );
+  watch(
+    () => state.weekDates,
+    (value, oldValue) => {
+      state.prevWeekDates = api2.getWeekOfDate("prev", state.weekDates[3].value);
+      state.nextWeekDates = api2.getWeekOfDate("next", state.weekDates[3].value);
+      api2.getCurWeekEvent();
+      emit("week-change", value, oldValue);
+    },
+    { deep: true }
+  );
+  watch(
+    () => state.eventsChangeHash,
+    () => {
+      if (state.mode === "schedule" || state.mode === "timeline") {
+        api2.getCurWeekEvent();
+      }
+    }
+  );
+  watch(
+    () => state.activedWeekIndex,
+    () => {
+      nextTick(() => {
+        state.showSelectedDateEvents = true;
+      });
+    }
+  );
+  watch(
+    () => props.month,
+    (val, oldVal) => {
+      if (val !== oldVal) {
+        state.activeMonth = val;
+      }
+    },
+    { immediate: true }
+  );
+  watch(
+    () => props.year,
+    (val, oldVal) => {
+      if (val !== oldVal) {
+        state.activeYear = val;
+      }
+    },
+    { immediate: true }
+  );
+  watch(
+    () => state.activeYear,
+    (value, oldValue) => {
+      if (value !== oldValue) {
+        state.currentDate = state.activeYear + "-" + state.activeMonth;
+        state.cascaderCurrent = [Number(state.activeYear), Number(state.activeMonth)];
+        api2.getAllDatesOfCurrWeek(state.currentDate + "-4");
+        emit("year-change", value, oldValue);
+        emit("update:modelValue", value, oldValue);
+        api2.handleEvents();
+      }
+    }
+  );
+  watch(
+    () => state.activeMonth,
+    (value, oldValue) => {
+      if (value !== oldValue) {
+        state.currentDate = state.activeYear + "-" + state.activeMonth;
+        state.cascaderCurrent = [Number(state.activeYear), Number(state.activeMonth)];
+        api2.getAllDatesOfCurrWeek(state.currentDate + "-4");
+        emit("month-change", value, oldValue);
+        api2.handleEvents();
+      }
+    }
+  );
+};
+const initApi = ({ vm, api: api2, state, t, props, emit, nextTick }) => {
+  Object.assign(api2, {
+    state,
+    touchstart: touchstart({ state }),
+    touchmove: touchmove({ state }),
+    touchend: touchend({ state, api: api2, vm }),
+    handleEvents: handleEvents({ props, state }),
+    computedCalendar: computedCalendar({ props, state }),
+    computeCascaderOptions: computeCascaderOptions(t),
+    isToday: isToday(state),
+    dateIsToday: dateIsToday(),
+    selectDay: selectDay({ state, emit }),
+    getEventByTime: getEventByTime({ props, state }),
+    toToday: toToday({ state, api: api2, nextTick }),
+    getAllWednesdaysInYear: getAllWednesdaysInYear({ state }),
+    getAllWednesdaysInMonth: getAllWednesdaysInMonth({ state }),
+    getAllDatesOfCurrWeek: throttle(50, true, getAllDatesOfCurrWeek({ props, state })),
+    initWeeklyCalendar: initWeeklyCalendar({ api: api2, state }),
+    getDatesOfPreviousWeek: getDatesOfPreviousWeek({ api: api2, state }),
+    getDatesOfNextWeek: getDatesOfNextWeek({ api: api2, state }),
+    currentDateChange: currentDateChange({ api: api2, state }),
+    newSchedule: newSchedule({ emit }),
+    getPrevWeek: throttle(50, true, getPrevWeek({ api: api2, state, emit })),
+    getNextWeek: throttle(50, true, getNextWeek({ api: api2, state, emit })),
+    goPrevMonth: throttle(50, true, goPrevMonth({ state })),
+    goNextMonth: throttle(50, true, goNextMonth({ state })),
+    handleMouseenter: handleMouseenter({ vm, state }),
+    handleMouseleave: handleMouseleave({ state }),
+    isSelectedDate: isSelectedDate({ state }),
+    isStartOrEndDay: isStartOrEndDay({ state }),
+    getDayBgColor: getDayBgColor({ props }),
+    isShowNewSchedule: isShowNewSchedule({ props }),
+    genDayTimes: genDayTimes({ props }),
+    isShowMark: isShowMark({ props }),
+    handleCascaderChange: handleCascaderChange({ state }),
+    setCascaderVisible: setCascaderVisible(state),
+    getEventByMonth: getEventByMonth({ state }),
+    getEventByDate: getEventByDate({ state }),
+    getWeekOfDate: getWeekOfDate(),
+    getEventShowTime: getEventShowTime({ state }),
+    getCurWeekEvent: getCurWeekEvent({ state, api: api2 }),
+    handleDropBtnClick: handleDropBtnClick({ api: api2, state })
+  });
+};
+const renderless = (props, { computed, reactive, watch, onMounted }, { vm, t, emit, nextTick }, { images, modesIcon }) => {
+  const api2 = {};
+  const state = initState({ reactive, props, computed, api: api2, images, modesIcon });
+  initWatch({ vm, api: api2, watch, props, state, emit, nextTick });
+  initApi({ vm, api: api2, state, t, props, emit, nextTick });
+  onMounted(() => {
+    api2.initWeeklyCalendar(`${state.activeYear}-${state.activeMonth}-4`);
+    api2.handleEvents();
+  });
+  return api2;
+};
+export {
+  api,
+  renderless
+};

package/card/index.js

@@ -1,4 +1,4 @@
-import "../chunk-PKUHTIDK.js";
+import "../chunk-G2ADBYYC.js";
 import { isNull } from "../common/type";
 const handelIconClick = ({ emit }) => (item, index, event) => {
   if (item.disabled)

package/card/vue.js

@@ -1,4 +1,4 @@
-import "../chunk-PKUHTIDK.js";
+import "../chunk-G2ADBYYC.js";
 import {
   handelIconClick,
   getSliceNum,

package/card-group/index.js

@@ -1,4 +1,4 @@
-import "../chunk-PKUHTIDK.js";
+import "../chunk-G2ADBYYC.js";
 const getStyle = ({ props }) => () => {
   const size = props.size || "medium";
   const sizeMap = {

package/card-group/vue.js

@@ -1,4 +1,4 @@
-import "../chunk-PKUHTIDK.js";
+import "../chunk-G2ADBYYC.js";
 import { getStyle } from "./index";
 const api = ["state"];
 const renderless = (props, { reactive, computed }, { vm }) => {

package/card-template/index.js

@@ -1,4 +1,4 @@
-import "../chunk-PKUHTIDK.js";
+import "../chunk-G2ADBYYC.js";
 import PopupManager from "../common/deps/popup-manager";
 const toolClick = (showMoreTools) => (cb) => {
   typeof cb === "function" && cb();

package/card-template/vue.js

@@ -1,4 +1,4 @@
-import "../chunk-PKUHTIDK.js";
+import "../chunk-G2ADBYYC.js";
 import { toolClick, computedTools, computedMoreTools } from "./index";
 const api = ["state", "toolClick"];
 const renderless = (props, { computed, reactive }, { t, refs, constants }) => {

package/carousel/index.js

@@ -1,4 +1,4 @@
-import "../chunk-PKUHTIDK.js";
+import "../chunk-G2ADBYYC.js";
 import throttle from "../common/deps/throttle";
 import { POSITION } from "../common";
 const pauseTimer = (state) => () => clearInterval(state.timer);

package/carousel/vue.js

@@ -1,4 +1,4 @@
-import "../chunk-PKUHTIDK.js";
+import "../chunk-G2ADBYYC.js";
 import {
   onComplete,
   handleMouseEnter,

package/carousel-item/index.js

@@ -1,4 +1,4 @@
-import "../chunk-PKUHTIDK.js";
+import "../chunk-G2ADBYYC.js";
 const processIndex = ({ activeIndex, index, length }) => {
   if (activeIndex === 0 && index === length - 1) {
     return -1;

package/carousel-item/vue.js

@@ -1,4 +1,4 @@
-import "../chunk-PKUHTIDK.js";
+import "../chunk-G2ADBYYC.js";
 import {
   processIndex,
   calculateTranslate,

package/cascader/index.js

@@ -1,4 +1,4 @@
-import "../chunk-PKUHTIDK.js";
+import "../chunk-G2ADBYYC.js";
 import browser from "../common/browser";
 import { isNull } from "../common/type";
 import debounce from "../common/deps/debounce";
@@ -120,10 +120,8 @@ const toggleDropDownVisible = ({ emit, nextTick, refs, state, updatePopper }) =>
   if (visible !== state.dropDownVisible) {
     state.dropDownVisible = visible;
     if (visible) {
-      nextTick(() => {
-        updatePopper();
-        state.panel.scrollIntoView();
-      });
+      updatePopper();
+      state.panel.scrollIntoView();
     }
     input && input.getInput && input.getInput().setAttribute("aria-expanded", visible);
     emit("visible-change", visible);

package/cascader/vue.js

@@ -1,7 +1,7 @@
 import {
   __spreadProps,
   __spreadValues
-} from "../chunk-PKUHTIDK.js";
+} from "../chunk-G2ADBYYC.js";
 import {
   getConfig,
   deleteTag,
@@ -61,6 +61,7 @@ const api = [
 const initState = ({ reactive, props, computed, parent, api: api2, t, constants, refs, inject }) => {
   const state = reactive({
     showAutoWidth: inject("showAutoWidth", null),
+    /** popper 元素是否显示。 它是通过v-show 绑定到页面上，造成隐藏时，popperJs并没有destory,有一定的性能影响 */
     dropDownVisible: false,
     checkedValue: props.modelValue || null,
     inputHover: false,

package/cascader-menu/index.js

@@ -1,12 +1,20 @@
-import "../chunk-PKUHTIDK.js";
+import "../chunk-G2ADBYYC.js";
 const handleExpand = (state) => (e) => state.activeNode = e.target;
-const handleMouseMove = ({ api, parent, refs, state, svg }) => (e) => {
+const handleMouseMove = ({
+  api,
+  parent,
+  refs,
+  state,
+  svg
+}) => (e) => {
   const { hoverZone } = refs;
   if (!state.activeNode || !hoverZone) {
     return;
   }
   if (state.activeNode.contains(e.target)) {
-    clearTimeout(state.hoverTimer);
+    if (state.hoverTimer) {
+      clearTimeout(state.hoverTimer);
+    }
     const { left } = refs.cascaderMenu.$parent.$el.getBoundingClientRect();
     const startX = e.clientX - left;
     const { offsetWidth, offsetHeight } = refs.cascaderMenu.$parent.$el;

package/cascader-menu/vue.js

@@ -1,4 +1,4 @@
-import "../chunk-PKUHTIDK.js";
+import "../chunk-G2ADBYYC.js";
 import { handleExpand, handleMouseMove, clearHoverZone } from "./index";
 import { CASCADER } from "../common";
 import { random } from "../common/string";

package/cascader-mobile/index.js

@@ -1,4 +1,4 @@
-import "../chunk-PKUHTIDK.js";
+import "../chunk-G2ADBYYC.js";
 import TreeStore from "../common/deps/tree-model/tree-store";
 const close = ({ state, emit }) => () => {
   state.search.show = false;

package/cascader-mobile/vue.js

@@ -1,4 +1,4 @@
-import "../chunk-PKUHTIDK.js";
+import "../chunk-G2ADBYYC.js";
 import {
   close,
   watchVisible,

package/cascader-node/index.js

@@ -1,4 +1,4 @@
-import "../chunk-PKUHTIDK.js";
+import "../chunk-G2ADBYYC.js";
 const comptCheckPath = ({ api, parent, state }) => () => {
   if (!state.config.checkStrictly) {
     return false;
@@ -17,7 +17,7 @@ const handleExpand = ({ api, parent, props, state }) => () => {
       }
       if (multiple) {
         const checked = state.isLeaf ? props.node.checked : false;
-        api.handleMultiCheckChange(checked);
+        api.handleMultiCheckChange(Boolean(checked));
       }
     });
   } else {

package/cascader-node/vue.js

@@ -1,4 +1,4 @@
-import "../chunk-PKUHTIDK.js";
+import "../chunk-G2ADBYYC.js";
 import { comptCheckPath, handleExpand, isInPath, handleCheckChange, handleMultiCheckChange } from "./index";
 const api = ["state", "handleMultiCheckChange", "handleCheckChange", "handleExpand"];
 const renderless = (props, { computed, reactive, inject }, { dispatch }) => {

package/cascader-panel/index.js

@@ -1,8 +1,9 @@
-import "../chunk-PKUHTIDK.js";
+import "../chunk-G2ADBYYC.js";
 import { isNull } from "../common/type";
 import { isEqual } from "../common/object";
 import { isEmpty } from "../cascader";
 import { KEY_CODE, CASCADER } from "../common";
+import scrollIntoViewCommon from "../common/deps/scroll-into-view";
 const watchCheckedValue = ({ api, emit, props, state }) => (value) => {
   if (!isEqual(value, props.modelValue)) {
     state.checkStrictly && api.calculateCheckedNodePaths();
@@ -34,12 +35,14 @@ const syncMenuState = ({ api, nextTick, state }) => () => {
 const syncMultiCheckState = ({ api, state }) => () => {
   const nodes = api.getFlattedNodes(state.leafOnly);
   nodes.forEach((node) => {
-    node.syncCheckState(state.checkedValue);
+    if (state.checkedValue) {
+      node.syncCheckState(state.checkedValue);
+    }
   });
 };
 const syncActivePath = ({ api, state }) => () => {
   if (!isEmpty(state.activePath)) {
-    const nodes = state.activePath.map((node) => api.getNodeByValue(node.getValue()));
+    const nodes = state.activePath.map((node) => api.getNodeByValue(node.getValue())).filter((node) => node);
     if (isNull(nodes[0])) {
       state.activePath = [];
     } else {
@@ -99,25 +102,25 @@ const checkNode = (api) => (el) => {
 const handleKeyDown = ({ api, emit, menus }) => (event) => {
   const { target, keyCode } = event;
   if (keyCode === KEY_CODE.ArrowUp) {
-    const prev = api.getSibling(target, -1);
-    focusNode(prev);
+    const prev = getSibling(target, -1);
+    api.focusNode(prev);
   } else if (keyCode === KEY_CODE.ArrowDown) {
-    const next = api.getSibling(target, 1);
-    focusNode(next);
+    const next = getSibling(target, 1);
+    api.focusNode(next);
   } else if (keyCode === KEY_CODE.ArrowLeft) {
-    const preMenu = menus[getMenuIndex(target) - 1];
+    const preMenu = menus[Number(api.getMenuIndex(target)) - 1];
     if (preMenu) {
       const expandedNode = preMenu.$el.querySelector(CASCADER.CascaderNodeExpand);
-      focusNode(expandedNode);
+      api.focusNode(expandedNode);
     }
   } else if (keyCode === KEY_CODE.ArrowRight) {
-    const nextMenu = menus[getMenuIndex(target) + 1];
+    const nextMenu = menus[Number(api.getMenuIndex(target)) + 1];
     if (nextMenu) {
       const firstNode = nextMenu.$el.querySelector(CASCADER.CascaderNodeTab);
-      focusNode(firstNode);
+      api.focusNode(firstNode);
     }
   } else if (keyCode === KEY_CODE.Enter) {
-    checkNode(target);
+    api.checkNode(target);
   } else if (~[KEY_CODE.Escape, KEY_CODE.Tab].indexOf(keyCode)) {
     emit("close");
   }
@@ -141,7 +144,8 @@ const handleExpand = ({ emit, state }) => (node, silent) => {
 const handleCheckChange = (state) => (value) => {
   state.checkedValue = value;
 };
-const lazyLoad = ({ api, $parent, state, Store }) => (node, onFullfiled) => {
+const lazyLoad = ({ api, $parent, state, Store }) => (currentNode, onFullfiled) => {
+  let node = currentNode;
   if (!node) {
     node = node || { root: true, level: 0 };
     state.store = new Store([], state.config);
@@ -159,7 +163,7 @@ const lazyLoad = ({ api, $parent, state, Store }) => (node, onFullfiled) => {
       const leafKey = state.config.leaf;
       if (Array.isArray(dataList) && dataList.filter((item) => item[valueKey] === nodeValue).length > 0) {
         const checkedNode = state.store.getNodeByValue(nodeValue);
-        if (!checkedNode.data[leafKey]) {
+        if (!(checkedNode == null ? void 0 : checkedNode.data[leafKey])) {
           api.lazyLoad(checkedNode, () => {
             api.handleExpand(checkedNode);
           });
@@ -182,7 +186,7 @@ const scrollIntoView = ({ menus }) => () => {
     if (menuElement) {
       const container = menuElement.querySelector(CASCADER.ScrollWrap);
       const activeNode = menuElement.querySelector(CASCADER.CascaderActice) || menuElement.querySelector(CASCADER.ActivePath);
-      scrollIntoView(container, activeNode);
+      scrollIntoViewCommon(container, activeNode);
     }
   });
 };
@@ -213,9 +217,10 @@ const getCheckedNodes = ({ api, state }) => (leafOnly, cascaderCheckedValue) =>
   };
   if (state.multiple) {
     const nodes = api.getFlattedNodes(leafOnly);
-    return nodes.filter((node) => node.checked && isCascaderChecked(node.value, cascaderCheckedValue));
+    return nodes.filter((node2) => node2.checked && isCascaderChecked(node2.value, cascaderCheckedValue));
   }
-  return isEmpty(state.checkedValue) ? [] : [api.getNodeByValue(state.checkedValue)];
+  const node = api.getNodeByValue(state.checkedValue);
+  return isEmpty(state.checkedValue) || !node ? [] : [node];
 };
 const clearCheckedNodes = ({ api, state }) => () => {
   const { multiple, emitPath } = state.config;

package/cascader-panel/node.js

@@ -1,4 +1,4 @@
-import "../chunk-PKUHTIDK.js";
+import "../chunk-G2ADBYYC.js";
 import { isEqual } from "../common/object";
 import { capitalize } from "../common/string";
 import { isNull } from "../common/type";
@@ -14,7 +14,7 @@ class Node {
   initState() {
     const { value, label } = this.config;
     this.value = this.data[value];
-    this.label = this.data[label];
+    this.label = String(this.data[label]);
     this.pathNodes = this.calculatePathNodes();
     this.path = this.pathNodes.map((node) => node.value);
     this.pathLabels = this.pathNodes.map((node) => node.label);
@@ -34,15 +34,18 @@ class Node {
       const leafValue = data[leaf];
       const isLeaf = !isNull(leafValue) ? leafValue : loaded ? !children.length : false;
       this.hasChildren = !isLeaf;
-      return isLeaf;
+      return Boolean(isLeaf);
     }
     return !hasChildren;
   }
+  /**
+   * 当前节点是否被disable
+   */
   get isDisabled() {
     const { data, parent, config } = this;
     const { checkStrictly, disabled } = config;
     const disabledKey = disabled;
-    return data[disabledKey] || !checkStrictly && parent && parent.isDisabled;
+    return Boolean(data[disabledKey] || !checkStrictly && parent && parent.isDisabled);
   }
   calculatePathNodes() {
     const nodes = [this];
@@ -62,6 +65,12 @@ class Node {
   getValueByOption() {
     return this.config.emitPath ? this.getPath() : this.getValue();
   }
+  /**
+   *
+   * @param allLevels 输入框中是否显示选中值的完整路径
+   * @param separator 分割符
+   * @returns 选中值的路径
+   */
   getText(allLevels, separator) {
     return allLevels ? this.pathLabels.join(separator) : this.label;
   }
@@ -98,7 +107,7 @@ class Node {
   }
   syncCheckState(checkedValue) {
     const value = this.getValueByOption();
-    const checked = this.isSameNode(checkedValue, value);
+    const checked = this.isSameNode(checkedValue);
     this.doCheck(checked);
   }
   setCheckState(checked) {

package/cascader-panel/store.js

@@ -1,4 +1,4 @@
-import "../chunk-PKUHTIDK.js";
+import "../chunk-G2ADBYYC.js";
 import Node from "./node";
 import { valueEquals, coerceTruthyValueToArray as toArray } from "./index";
 const flatNodes = (data, leafOnly) => data.reduce((prev, node) => {
@@ -24,21 +24,38 @@ class Store {
     this.flattedNodes = this.getFlattedNodes(false, false);
     this.leafNodes = this.getFlattedNodes(true, false);
   }
+  /**
+   * 添加节点到parentNode
+   */
   appendNode(nodeData, parentNode) {
     const { config, nodes } = this;
     const node = new Node(nodeData, config, parentNode);
     const children = parentNode ? parentNode.children : nodes;
     children.push(node);
   }
+  /**
+   * 添加节点到parentNode
+   */
   appendNodes(nodeDataList, parentNode) {
     nodeDataList = toArray(nodeDataList);
     nodeDataList.forEach((nodeData) => this.appendNode(nodeData, parentNode));
   }
+  /**
+   * 获取节点值
+   * @param leafOnly 只包含叶子节点
+   * @param cached 取缓存（flattedNodes或者leafNodes）中的数据
+   * @returns
+   */
   getFlattedNodes(leafOnly, cached = true) {
     const { leafNodes, flattedNodes } = this;
     const cachedNodes = leafOnly ? leafNodes : flattedNodes;
     return cached ? cachedNodes : flatNodes(this.nodes, leafOnly);
   }
+  /**
+   * 通过节点值获取Node节点
+   * @param value
+   * @returns
+   */
   getNodeByValue(value) {
     if (value) {
       const lazy = !this.config.lazy;