@antsoo-lib/components 0.0.1

package/dist/src/vc-tree/contextTypes.d.ts

@@ -0,0 +1,109 @@
+import { ComputedRef, PropType, ShallowRef, DefineComponent, ExtractPropTypes, VNode, RendererNode, RendererElement, ComponentOptionsMixin, PublicProps, ComponentProvideOptions } from 'vue';
+import { VueNode } from '../_util/type';
+import { DraggableConfig } from './Tree';
+import { DataEntity, Direction, DragNodeEvent, EventDataNode, FlattenNode, IconType, Key } from './interface';
+export interface NodeMouseEventParams {
+    event: MouseEvent;
+    node: EventDataNode;
+}
+export interface NodeDragEventParams {
+    event: DragEvent;
+    node: EventDataNode;
+}
+export type NodeMouseEventHandler = (e: MouseEvent, node: EventDataNode) => void;
+export type NodeDragEventHandler = (e: DragEvent, node: DragNodeEvent, outsideTree?: boolean) => void;
+export interface TreeContextProps {
+    prefixCls: string;
+    selectable: boolean;
+    showIcon: boolean;
+    icon: IconType;
+    switcherIcon: IconType;
+    draggable: DraggableConfig | false;
+    draggingNodeKey?: Key;
+    checkable: boolean;
+    customCheckable: () => any;
+    checkStrictly: boolean;
+    disabled: boolean;
+    keyEntities: Record<Key, DataEntity<any>>;
+    dropLevelOffset?: number;
+    dropContainerKey: Key | null;
+    dropTargetKey: Key | null;
+    dropPosition: -1 | 0 | 1 | null;
+    indent: number | null;
+    dropIndicatorRender: (props: {
+        dropPosition: -1 | 0 | 1;
+        dropLevelOffset: number;
+        indent: number | null;
+        prefixCls: string;
+        direction: Direction;
+    }) => VueNode;
+    dragOverNodeKey: Key | null;
+    dragging: boolean;
+    direction: Direction;
+    loadData: (treeNode: EventDataNode) => Promise<void>;
+    filterTreeNode: (treeNode: EventDataNode) => boolean;
+    onNodeClick: NodeMouseEventHandler;
+    onNodeDoubleClick: NodeMouseEventHandler;
+    onNodeExpand: NodeMouseEventHandler;
+    onNodeSelect: NodeMouseEventHandler;
+    onNodeCheck: (e: MouseEvent, treeNode: EventDataNode, checked: boolean) => void;
+    onNodeLoad: (treeNode: EventDataNode) => void;
+    onNodeMouseEnter: NodeMouseEventHandler;
+    onNodeMouseLeave: NodeMouseEventHandler;
+    onNodeContextMenu: NodeMouseEventHandler;
+    onNodeDragStart: NodeDragEventHandler;
+    onNodeDragEnter: NodeDragEventHandler;
+    onNodeDragOver: NodeDragEventHandler;
+    onNodeDragLeave: NodeDragEventHandler;
+    onNodeDragEnd: NodeDragEventHandler;
+    onNodeDrop: NodeDragEventHandler;
+    slots: {
+        title?: (data: any) => any;
+        titleRender?: (data: any) => any;
+        [key: string]: ((...args: any[]) => any) | undefined;
+    };
+}
+export declare const TreeContext: DefineComponent<ExtractPropTypes<{
+    value: {
+        type: PropType<TreeContextProps>;
+    };
+}>, () => VNode<RendererNode, RendererElement, {
+    [key: string]: any;
+}>[] | undefined, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, PublicProps, Readonly< ExtractPropTypes<{
+    value: {
+        type: PropType<TreeContextProps>;
+    };
+}>> & Readonly<{}>, {}, {}, {}, {}, string, ComponentProvideOptions, true, {}, any>;
+export declare const useInjectTreeContext: () => ComputedRef<TreeContextProps>;
+interface KeysStateKeyType {
+    expandedKeysSet: ComputedRef<Set<Key>>;
+    selectedKeysSet: ComputedRef<Set<Key>>;
+    loadedKeysSet: ComputedRef<Set<Key>>;
+    loadingKeysSet: ComputedRef<Set<Key>>;
+    checkedKeysSet: ComputedRef<Set<Key>>;
+    halfCheckedKeysSet: ComputedRef<Set<Key>>;
+    expandedKeys: ShallowRef<Key[]>;
+    selectedKeys: ShallowRef<Key[]>;
+    loadedKeys: ShallowRef<Key[]>;
+    loadingKeys: ShallowRef<Key[]>;
+    checkedKeys: ShallowRef<Key[]>;
+    halfCheckedKeys: ShallowRef<Key[]>;
+    flattenNodes: ShallowRef<FlattenNode[]>;
+}
+export declare const useProvideKeysState: (state: KeysStateKeyType) => void;
+export declare const useInjectKeysState: () => {
+    expandedKeys: ShallowRef<Key[], Key[]>;
+    selectedKeys: ShallowRef<Key[], Key[]>;
+    loadedKeys: ShallowRef<Key[], Key[]>;
+    loadingKeys: ShallowRef<Key[], Key[]>;
+    checkedKeys: ShallowRef<Key[], Key[]>;
+    halfCheckedKeys: ShallowRef<Key[], Key[]>;
+    expandedKeysSet: ComputedRef<Set<Key>>;
+    selectedKeysSet: ComputedRef<Set<Key>>;
+    loadedKeysSet: ComputedRef<Set<Key>>;
+    loadingKeysSet: ComputedRef<Set<Key>>;
+    checkedKeysSet: ComputedRef<Set<Key>>;
+    halfCheckedKeysSet: ComputedRef<Set<Key>>;
+    flattenNodes: ShallowRef<FlattenNode[], FlattenNode[]>;
+};
+export {};

