@vunk/plus 1.13.1 → 1.15.0

package/antx/_util/cssinjs-utils/util/getDefaultComponentToken.d.ts

@@ -0,0 +1,5 @@
+import type { TokenType } from '../../cssinjs';
+import type { GetDefaultToken } from './genStyleUtils';
+import type { GlobalToken, TokenMap, TokenMapKey } from '../interface';
+declare function getDefaultComponentToken<CompTokenMap extends TokenMap, AliasToken extends TokenType, C extends TokenMapKey<CompTokenMap>>(component: C, token: GlobalToken<CompTokenMap, AliasToken>, getDefaultToken: GetDefaultToken<CompTokenMap, AliasToken, C>): any;
+export default getDefaultComponentToken;

package/antx/_util/cssinjs-utils/util/maxmin.d.ts

@@ -0,0 +1,8 @@
+declare function genMaxMin(type: 'css' | 'js'): {
+    max: (...values: number[]) => number;
+    min: (...values: number[]) => number;
+} | {
+    max: (...args: (string | number)[]) => string;
+    min: (...args: (string | number)[]) => string;
+};
+export default genMaxMin;

package/antx/_util/cssinjs-utils/util/statistic.d.ts

@@ -0,0 +1,20 @@
+import type { TokenMap } from '../interface';
+/**
+ * This function will do as `Object.assign` in production. But will use Object.defineProperty:get to
+ * pass all value access in development. To support statistic field usage with alias token.
+ */
+export declare function merge<CompTokenMap extends TokenMap>(...objs: Partial<CompTokenMap>[]): CompTokenMap;
+/** @internal Internal Usage. Not use in your production. */
+export declare const statistic: Record<string, {
+    global: string[];
+    component: Record<string, string | number>;
+}>;
+/** @internal Internal Usage. Not use in your production. */
+export declare const _statistic_build_: typeof statistic;
+/** Statistic token usage case. Should use `merge` function if you do not want spread record. */
+declare const statisticToken: <CompTokenMap extends TokenMap>(token: CompTokenMap) => {
+    token: CompTokenMap;
+    keys: Set<string>;
+    flush: (componentName: string, componentToken: Record<string, string | number>) => void;
+};
+export default statisticToken;

package/antx/_util/getScrollBarSize.d.ts

@@ -0,0 +1,5 @@
+export default function getScrollBarSize(fresh?: boolean): number;
+export declare function getTargetScrollBarSize(target: HTMLElement): {
+    width: number;
+    height: number;
+};

package/antx/_util/getValue.d.ts

@@ -0,0 +1,2 @@
+declare function get(entity: any, path: (string | number | symbol)[] | readonly (string | number | symbol)[]): any;
+export default get;

package/antx/_util/hooks/use-event-callback.d.ts

@@ -0,0 +1 @@
+export declare function useEventCallback<T>(handler?: (value: T) => void): (value: T) => void;

package/antx/_util/hooks/use-state.d.ts

@@ -0,0 +1,2 @@
+import type { Ref } from 'vue';
+export default function useState<T, R = Ref<T>>(defaultStateValue?: T | (() => T)): [R, (val: T) => void];

package/antx/_util/hooks/use-x-component-config.d.ts

@@ -0,0 +1,4 @@
+import type { XComponentStyleConfig, XComponentsConfig } from '../../x-provider/context';
+import { Ref } from 'vue';
+declare const useXComponentConfig: <C extends keyof XComponentsConfig>(component: C) => Ref<Required<XComponentsConfig>[C] & XComponentStyleConfig>;
+export default useXComponentConfig;

package/antx/_util/hooks/useMergedState.d.ts

@@ -0,0 +1,7 @@
+import type { Ref, UnwrapRef } from 'vue';
+export default function useMergedState<T, R = Ref<T>>(defaultStateValue: T | (() => T), option?: {
+    defaultValue?: T | (() => T);
+    value?: Ref<T> | Ref<UnwrapRef<T>>;
+    onChange?: (val: T, prevValue: T) => void;
+    postState?: (val: T) => T;
+}): [R, (val: T) => void];

package/antx/_util/motion.d.ts

@@ -0,0 +1,3 @@
+import type { CSSMotionProps } from './transition';
+declare const initCollapseMotion: (rootCls?: string) => CSSMotionProps;
+export default initCollapseMotion;

package/antx/_util/pick-attrs.d.ts

