@antsoo-lib/components 0.0.1

package/dist/src/upload/interface.d.ts

@@ -0,0 +1,355 @@
+import { CSSProperties, ExtractPropTypes, ImgHTMLAttributes, PropType } from 'vue';
+import { VueNode } from '../_util/type';
+import { ProgressProps } from '../progress';
+import { RcFile as OriRcFile, UploadRequestOption as RcCustomRequestOptions } from '../vc-upload/interface';
+export interface FileType extends OriRcFile {
+    readonly lastModifiedDate: Date;
+}
+export type UploadFileStatus = 'error' | 'success' | 'done' | 'uploading' | 'removed';
+export interface HttpRequestHeader {
+    [key: string]: string;
+}
+export interface UploadFile<T = any> {
+    uid: string;
+    size?: number;
+    name: string;
+    fileName?: string;
+    lastModified?: number;
+    lastModifiedDate?: Date;
+    url?: string;
+    status?: UploadFileStatus;
+    percent?: number;
+    thumbUrl?: string;
+    crossOrigin?: ImgHTMLAttributes['crossorigin'];
+    originFileObj?: FileType;
+    response?: T;
+    error?: any;
+    linkProps?: any;
+    type?: string;
+    xhr?: T;
+    preview?: string;
+}
+export interface InternalUploadFile<T = any> extends UploadFile<T> {
+    originFileObj: FileType;
+}
+export interface ShowUploadListInterface {
+    showRemoveIcon?: boolean;
+    showPreviewIcon?: boolean;
+    showDownloadIcon?: boolean;
+}
+export interface UploadChangeParam<T = UploadFile> {
+    file: T;
+    fileList: T[];
+    event?: {
+        percent: number;
+    };
+}
+export interface UploadLocale {
+    uploading?: string;
+    removeFile?: string;
+    downloadFile?: string;
+    uploadError?: string;
+    previewFile?: string;
+}
+export type UploadType = 'drag' | 'select';
+export type UploadListType = 'text' | 'picture' | 'picture-card';
+export type UploadListProgressProps = Omit<ProgressProps, 'percent' | 'type'> & {
+    class?: string;
+    style?: CSSProperties;
+};
+export type ItemRender<T = any> = (opt: {
+    originNode: VueNode;
+    file: UploadFile;
+    fileList: Array<UploadFile<T>>;
+    actions: {
+        download: () => void;
+        preview: () => void;
+        remove: () => void;
+    };
+}) => VueNode;
+type PreviewFileHandler = (file: FileType | Blob) => PromiseLike<string>;
+type TransformFileHandler = (file: FileType) => string | Blob | FileType | PromiseLike<string | Blob | FileType>;
+type BeforeUploadValueType = void | boolean | string | Blob | FileType;
+declare function uploadProps<T = any>(): {
+    capture: {
+        type: PropType<boolean | "user" | "environment">;
+        default: boolean | "user" | "environment";
+    };
+    type: {
+        type: PropType<UploadType>;
+        default: UploadType;
+    };
+    name: StringConstructor;
+    defaultFileList: {
+        type: PropType<UploadFile<T>[]>;
+        default: UploadFile<T>[];
+    };
+    fileList: {
+        type: PropType<UploadFile<T>[]>;
+        default: UploadFile<T>[];
+    };
+    action: {
+        type: PropType<string | ((file: FileType) => string) | ((file: FileType) => PromiseLike<string>)>;
+        default: string | ((file: FileType) => string) | ((file: FileType) => PromiseLike<string>);
+    };
+    directory: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    data: {
+        type: PropType<Record<string, unknown> | ((file: UploadFile<T>) => Record<string, unknown> | Promise<Record<string, unknown>>)>;
+        default: Record<string, unknown> | ((file: UploadFile<T>) => Record<string, unknown> | Promise<Record<string, unknown>>);
+    };
+    method: {
+        type: PropType<"post" | "POST" | "PUT" | "PATCH" | "put" | "patch">;
+        default: "post" | "POST" | "PUT" | "PATCH" | "put" | "patch";
+    };
+    headers: {
+        type: PropType<HttpRequestHeader>;
+        default: HttpRequestHeader;
+    };
+    showUploadList: {
+        type: PropType<boolean | ShowUploadListInterface>;
+        default: boolean | ShowUploadListInterface;
+    };
+    multiple: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    accept: StringConstructor;
+    beforeUpload: {
+        type: PropType<(file: FileType, FileList: FileType[]) => BeforeUploadValueType | Promise<BeforeUploadValueType>>;
+        default: (file: FileType, FileList: FileType[]) => BeforeUploadValueType | Promise<BeforeUploadValueType>;
+    };
+    onChange: {
+        type: PropType<(info: UploadChangeParam<UploadFile<T>>) => void>;
+        default: (info: UploadChangeParam<UploadFile<T>>) => void;
+    };
+    'onUpdate:fileList': {
+        type: PropType<(fileList: UploadChangeParam<UploadFile<T>>["fileList"]) => void>;
+        default: (fileList: UploadChangeParam<UploadFile<T>>["fileList"]) => void;
+    };
+    onDrop: {
+        type: PropType<(event: DragEvent) => void>;
+        default: (event: DragEvent) => void;
+    };
+    listType: {
+        type: PropType<UploadListType>;
+        default: UploadListType;
+    };
+    onPreview: {
+        type: PropType<(file: UploadFile<T>) => void>;
+        default: (file: UploadFile<T>) => void;
+    };
+    onDownload: {
+        type: PropType<(file: UploadFile<T>) => void>;
+        default: (file: UploadFile<T>) => void;
+    };
+    onReject: {
+        type: PropType<(fileList: FileType[]) => void>;
+        default: (fileList: FileType[]) => void;
+    };
+    onRemove: {
+        type: PropType<(file: UploadFile<T>) => void | boolean | Promise<void | boolean>>;
+        default: (file: UploadFile<T>) => void | boolean | Promise<void | boolean>;
+    };
+    /** @deprecated Please use `onRemove` directly */
+    remove: {
+        type: PropType<(file: UploadFile<T>) => void | boolean | Promise<void | boolean>>;
+        default: (file: UploadFile<T>) => void | boolean | Promise<void | boolean>;
+    };
+    supportServerRender: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    disabled: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    prefixCls: StringConstructor;
+    customRequest: {
+        type: PropType<(options: RcCustomRequestOptions) => void>;
+        default: (options: RcCustomRequestOptions) => void;
+    };
+    withCredentials: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    openFileDialogOnClick: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    locale: {
+        type: PropType<UploadLocale>;
+        default: UploadLocale;
+    };
+    id: StringConstructor;
+    previewFile: {
+        type: PropType<PreviewFileHandler>;
+        default: PreviewFileHandler;
+    };
+    /** @deprecated Please use `beforeUpload` directly */
+    transformFile: {
+        type: PropType<TransformFileHandler>;
+        default: TransformFileHandler;
+    };
+    iconRender: {
+        type: PropType<(opt: {
+            file: UploadFile<T>;
+            listType?: UploadListType;
+        }) => VueNode>;
+        default: (opt: {
+            file: UploadFile<T>;
+            listType?: UploadListType;
+        }) => VueNode;
+    };
+    isImageUrl: {
+        type: PropType<(file: UploadFile) => boolean>;
+        default: (file: UploadFile) => boolean;
+    };
+    progress: {
+        type: PropType<UploadListProgressProps>;
+        default: UploadListProgressProps;
+    };
+    itemRender: {
+        type: PropType<ItemRender<T>>;
+        default: ItemRender<T>;
+    };
+    /** Config max count of `fileList`. Will replace current one when `maxCount` is 1 */
+    maxCount: NumberConstructor;
+    height: {
+        type: PropType<unknown>;
+        default: unknown;
+    };
+    removeIcon: {
+        type: PropType<(opt: {
+            file: UploadFile;
+        }) => VueNode>;
+        default: (opt: {
+            file: UploadFile;
+        }) => VueNode;
+    };
+    downloadIcon: {
+        type: PropType<(opt: {
+            file: UploadFile;
+        }) => VueNode>;
+        default: (opt: {
+            file: UploadFile;
+        }) => VueNode;
+    };
+    previewIcon: {
+        type: PropType<(opt: {
+            file: UploadFile;
+        }) => VueNode>;
+        default: (opt: {
+            file: UploadFile;
+        }) => VueNode;
+    };
+};
+export type UploadProps = Partial<ExtractPropTypes<ReturnType<typeof uploadProps>>>;
+export interface UploadState<T = any> {
+    fileList: UploadFile<T>[];
+    dragState: string;
+}
+declare function uploadListProps<T = any>(): {
+    listType: {
+        type: PropType<UploadListType>;
+        default: UploadListType;
+    };
+    onPreview: {
+        type: PropType<(file: UploadFile<T>) => void>;
+        default: (file: UploadFile<T>) => void;
+    };
+    onDownload: {
+        type: PropType<(file: UploadFile<T>) => void>;
+        default: (file: UploadFile<T>) => void;
+    };
+    onRemove: {
+        type: PropType<(file: UploadFile<T>) => void | boolean>;
+        default: (file: UploadFile<T>) => void | boolean;
+    };
+    items: {
+        type: PropType<UploadFile<T>[]>;
+        default: UploadFile<T>[];
+    };
+    progress: {
+        type: PropType<UploadListProgressProps>;
+        default: UploadListProgressProps;
+    };
+    prefixCls: {
+        type: PropType<string>;
+        default: string;
+    };
+    showRemoveIcon: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    showDownloadIcon: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    showPreviewIcon: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    removeIcon: {
+        type: PropType<(opt: {
+            file: UploadFile;
+        }) => VueNode>;
+        default: (opt: {
+            file: UploadFile;
+        }) => VueNode;
+    };
+    downloadIcon: {
+        type: PropType<(opt: {
+            file: UploadFile;
+        }) => VueNode>;
+        default: (opt: {
+            file: UploadFile;
+        }) => VueNode;
+    };
+    previewIcon: {
+        type: PropType<(opt: {
+            file: UploadFile;
+        }) => VueNode>;
+        default: (opt: {
+            file: UploadFile;
+        }) => VueNode;
+    };
+    locale: {
+        type: PropType<UploadLocale>;
+        default: UploadLocale;
+    };
+    previewFile: {
+        type: PropType<PreviewFileHandler>;
+        default: PreviewFileHandler;
+    };
+    iconRender: {
+        type: PropType<(opt: {
+            file: UploadFile<T>;
+            listType?: UploadListType;
+        }) => VueNode>;
+        default: (opt: {
+            file: UploadFile<T>;
+            listType?: UploadListType;
+        }) => VueNode;
+    };
+    isImageUrl: {
+        type: PropType<(file: UploadFile) => boolean>;
+        default: (file: UploadFile) => boolean;
+    };
+    appendAction: {
+        type: PropType<() => VueNode>;
+        default: () => VueNode;
+    };
+    appendActionVisible: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    itemRender: {
+        type: PropType<ItemRender<T>>;
+        default: ItemRender<T>;
+    };
+};
+export type UploadListProps = Partial<ExtractPropTypes<ReturnType<typeof uploadListProps>>>;
+export { uploadListProps, uploadProps };