package/dist/src/vc-tree/index.d.ts

@@ -0,0 +1,7 @@
+import { default as Tree } from './Tree';
+import { default as TreeNode } from './TreeNode';
+import { BasicDataNode } from './interface';
+import { TreeNodeProps, TreeProps } from './props';
+export { TreeNode };
+export type { BasicDataNode, TreeNodeProps, TreeProps };
+export default Tree;

package/dist/src/vc-tree/interface.d.ts

@@ -0,0 +1,83 @@
+import { CSSProperties, VNode } from 'vue';
+import { TreeNodeProps } from './props';
+export type { ScrollTo } from '../vc-virtual-list/List';
+/** For fieldNames, we provides a abstract interface */
+export interface BasicDataNode {
+    checkable?: boolean;
+    disabled?: boolean;
+    disableCheckbox?: boolean;
+    icon?: IconType;
+    isLeaf?: boolean;
+    selectable?: boolean;
+    switcherIcon?: IconType;
+    /** Set style of TreeNode. This is not recommend if you don't have any force requirement */
+    class?: string;
+    style?: CSSProperties;
+    slots?: Record<string, string>;
+    [key: string]: any;
+}
+export interface DataNode extends BasicDataNode {
+    children?: DataNode[];
+    key: string | number;
+    title?: any;
+}
+export interface EventDataNode extends DataNode {
+    expanded?: boolean;
+    selected?: boolean;
+    checked: boolean;
+    loaded?: boolean;
+    loading?: boolean;
+    halfChecked?: boolean;
+    dragOver?: boolean;
+    dragOverGapTop?: boolean;
+    dragOverGapBottom?: boolean;
+    pos?: string;
+    active?: boolean;
+    dataRef?: DataNode;
+    parent?: DataNode;
+    eventKey?: Key;
+}
+export type IconType = any;
+export type Key = string | number;
+export type NodeElement = VNode<TreeNodeProps>;
+export interface DragNodeEvent {
+    key: Key;
+    eventData: EventDataNode;
+    eventKey: Key;
+    selectHandle: HTMLSpanElement;
+    pos: string;
+}
+export interface Entity {
+    node: NodeElement;
+    index: number;
+    key: Key;
+    pos: string;
+    parent?: Entity;
+    children?: Entity[];
+}
+export interface DataEntity<TreeDataType extends BasicDataNode = DataNode> extends Omit<Entity, 'node' | 'parent' | 'children'> {
+    node: TreeDataType;
+    nodes: TreeDataType[];
+    parent?: DataEntity<TreeDataType>;
+    children?: DataEntity<TreeDataType>[];
+    level: number;
+}
+export interface FlattenNode {
+    parent: FlattenNode | null;
+    children: FlattenNode[];
+    pos: string;
+    data: DataNode;
+    title: any;
+    key: Key;
+    isStart: boolean[];
+    isEnd: boolean[];
+}
+export type GetKey<RecordType> = (record: RecordType, index?: number) => Key;
+export type GetCheckDisabled<RecordType> = (record: RecordType) => boolean;
+export type Direction = 'ltr' | 'rtl' | undefined;
+export interface FieldNames {
+    title?: string;
+    _title?: string[];
+    key?: string;
+    children?: string;
+}