@@ -0,0 +1,11 @@
+export interface PickConfig {
+    aria?: boolean;
+    data?: boolean;
+    attr?: boolean;
+}
+/**
+ * Picker props from exist props with filter
+ * @param props Passed props
+ * @param ariaOnly boolean | { aria?: boolean; data?: boolean; attr?: boolean; } filter config
+ */
+export default function pickAttrs(props: object, ariaOnly?: boolean | PickConfig): {};

package/antx/_util/setStyle.d.ts

@@ -0,0 +1,12 @@
+import type { CSSProperties } from 'vue';
+/**
+ * Easy to set element style, return previous style
+ * IE browser compatible(IE browser doesn't merge overflow style, need to set it separately)
+ * https://github.com/ant-design/ant-design/issues/19393
+ *
+ */
+export interface SetStyleOptions {
+    element?: HTMLElement;
+}
+declare function setStyle(style: CSSProperties, options?: SetStyleOptions): CSSProperties;
+export default setStyle;

package/antx/_util/transition.d.ts

@@ -0,0 +1,29 @@
+import type { BaseTransitionProps, CSSProperties, Ref, TransitionGroupProps, TransitionProps } from 'vue';
+declare const SelectPlacements: ["bottomLeft", "bottomRight", "topLeft", "topRight"];
+export type SelectCommonPlacement = (typeof SelectPlacements)[number];
+declare const getTransitionDirection: (placement: SelectCommonPlacement | undefined) => "slide-up" | "slide-down";
+export declare const getTransitionProps: (transitionName: string, opt?: TransitionProps) => TransitionProps;
+export declare const getTransitionGroupProps: (transitionName: string, opt?: TransitionProps) => TransitionGroupProps;
+export declare type MotionEvent = (TransitionEvent | AnimationEvent) & {
+    deadline?: boolean;
+};
+export declare type MotionEventHandler = (element: Element, done?: () => void) => CSSProperties;
+export declare type MotionEndEventHandler = (element: Element, done?: MotionEvent) => boolean | void;
+export interface CSSMotionProps extends Partial<BaseTransitionProps<Element>> {
+    name?: string;
+    css?: boolean;
+    motionName?: string;
+    motionDeadline?: number;
+    onAppearStart?: MotionEventHandler;
+    onEnterStart?: MotionEventHandler;
+    onAppearActive?: MotionEventHandler;
+    onEnterActive?: MotionEventHandler;
+    onLeaveStart?: MotionEventHandler;
+    onLeaveActive?: MotionEventHandler;
+    onAppearEnd?: MotionEndEventHandler;
+    onEnterEnd?: MotionEndEventHandler;
+    onLeaveEnd?: MotionEndEventHandler;
+}
+declare const collapseMotion: (name: string, style: Ref<CSSProperties>, className: Ref<string>) => CSSMotionProps;
+declare const getTransitionName: (rootPrefixCls: string, motion: string, transitionName?: string) => string;
+export { collapseMotion, getTransitionName, getTransitionDirection };

package/antx/_util/type.d.ts

@@ -0,0 +1,62 @@
+import type { PropType, Plugin, Ref, VNode, SlotsType } from 'vue';
+export declare const tuple: <T extends string[]>(...args: T) => T;
+export declare const tupleNum: <T extends number[]>(...args: T) => T;
+/**
+ * https://stackoverflow.com/a/59187769
+ * Extract the type of an element of an array/tuple without performing indexing
+ */
+export type ElementOf<T> = T extends (infer E)[] ? E : T extends readonly (infer F)[] ? F : never;
+/**
+ * https://github.com/Microsoft/TypeScript/issues/29729
+ */
+export type LiteralUnion<T extends string> = T | (string & {});
+export type Data = Record<string, unknown>;
+export type Key = string | number;
+type DefaultFactory<T> = (props: Data) => T | null | undefined;
+export interface PropOptions<T = any, D = T> {
+    type?: PropType<T> | true | null;
+    required?: boolean;
+    default?: D | DefaultFactory<D> | null | undefined | object;
+    validator?(value: unknown): boolean;
+}
+declare type VNodeChildAtom = VNode | string | number | boolean | null | undefined | void;
+export type VueNode = VNodeChildAtom | VNodeChildAtom[] | VNode;
+export declare const withInstall: <T>(comp: T) => T & Plugin;
+export type MaybeRef<T> = T | Ref<T>;
+export declare function eventType<T>(): {
+    type: PropType<T | T[]>;
+};
+export declare function objectType<T = {}>(defaultVal?: T): {
+    type: PropType<T>;
+    default: T;
+};
+export declare function booleanType(defaultVal?: boolean): {
+    type: BooleanConstructor;
+    default: boolean;
+};
+export declare function functionType<T = () => {}>(defaultVal?: T): {
+    type: PropType<T>;
+    default: T;
+};
+export declare function anyType<T = any>(defaultVal?: T, required?: boolean): {
+    default: T;
+    type: PropType<T>;
+};
+export declare function vNodeType<T = VueNode>(): {
+    type: PropType<T>;
+};
+export declare function arrayType<T extends any[]>(defaultVal?: T): {
+    type: PropType<T>;
+    default: T;
+};
+export declare function stringType<T extends string = string>(defaultVal?: T): {
+    type: PropType<T>;
+    default: T;
+};
+export declare function someType<T>(types?: any[], defaultVal?: T): {
+    type: PropType<T>;
+    default: T;
+};
+export type CustomSlotsType<T> = SlotsType<T>;
+export type AnyObject = Record<PropertyKey, any>;
+export {};

