@zidian-primitive/cascader 0.2.2 → 0.3.0

package/esm/components/node/CascaderNode.js

@@ -1,8 +1,9 @@
 import { jsx, jsxs, Fragment } from 'react/jsx-runtime';
-import { useContext, useRef, useCallback, useEffect } from 'react';
+import { memo, useContext, useRef, useCallback, useEffect } from 'react';
 import { CascaderContext, CascaderPanelContext } from '../../context/index.js';
+import { getNextStatus } from '../../utils/logic.js';
 
-const CascaderNode = (props) => {
+const CascaderNode = memo((props) => {
   const {
     node,
     isLeaf,
@@ -12,7 +13,7 @@ const CascaderNode = (props) => {
     render,
     ...elementProps
   } = props;
-  const { onSelectChange } = useContext(CascaderContext);
+  const { setNodeCheckStatus } = useContext(CascaderContext);
   const { showIndicator, registerNode } = useContext(CascaderPanelContext);
   const nodeRef = useRef(null);
   const handleRef = useCallback((el) => {
@@ -24,23 +25,34 @@ const CascaderNode = (props) => {
   const handleClick = (event) => {
     if (isLeaf) {
       if (onClick) onClick(node);
-      if (onTrigger) onTrigger(node.level, node.indices);
-    } else {
-      if (onTrigger) onTrigger(node.level, node.indices);
     }
+    if (onTrigger) onTrigger(node.level, node.indices);
   };
   useEffect(() => {
-    if (isActive && nodeRef.current) {
-      const parent = nodeRef.current.parentElement;
-      if (parent) {
-        parent.scrollTo({
-          top: nodeRef.current.offsetTop,
-          behavior: "smooth"
-        });
-      }
+    if (!isActive || !nodeRef.current) return;
+    const node2 = nodeRef.current;
+    const parent = node2.parentElement;
+    if (!parent) return;
+    const nodeTop = node2.offsetTop;
+    const nodeBottom = nodeTop + node2.offsetHeight;
+    const viewTop = parent.scrollTop;
+    const viewBottom = viewTop + parent.clientHeight;
+    if (nodeTop < viewTop) {
+      parent.scrollTo({
+        top: nodeTop,
+        behavior: "smooth"
+      });
+    } else if (nodeBottom > viewBottom) {
+      parent.scrollTo({
+        top: nodeBottom - parent.clientHeight,
+        behavior: "smooth"
+      });
     }
   }, [isActive]);
-  return /* @__PURE__ */ jsx("div", { ref: handleRef, onClick: handleClick, "data-active": isActive, ...elementProps, children: render ? render({ node, onSelectChange }) : /* @__PURE__ */ jsxs(Fragment, { children: [
+  return /* @__PURE__ */ jsx("div", { ref: handleRef, onClick: handleClick, "data-active": isActive ? isActive : void 0, ...elementProps, children: render ? render({
+    node,
+    handleToggleSelect: (node?.checkStatus || node.checkStatus === 0) && setNodeCheckStatus ? (nodeIdx) => setNodeCheckStatus(nodeIdx, getNextStatus(node.checkStatus)) : void 0
+  }) : /* @__PURE__ */ jsxs(Fragment, { children: [
     /* @__PURE__ */ jsx("span", { style: { flex: 1 }, children: node.label }),
     !isLeaf && /* @__PURE__ */ jsx(
       "svg",
@@ -55,7 +67,7 @@ const CascaderNode = (props) => {
       }
     )
   ] }) });
-};
+});
 CascaderNode.displayName = "CascaderNode";
 
 export { CascaderNode };

package/esm/components/root/CascaderRoot.js

@@ -5,15 +5,13 @@ import { CascaderContext } from '../../context/index.js';
 const CascaderRoot = forwardRef((props, ref) => {
   const {
     isSelected = false,
-    selectType,
-    onSelectChange,
     children,
+    setNodeCheckStatus,
     ...elementProps
   } = props;
   return /* @__PURE__ */ jsx(CascaderContext.Provider, { value: {
     isSelected,
-    selectType,
-    onSelectChange
+    setNodeCheckStatus
   }, children: /* @__PURE__ */ jsx("div", { ref, ...elementProps, children }) });
 });
 CascaderRoot.displayName = "CascaderRoot";

package/esm/context/index.js

@@ -4,8 +4,7 @@ const BLANK_FUNCTION = () => {
 };
 const CascaderContext = createContext({
   isSelected: false,
-  selectType: "single",
-  onSelectChange: void 0
+  setNodeCheckStatus: void 0
 });
 const CascaderPanelContext = createContext({
   showIndicator: false,

package/esm/hooks/useCascader.js

@@ -1,9 +1,9 @@
 import { useMemo, useCallback, useState, useEffect } from 'react';
+import { changeMultipleNodeStatus, CHECK_ALL, changeSelected, changeNodeStatus } from '../utils/logic.js';
 import { buildCascaderEngine, getShowPath, getCascadeColumns, changeShowPath } from '../utils/data.js';
-import { setMultipleNodeStatus, setNodeCheckStatus } from '../utils/logic.js';
 
 function useCascader(options) {
-  const { data, handleDataConfig, selectOption, curShow } = options;
+  const { data, handleDataConfig, selectOption, pathOption } = options;
   const sortedData = useMemo(() => {
     return [...data].sort((a, b) => {
       for (const field of handleDataConfig.levels) {
@@ -16,48 +16,109 @@ function useCascader(options) {
   const sourceNodeData = useMemo(() => {
     return buildCascaderEngine(sortedData, handleDataConfig);
   }, [sortedData, handleDataConfig]);
-  const getInitialStatus = useCallback((sourceNodeData2) => {
+  const showConfig = useMemo(() => {
+    return pathOption?.showConfig ? pathOption.showConfig : { depth: handleDataConfig.levels.length - 1, showType: "label" };
+  }, [pathOption?.showConfig]);
+  const selectValueType = useMemo(() => selectOption?.valueType ?? "label", [selectOption?.valueType]);
+  const getStatusByOption = useCallback((sourceNodeData2, selected) => {
     const statusArray = new Uint8Array(sourceNodeData2.length);
-    if (selectOption?.defaultSelected) {
-      const defaultIndices = sourceNodeData2.filter(
-        (node) => selectOption.defaultSelected.find(
-          (selected) => node.raw?.value === selected
-        )
-      ).map((node) => node.index);
-      return setMultipleNodeStatus(sourceNodeData2, statusArray, defaultIndices, 1);
+    if (selected) {
+      const levels = handleDataConfig.levels;
+      const selectIndices = [];
+      for (let node of sourceNodeData2) {
+        if (node.depth === levels.length - 1 && selected.includes(node[selectValueType])) {
+          selectIndices.push(node.index);
+        }
+      }
+      return changeMultipleNodeStatus(sourceNodeData2, selectIndices, CHECK_ALL, statusArray);
     }
     return statusArray;
-  }, [selectOption]);
-  const initPath = useMemo(() => getShowPath(sourceNodeData, sourceNodeData.find((node) => curShow === node.value || curShow === node.label)), [sourceNodeData, curShow]);
-  const [checkStatusArray, setCheckStatusArray] = useState(getInitialStatus(sourceNodeData));
-  const [path, setPath] = useState(initPath);
-  const columns = useMemo(() => {
-    return getCascadeColumns(sourceNodeData, path);
-  }, [sourceNodeData, initPath, path]);
-  const handleChangePath = (depth, index) => {
-    setPath(changeShowPath(
-      sourceNodeData,
-      { oldPath: path, action: { depth, nodeIdx: index } }
-    ));
-  };
-  const handleChangeCheckStatus = (nodeIdx) => {
-    const newStatusArray = setNodeCheckStatus(sourceNodeData, checkStatusArray, nodeIdx);
-    setCheckStatusArray(newStatusArray);
-  };
+  }, [selectValueType, handleDataConfig]);
+  const getPathByOption = useCallback((sourceNodeData2, value) => {
+    return getShowPath(
+      sourceNodeData2,
+      sourceNodeData2.find((node) => showConfig.depth === node.depth && node[showConfig.showType] === value)
+    );
+  }, [showConfig]);
+  const isControlled = useMemo(() => pathOption?.showValue || pathOption?.showValue === 0, [pathOption?.showValue]);
+  const initialPath = useMemo(() => getPathByOption(
+    sourceNodeData,
+    pathOption?.showValue ?? pathOption?.defaultShowValue
+  ), [sourceNodeData, pathOption?.defaultShowValue, pathOption?.showValue]);
+  const initialSelected = useMemo(() => new Set(
+    selectOption?.selected ?? selectOption?.defaultSelected
+  ), [selectOption?.selected, selectOption?.defaultSelected]);
+  const initialStatusArray = useMemo(() => getStatusByOption(
+    sourceNodeData,
+    selectOption?.selected ?? selectOption?.defaultSelected
+  ), [sourceNodeData]);
+  const [internalPath, setInternalPath] = useState(initialPath);
+  const [internalSelected, setInternalSelected] = useState(initialSelected);
+  const [checkStatusArray, setCheckStatusArray] = useState(initialStatusArray);
+  const path = useMemo(() => isControlled ? initialPath : internalPath, [sourceNodeData, internalPath, isControlled]);
+  const columns = useMemo(() => getCascadeColumns(sourceNodeData, path), [sourceNodeData, initialPath, path]);
+  const handleChangePath = useCallback((depth, index) => {
+    if (pathOption?.onShowValueChange && depth === showConfig.depth) {
+      pathOption.onShowValueChange(sourceNodeData[index][showConfig.showType], depth);
+    }
+    if (pathOption?.showValue !== 0 && !pathOption?.showValue) {
+      setInternalPath(changeShowPath(
+        sourceNodeData,
+        { oldPath: path, action: { depth, nodeIdx: index } }
+      ));
+    }
+  }, [pathOption, sourceNodeData]);
+  const handleChangeCheckStatus = useCallback((nodeIdx, checkStatus) => {
+    if (selectOption) {
+      if (selectOption?.selected) {
+        const newSelectSet = changeSelected(
+          checkStatus,
+          sourceNodeData,
+          nodeIdx,
+          initialSelected,
+          selectValueType
+        );
+        if (selectOption?.onSelectedChange) selectOption.onSelectedChange(Array.from(newSelectSet));
+        return;
+      }
+      if (selectOption?.defaultSelected) {
+        const newSelectSet = changeSelected(
+          checkStatus,
+          sourceNodeData,
+          nodeIdx,
+          internalSelected,
+          selectValueType
+        );
+        setInternalSelected(newSelectSet);
+        setCheckStatusArray(changeNodeStatus(sourceNodeData, checkStatusArray, nodeIdx, checkStatus));
+        if (selectOption?.onSelectedChange) selectOption.onSelectedChange(Array.from(newSelectSet));
+      }
+    }
+  }, [selectOption, sourceNodeData, checkStatusArray, selectValueType]);
   useEffect(() => {
-    setCheckStatusArray(getInitialStatus(sourceNodeData));
-    const targetNode = sourceNodeData.find((n) => n.value === curShow);
-    setPath(getShowPath(sourceNodeData, targetNode));
+    setInternalPath(initialPath);
+    setInternalSelected(initialSelected);
+    setCheckStatusArray(initialStatusArray);
   }, [data]);
   useEffect(() => {
-    if (curShow || curShow === 0) {
-      setPath(getShowPath(sourceNodeData, sourceNodeData.find((node) => curShow === node.value || curShow === node.label)));
+    if (selectOption?.selected) {
+      setCheckStatusArray(initialStatusArray);
+    }
+  }, [selectOption?.selected]);
+  useEffect(() => {
+    if (pathOption?.defaultShowValue) {
+      setInternalPath(initialPath);
+    }
+  }, [pathOption?.defaultShowValue]);
+  useEffect(() => {
+    if (selectOption?.defaultSelected) {
+      setInternalSelected(initialSelected);
     }
-  }, [curShow]);
+  }, [selectOption?.defaultSelected]);
   return {
+    path,
     nodes: sourceNodeData,
     columns,
-    path,
     checkStatusArray,
     handleChangePath,
     handleChangeCheckStatus

package/esm/index.js

@@ -1,9 +1,7 @@
 export { CascaderRoot } from './components/root/CascaderRoot.js';
 export { CascaderNode } from './components/node/CascaderNode.js';
-export { CascaderNodeCheck } from './components/node/CascaderNodeCheck.js';
 export { CascaderPanel } from './components/panel/CascaderPanel.js';
-export { CascaderPanelHeader } from './components/panel/CascaderPanelHeader.js';
 export { CascaderPanelIndicator } from './components/panel/CascaderPanelIndicator.js';
 export { useCascader } from './hooks/useCascader.js';
 export { buildCascaderEngine, changeShowPath, getCascadeColumns, getShowPath } from './utils/data.js';
-export { setMultipleNodeStatus, setNodeCheckStatus } from './utils/logic.js';
+export { CHECK_ALL, CHECK_INDETERMINATE, CHECK_NONE, changeMultipleNodeStatus, changeNodeStatus, changeSelected, changeSelectedPatch, getNextStatus } from './utils/logic.js';

package/esm/utils/data.js

@@ -1,17 +1,3 @@
-function createCascaderNode(option) {
-  const { depth, currentIndex, parentIndex, row, label, value, pathId } = option;
-  return {
-    depth,
-    index: currentIndex,
-    parentIndex,
-    range: [currentIndex, currentIndex],
-    childrenIndices: [],
-    pathId,
-    label,
-    value,
-    raw: row
-  };
-}
 function buildCascaderEngine(data, config) {
   let currentIndex = 0;
   const currentConfig = config;
@@ -39,16 +25,17 @@ function buildCascaderEngine(data, config) {
       if (nodeIdx === void 0) {
         nodeIdx = currentIndex++;
         nodeMap.set(currentPathId, nodeIdx);
-        levelIndex === levelConfigs.length - 1;
-        nodes[nodeIdx] = createCascaderNode({
-          parentIndex,
-          currentIndex: nodeIdx,
-          pathId: currentPathId,
-          depth: levelIndex,
+        nodes[nodeIdx] = {
+          nodeId: currentPathId,
           label,
           value,
-          row: item
-        });
+          index: nodeIdx,
+          parentIndex,
+          depth: levelIndex,
+          range: [nodeIdx, nodeIdx],
+          childrenIndices: [],
+          data: item
+        };
         if (parentIndex !== -1) {
           nodes[parentIndex].childrenIndices.push(nodeIdx);
         }
@@ -94,11 +81,16 @@ function getShowPath(nodes, targetNode) {
   let showPath = [];
   if (targetNode) {
     let parentNode = targetNode;
+    let childNode = targetNode.childrenIndices[0] ? nodes[targetNode.childrenIndices[0]] : null;
     showPath = new Array((targetNode?.depth ?? 0) + 1);
     while (parentNode) {
       showPath[parentNode.depth] = parentNode.index;
       parentNode = parentNode.parentIndex !== -1 ? nodes[parentNode.parentIndex] : void 0;
     }
+    while (childNode) {
+      showPath[childNode.depth] = childNode.index;
+      childNode = childNode.childrenIndices[0] ? childNode : null;
+    }
     return showPath;
   }
   while (currentNode) {

package/esm/utils/logic.js

@@ -1,6 +1,9 @@
 const CHECK_NONE = 0;
 const CHECK_ALL = 1;
 const CHECK_INDETERMINATE = 2;
+const getNextStatus = (curCheckStatus) => {
+  return curCheckStatus === CHECK_ALL ? CHECK_NONE : curCheckStatus === CHECK_INDETERMINATE ? CHECK_NONE : CHECK_ALL;
+};
 function propagateToChildren(statusArray, range, status) {
   const [start, end] = range;
   statusArray.fill(status, start, end + 1);
@@ -29,11 +32,10 @@ function propagateToParents(nodes, statusArray, childIndex) {
     propagateToParents(nodes, statusArray, parentIdx);
   }
 }
-function setNodeCheckStatus(nodes, currentStatusArray, nodeIndex) {
-  const nextStatus = new Uint8Array(currentStatusArray);
+function changeNodeStatus(nodes, currentStatusArray, nodeIndex, checkStatus) {
   const targetNode = nodes[nodeIndex];
-  const targetValue = nextStatus[nodeIndex] === CHECK_ALL ? CHECK_NONE : nextStatus[nodeIndex] === CHECK_INDETERMINATE ? CHECK_NONE : CHECK_ALL;
-  propagateToChildren(nextStatus, targetNode.range, targetValue);
+  const nextStatus = new Uint8Array(currentStatusArray);
+  propagateToChildren(nextStatus, targetNode.range, checkStatus);
   propagateToParents(nodes, nextStatus, nodeIndex);
   return nextStatus;
 }
@@ -57,7 +59,7 @@ function syncUpPath(nodes, statusArray, parentIdx) {
     currIdx = node.parentIndex;
   }
 }
-function setMultipleNodeStatus(nodes, currentStatusArray, indices, targetStatus) {
+function changeMultipleNodeStatus(nodes, indices, targetStatus, currentStatusArray) {
   const nextStatus = new Uint8Array(currentStatusArray);
   const parentsToSync = /* @__PURE__ */ new Set();
   indices.forEach((index) => {
@@ -75,5 +77,35 @@ function setMultipleNodeStatus(nodes, currentStatusArray, indices, targetStatus)
   });
   return nextStatus;
 }
+function changeSelectedPatch(nodes, indices, isChecked, currentSet) {
+  const nextSet = new Set(currentSet);
+  indices.forEach((idx) => {
+    const node = nodes[idx];
+    const [start, end] = node.range;
+    for (let i = start; i <= end; i++) {
+      if (nodes[i].childrenIndices.length === 0) {
+        if (isChecked) nextSet.add(nodes[i].index);
+        else nextSet.delete(nodes[i].index);
+      }
+    }
+  });
+  return nextSet;
+}
+function changeSelected(checkStatus, nodes, nodeIdx, currentSet, selectValueType) {
+  const nextSet = new Set(currentSet);
+  const targetNode = nodes[nodeIdx];
+  const [start, end] = targetNode.range;
+  for (let i = start; i <= end; i++) {
+    const node = nodes[i];
+    if (node.childrenIndices.length === 0) {
+      if (checkStatus === CHECK_ALL) {
+        nextSet.add(node[selectValueType]);
+      } else if (checkStatus === CHECK_NONE) {
+        nextSet.delete(node[selectValueType]);
+      }
+    }
+  }
+  return nextSet;
+}
 
-export { setMultipleNodeStatus, setNodeCheckStatus };
+export { CHECK_ALL, CHECK_INDETERMINATE, CHECK_NONE, changeMultipleNodeStatus, changeNodeStatus, changeSelected, changeSelectedPatch, getNextStatus };

package/lib/components/index.d.ts

@@ -1,6 +1,4 @@
 export * from "./root/CascaderRoot";
 export * from "./node/CascaderNode";
-export * from "./node/CascaderNodeCheck";
 export * from "./panel/CascaderPanel";
-export * from "./panel/CascaderPanelHeader";
 export * from "./panel/CascaderPanelIndicator";

package/lib/components/root/CascaderRoot.d.ts

@@ -1,7 +1,7 @@
 import { ComponentProps } from "react";
+import { CheckStatus } from "../../types";
 export interface CascaderRootProps extends ComponentProps<'div'> {
     isSelected?: boolean;
-    selectType?: "single" | "multiple";
-    onSelectChange?: (nodeIdx: number) => void;
+    setNodeCheckStatus?: (nodeIdx: number, nodeCheckStatus: CheckStatus) => void;
 }
 export declare const CascaderRoot: import("react").ForwardRefExoticComponent<Omit<CascaderRootProps, "ref"> & import("react").RefAttributes<unknown>>;

package/lib/context/index.d.ts

@@ -1,8 +1,8 @@
 import { CSSProperties } from "react";
+import { CheckStatus } from "../types";
 export declare const CascaderContext: import("react").Context<{
     isSelected: boolean;
-    selectType: "single" | "multiple" | undefined;
-    onSelectChange: ((nodeIdx: number) => void) | undefined;
+    setNodeCheckStatus: ((nodeIdx: number, nodeCheckStatus: CheckStatus) => void) | undefined;
 }>;
 export declare const CascaderPanelContext: import("react").Context<{
     showIndicator: boolean;

package/lib/hooks/useCascader.d.ts

@@ -1,15 +1,15 @@
-import { CascaderNodeType, CascaderSelectOption, FlatDataConfig } from "../types";
+import { CascaderNodeType, CascaderPathOption, CascaderSelectOption, CheckStatus, FlatDataConfig } from "../types";
 export type CascaderHookOption<T> = {
     data: T[];
     handleDataConfig: FlatDataConfig;
+    pathOption?: CascaderPathOption;
     selectOption?: CascaderSelectOption;
-    curShow?: string | number;
 };
 export declare function useCascader<T extends Record<string, any>>(options: CascaderHookOption<T>): {
+    path: number[];
     nodes: CascaderNodeType<T>[];
     columns: CascaderNodeType<T>[][];
-    path: number[];
     checkStatusArray: Uint8Array<ArrayBufferLike>;
     handleChangePath: (depth: number, index: number) => void;
-    handleChangeCheckStatus: (nodeIdx: number) => void;
+    handleChangeCheckStatus: (nodeIdx: number, checkStatus: CheckStatus) => void;
 };

package/lib/index.d.ts

@@ -1,4 +1,5 @@
 export * from "./components";
 export * from "./hooks/useCascader";
-export * from "./utils/index";
+export * from "./utils/data";
+export * from "./utils/logic";
 export * from "./types";

package/lib/types/index.d.ts

@@ -4,15 +4,15 @@ export type CheckStatus = 0 | 1 | 2;
  *                  Data
  *---------------------------------------------**/
 export interface CascaderNodeType<T = any> {
+    label: string;
+    value: string | number;
+    nodeId: string;
     depth: number;
     index: number;
     parentIndex: number;
-    range: [number, number];
     childrenIndices: number[];
-    pathId: string;
-    label: string;
-    value: string | number;
-    raw: T | null;
+    range: [number, number];
+    data: T | null;
 }
 export interface CascaderItem<T> {
     indices: number;
@@ -20,7 +20,7 @@ export interface CascaderItem<T> {
     field: string;
     label: string;
     value: string | number;
-    originData?: T;
+    data?: T;
     checkStatus?: CheckStatus;
 }
 /**--------------------------------------------
@@ -42,9 +42,20 @@ export type GetCascaderColumnsOption = {
 /**--------------------------------------------
  *                  Other
  *---------------------------------------------**/
+export type CascaderPathOption = {
+    showConfig?: {
+        depth: number;
+        showType: "label" | "value";
+    };
+    showValue?: string | number;
+    defaultShowValue?: string | number;
+    onShowValueChange?: (value: string | number, depth: number) => void;
+};
 export type CascaderSelectOption = {
-    defaultSelected: string[];
-    selectType: "single" | "multiple";
+    valueType?: "label" | "value";
+    selected?: (string | number)[];
+    defaultSelected?: (string | number)[];
+    onSelectedChange?: (selected: (string | number)[]) => void;
 };
 /**--------------------------------------------
  *                  Slot
@@ -56,5 +67,5 @@ export type PanelHeaderSlot = (props: {
 export type PanelIndicatorSlot = (props?: any) => ReactNode;
 export type NodeSlotType = (props: {
     node: CascaderItem<any>;
-    onSelectChange?: (nodeIdx: number) => void;
+    handleToggleSelect?: (nodeIdx: number) => void;
 }) => ReactNode;

package/lib/utils/data.d.ts

@@ -1,5 +1,17 @@
 import { CascaderNodeType, FlatDataConfig, GetShowIndicesOption } from '../types/index.js';
+/**--------------------------------------------
+ * 创建级连线性数组
+ *---------------------------------------------**/
 export declare function buildCascaderEngine<T extends Record<string, any>>(data: T[], config: FlatDataConfig): CascaderNodeType<T>[];
+/**--------------------------------------------
+ * 根据选中路径生成展示列表
+ *---------------------------------------------**/
 export declare function getCascadeColumns<T>(nodes: CascaderNodeType<T>[], path: number[]): CascaderNodeType<T>[][];
+/**--------------------------------------------
+ * 改变级联选择器的显示路径
+ *---------------------------------------------**/
 export declare function changeShowPath<T>(nodes: CascaderNodeType<T>[], option: GetShowIndicesOption): number[];
+/**--------------------------------------------
+ * 获取级联选择器的显示路径
+ *---------------------------------------------**/
 export declare function getShowPath<T>(nodes: CascaderNodeType<T>[], targetNode?: CascaderNodeType): number[];

package/lib/utils/logic.d.ts

@@ -1,3 +1,15 @@
-import { CascaderNodeType } from "src/types";
-export declare function setNodeCheckStatus<T>(nodes: CascaderNodeType<T>[], currentStatusArray: Uint8Array, nodeIndex: number): Uint8Array;
-export declare function setMultipleNodeStatus<T>(nodes: CascaderNodeType<T>[], currentStatusArray: Uint8Array, indices: number[], targetStatus: number): Uint8Array;
+import { CascaderNodeType, CheckStatus } from "src/types";
+export declare const CHECK_NONE: CheckStatus;
+export declare const CHECK_ALL: CheckStatus;
+export declare const CHECK_INDETERMINATE: CheckStatus;
+/**--------------------------------------------
+ * 获取切换节点状态
+ *---------------------------------------------**/
+export declare const getNextStatus: (curCheckStatus: CheckStatus) => CheckStatus;
+export declare function changeNodeStatus<T>(nodes: CascaderNodeType<T>[], currentStatusArray: Uint8Array, nodeIndex: number, checkStatus: CheckStatus): Uint8Array;
+export declare function changeMultipleNodeStatus<T>(nodes: CascaderNodeType<T>[], indices: number[], targetStatus: CheckStatus, currentStatusArray: Uint8Array): Uint8Array;
+/**--------------------------------------------
+ * 获取选中状态的所有叶子节点数据
+ *---------------------------------------------**/
+export declare function changeSelectedPatch<T>(nodes: CascaderNodeType<T>[], indices: number[], isChecked: boolean, currentSet: Set<string | number>): Set<string | number>;
+export declare function changeSelected<T>(checkStatus: CheckStatus, nodes: CascaderNodeType<T>[], nodeIdx: number, currentSet: Set<string | number>, selectValueType: "label" | "value"): Set<string | number>;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@zidian-primitive/cascader",
-  "version": "0.2.2",
+  "version": "0.3.0",
   "main": "./src/index.ts",
   "license": "MIT",
   "type": "module",

package/src/index.ts

@@ -2,7 +2,8 @@ export * from "./components"
 
 export * from "./hooks/useCascader"
 
-export * from "./utils/index"
+export * from "./utils/data"
+export * from "./utils/logic"
 
 export * from "./types"