package/dist/src/vc-tree/useMaxLevel.d.ts

@@ -0,0 +1,6 @@
+import { ShallowRef, Ref } from 'vue';
+import { BasicDataNode, DataEntity, DataNode, Key } from './interface';
+export default function useMaxLevel<TreeDataType extends BasicDataNode = DataNode>(keyEntities: ShallowRef<Record<Key, DataEntity<TreeDataType>>>): {
+    maxLevel: Ref<number, number>;
+    levelEntities: ShallowRef<Map<number, Set<DataEntity<TreeDataType>>> | undefined, Map<number, Set<DataEntity<TreeDataType>>> | undefined>;
+};

package/dist/src/vc-tree/util.d.ts

@@ -0,0 +1,51 @@
+import { BasicDataNode, DataEntity, DataNode, Direction, DragNodeEvent, FlattenNode, Key, NodeElement } from './interface';
+import { AllowDrop, TreeProps } from './props';
+export declare function arrDel(list: Key[], value: Key): Key[];
+export declare function arrAdd(list: Key[], value: Key): Key[];
+export declare function posToArr(pos: string): string[];
+export declare function getPosition(level: string | number, index: number): string;
+export declare function isTreeNode(node: NodeElement): any;
+export declare function getDragChildrenKeys<TreeDataType extends BasicDataNode = DataNode>(dragNodeKey: Key, keyEntities: Record<Key, DataEntity<TreeDataType>>): Key[];
+export declare function isLastChild<TreeDataType extends BasicDataNode = DataNode>(treeNodeEntity: DataEntity<TreeDataType>): boolean;
+export declare function isFirstChild<TreeDataType extends BasicDataNode = DataNode>(treeNodeEntity: DataEntity<TreeDataType>): boolean;
+export declare function calcDropPosition<TreeDataType extends BasicDataNode = DataNode>(event: MouseEvent, dragNode: DragNodeEvent, targetNode: DragNodeEvent, indent: number, startMousePosition: {
+    x: number;
+    y: number;
+}, allowDrop: AllowDrop<TreeDataType>, flattenedNodes: FlattenNode[], keyEntities: Record<Key, DataEntity<TreeDataType>>, expandKeysSet: Set<Key>, direction: Direction): {
+    dropPosition: -1 | 0 | 1;
+    dropLevelOffset: number;
+    dropTargetKey: Key;
+    dropTargetPos: string;
+    dropContainerKey: Key;
+    dragOverNodeKey: Key;
+    dropAllowed: boolean;
+};
+/**
+ * Return selectedKeys according with multiple prop
+ * @param selectedKeys
+ * @param props
+ * @returns [string]
+ */
+export declare function calcSelectedKeys(selectedKeys: Key[], props: TreeProps): Key[] | undefined;
+export declare function convertDataToTree(treeData: DataNode[], processor?: {
+    processProps: (prop: DataNode) => any;
+}): NodeElement[];
+/**
+ * Parse `checkedKeys` to { checkedKeys, halfCheckedKeys } style
+ */
+export declare function parseCheckedKeys(keys: Key[] | {
+    checked: Key[];
+    halfChecked: Key[];
+}): {
+    checkedKeys: Key[];
+    halfCheckedKeys: undefined;
+} | {
+    checkedKeys: Key[];
+    halfCheckedKeys: Key[];
+} | null;
+/**
+ * If user use `autoExpandParent` we should get the list of parent node
+ * @param keyList
+ * @param keyEntities
+ */
+export declare function conductExpandParent(keyList: Key[], keyEntities: Record<Key, DataEntity>): Key[];