package/antx/_util/warning.d.ts

@@ -0,0 +1,47 @@
+import { ComputedRef } from 'vue';
+export declare function noop(): void;
+export declare function resetWarned(): void;
+type Warning = (valid: boolean, component: string, message?: string) => void;
+declare let warning: Warning;
+type BaseTypeWarning = (valid: boolean, 
+/**
+ * - deprecated: Some API will be removed in future but still support now.
+ * - usage: Some API usage is not correct.
+ * - breaking: Breaking change like API is removed.
+ */
+type: 'deprecated' | 'usage' | 'breaking', message?: string) => void;
+type TypeWarning = BaseTypeWarning & {
+    deprecated: (valid: boolean, oldProp: string, newProp: string, message?: string) => void;
+};
+export interface WarningContextProps {
+    /**
+     * @descCN 设置警告等级，设置 `false` 时会将废弃相关信息聚合为单条信息。
+     * @descEN Set the warning level. When set to `false`, discard related information will be aggregated into a single message.
+     */
+    strict?: boolean;
+}
+export declare const globalWarningContextApi: import("vue").ShallowRef<WarningContextProps, WarningContextProps>;
+export declare const useWarningContextProvider: (value: ComputedRef<WarningContextProps>) => void;
+export declare const useWarningContextInject: () => ComputedRef<WarningContextProps>;
+export declare const WarningContextProvider: import("vue").DefineComponent<import("vue").ExtractPropTypes<{
+    value: {
+        type: import("vue").PropType<WarningContextProps>;
+        default: WarningContextProps;
+    };
+}>, () => import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
+    [key: string]: any;
+}>[], {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
+    value: {
+        type: import("vue").PropType<WarningContextProps>;
+        default: WarningContextProps;
+    };
+}>> & Readonly<{}>, {
+    value: WarningContextProps;
+}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
+/**
+ * This is a hook but we not named as `useWarning`
+ * since this is only used in development.
+ * We should always wrap this in `if (process.env.NODE_ENV !== 'production')` condition
+ */
+export declare const devUseWarning: (component: string) => TypeWarning;
+export default warning;

package/antx/attachments/Attachments.vue.d.ts

@@ -0,0 +1,16 @@
+import { type VNode } from 'vue';
+import type { AttachmentsProps, AttachmentsRef } from './interface';
+type __VLS_Slots = {
+    placeholder?(props?: {
+        type: 'inline' | 'drop';
+    }): VNode | string;
+};
+declare const __VLS_base: import("vue").DefineComponent<AttachmentsProps, AttachmentsRef, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<AttachmentsProps> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
+declare const __VLS_export: __VLS_WithSlots<typeof __VLS_base, __VLS_Slots>;
+declare const _default: typeof __VLS_export;
+export default _default;
+type __VLS_WithSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};

package/antx/attachments/DropArea.vue.d.ts

@@ -0,0 +1,4 @@
+import type { DropUploaderProps } from './interface';
+declare const __VLS_export: import("vue").DefineComponent<DropUploaderProps, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<DropUploaderProps> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
+declare const _default: typeof __VLS_export;
+export default _default;

package/antx/attachments/FileList/AudioIcon.vue.d.ts

