@douyinfe/semi-foundation 2.1.0 → 2.1.4

package/lib/cjs/tree/foundation.d.ts

@@ -0,0 +1,281 @@
+/**
+ * The drag and drop handler implementation is referenced from rc-tree
+ * https://github.com/react-component/tree
+ */
+import BaseFoundation, { DefaultAdapter } from '../base/foundation';
+export interface BasicTreeNodeProps {
+    [x: string]: any;
+    expanded?: boolean;
+    selected?: boolean;
+    checked?: boolean;
+    halfChecked?: boolean;
+    active?: boolean;
+    disabled?: boolean;
+    loaded?: boolean;
+    loading?: boolean;
+    isLeaf?: boolean;
+    pos?: string;
+    children?: BasicTreeNodeData[];
+    icon?: any;
+    directory?: boolean;
+    selectedKey?: string;
+    motionKey?: string[] | string;
+    eventKey?: string;
+}
+export interface BasicTreeNodeData {
+    [x: string]: any;
+    key: string;
+    value?: number | string;
+    label?: any;
+    icon?: any;
+    disabled?: boolean;
+    isLeaf?: boolean;
+    children?: BasicTreeNodeData[];
+}
+export interface BasicKeyEntities {
+    [key: string]: BasicKeyEntity;
+}
+export interface BasicKeyEntity {
+    children?: BasicKeyEntities;
+    data?: BasicTreeNodeData;
+    ind?: number;
+    key?: string;
+    level?: number;
+    parent?: undefined | BasicKeyEntity;
+    parentPos?: null | string;
+    pos?: string;
+}
+export interface BasicDragTreeNode extends BasicTreeNodeData {
+    expanded: boolean;
+    /**
+     * The positional relationship of the current node in the entire
+     * treeData, such as the 0th node of the 2nd node of the 1st node
+     * of the 0th layer: '0-1-2-0'
+     */
+    pos: string;
+}
+export interface BasicFlattenNode {
+    _innerDataTag?: boolean;
+    children?: BasicFlattenNode[];
+    data?: BasicTreeNodeData;
+    key?: string;
+    label?: any;
+    parent?: null | BasicFlattenNode;
+    pos?: string;
+    value?: string;
+}
+export interface BasicDragProps {
+    event: any;
+    node: BasicDragTreeNode;
+}
+export interface BasicDragEnterProps extends BasicDragProps {
+    expandedKeys?: string[];
+}
+export declare type ExpandAction = false | 'click' | 'doubleClick';
+export declare type BasicValue = string | number | BasicTreeNodeData | Array<BasicTreeNodeData | string | number>;
+export interface BasicOnDragProps {
+    event: any;
+    node: BasicDragTreeNode;
+    dragNode: BasicDragTreeNode;
+    dragNodesKeys: string[];
+    /**
+     * dropPosition represents the position of the dragged node being
+     * dropped in the current level. If inserted before the 0th node
+     * of the same level, it is -1, after the 0th node, it is 1, and
+     * it is 0 when it falls on it. And so on. With dropToGap, a more
+     * complete judgment can be obtained.
+     */
+    dropPosition: number;
+    /**
+     * Indicates whether the dragged node is dropped between nodes, if
+     *  it is false, it is dropped above a node
+     */
+    dropToGap: boolean;
+}
+export interface BasicRenderFullLabelProps {
+    onClick: (e: any) => void;
+    onContextMenu: (e: any) => void;
+    onDoubleClick: (e: any) => void;
+    className: string;
+    onExpand: (e: any) => void;
+    data: BasicTreeNodeData;
+    level: number;
+    style: any;
+    onCheck: (e: any) => void;
+    expandIcon: any;
+    checkStatus: {
+        checked: boolean;
+        halfChecked: boolean;
+    };
+    expandStatus: {
+        expanded: boolean;
+        loading: boolean;
+    };
+}
+export interface BasicSearchRenderProps {
+    className: string;
+    placeholder: string;
+    prefix: any;
+    showClear?: boolean;
+    value: string;
+    onChange: (value: string) => void;
+}
+export interface TreeDataSimpleJson {
+    [x: string]: string | TreeDataSimpleJson;
+}
+export interface Virtualize {
+    itemSize: number;
+    height?: number | string;
+    width?: number | string;
+}
+export interface BasicTreeProps {
+    autoExpandParent?: boolean;
+    autoExpandWhenDragEnter?: boolean;
+    blockNode?: boolean;
+    children?: any;
+    className?: string;
+    expandAll?: boolean;
+    defaultExpandAll?: boolean;
+    defaultExpandedKeys?: string[];
+    defaultValue?: BasicValue;
+    directory?: boolean;
+    disabled?: boolean;
+    disableStrictly?: boolean;
+    draggable?: boolean;
+    emptyContent?: any;
+    expandAction?: ExpandAction;
+    expandedKeys?: string[];
+    filterTreeNode?: boolean | ((inputValue: string, treeNodeString: string) => boolean);
+    hideDraggingNode?: boolean;
+    labelEllipsis?: boolean;
+    leafOnly?: boolean;
+    loadData?: (treeNode?: BasicTreeNodeData) => Promise<void>;
+    loadedKeys?: string[];
+    motion?: boolean;
+    multiple?: boolean;
+    onChange?: (value?: BasicValue) => void;
+    onChangeWithObject?: boolean;
+    onDoubleClick?: (e: any, node: BasicTreeNodeData) => void;
+    onDragEnd?: (dragProps: BasicDragProps) => void;
+    onDragEnter?: (dragEnterProps: BasicDragEnterProps) => void;
+    onDragLeave?: (dragProps: BasicDragProps) => void;
+    onDragOver?: (dragProps: BasicDragProps) => void;
+    onDragStart?: (dragProps: BasicDragProps) => void;
+    onDrop?: (onDragProps: BasicOnDragProps) => void;
+    onExpand?: (expandedKeys: string[], expandedOtherProps: BasicExpandedOtherProps) => void;
+    onLoad?: (loadedKeys?: Set<string>, treeNode?: BasicTreeNodeData) => void;
+    onContextMenu?: (e: any, node: BasicTreeNodeData) => void;
+    onSearch?: (sunInput: string) => void;
+    onSelect?: (selectedKeys: string, selected: boolean, selectedNode: BasicTreeNodeData) => void;
+    renderDraggingNode?: (nodeInstance: HTMLElement, node: BasicTreeNodeData) => HTMLElement;
+    renderFullLabel?: (renderFullLabelProps: BasicRenderFullLabelProps) => any;
+    renderLabel?: (label?: any, treeNode?: BasicTreeNodeData) => any;
+    searchClassName?: string;
+    searchPlaceholder?: string;
+    searchRender?: ((searchRenderProps: BasicSearchRenderProps) => any) | false;
+    searchStyle?: any;
+    showClear?: boolean;
+    showFilteredOnly?: boolean;
+    style?: any;
+    treeData?: BasicTreeNodeData[];
+    treeDataSimpleJson?: TreeDataSimpleJson;
+    treeNodeFilterProp?: string;
+    value?: BasicValue;
+    virtualize?: Virtualize;
+    icon?: any;
+}
+export interface BasicTreeInnerData {
+    inputValue: string;
+    keyEntities: BasicKeyEntities;
+    treeData: BasicTreeNodeData[];
+    flattenNodes: BasicFlattenNode[];
+    selectedKeys: string[];
+    checkedKeys: Set<string>;
+    halfCheckedKeys: Set<string>;
+    motionKeys: Set<string>;
+    motionType: string;
+    expandedKeys: Set<string>;
+    filteredKeys: Set<string>;
+    filteredExpandedKeys: Set<string>;
+    filteredShownKeys: Set<string>;
+    prevProps: null | BasicTreeProps;
+    loadedKeys: Set<string>;
+    loadingKeys: Set<string>;
+    cachedFlattenNodes: BasicFlattenNode[] | undefined;
+    cachedKeyValuePairs: {
+        [x: string]: string;
+    };
+    disabledKeys: Set<string>;
+    dragging: boolean;
+    dragNodesKeys: Set<string>;
+    dragOverNodeKey: string[] | string | null;
+    dropPosition: number | null;
+}
+export interface BasicExpandedOtherProps {
+    expanded: boolean;
+    node: BasicTreeNodeData;
+}
+export interface TreeAdapter extends DefaultAdapter<BasicTreeProps, BasicTreeInnerData> {
+    updateInputValue: (value: string) => void;
+    focusInput: () => void;
+    updateState: (states: Partial<BasicTreeInnerData>) => void;
+    notifyExpand: (expandedKeys: Set<string>, { expanded: bool, node }: BasicExpandedOtherProps) => void;
+    notifySelect: (selectKey: string, bool: boolean, node: BasicTreeNodeData) => void;
+    notifyChange: (value: BasicValue) => void;
+    notifySearch: (input: string) => void;
+    notifyRightClick: (e: any, node: BasicTreeNodeData) => void;
+    notifyDoubleClick: (e: any, node: BasicTreeNodeData) => void;
+    cacheFlattenNodes: (bool: boolean) => void;
+    setDragNode: (treeNode: any) => void;
+}
+export default class TreeFoundation extends BaseFoundation<TreeAdapter, BasicTreeProps, BasicTreeInnerData> {
+    delayedDragEnterLogic: any;
+    constructor(adapter: TreeAdapter);
+    _isMultiple(): any;
+    _isAnimated(): any;
+    _isDisabled(treeNode?: BasicTreeNodeProps): any;
+    _isExpandControlled(): boolean;
+    _isLoadControlled(): boolean;
+    _isFilterable(): boolean;
+    _showFilteredOnly(): any;
+    getCopyFromState(items: string[] | string): Partial<BasicTreeInnerData>;
+    getTreeNodeProps(key: string): BasicTreeNodeProps;
+    notifyJsonChange(key: string[] | string, e: any): void;
+    notifyMultipleChange(key: string[] | string, e: any): void;
+    notifyChange(key: string[] | string, e: any): void;
+    handleInputChange(sugInput: string): void;
+    handleNodeSelect(e: any, treeNode: BasicTreeNodeProps): void;
+    handleNodeRightClick(e: any, treeNode: BasicTreeNodeProps): void;
+    handleNodeDoubleClick(e: any, treeNode: BasicTreeNodeProps): void;
+    handleSingleSelect(e: any, treeNode: BasicTreeNodeProps): void;
+    calcCheckedKeys(eventKey: string, targetStatus: boolean): {
+        checkedKeys: Set<string>;
+        halfCheckedKeys: Set<string>;
+    };
+    calcChekcedStatus(targetStatus: boolean, eventKey: string): boolean;
+    calcNonDisabedCheckedKeys(eventKey: string, targetStatus: boolean): {
+        checkedKeys: Set<string>;
+        halfCheckedKeys: Set<any>;
+    };
+    handleMultipleSelect(e: any, treeNode: BasicTreeNodeProps): void;
+    setExpandedStatus(treeNode: BasicTreeNodeProps): {
+        expandedKeys: Set<string>;
+        expanded: boolean;
+        data: any;
+    };
+    handleNodeExpand(e: any, treeNode: BasicTreeNodeProps): void;
+    handleNodeLoad(loadedKeys: Set<string>, loadingKeys: Set<string>, data: BasicTreeNodeData, resolve: (value?: any) => void): {
+        loadingKeys?: undefined;
+    } | {
+        loadingKeys: Set<string>;
+    };
+    getDragEventNodeData(node: BasicTreeNodeData): any;
+    triggerDragEvent(name: string, event: any, node: BasicTreeNodeData, extra?: {}): void;
+    clearDragState: () => void;
+    handleNodeDragStart(e: any, treeNode: BasicTreeNodeData): void;
+    handleNodeDragEnter(e: any, treeNode: BasicTreeNodeData, dragNode: any): void;
+    handleNodeDragOver(e: any, treeNode: BasicTreeNodeData, dragNode: any): void;
+    handleNodeDragLeave(e: any, treeNode: BasicTreeNodeData): void;
+    handleNodeDragEnd(e: any, treeNode: BasicTreeNodeData): void;
+    handleNodeDrop(e: any, treeNode: BasicTreeNodeData, dragNode: any): void;
+}