package/dist/src/vc-tree/utils/conductUtil.d.ts

@@ -0,0 +1,17 @@
+import { BasicDataNode, DataEntity, DataNode, GetCheckDisabled, Key } from '../interface';
+interface ConductReturnType {
+    checkedKeys: Key[];
+    halfCheckedKeys: Key[];
+}
+export declare function isCheckDisabled<TreeDataType>(node: TreeDataType): boolean;
+/**
+ * Conduct with keys.
+ * @param keyList current key list
+ * @param keyEntities key - dataEntity map
+ * @param mode `fill` to fill missing key, `clean` to remove useless key
+ */
+export declare function conductCheck<TreeDataType extends BasicDataNode = DataNode>(keyList: Key[], checked: true | {
+    checked: false;
+    halfCheckedKeys: Key[];
+}, keyEntities: Record<Key, DataEntity<TreeDataType>>, maxLevel: number, levelEntities: Map<number, Set<DataEntity<TreeDataType>>>, getCheckDisabled?: GetCheckDisabled<TreeDataType>): ConductReturnType;
+export {};

package/dist/src/vc-tree/utils/diffUtil.d.ts

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

package/dist/src/vc-tree/utils/treeUtil.d.ts

@@ -0,0 +1,89 @@
+import { VueNode } from '../../_util/type';
+import { BasicDataNode, DataEntity, DataNode, EventDataNode, FieldNames, FlattenNode, GetKey, Key } from '../interface';
+import { TreeNodeProps } from '../props';
+export declare function getKey(key: Key, pos: string): Key;
+export declare function fillFieldNames(fieldNames?: FieldNames): Required<FieldNames>;
+/**
+ * Warning if TreeNode do not provides key
+ */
+export declare function warningWithoutKey(treeData: DataNode[], fieldNames: FieldNames): void;
+/**
+ * Convert `children` of Tree into `treeData` structure.
+ */
+export declare function convertTreeToData(rootNodes: VueNode): DataNode[];
+/**
+ * Flat nest tree data into flatten list. This is used for virtual list render.
+ * @param treeNodeList Origin data node list
+ * @param expandedKeys
+ * need expanded keys, provides `true` means all expanded (used in `rc-tree-select`).
+ */
+export declare function flattenTreeData(treeNodeList: DataNode[], expandedKeys: Key[] | true, fieldNames: FieldNames): FlattenNode[];
+type ExternalGetKey = GetKey<DataNode> | string;
+interface TraverseDataNodesConfig {
+    childrenPropName?: string;
+    externalGetKey?: ExternalGetKey;
+    fieldNames?: FieldNames;
+}
+/**
+ * Traverse all the data by `treeData`.
+ * Please not use it out of the `rc-tree` since we may refactor this code.
+ */
+export declare function traverseDataNodes(dataNodes: DataNode[], callback: (data: {
+    node: DataNode;
+    index: number;
+    pos: string;
+    key: Key;
+    parentPos: string | number;
+    level: number;
+    nodes: DataNode[];
+}) => void, config?: TraverseDataNodesConfig | string): void;
+interface Wrapper {
+    posEntities: Record<string, DataEntity>;
+    keyEntities: Record<Key, DataEntity>;
+}
+/**
+ * Convert `treeData` into entity records.
+ */
+export declare function convertDataToEntities(dataNodes: DataNode[], { initWrapper, processEntity, onProcessFinished, externalGetKey, childrenPropName, fieldNames, }?: {
+    initWrapper?: (wrapper: Wrapper) => Wrapper;
+    processEntity?: (entity: DataEntity, wrapper: Wrapper) => void;
+    onProcessFinished?: (wrapper: Wrapper) => void;
+    externalGetKey?: ExternalGetKey;
+    childrenPropName?: string;
+    fieldNames?: FieldNames;
+}, 
+/** @deprecated Use `config.externalGetKey` instead */
+legacyExternalGetKey?: ExternalGetKey): {
+    posEntities: {};
+    keyEntities: {};
+};
+export interface TreeNodeRequiredProps<TreeDataType extends BasicDataNode = DataNode> {
+    expandedKeysSet: Set<Key>;
+    selectedKeysSet: Set<Key>;
+    loadedKeysSet: Set<Key>;
+    loadingKeysSet: Set<Key>;
+    checkedKeysSet: Set<Key>;
+    halfCheckedKeysSet: Set<Key>;
+    dragOverNodeKey: Key;
+    dropPosition: number;
+    keyEntities: Record<Key, DataEntity<TreeDataType>>;
+}
+/**
+ * Get TreeNode props with Tree props.
+ */
+export declare function getTreeNodeProps<TreeDataType extends BasicDataNode = DataNode>(key: Key, { expandedKeysSet, selectedKeysSet, loadedKeysSet, loadingKeysSet, checkedKeysSet, halfCheckedKeysSet, dragOverNodeKey, dropPosition, keyEntities, }: TreeNodeRequiredProps<TreeDataType>): {
+    eventKey: Key;
+    expanded: boolean;
+    selected: boolean;
+    loaded: boolean;
+    loading: boolean;
+    checked: boolean;
+    halfChecked: boolean;
+    pos: string;
+    parent: DataEntity<TreeDataType> | undefined;
+    dragOver: boolean;
+    dragOverGapTop: boolean;
+    dragOverGapBottom: boolean;
+};
+export declare function convertNodePropsToEventData(props: TreeNodeProps & ReturnType<typeof getTreeNodeProps>): EventDataNode;
+export {};