@@ -0,0 +1,3 @@
+declare const __VLS_export: import("vue").DefineComponent<{}, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<{}> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
+declare const _default: typeof __VLS_export;
+export default _default;

package/antx/attachments/FileList/FileList.vue.d.ts

@@ -0,0 +1,4 @@
+import type { FileListProps } from '../interface';
+declare const __VLS_export: import("vue").DefineComponent<FileListProps, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<FileListProps> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
+declare const _default: typeof __VLS_export;
+export default _default;

package/antx/attachments/FileList/FileListCard.vue.d.ts

@@ -0,0 +1,6 @@
+import type { FileListCardProps } from '../interface';
+declare const __VLS_export: import("vue").DefineComponent<FileListCardProps, {
+    nativeElement: Readonly<import("vue").ShallowRef<HTMLDivElement>>;
+}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<FileListCardProps> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
+declare const _default: typeof __VLS_export;
+export default _default;

package/antx/attachments/FileList/Progress.vue.d.ts

@@ -0,0 +1,103 @@
+declare const __VLS_export: import("vue").DefineComponent<Partial<import("vue").ExtractPropTypes<{
+    prefixCls: StringConstructor;
+    type: {
+        type: import("vue").PropType<"circle" | "line" | "dashboard">;
+        default: "circle" | "line" | "dashboard";
+    };
+    percent: NumberConstructor;
+    format: {
+        type: import("vue").PropType<(percent?: number, successPercent?: number) => import("@vunk/plus/ant/_util/type").VueNode>;
+        default: (percent?: number, successPercent?: number) => import("@vunk/plus/ant/_util/type").VueNode;
+    };
+    status: {
+        type: import("vue").PropType<"normal" | "active" | "success" | "exception">;
+        default: "normal" | "active" | "success" | "exception";
+    };
+    showInfo: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    strokeWidth: NumberConstructor;
+    strokeLinecap: {
+        type: import("vue").PropType<"round" | "butt" | "square">;
+        default: "round" | "butt" | "square";
+    };
+    strokeColor: {
+        default: string | string[] | import("@vunk/plus/ant/progress/props").ProgressGradient;
+        type: import("vue").PropType<string | string[] | import("@vunk/plus/ant/progress/props").ProgressGradient>;
+    };
+    trailColor: StringConstructor;
+    width: NumberConstructor;
+    success: {
+        type: import("vue").PropType<import("@vunk/plus/ant/progress/props").SuccessProps>;
+        default: import("@vunk/plus/ant/progress/props").SuccessProps;
+    };
+    gapDegree: NumberConstructor;
+    gapPosition: {
+        type: import("vue").PropType<"left" | "right" | "bottom" | "top">;
+        default: "left" | "right" | "bottom" | "top";
+    };
+    size: {
+        type: import("vue").PropType<import("@vunk/plus/ant/progress/props").ProgressSize>;
+        default: import("@vunk/plus/ant/progress/props").ProgressSize;
+    };
+    steps: NumberConstructor;
+    successPercent: NumberConstructor;
+    title: StringConstructor;
+    progressStatus: {
+        type: import("vue").PropType<"normal" | "active" | "success" | "exception">;
+        default: "normal" | "active" | "success" | "exception";
+    };
+}>>, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<Partial<import("vue").ExtractPropTypes<{
+    prefixCls: StringConstructor;
+    type: {
+        type: import("vue").PropType<"circle" | "line" | "dashboard">;
+        default: "circle" | "line" | "dashboard";
+    };
+    percent: NumberConstructor;
+    format: {
+        type: import("vue").PropType<(percent?: number, successPercent?: number) => import("@vunk/plus/ant/_util/type").VueNode>;
+        default: (percent?: number, successPercent?: number) => import("@vunk/plus/ant/_util/type").VueNode;
+    };
+    status: {
+        type: import("vue").PropType<"normal" | "active" | "success" | "exception">;
+        default: "normal" | "active" | "success" | "exception";
+    };
+    showInfo: {
+        type: BooleanConstructor;
+        default: boolean;
+    };
+    strokeWidth: NumberConstructor;
+    strokeLinecap: {
+        type: import("vue").PropType<"round" | "butt" | "square">;
+        default: "round" | "butt" | "square";
+    };
+    strokeColor: {
+        default: string | string[] | import("@vunk/plus/ant/progress/props").ProgressGradient;
+        type: import("vue").PropType<string | string[] | import("@vunk/plus/ant/progress/props").ProgressGradient>;
+    };
+    trailColor: StringConstructor;
+    width: NumberConstructor;
+    success: {
+        type: import("vue").PropType<import("@vunk/plus/ant/progress/props").SuccessProps>;
+        default: import("@vunk/plus/ant/progress/props").SuccessProps;
+    };
+    gapDegree: NumberConstructor;
+    gapPosition: {
+        type: import("vue").PropType<"left" | "right" | "bottom" | "top">;
+        default: "left" | "right" | "bottom" | "top";
+    };
+    size: {
+        type: import("vue").PropType<import("@vunk/plus/ant/progress/props").ProgressSize>;
+        default: import("@vunk/plus/ant/progress/props").ProgressSize;
+    };
+    steps: NumberConstructor;
+    successPercent: NumberConstructor;
+    title: StringConstructor;
+    progressStatus: {
+        type: import("vue").PropType<"normal" | "active" | "success" | "exception">;
+        default: "normal" | "active" | "success" | "exception";
+    };
+}>>> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
+declare const _default: typeof __VLS_export;
+export default _default;