package/dist/src/upload/style/dragger.d.ts

@@ -0,0 +1,4 @@
+import { UploadToken } from '.';
+import { GenerateStyle } from '../../theme/internal';
+declare const genDraggerStyle: GenerateStyle<UploadToken>;
+export default genDraggerStyle;

package/dist/src/upload/style/index.d.ts

@@ -0,0 +1,11 @@
+import { FullToken, UseComponentStyleResult } from '../../theme/internal';
+import { Ref } from 'vue';
+export interface ComponentToken {
+}
+export interface UploadToken extends FullToken<'Upload'> {
+    uploadThumbnailSize: number;
+    uploadProgressOffset: number;
+    uploadPicCardSize: number;
+}
+declare const _default: (_prefixCls?: Ref<string>) => UseComponentStyleResult;
+export default _default;

package/dist/src/upload/style/list.d.ts

@@ -0,0 +1,4 @@
+import { UploadToken } from '.';
+import { GenerateStyle } from '../../theme/internal';
+declare const genListStyle: GenerateStyle<UploadToken>;
+export default genListStyle;

package/dist/src/upload/style/motion.d.ts

@@ -0,0 +1,4 @@
+import { UploadToken } from '.';
+import { GenerateStyle } from '../../theme/internal';
+declare const genMotionStyle: GenerateStyle<UploadToken>;
+export default genMotionStyle;