package/dist/src/vc-tree-select/LegacyContext.d.ts

@@ -0,0 +1,30 @@
+import { TreeProps } from '../tree';
+import { DataEntity, IconType } from '../vc-tree/interface';
+import { InternalDataEntity, Key, LegacyDataNode, RawValueType } from './interface';
+export interface LegacyContextProps {
+    checkable: boolean;
+    checkedKeys: Key[];
+    customCheckable: () => any;
+    halfCheckedKeys: Key[];
+    treeExpandedKeys: Key[];
+    treeDefaultExpandedKeys: Key[];
+    onTreeExpand: (keys: Key[]) => void;
+    treeDefaultExpandAll: boolean;
+    treeIcon: IconType;
+    showTreeIcon: boolean;
+    switcherIcon: IconType;
+    treeLine: TreeProps['showLine'];
+    treeNodeFilterProp: string;
+    treeLoadedKeys: Key[];
+    treeMotion: any;
+    loadData: (treeNode: LegacyDataNode) => Promise<unknown>;
+    onTreeLoad: (loadedKeys: Key[]) => void;
+    keyEntities: Record<RawValueType, DataEntity<any>>;
+    customSlots: {
+        title?: (data: InternalDataEntity) => any;
+        treeCheckable: () => any;
+        [key: string]: ((...args: any[]) => any) | undefined;
+    };
+}
+export declare function useProvideLegacySelectContext(props: LegacyContextProps): void;
+export default function useInjectLegacySelectContext(): LegacyContextProps;