package/antx/attachments/FileList/VideoIcon.vue.d.ts

@@ -0,0 +1,3 @@
+declare const __VLS_export: import("vue").DefineComponent<{}, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<{}> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
+declare const _default: typeof __VLS_export;
+export default _default;

package/antx/attachments/FileList/index.d.ts

@@ -0,0 +1,3 @@
+import FileList from './FileList.vue';
+import FileListCard from './FileListCard.vue';
+export { FileList, FileListCard };

package/antx/attachments/PlaceholderUploader.vue.d.ts

@@ -0,0 +1,6 @@
+import type { PlaceholderProps } from './interface';
+declare const __VLS_export: import("vue").DefineComponent<PlaceholderProps, {
+    nativeElement: import("vue").ComputedRef<HTMLElement>;
+}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<PlaceholderProps> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
+declare const _default: typeof __VLS_export;
+export default _default;

package/antx/attachments/SilentUploader.vue.d.ts

@@ -0,0 +1,6 @@
+import type { SilentUploaderProps } from './interface';
+declare const __VLS_export: import("vue").DefineComponent<SilentUploaderProps, {
+    nativeElement: import("vue").ComputedRef<HTMLElement>;
+}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<SilentUploaderProps> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
+declare const _default: typeof __VLS_export;
+export default _default;

package/antx/attachments/constants.d.ts

@@ -0,0 +1,9 @@
+export declare const IMG_EXTS: Set<string>;
+export declare const AUDIO_EXTS: Set<string>;
+export declare const VIDEO_EXTS: Set<string>;
+export declare const MARKDOWN_EXTS: Set<string>;
+export declare const ZIP_EXTS: Set<string>;
+export declare const EXCEL_EXTS: Set<string>;
+export declare const PPT_EXTS: Set<string>;
+export declare const WORD_EXTS: Set<string>;
+export declare const PDF_EXTS: Set<string>;

package/antx/attachments/context.d.ts

@@ -0,0 +1,21 @@
+import { ComputedRef } from "vue";
+import { AttachmentContextProps } from "./interface";
+export declare const globalAttachmentContextApi: import("vue").ShallowRef<AttachmentContextProps, AttachmentContextProps>;
+export declare const useAttachmentContextProvider: (value: ComputedRef<AttachmentContextProps>) => void;
+export declare const useAttachmentContextInject: () => ComputedRef<AttachmentContextProps>;
+export declare const AttachmentContextProvider: import("vue").DefineComponent<import("vue").ExtractPropTypes<{
+    value: {
+        type: import("vue").PropType<AttachmentContextProps>;
+        default: AttachmentContextProps;
+    };
+}>, () => import("vue").VNode<import("vue").RendererNode, import("vue").RendererElement, {
+    [key: string]: any;
+}>[], {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
+    value: {
+        type: import("vue").PropType<AttachmentContextProps>;
+        default: AttachmentContextProps;
+    };
+}>> & Readonly<{}>, {
+    value: AttachmentContextProps;
+}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
+export default AttachmentContextProvider;

package/antx/attachments/index.d.ts