package/dist/src/upload/style/picture.d.ts

@@ -0,0 +1,5 @@
+import { UploadToken } from '.';
+import { GenerateStyle } from '../../theme/internal';
+declare const genPictureStyle: GenerateStyle<UploadToken>;
+declare const genPictureCardStyle: GenerateStyle<UploadToken>;
+export { genPictureCardStyle, genPictureStyle };

package/dist/src/upload/style/rtl.d.ts

@@ -0,0 +1,4 @@
+import { UploadToken } from '.';
+import { GenerateStyle } from '../../theme/internal';
+declare const genRtlStyle: GenerateStyle<UploadToken>;
+export default genRtlStyle;

package/dist/src/upload/utils.d.ts

@@ -0,0 +1,8 @@
+import { FileType, InternalUploadFile, UploadFile } from './interface';
+export declare function file2Obj(file: FileType): InternalUploadFile;
+/** Upload fileList. Replace file if exist or just push into it. */
+export declare function updateFileList(file: UploadFile<any>, fileList: UploadFile<any>[]): UploadFile<any>[];
+export declare function getFileItem(file: FileType, fileList: UploadFile[]): UploadFile<any>;
+export declare function removeFileItem(file: UploadFile, fileList: UploadFile[]): UploadFile<any>[] | null;
+export declare const isImageUrl: (file: UploadFile) => boolean;
+export declare function previewImage(file: File | Blob): Promise<string>;