package/dist/src/vc-tree-select/OptionList.d.ts

@@ -0,0 +1,3 @@
+import { DefineComponent, ComponentOptionsMixin, PublicProps, ComponentProvideOptions } from 'vue';
+declare const _default: DefineComponent<{}, () => import("vue/jsx-runtime").JSX.Element, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, PublicProps, Readonly<{}> & Readonly<{}>, {}, {}, {}, {}, string, ComponentProvideOptions, true, {}, any>;
+export default _default;

package/dist/src/vc-tree-select/TreeNode.d.ts

@@ -0,0 +1,10 @@
+import { FunctionalComponent } from 'vue';
+import { DataNode, Key } from './interface';
+export interface TreeNodeProps extends Omit<DataNode, 'children'> {
+    value: Key;
+}
+/** This is a placeholder, not real render in dom */
+declare const TreeNode: FunctionalComponent<TreeNodeProps> & {
+    isTreeSelectNode: boolean;
+};
+export default TreeNode;

package/dist/src/vc-tree-select/TreeSelectContext.d.ts

@@ -0,0 +1,14 @@
+import { ExpandAction } from '../vc-tree/props';
+import { DefaultOptionType, InternalFieldName, OnInternalSelect } from './TreeSelect';
+export interface TreeSelectContextProps {
+    virtual?: boolean;
+    dropdownMatchSelectWidth?: boolean | number;
+    listHeight: number;
+    listItemHeight: number;
+    treeData: DefaultOptionType[];
+    fieldNames: InternalFieldName;
+    onSelect: OnInternalSelect;
+    treeExpandAction?: ExpandAction;
+}
+export declare function useProvideSelectContext(props: TreeSelectContextProps): void;
+export default function useInjectSelectContext(): TreeSelectContextProps;

package/dist/src/vc-tree-select/hooks/useCache.d.ts

@@ -0,0 +1,8 @@
+import { Ref } from 'vue';
+import { LabeledValueType } from '../TreeSelect';
+/**
+ * This function will try to call requestIdleCallback if available to save performance.
+ * No need `getLabel` here since already fetch on `rawLabeledValue`.
+ */
+declare const _default: (values: Ref<LabeledValueType[]>) => [Ref<LabeledValueType[]>];
+export default _default;

package/dist/src/vc-tree-select/hooks/useCheckedKeys.d.ts

@@ -0,0 +1,6 @@
+import { Ref, ShallowRef } from 'vue';
+import { Key } from '../../_util/type';
+import { DataEntity } from '../../vc-tree/interface';
+import { LabeledValueType, RawValueType } from '../TreeSelect';
+declare const _default: (rawLabeledValues: ShallowRef<LabeledValueType[]>, rawHalfCheckedValues: ShallowRef<LabeledValueType[]>, treeConduction: Ref<boolean>, keyEntities: Ref<Record<Key, DataEntity>>, maxLevel: Ref<number>, levelEntities: ShallowRef<Map<number, Set<DataEntity>>>) => ShallowRef<RawValueType[], RawValueType[]>[];
+export default _default;

package/dist/src/vc-tree-select/hooks/useDataEntities.d.ts

@@ -0,0 +1,9 @@
+import { Ref, ShallowRef } from 'vue';
+import { DataEntity } from '../../vc-tree/interface';
+import { FieldNames, RawValueType } from '../TreeSelect';
+import { DataNode } from '../../tree';
+declare const _default: (treeData: ShallowRef<any>, fieldNames: Ref<FieldNames>) => {
+    valueEntities: ShallowRef<Map<RawValueType, DataEntity< DataNode>>, Map<RawValueType, DataEntity< DataNode>>>;
+    keyEntities: ShallowRef<Record<string, DataEntity< DataNode>>, Record<string, DataEntity< DataNode>>>;
+};
+export default _default;

