@central-design-system/components 3.0.0-beta.8 → 3.0.0-rc.1

package/dist/components/CdsTree/interface.d.ts

@@ -1,8 +1,37 @@
+import { ITreeProps } from './composable';
 import type { CSSProperties, VNode } from 'vue';
+import type { TCdsIconsName } from '@central-design-system/icons';
 export declare namespace NTree {
     type TKey = string | number;
-    type TNodeElement = VNode<any>;
+    type TNodeElement = VNode<ITreeProps>;
     type TGetCheckDisabled<RecordType> = (record: RecordType) => boolean;
+    type TExpandAction = false | 'click' | 'doubleclick' | 'dblclick';
+    type TDraggableFn = (node: IDataNode) => boolean;
+    type TAllowDrop<TreeDataType extends IBasicDataNode = IDataNode> = (options: IAllowDropOptions<TreeDataType>) => boolean;
+    type TEventHandler = (...args: any[]) => void;
+    type TDragNodeEvent = {
+        key: TKey;
+        eventData: IEventDataNode;
+        eventKey: TKey;
+        selectHandle: HTMLSpanElement;
+        pos: string;
+    };
+    type TNodeMouseEventHandler = (event: MouseEvent, node: IEventDataNode) => void;
+    type TNodeMouseEventParams = {
+        event: MouseEvent;
+        node: IEventDataNode;
+    };
+    type TNodeDragEventParams = {
+        event: DragEvent;
+        node: IEventDataNode;
+    };
+    type TNodeDragEventHandler = (event: DragEvent, node: TDragNodeEvent | null, outsideTree?: boolean) => void;
+    type TIconType = any;
+    type DraggableFn = (node: IDataNode) => boolean;
+    type TDraggableConfig = {
+        icon?: TCdsIconsName | boolean;
+        nodeDraggable?: DraggableFn;
+    };
     interface IBasicDataNode {
         checkable?: boolean;
         selectable?: boolean;
@@ -10,7 +39,8 @@ export declare namespace NTree {
         disableCheckbox?: boolean;
         icon?: any;
         isLeaf?: boolean;
-        switcherIcon?: any;
+        switcherIcon?: TIconType;
+        /** Set style of TreeNode. This is not recommend if you don't have any force requirement */
         class?: string;
         style?: CSSProperties;
         slots?: Record<string, string>;
@@ -18,7 +48,7 @@ export declare namespace NTree {
     }
     interface IDataNode extends IBasicDataNode {
         children?: IDataNode[];
-        key: string | number;
+        key?: string | number;
         title?: any;
     }
     interface IEntity {
@@ -29,7 +59,7 @@ export declare namespace NTree {
         parent?: IEntity;
         children?: IEntity[];
     }
-    interface EventDataNode extends IDataNode {
+    interface IEventDataNode extends IDataNode {
         expanded?: boolean;
         selected?: boolean;
         checked: boolean;
@@ -54,7 +84,77 @@ export declare namespace NTree {
     }
     interface IFieldNames {
         title?: string;
+        /** @private Internal usage, safe to remove if no need */
+        _title?: string[];
         key?: string;
         children?: string;
     }
+    interface IAllowDropOptions<TreeDataType extends IBasicDataNode = IDataNode> {
+        dragNode: IEventDataNode;
+        dropNode: TreeDataType;
+        dropPosition: -1 | 0 | 1;
+    }
+    interface ICheckInfo {
+        event: 'check';
+        node: IEventDataNode;
+        checked: boolean;
+        nativeEvent: MouseEvent;
+        checkedNodes: IDataNode[];
+        checkedNodesPositions?: {
+            node: IDataNode;
+            pos: string;
+        }[];
+        halfCheckedKeys?: TKey[];
+    }
+    interface IFlattenNode {
+        parent: IFlattenNode | null;
+        children: IFlattenNode[] | null;
+        pos: string;
+        data: IDataNode;
+        title: any;
+        key: TKey;
+        isStart: boolean[];
+        isEnd: boolean[];
+    }
+    interface ITreeNodeRequiredProps<TreeDataType extends IBasicDataNode = IDataNode> {
+        expandedKeysSet: Set<TKey>;
+        selectedKeysSet: Set<TKey>;
+        loadedKeysSet: Set<TKey>;
+        loadingKeysSet: Set<TKey>;
+        checkedKeysSet: Set<TKey>;
+        halfCheckedKeysSet: Set<TKey>;
+        dragOverNodeKey: TKey | null;
+        dropPosition: number | null;
+        keyEntities: Record<TKey, IDataEntity<TreeDataType>>;
+    }
+    interface IDragState {
+        draggingNodeKey: TKey | null;
+        dragChildrenKeys: TKey[];
+        dropTargetKey: TKey | null;
+        dropPosition: IAllowDropOptions['dropPosition'] | null;
+        dropContainerKey: TKey | null;
+        dropLevelOffset: number | null;
+        dropTargetPos: string | null;
+        dropAllowed: boolean;
+        dragOverNodeKey: TKey | null;
+    }
+    interface ITreeNodeAttribute {
+        eventKey: string;
+        prefixCls: string;
+        class: string;
+        expanded: boolean;
+        selected: boolean;
+        checked: boolean;
+        halfChecked: boolean;
+        children: any;
+        title: any;
+        pos: string;
+        dragOver: boolean;
+        dragOverGapTop: boolean;
+        dragOverGapBottom: boolean;
+        isLeaf: boolean;
+        selectable: boolean;
+        disabled: boolean;
+        disableCheckbox: boolean;
+    }
 }

package/dist/components/CdsTree/utils/conduct.d.ts

@@ -7,5 +7,5 @@ export declare function isCheckDisabled<TreeDataType>(node: TreeDataType): boole
 export declare function conductCheck<TreeDataType extends NTree.IBasicDataNode = NTree.IDataNode>(keyList: NTree.TKey[], checked: true | {
     checked: false;
     halfCheckedKeys: NTree.TKey[];
-}, keyEntities: Record<NTree.TKey, NTree.IDataEntity<TreeDataType>>, maxLevel: number, levelEntities: Map<number, Set<NTree.IDataEntity<TreeDataType>>>, getCheckedDisabled?: NTree.TGetCheckDisabled<TreeDataType>): IConductReturnType;
+}, keyEntities: Record<NTree.TKey, NTree.IDataEntity<TreeDataType>>, maxLevel: number, levelEntities: Map<number, Set<NTree.IDataEntity<TreeDataType>>>, getCheckedDisabled?: NTree.TGetCheckDisabled<TreeDataType>, preserveSelectedRowKeys?: boolean): IConductReturnType;
 export {};

package/dist/components/CdsTree/utils/data.d.ts

@@ -1,4 +1,7 @@
+import { VueNode } from '../../../utils';
+import { ITreeNodeProps } from '../../../components/CdsTree/composable/treeNode';
 import { NTree } from '../interface';
+import { ITreeProps } from '../composable';
 declare type TExternalGetKey = GetKey<NTree.IDataNode> | string;
 interface IWrapper {
     posEntities: Record<string, any>;
@@ -16,6 +19,10 @@ export declare function convertDataToEntities(dataNodes: NTree.IDataNode[], { in
     posEntities: any;
     keyEntities: any;
 };
+/**
+ * Convert `children` of Tree into `treeData` structure.
+ */
+export declare function convertTreeToData(rootNodes: VueNode): NTree.IDataNode[];
 interface ITraverseConfig {
     childrenPropName?: string;
     externalGetKey?: TExternalGetKey;
@@ -30,7 +37,70 @@ export declare function traverseDataNodes(dataNodes: NTree.IDataNode[], callback
     level?: number;
     nodes: NTree.IDataNode[];
 }) => void, config?: ITraverseConfig | string): void;
+/**
+ * If user use `autoExpandParent` we should get the list of parent node
+ * @param keyList
+ * @param keyEntities
+ */
+export declare function conductExpandParent(keyList: NTree.TKey[], keyEntities: Record<NTree.TKey, NTree.IDataEntity>): NTree.TKey[];
+/**
+ * Flat nest tree data into flatten list. This is used for virtual list render.
+ * @param treeNodeList Origin data node list
+ * @param expandedKeys
+ * @param fieldNames
+ * need expanded keys, provides `true` means all expanded.
+ */
+export declare function flattenTreeData(treeNodeList: NTree.IDataNode[], expandedKeys: NTree.TKey[] | true, fieldNames: NTree.IFieldNames): NTree.IFlattenNode[];
 export declare function fillFieldNames(fieldNames?: NTree.IFieldNames): Required<NTree.IFieldNames>;
+/**
+ * Get TreeNode props with Tree props.
+ */
+export declare function getTreeNodeProps<TreeDataType extends NTree.IBasicDataNode = NTree.IDataNode>(key: NTree.TKey, { expandedKeysSet, selectedKeysSet, loadedKeysSet, loadingKeysSet, checkedKeysSet, halfCheckedKeysSet, dragOverNodeKey, dropPosition, keyEntities }: NTree.ITreeNodeRequiredProps<TreeDataType>): {
+    eventKey: NTree.TKey;
+    expanded: boolean;
+    selected: boolean;
+    loaded: boolean;
+    loading: boolean;
+    checked: boolean;
+    halfChecked: boolean;
+    pos: string;
+    parent: NTree.IDataEntity<TreeDataType> | undefined;
+    dragOver: boolean;
+    dragOverGapTop: boolean;
+    dragOverGapBottom: boolean;
+};
+export declare function calcDropPosition<TreeDataType extends NTree.IBasicDataNode = NTree.IDataNode>(event: MouseEvent, dragNode: NTree.TDragNodeEvent, targetNode: NTree.TDragNodeEvent, indent: number, startMousePosition: {
+    x: number;
+    y: number;
+}, allowDrop: NTree.TAllowDrop<TreeDataType>, flattenedNodes: NTree.IFlattenNode[], keyEntities: Record<NTree.TKey, NTree.IDataEntity<TreeDataType>>, expandKeysSet: Set<NTree.TKey>): Omit<NTree.IDragState, 'draggingNodeKey' | 'dragChildrenKeys'>;
+/**
+ * Return selectedKeys according with multiple prop
+ * @param selectedKeys
+ * @param props
+ * @returns [string]
+ */
+export declare function calcSelectedKeys(selectedKeys: NTree.TKey[], props: ITreeProps): NTree.TKey[] | undefined;
+/**
+ * Parse `checkedKeys` to { checkedKeys, halfCheckedKeys } style
+ */
+export declare function parseCheckedKeys(keys: NTree.TKey[] | {
+    checked: NTree.TKey[];
+    halfChecked: NTree.TKey[];
+}): {
+    checkedKeys: NTree.TKey[];
+    halfCheckedKeys: undefined;
+} | {
+    checkedKeys: NTree.TKey[];
+    halfCheckedKeys: NTree.TKey[];
+} | null;
+export declare function getDragChildrenKeys<TreeDataType extends NTree.IBasicDataNode = NTree.IDataNode>(dragNodeKey: NTree.TKey, keyEntities: Record<NTree.TKey, NTree.IDataEntity<TreeDataType>>): NTree.TKey[];
 export declare function getKey(key: NTree.TKey, pos: string): NTree.TKey;
 export declare function getPosition(level?: string | number, index?: number): string;
+export declare function isTreeNode(node: NTree.TNodeElement): any;
+export declare function arrDel(list: NTree.TKey[], value: NTree.TKey): NTree.TKey[];
+export declare function arrAdd(list: NTree.TKey[], value: NTree.TKey): NTree.TKey[];
+export declare function posToArr(pos: string): string[];
+export declare function isLastChild<TreeDataType extends NTree.IBasicDataNode = NTree.IDataNode>(treeNodeEntity?: NTree.IDataEntity<TreeDataType>): boolean;
+export declare function isFirstChild<TreeDataType extends NTree.IBasicDataNode = NTree.IDataNode>(treeNodeEntity?: NTree.IDataEntity<TreeDataType>): boolean;
+export declare function convertNodePropsToEventData(props: ITreeNodeProps & ReturnType<typeof getTreeNodeProps>): NTree.IEventDataNode;
 export {};

package/dist/components/CdsTree/utils/diff.d.ts

@@ -0,0 +1,6 @@
+import { NTree } from '../interface';
+export declare function findExpandedKeys(prev?: NTree.TKey[], next?: NTree.TKey[]): {
+    add: boolean;
+    key: NTree.TKey | null;
+};
+export declare function getExpandRange(shorter: NTree.IFlattenNode[], longer: NTree.IFlattenNode[], key: NTree.TKey): NTree.IFlattenNode[];

package/dist/components/CdsTree/utils/directory.d.ts

@@ -0,0 +1,9 @@
+import { NTree } from '../interface';
+export declare function calcRangeKeys({ treeData, expandedKeys, startKey, endKey, fieldNames }: {
+    treeData: NTree.IDataNode[];
+    expandedKeys: NTree.TKey[];
+    startKey?: NTree.TKey;
+    endKey?: NTree.TKey;
+    fieldNames?: NTree.IFieldNames;
+}): NTree.TKey[];
+export declare function convertDirectoryKeysToNodes(treeData: NTree.IDataNode[], keys: NTree.TKey[], fieldNames: NTree.IFieldNames): NTree.IDataNode[];

package/dist/components/CdsTree/utils/index.d.ts

@@ -1,2 +1,4 @@
 export * from './data';
 export * from './conduct';
+export * from './diff';
+export * from './directory';