package/dist/src/vc-align/Align.d.ts

@@ -0,0 +1,45 @@
+import { PropType, DefineComponent, ExtractPropTypes, VNode, RendererNode, RendererElement, ComponentOptionsMixin, PublicProps, ComponentProvideOptions } from 'vue';
+import { AlignResult, AlignType, TargetType } from './interface';
+type OnAlign = (source: HTMLElement, result: AlignResult) => void;
+export interface AlignProps {
+    align: AlignType;
+    target: TargetType;
+    onAlign?: OnAlign;
+    monitorBufferTime?: number;
+    monitorWindowResize?: boolean;
+    disabled?: boolean;
+}
+export declare const alignProps: {
+    align: PropType<AlignType>;
+    target: PropType<TargetType>;
+    onAlign: PropType<OnAlign>;
+    monitorBufferTime: NumberConstructor;
+    monitorWindowResize: BooleanConstructor;
+    disabled: BooleanConstructor;
+};
+export interface RefAlign {
+    forceAlign: () => void;
+}
+declare const _default: DefineComponent<ExtractPropTypes<{
+    align: PropType<AlignType>;
+    target: PropType<TargetType>;
+    onAlign: PropType<OnAlign>;
+    monitorBufferTime: NumberConstructor;
+    monitorWindowResize: BooleanConstructor;
+    disabled: BooleanConstructor;
+}>, () => VNode<RendererNode, RendererElement, {
+    [key: string]: any;
+}> | null, {}, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, "align"[], "align", PublicProps, Readonly< ExtractPropTypes<{
+    align: PropType<AlignType>;
+    target: PropType<TargetType>;
+    onAlign: PropType<OnAlign>;
+    monitorBufferTime: NumberConstructor;
+    monitorWindowResize: BooleanConstructor;
+    disabled: BooleanConstructor;
+}>> & Readonly<{
+    onAlign?: ((...args: any[]) => any) | undefined;
+}>, {
+    disabled: boolean;
+    monitorWindowResize: boolean;
+}, {}, {}, {}, string, ComponentProvideOptions, true, {}, any>;
+export default _default;

package/dist/src/vc-align/hooks/useBuffer.d.ts

@@ -0,0 +1,3 @@
+import { ComputedRef } from 'vue';
+declare const _default: (callback: () => boolean, buffer: ComputedRef<number>) => ((force?: boolean) => void)[];
+export default _default;

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

@@ -0,0 +1,2 @@
+import { default as Align } from './Align';
+export default Align;

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

@@ -0,0 +1,56 @@
+/** Two char of 't' 'b' 'c' 'l' 'r'. Example: 'lt' */
+export type AlignPoint = string;
+export interface AlignType {
+    /**
+     * move point of source node to align with point of target node.
+     * Such as ['tr','cc'], align top right point of source node with center point of target node.
+     * Point can be 't'(top), 'b'(bottom), 'c'(center), 'l'(left), 'r'(right) */
+    points?: AlignPoint[];
+    /**
+     * offset source node by offset[0] in x and offset[1] in y.
+     * If offset contains percentage string value, it is relative to sourceNode region.
+     */
+    offset?: number[];
+    /**
+     * offset target node by offset[0] in x and offset[1] in y.
+     * If targetOffset contains percentage string value, it is relative to targetNode region.
+     */
+    targetOffset?: number[];
+    /**
+     * If adjustX field is true, will adjust source node in x direction if source node is invisible.
+     * If adjustY field is true, will adjust source node in y direction if source node is invisible.
+     */
+    overflow?: {
+        adjustX?: boolean | number;
+        adjustY?: boolean | number;
+    };
+    /**
+     * Whether use css right instead of left to position
+     */
+    useCssRight?: boolean;
+    /**
+     * Whether use css bottom instead of top to position
+     */
+    useCssBottom?: boolean;
+    /**
+     * Whether use css transform instead of left/top/right/bottom to position if browser supports.
+     * Defaults to false.
+     */
+    useCssTransform?: boolean;
+}
+export interface AlignResult {
+    points: AlignPoint[];
+    offset: number[];
+    targetOffset: number[];
+    overflow: {
+        adjustX: boolean | number;
+        adjustY: boolean | number;
+    };
+}
+export interface TargetPoint {
+    clientX?: number;
+    clientY?: number;
+    pageX?: number;
+    pageY?: number;
+}
+export type TargetType = (() => HTMLElement) | TargetPoint;

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