package/dist/src/vc-tree-select/hooks/useFilterTreeData.d.ts

@@ -0,0 +1,8 @@
+import { Ref, ShallowRef, ComputedRef } from 'vue';
+import { DefaultOptionType, InternalFieldName, TreeSelectProps } from '../TreeSelect';
+declare const _default: (treeData: ShallowRef<DefaultOptionType[]>, searchValue: Ref<string>, { treeNodeFilterProp, filterTreeNode, fieldNames, }: {
+    fieldNames: Ref<InternalFieldName>;
+    treeNodeFilterProp: Ref<string>;
+    filterTreeNode: Ref<TreeSelectProps["filterTreeNode"]>;
+}) => ComputedRef<any>;
+export default _default;

package/dist/src/vc-tree-select/hooks/useTreeData.d.ts

@@ -0,0 +1,9 @@
+import { Ref, ShallowRef } from 'vue';
+import { VueNode } from '../../_util/type';
+import { DefaultOptionType } from '../TreeSelect';
+import { DataNode, SimpleModeConfig } from '../interface';
+/**
+ * Convert `treeData` or `children` into formatted `treeData`.
+ * Will not re-calculate if `treeData` or `children` not change.
+ */
+export default function useTreeData(treeData: Ref<DataNode[]>, children: Ref<VueNode[]>, simpleMode: Ref<boolean | SimpleModeConfig>): ShallowRef<DefaultOptionType[]>;

package/dist/src/vc-tree-select/index.d.ts

@@ -0,0 +1,6 @@
+import { default as TreeNode } from './TreeNode';
+import { TreeSelectProps, default as TreeSelect, treeSelectProps } from './TreeSelect';
+import { SHOW_ALL, SHOW_CHILD, SHOW_PARENT } from './utils/strategyUtil';
+export { SHOW_ALL, SHOW_CHILD, SHOW_PARENT, TreeNode, treeSelectProps };
+export type { TreeSelectProps };
+export default TreeSelect;

package/dist/src/vc-tree-select/interface.d.ts

@@ -0,0 +1,82 @@
+export type SelectSource = 'option' | 'selection' | 'input' | 'clear';
+export type Key = string | number;
+export type RawValueType = string | number;
+export interface LabelValueType {
+    key?: Key;
+    value?: RawValueType;
+    label?: any;
+    /** Only works on `treeCheckStrictly` */
+    halfChecked?: boolean;
+}
+export type DefaultValueType = RawValueType | RawValueType[] | LabelValueType | LabelValueType[];
+export interface DataNode {
+    value?: RawValueType;
+    title?: any;
+    label?: any;
+    key?: Key;
+    disabled?: boolean;
+    disableCheckbox?: boolean;
+    checkable?: boolean;
+    selectable?: boolean;
+    children?: DataNode[];
+    /** Customize data info */
+    [prop: string]: any;
+}
+export interface InternalDataEntity {
+    key: Key;
+    value: RawValueType;
+    title?: any;
+    checkable: boolean;
+    disableCheckbox: boolean;
+    disabled: boolean;
+    selectable: boolean;
+    isLeaf: boolean;
+    children?: InternalDataEntity[];
+    /** Origin DataNode */
+    node: DataNode;
+    dataRef: DataNode;
+    slots?: Record<string, string>;
+}
+export interface LegacyDataNode extends DataNode {
+    props: any;
+}
+export interface TreeDataNode extends DataNode {
+    key: Key;
+    children?: TreeDataNode[];
+}
+export interface FlattenDataNode {
+    data: InternalDataEntity;
+    key: Key;
+    value: RawValueType;
+    level: number;
+    parent?: FlattenDataNode;
+}
+export interface SimpleModeConfig {
+    id?: Key;
+    pId?: Key;
+    rootPId?: Key;
+}
+/** @deprecated This is only used for legacy compatible. Not works on new code. */
+export interface LegacyCheckedNode {
+    pos: string;
+    node: any;
+    children?: LegacyCheckedNode[];
+}
+export interface ChangeEventExtra {
+    /** @deprecated Please save prev value by control logic instead */
+    preValue: LabelValueType[];
+    triggerValue: RawValueType;
+    /** @deprecated Use `onSelect` or `onDeselect` instead. */
+    selected?: boolean;
+    /** @deprecated Use `onSelect` or `onDeselect` instead. */
+    checked?: boolean;
+    /** @deprecated This prop not work as react node anymore. */
+    triggerNode: any;
+    /** @deprecated This prop not work as react node anymore. */
+    allCheckedNodes: LegacyCheckedNode[];
+}
+export interface FieldNames {
+    value?: string;
+    label?: string;
+    children?: string;
+}