@@ -0,0 +1,26 @@
+export type { Attachment, AttachmentsProps, AttachmentsRef } from './interface';
+declare const Attachments: {
+    new (...args: any[]): import("vue").CreateComponentPublicInstanceWithMixins<Readonly<import("./interface").AttachmentsProps> & Readonly<{}>, import("./interface").AttachmentsRef, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, import("vue").PublicProps, {}, true, {}, {}, import("vue").GlobalComponents, import("vue").GlobalDirectives, string, {}, any, import("vue").ComponentProvideOptions, {
+        P: {};
+        B: {};
+        D: {};
+        C: {};
+        M: {};
+        Defaults: {};
+    }, Readonly<import("./interface").AttachmentsProps> & Readonly<{}>, import("./interface").AttachmentsRef, {}, {}, {}, {}>;
+    __isFragment?: never;
+    __isTeleport?: never;
+    __isSuspense?: never;
+} & import("vue").ComponentOptionsBase<Readonly<import("./interface").AttachmentsProps> & Readonly<{}>, import("./interface").AttachmentsRef, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, {}, {}, string, {}, import("vue").GlobalComponents, import("vue").GlobalDirectives, string, import("vue").ComponentProvideOptions> & import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps & (new () => {
+    $slots: {
+        placeholder?(props?: {
+            type: "inline" | "drop";
+        }): import("vue").VNode | string;
+    };
+}) & {
+    FileCard: import("vue").DefineComponent<import("./interface").FileListCardProps, {
+        nativeElement: Readonly<import("vue").ShallowRef<HTMLDivElement>>;
+    }, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<import("./interface").FileListCardProps> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
+};
+export default Attachments;
+export { Attachments, };

package/antx/attachments/interface.d.ts