@@ -0,0 +1,4 @@
+import { TargetPoint } from './interface';
+export declare function isSamePoint(prev: TargetPoint, next: TargetPoint): boolean;
+export declare function restoreFocus(activeElement: any, container: any): void;
+export declare function monitorResize(element: HTMLElement, callback: Function): () => void;

package/dist/src/vc-cascader/OptionList/Checkbox.d.ts

@@ -0,0 +1,15 @@
+import { MouseEventHandler } from '../../_util/EventInterface';
+export interface CheckboxProps {
+    prefixCls: string;
+    checked?: boolean;
+    halfChecked?: boolean;
+    disabled?: boolean;
+    onClick?: MouseEventHandler;
+}
+declare function Checkbox({ prefixCls, checked, halfChecked, disabled, onClick, }: CheckboxProps): import("vue/jsx-runtime").JSX.Element;
+declare namespace Checkbox {
+    var props: string[];
+    var displayName: string;
+    var inheritAttrs: boolean;
+}
+export default Checkbox;

package/dist/src/vc-cascader/OptionList/Column.d.ts

@@ -0,0 +1,26 @@
+import { Key } from '../../_util/type';
+import { DefaultOptionType, SingleValueType } from '../Cascader';
+export declare const FIX_LABEL = "__cascader_fix_label__";
+export interface ColumnProps {
+    prefixCls: string;
+    multiple?: boolean;
+    options: DefaultOptionType[];
+    /** Current Column opened item key */
+    activeValue?: Key;
+    /** The value path before current column */
+    prevValuePath: Key[];
+    onToggleOpen: (open: boolean) => void;
+    onSelect: (valuePath: SingleValueType, leaf: boolean) => void;
+    onActive: (valuePath: SingleValueType) => void;
+    checkedSet: Set<Key>;
+    halfCheckedSet: Set<Key>;
+    loadingKeys: Key[];
+    isSelectable: (option: DefaultOptionType) => boolean;
+}
+declare function Column({ prefixCls, multiple, options, activeValue, prevValuePath, onToggleOpen, onSelect, onActive, checkedSet, halfCheckedSet, loadingKeys, isSelectable, }: ColumnProps): import("vue/jsx-runtime").JSX.Element;
+declare namespace Column {
+    var props: string[];
+    var displayName: string;
+    var inheritAttrs: boolean;
+}
+export default Column;

package/dist/src/vc-cascader/OptionList/index.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-cascader/OptionList/useActive.d.ts

@@ -0,0 +1,7 @@
+import { Ref } from 'vue';
+import { Key } from '../../_util/type';
+/**
+ * Control the active open options path.
+ */
+declare const _default: () => [Ref<Key[]>, (activeValueCells: Key[]) => void];
+export default _default;

package/dist/src/vc-cascader/OptionList/useKeyboard.d.ts

@@ -0,0 +1,5 @@
+import { Ref, SetupContext } from 'vue';
+import { Key } from '../../_util/type';
+import { DefaultOptionType, InternalFieldNames, SingleValueType } from '../Cascader';
+declare const _default: (context: SetupContext, options: Ref<DefaultOptionType[]>, fieldNames: Ref<InternalFieldNames>, activeValueCells: Ref<Key[]>, setActiveValueCells: (activeValueCells: Key[]) => void, onKeyBoardSelect: (valueCells: SingleValueType, option: DefaultOptionType) => void) => void;
+export default _default;

package/dist/src/vc-cascader/context.d.ts