package/dist/src/vc-tree-select/utils/legacyUtil.d.ts

@@ -0,0 +1,6 @@
+import { VueNode } from '../../_util/type';
+import { DefaultOptionType, FieldNames } from '../TreeSelect';
+import { ChangeEventExtra, DataNode, RawValueType } from '../interface';
+export declare function convertChildrenToData(rootNodes: VueNode[]): DataNode[];
+export declare function fillLegacyProps(dataNode: DataNode): any;
+export declare function fillAdditionalInfo(extra: ChangeEventExtra, triggerValue: RawValueType, checkedValues: RawValueType[], treeData: DefaultOptionType[], showPosition: boolean, fieldNames: FieldNames): void;

package/dist/src/vc-tree-select/utils/strategyUtil.d.ts

@@ -0,0 +1,8 @@
+import { DataEntity } from '../../vc-tree/interface';
+import { InternalFieldName } from '../TreeSelect';
+import { Key, RawValueType } from '../interface';
+export declare const SHOW_ALL = "SHOW_ALL";
+export declare const SHOW_PARENT = "SHOW_PARENT";
+export declare const SHOW_CHILD = "SHOW_CHILD";
+export type CheckedStrategy = typeof SHOW_ALL | typeof SHOW_PARENT | typeof SHOW_CHILD;
+export declare function formatStrategyValues(values: Key[], strategy: CheckedStrategy, keyEntities: Record<Key, DataEntity>, fieldNames: InternalFieldName): RawValueType[];

package/dist/src/vc-tree-select/utils/valueUtil.d.ts

@@ -0,0 +1,13 @@
+import { DefaultOptionType, InternalFieldName } from '../TreeSelect';
+import { DataNode, FieldNames, Key } from '../interface';
+export declare function toArray<T>(value: T | T[]): T[];
+export declare function fillFieldNames(fieldNames?: FieldNames): {
+    _title: string[];
+    value: string;
+    key: string;
+    children: string;
+};
+export declare function isCheckDisabled(node: DataNode): boolean;
+/** Loop fetch all the keys exist in the tree */
+export declare function getAllKeys(treeData: DefaultOptionType[], fieldNames: InternalFieldName): Key[];
+export declare function isNil(val: any): boolean;

package/dist/src/vc-tree-select/utils/warningPropsUtil.d.ts

@@ -0,0 +1,5 @@
+import { TreeSelectProps } from '../TreeSelect';
+declare function warningProps(props: TreeSelectProps & {
+    searchPlaceholder?: string;
+}): void;
+export default warningProps;

package/dist/src/vc-trigger/Popup/Mask.d.ts

@@ -0,0 +1,14 @@
+import { AnimationType, TransitionNameType } from '../interface';
+export interface MaskProps {
+    prefixCls: string;
+    visible?: boolean;
+    zIndex?: number;
+    mask?: boolean;
+    maskAnimation?: AnimationType;
+    maskTransitionName?: TransitionNameType;
+}
+declare function Mask(props: MaskProps): import("vue/jsx-runtime").JSX.Element | null;
+declare namespace Mask {
+    var displayName: string;
+}
+export default Mask;