@@ -0,0 +1,130 @@
+import type { ImageProps, UploadChangeParam, UploadFile, UploadProps } from "@vunk/plus/ant";
+import type { CSSProperties, VNode } from "vue";
+export interface AttachmentContextProps {
+    disabled?: boolean;
+}
+export interface DropUploaderProps {
+    prefixCls: string;
+    className: string;
+    getDropContainer?: null | (() => HTMLElement | null | undefined);
+    children?: VNode;
+}
+export interface SilentUploaderProps {
+    children: VNode;
+    upload: UploadProps;
+    rootClassName?: string;
+}
+export interface PlaceholderConfig {
+    icon?: VNode;
+    title?: VNode | string;
+    description?: VNode | string;
+}
+export type PlaceholderType = PlaceholderConfig | VNode | string;
+export interface PlaceholderProps {
+    prefixCls: string;
+    placeholder?: PlaceholderType;
+    upload?: UploadProps;
+    className?: string;
+    style?: CSSProperties;
+}
+export type SemanticType = 'list' | 'item' | 'placeholder' | 'upload';
+export interface FileListProps {
+    prefixCls: string;
+    items: Attachment[];
+    onRemove: (item: Attachment) => void;
+    overflow?: 'scrollX' | 'scrollY' | 'wrap';
+    upload: UploadProps;
+    imageProps?: ImageProps;
+    listClassName?: string;
+    listStyle?: CSSProperties;
+    itemClassName?: string;
+    itemStyle?: CSSProperties;
+    uploadClassName?: string;
+    uploadStyle?: CSSProperties;
+}
+export interface FileListCardProps {
+    prefixCls?: string;
+    item: Attachment;
+    onRemove?: (item: Attachment) => void;
+    className?: string;
+    style?: CSSProperties;
+    imageProps?: ImageProps;
+    icon?: VNode | PresetIcons;
+    type?: 'file' | 'image';
+}
+export interface ProgressProps {
+    prefixCls: string;
+    percent: number;
+}
+export type Attachment = UploadProps['fileList'][number] & {
+    description?: VNode | string;
+};
+export interface AntdUploadProps {
+    capture?: UploadProps['capture'];
+    type?: UploadProps['type'];
+    name?: UploadProps['name'];
+    defaultFileList?: UploadProps['defaultFileList'];
+    /** @deprecated remove this prop */
+    action?: UploadProps['action'];
+    directory?: UploadProps['directory'];
+    data?: UploadProps['data'];
+    method?: UploadProps['method'];
+    headers?: UploadProps['headers'];
+    showUploadList?: UploadProps['showUploadList'];
+    multiple?: UploadProps['multiple'];
+    accept?: UploadProps['accept'];
+    beforeUpload?: UploadProps['beforeUpload'];
+    onChange?: UploadProps['onChange'];
+    'onUpdate:fileList'?: UploadProps['onUpdate:fileList'];
+    onDrop?: UploadProps['onDrop'];
+    listType?: UploadProps['listType'];
+    onPreview?: UploadProps['onPreview'];
+    onDownload?: UploadProps['onDownload'];
+    onReject?: UploadProps['onReject'];
+    onRemove?: UploadProps['onRemove'];
+    /** @deprecated Please use `onRemove` directly */
+    remove?: UploadProps['remove'];
+    supportServerRender?: UploadProps['supportServerRender'];
+    disabled?: UploadProps['disabled'];
+    prefixCls?: UploadProps['prefixCls'];
+    customRequest?: UploadProps['customRequest'];
+    withCredentials?: UploadProps['withCredentials'];
+    openFileDialogOnClick?: UploadProps['openFileDialogOnClick'];
+    locale?: UploadProps['locale'];
+    id?: UploadProps['id'];
+    previewFile?: UploadProps['previewFile'];
+    /** @deprecated Please use `beforeUpload` directly */
+    transformFile?: UploadProps['transformFile'];
+    iconRender?: UploadProps['iconRender'];
+    isImageUrl?: UploadProps['isImageUrl'];
+    progress?: UploadProps['progress'];
+    itemRender?: UploadProps['itemRender'];
+    /** Config max count of `fileList`. Will replace current one when `maxCount` is 1 */
+    maxCount?: UploadProps['maxCount'];
+    height?: UploadProps['height'];
+    removeIcon?: UploadProps['removeIcon'];
+    downloadIcon?: UploadProps['downloadIcon'];
+    previewIcon?: UploadProps['previewIcon'];
+}
+export interface AttachmentsProps extends AntdUploadProps {
+    prefixCls?: string;
+    rootClassName?: string;
+    rootStyle?: CSSProperties;
+    style?: CSSProperties;
+    className?: string;
+    classNames?: Partial<Record<SemanticType, string>>;
+    styles?: Partial<Record<SemanticType, CSSProperties>>;
+    children?: VNode;
+    disabled?: boolean;
+    placeholder?: PlaceholderType | ((type: 'inline' | 'drop') => PlaceholderType);
+    getDropContainer?: null | (() => HTMLElement | null | undefined);
+    items?: Attachment[];
+    overflow?: FileListProps['overflow'];
+    imageProps?: FileListProps['imageProps'];
+    onChange?: (info: UploadChangeParam<UploadFile>) => void;
+}
+export interface AttachmentsRef {
+    nativeElement: HTMLDivElement | null;
+    upload: (file: File | File[] | FileList) => void;
+}
+export type PresetIcons = 'default' | 'excel' | 'image' | 'markdown' | 'pdf' | 'ppt' | 'word' | 'zip' | 'video' | 'audio';

package/antx/attachments/style/fileCard.d.ts

@@ -0,0 +1,4 @@
+import type { AttachmentsToken } from '.';
+import type { GenerateStyle } from '../../theme/cssinjs-utils';
+declare const genFileCardStyle: GenerateStyle<AttachmentsToken>;
+export default genFileCardStyle;

package/antx/attachments/style/index.d.ts

@@ -0,0 +1,9 @@
+import type { FullToken, GetDefaultToken } from '../../theme/cssinjs-utils';
+export interface ComponentToken {
+    colorBgPlaceholderHover: string;
+}
+export interface AttachmentsToken extends FullToken<'Attachments'> {
+}
+export declare const prepareComponentToken: GetDefaultToken<'Attachments'>;
+declare const _default: (prefixCls: import("vue").MaybeRefOrGetter<string>, rootCls?: string) => readonly [(node: import("vue").VNode) => import("vue").VNode, import("vue").Ref<string, string>, string];
+export default _default;

package/antx/attachments/util.d.ts

@@ -0,0 +1,3 @@
+export declare const isImageFileType: (type: string) => boolean;
+export declare function previewImage(file: File | Blob): Promise<string>;
+export declare function matchExt(suffix: string, ext: Set<string>): boolean;

package/antx/components.d.ts

@@ -0,0 +1,4 @@
+export { Sender } from './sender';
+export type { SenderProps } from './sender';
+export { Attachments } from './attachments';
+export type { Attachment, AttachmentsProps, AttachmentsRef } from './attachments';