@@ -0,0 +1,22 @@
+import { CSSProperties, Ref } from 'vue';
+import { VueNode } from '../_util/type';
+import { BaseCascaderProps, DefaultOptionType, InternalFieldNames, SingleValueType } from './Cascader';
+export interface CascaderContextProps {
+    options: Ref<BaseCascaderProps['options']>;
+    fieldNames: Ref<InternalFieldNames>;
+    values: Ref<SingleValueType[]>;
+    halfValues: Ref<SingleValueType[]>;
+    changeOnSelect: Ref<boolean>;
+    onSelect: (valuePath: SingleValueType) => void;
+    checkable: Ref<boolean | VueNode>;
+    searchOptions: Ref<DefaultOptionType[]>;
+    dropdownPrefixCls?: Ref<string>;
+    loadData: Ref<(selectOptions: DefaultOptionType[]) => void>;
+    expandTrigger: Ref<'hover' | 'click'>;
+    expandIcon: Ref<VueNode>;
+    loadingIcon: Ref<VueNode>;
+    dropdownMenuColumnStyle: Ref<CSSProperties>;
+    customSlots: Ref<Record<string, Function>>;
+}
+export declare const useProvideCascader: (props: CascaderContextProps) => void;
+export declare const useInjectCascader: () => CascaderContextProps | undefined;

package/dist/src/vc-cascader/hooks/useDisplayValues.d.ts

@@ -0,0 +1,9 @@
+import { Ref, ComputedRef } from 'vue';
+import { BaseCascaderProps, DefaultOptionType, InternalFieldNames, SingleValueType } from '../Cascader';
+declare const _default: (rawValues: Ref<SingleValueType[]>, options: Ref<DefaultOptionType[]>, fieldNames: Ref<InternalFieldNames>, multiple: Ref<boolean>, displayRender: Ref<BaseCascaderProps["displayRender"]>) => ComputedRef<{
+    label: any;
+    value: string;
+    key: string;
+    valueCells: SingleValueType;
+}[]>;
+export default _default;

package/dist/src/vc-cascader/hooks/useEntities.d.ts

@@ -0,0 +1,10 @@
+import { Ref, ComputedRef } from 'vue';
+import { DataEntity } from '../../vc-tree/interface';
+import { DefaultOptionType, InternalFieldNames } from '../Cascader';
+export interface OptionsInfo {
+    keyEntities: Record<string, DataEntity>;
+    pathKeyEntities: Record<string, DataEntity>;
+}
+/** Lazy parse options data into conduct-able info to avoid perf issue in single mode */
+declare const _default: (options: Ref<DefaultOptionType[]>, fieldNames: Ref<InternalFieldNames>) => ComputedRef<any>;
+export default _default;

package/dist/src/vc-cascader/hooks/useMissingValues.d.ts

@@ -0,0 +1,4 @@
+import { Ref, ComputedRef } from 'vue';
+import { DefaultOptionType, InternalFieldNames, SingleValueType } from '../Cascader';
+declare const _default: (options: Ref<DefaultOptionType[]>, fieldNames: Ref<InternalFieldNames>, rawValues: Ref<SingleValueType[]>) => ComputedRef<SingleValueType[][]>;
+export default _default;

package/dist/src/vc-cascader/hooks/useSearchConfig.d.ts

@@ -0,0 +1,29 @@
+import { Ref, ShallowRef } from 'vue';
+import { BaseCascaderProps, ShowSearchType } from '../Cascader';
+import { DefaultOptionType, FieldNames } from '..';
+export default function useSearchConfig(showSearch?: Ref<BaseCascaderProps['showSearch']>): {
+    showSearch: ShallowRef<boolean, boolean>;
+    searchConfig: Ref<{
+        filter?: ((inputValue: string, options: DefaultOptionType[], fieldNames: FieldNames) => boolean) | undefined;
+        render?: ((arg?: {
+            inputValue: string;
+            path: DefaultOptionType[];
+            prefixCls: string;
+            fieldNames: FieldNames;
+        } | undefined) => any) | undefined;
+        sort?: ((a: DefaultOptionType[], b: DefaultOptionType[], inputValue: string, fieldNames: FieldNames) => number) | undefined;
+        matchInputWidth?: boolean | undefined;
+        limit?: number | false | undefined;
+    }, ShowSearchType< DefaultOptionType> | {
+        filter?: ((inputValue: string, options: DefaultOptionType[], fieldNames: FieldNames) => boolean) | undefined;
+        render?: ((arg?: {
+            inputValue: string;
+            path: DefaultOptionType[];
+            prefixCls: string;
+            fieldNames: FieldNames;
+        } | undefined) => any) | undefined;
+        sort?: ((a: DefaultOptionType[], b: DefaultOptionType[], inputValue: string, fieldNames: FieldNames) => number) | undefined;
+        matchInputWidth?: boolean | undefined;
+        limit?: number | false | undefined;
+    }>;
+};