@vunk/plus 1.13.1 → 1.15.0

package/ant/_util/props-util/initDefaultProps.d.ts

@@ -0,0 +1,6 @@
+import type { PropType } from 'vue';
+import type { VueTypeValidableDef, VueTypeDef } from 'vue-types';
+declare const initDefaultProps: <T>(types: T, defaultProps: { [K in keyof T]?: T[K] extends VueTypeValidableDef<infer U> ? U : T[K] extends VueTypeDef<infer U> ? U : T[K] extends {
+    type: PropType<infer U>;
+} ? U : any; }) => T;
+export default initDefaultProps;

package/ant/_util/raf.d.ts

@@ -0,0 +1,5 @@
+declare function wrapperRaf(callback: () => void, times?: number): number;
+declare namespace wrapperRaf {
+    var cancel: (id: number) => void;
+}
+export default wrapperRaf;

package/ant/_util/responsiveObserve.d.ts

@@ -0,0 +1,21 @@
+export type Breakpoint = 'xxxl' | 'xxl' | 'xl' | 'lg' | 'md' | 'sm' | 'xs';
+export type BreakpointMap = Record<Breakpoint, string>;
+export type ScreenMap = Partial<Record<Breakpoint, boolean>>;
+export type ScreenSizeMap = Partial<Record<Breakpoint, number>>;
+export declare const responsiveArray: Breakpoint[];
+type SubscribeFunc = (screens: ScreenMap) => void;
+export default function useResponsiveObserver(): import("vue").ComputedRef<{
+    matchHandlers: {
+        [prop: string]: {
+            mql: MediaQueryList;
+            listener: ((this: MediaQueryList, ev: MediaQueryListEvent) => any) | null;
+        };
+    };
+    dispatch(pointMap: ScreenMap): boolean;
+    subscribe(func: SubscribeFunc): number;
+    unsubscribe(paramToken: number): void;
+    unregister(): void;
+    register(): void;
+    responsiveMap: BreakpointMap;
+}>;
+export {};

package/ant/_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/ant/_util/statusUtils.d.ts

@@ -0,0 +1,6 @@
+import type { ValidateStatus } from '../form/FormItem';
+declare const InputStatuses: readonly ["warning", "error", ""];
+export type InputStatus = (typeof InputStatuses)[number];
+export declare function getStatusClassNames(prefixCls: string, status?: ValidateStatus, hasFeedback?: boolean): string;
+export declare const getMergedStatus: (contextStatus?: ValidateStatus, customStatus?: InputStatus) => "" | "validating" | "error" | "success" | "warning";
+export {};

package/ant/_util/styleChecker.d.ts

@@ -0,0 +1,4 @@
+export declare const canUseDocElement: () => HTMLElement;
+export declare function isStyleSupport(styleName: string | string[], styleValue?: any): boolean;
+export declare const detectFlexGapSupported: () => boolean;
+export default isStyleSupport;

package/ant/_util/transButton.d.ts

@@ -0,0 +1,34 @@
+declare const TransButton: import("vue").DefineComponent<import("vue").ExtractPropTypes<{
+    noStyle: {
+        type: BooleanConstructor;
+        default: any;
+    };
+    onClick: FunctionConstructor;
+    disabled: {
+        type: BooleanConstructor;
+        default: any;
+    };
+    autofocus: {
+        type: BooleanConstructor;
+        default: any;
+    };
+}>, () => import("vue/jsx-runtime").JSX.Element, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
+    noStyle: {
+        type: BooleanConstructor;
+        default: any;
+    };
+    onClick: FunctionConstructor;
+    disabled: {
+        type: BooleanConstructor;
+        default: any;
+    };
+    autofocus: {
+        type: BooleanConstructor;
+        default: any;
+    };
+}>> & Readonly<{}>, {
+    disabled: boolean;
+    autofocus: boolean;
+    noStyle: boolean;
+}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
+export default TransButton;

package/ant/_util/transition.d.ts

@@ -0,0 +1,18 @@
+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?: () => void) => boolean | void;
+export interface CSSMotionProps extends Partial<BaseTransitionProps<Element>> {
+    name?: string;
+    css?: boolean;
+}
+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/ant/_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/ant/_util/util.d.ts

@@ -0,0 +1,18 @@
+import type { VueNode } from './type';
+export declare const isFunction: (val: any) => boolean;
+export declare const controlDefaultValue: any;
+export declare const isArray: (arg: any) => arg is any[];
+export declare const isString: (val: any) => val is string;
+export declare const isSymbol: (val: any) => val is symbol;
+export declare const isObject: (val: any) => boolean;
+declare const isOn: (key: any) => boolean;
+declare const cacheStringFunction: (fn: any) => (str: any) => any;
+declare const camelize: (str: any) => any;
+declare const hyphenate: (str: any) => any;
+declare const capitalize: (str: any) => any;
+declare function resolvePropValue(options: any, props: any, key: any, value: any): any;
+export declare function getDataAndAriaProps(props: any): {};
+export declare function toPx(val: any): any;
+export declare function renderHelper<T = Record<string, any>>(v: VueNode | ((arg0: T) => VueNode), props?: T, defaultV?: any): any;
+export declare function wrapPromiseFn(openFn: (resolve: VoidFunction) => VoidFunction): any;
+export { isOn, cacheStringFunction, camelize, hyphenate, capitalize, resolvePropValue };

package/ant/_util/vnode.d.ts

@@ -0,0 +1,11 @@
+import type { Slots, VNode, VNodeArrayChildren, VNodeProps } from 'vue';
+import type { RefObject } from './createRef';
+type NodeProps = Record<string, any> & Omit<VNodeProps, 'ref'> & {
+    ref?: VNodeProps['ref'] | RefObject;
+};
+export declare function cloneElement<T, U>(vnode: VNode<T, U> | VNode<T, U>[], nodeProps?: NodeProps, override?: boolean, mergeRef?: boolean): VNode<T, U>;
+export declare function cloneVNodes(vnodes: any, nodeProps?: {}, override?: boolean): any;
+export declare function deepCloneElement<T, U>(vnode: VNode<T, U> | VNode<T, U>[], nodeProps?: NodeProps, override?: boolean, mergeRef?: boolean): any;
+export declare function triggerVNodeUpdate(vm: VNode, attrs: Record<string, any>, dom: any): void;
+export declare function customRenderSlot(slots: Slots, name: string, props: Record<string, unknown>, fallback?: () => VNodeArrayChildren): VNodeArrayChildren;
+export {};

package/ant/_util/vue-types/index.d.ts

@@ -0,0 +1,12 @@
+import type { CSSProperties } from 'vue';
+import type { VueTypeValidableDef, VueTypesInterface } from 'vue-types';
+import type { VueNode } from '../type';
+export declare function withUndefined<T extends {
+    default?: any;
+}>(type: T): T;
+declare const _default: VueTypesInterface & {
+    readonly looseBool: VueTypeValidableDef<boolean>;
+    readonly style: VueTypeValidableDef<CSSProperties>;
+    readonly VueNode: VueTypeValidableDef<VueNode>;
+};
+export default _default;

package/ant/_util/warning.d.ts

@@ -0,0 +1,6 @@
+import { resetWarned } from '../vc-util/warning';
+export { resetWarned };
+export declare function noop(): void;
+type Warning = (valid: boolean, component: string, message?: string) => void;
+declare let warning: Warning;
+export default warning;

package/ant/_util/wave/WaveEffect.d.ts

@@ -0,0 +1,6 @@
+export interface WaveEffectProps {
+    className: string;
+    target: HTMLElement;
+}
+declare function showWaveEffect(node: HTMLElement, className: string): () => void;
+export default showWaveEffect;

package/ant/_util/wave/index.d.ts

@@ -0,0 +1,13 @@
+export interface WaveProps {
+    disabled?: boolean;
+}
+declare const _default: import("vue").DefineComponent<import("vue").ExtractPropTypes<{
+    disabled: BooleanConstructor;
+}>, () => 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<{
+    disabled: BooleanConstructor;
+}>> & Readonly<{}>, {
+    disabled: boolean;
+}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
+export default _default;

package/ant/_util/wave/style.d.ts

@@ -0,0 +1,6 @@
+import type { FullToken } from '../../theme/internal';
+export interface ComponentToken {
+}
+export type WaveToken = FullToken<'Wave'>;
+declare const _default: (_prefixCls?: import("vue").Ref<string>) => import("../../theme/internal").UseComponentStyleResult;
+export default _default;

package/ant/_util/wave/useWave.d.ts

@@ -0,0 +1,4 @@
+import type { ComputedRef, Ref } from 'vue';
+export default function useWave(className: Ref<string>, wave?: ComputedRef<{
+    disabled?: boolean;
+}>): VoidFunction;

package/ant/_util/wave/util.d.ts

@@ -0,0 +1,3 @@
+export declare function isNotGrey(color: string): boolean;
+export declare function isValidWaveColor(color: string): boolean;
+export declare function getTargetWaveColor(node: HTMLElement): string;

package/ant/button/LoadingIcon.d.ts

@@ -0,0 +1,12 @@
+declare const _default: import("vue").DefineComponent<import("vue").ExtractPropTypes<{
+    prefixCls: StringConstructor;
+    loading: (ObjectConstructor | BooleanConstructor)[];
+    existIcon: BooleanConstructor;
+}>, () => import("vue/jsx-runtime").JSX.Element, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
+    prefixCls: StringConstructor;
+    loading: (ObjectConstructor | BooleanConstructor)[];
+    existIcon: BooleanConstructor;
+}>> & Readonly<{}>, {
+    existIcon: boolean;
+}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
+export default _default;

package/ant/button/button-group.d.ts

@@ -0,0 +1,33 @@
+import type { ExtractPropTypes, PropType } from 'vue';
+import type { SizeType } from '../config-provider';
+export declare const buttonGroupProps: () => {
+    prefixCls: StringConstructor;
+    size: {
+        type: PropType<SizeType>;
+    };
+};
+export type ButtonGroupProps = Partial<ExtractPropTypes<ReturnType<typeof buttonGroupProps>>>;
+export declare const GroupSizeContext: {
+    useProvide: (props: {
+        size: SizeType;
+    }, newProps?: {
+        size: SizeType;
+    }) => {
+        size: SizeType;
+    };
+    useInject: () => {
+        size: SizeType;
+    };
+};
+declare const _default: import("vue").DefineComponent<ExtractPropTypes<{
+    prefixCls: StringConstructor;
+    size: {
+        type: PropType<SizeType>;
+    };
+}>, () => import("vue/jsx-runtime").JSX.Element, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<ExtractPropTypes<{
+    prefixCls: StringConstructor;
+    size: {
+        type: PropType<SizeType>;
+    };
+}>> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
+export default _default;

package/ant/button/button.d.ts

@@ -0,0 +1,112 @@
+import buttonProps from './buttonTypes';
+import type { ButtonType } from './buttonTypes';
+import type { CustomSlotsType } from '../_util/type';
+export { buttonProps };
+declare const _default: import("vue").DefineComponent<import("vue").ExtractPropTypes<{
+    prefixCls: StringConstructor;
+    type: import("vue").PropType<ButtonType>;
+    htmlType: {
+        type: import("vue").PropType<import("./buttonTypes").ButtonHTMLType>;
+        default: string;
+    };
+    shape: {
+        type: import("vue").PropType<import("./buttonTypes").ButtonShape>;
+    };
+    size: {
+        type: import("vue").PropType<import(".").ButtonSize>;
+    };
+    loading: {
+        type: import("vue").PropType<boolean | {
+            delay?: number;
+        }>;
+        default: () => boolean | {
+            delay?: number;
+        };
+    };
+    disabled: {
+        type: BooleanConstructor;
+        default: any;
+    };
+    ghost: {
+        type: BooleanConstructor;
+        default: any;
+    };
+    block: {
+        type: BooleanConstructor;
+        default: any;
+    };
+    danger: {
+        type: BooleanConstructor;
+        default: any;
+    };
+    icon: import("vue-types").VueTypeValidableDef<any, import("vue-types").ValidatorFunction<any>>;
+    href: StringConstructor;
+    target: StringConstructor;
+    title: StringConstructor;
+    onClick: {
+        type: import("vue").PropType<import("..").MouseEventHandler | import("..").MouseEventHandler[]>;
+    };
+    onMousedown: {
+        type: import("vue").PropType<import("..").MouseEventHandler | import("..").MouseEventHandler[]>;
+    };
+}>, () => import("../_util/type").VueNode, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
+    prefixCls: StringConstructor;
+    type: import("vue").PropType<ButtonType>;
+    htmlType: {
+        type: import("vue").PropType<import("./buttonTypes").ButtonHTMLType>;
+        default: string;
+    };
+    shape: {
+        type: import("vue").PropType<import("./buttonTypes").ButtonShape>;
+    };
+    size: {
+        type: import("vue").PropType<import(".").ButtonSize>;
+    };
+    loading: {
+        type: import("vue").PropType<boolean | {
+            delay?: number;
+        }>;
+        default: () => boolean | {
+            delay?: number;
+        };
+    };
+    disabled: {
+        type: BooleanConstructor;
+        default: any;
+    };
+    ghost: {
+        type: BooleanConstructor;
+        default: any;
+    };
+    block: {
+        type: BooleanConstructor;
+        default: any;
+    };
+    danger: {
+        type: BooleanConstructor;
+        default: any;
+    };
+    icon: import("vue-types").VueTypeValidableDef<any, import("vue-types").ValidatorFunction<any>>;
+    href: StringConstructor;
+    target: StringConstructor;
+    title: StringConstructor;
+    onClick: {
+        type: import("vue").PropType<import("..").MouseEventHandler | import("..").MouseEventHandler[]>;
+    };
+    onMousedown: {
+        type: import("vue").PropType<import("..").MouseEventHandler | import("..").MouseEventHandler[]>;
+    };
+}>> & Readonly<{}>, {
+    block: boolean;
+    disabled: boolean;
+    ghost: boolean;
+    danger: boolean;
+    htmlType: import("./buttonTypes").ButtonHTMLType;
+    loading: boolean | {
+        delay?: number;
+    };
+}, CustomSlotsType<{
+    icon: any;
+    default: any;
+}>, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
+export default _default;

package/ant/button/buttonTypes.d.ts

@@ -0,0 +1,58 @@
+import type { ExtractPropTypes, PropType } from 'vue';
+import type { SizeType } from '../config-provider';
+import type { MouseEventHandler } from '../_util/EventInterface';
+export type ButtonType = 'link' | 'default' | 'primary' | 'ghost' | 'dashed' | 'text';
+export type ButtonShape = 'default' | 'circle' | 'round';
+export type ButtonHTMLType = 'submit' | 'button' | 'reset';
+export type LegacyButtonType = ButtonType | 'danger';
+export declare function convertLegacyProps(type?: LegacyButtonType): ButtonProps;
+export declare const buttonProps: () => {
+    prefixCls: StringConstructor;
+    type: PropType<ButtonType>;
+    htmlType: {
+        type: PropType<ButtonHTMLType>;
+        default: string;
+    };
+    shape: {
+        type: PropType<ButtonShape>;
+    };
+    size: {
+        type: PropType<SizeType>;
+    };
+    loading: {
+        type: PropType<boolean | {
+            delay?: number;
+        }>;
+        default: () => boolean | {
+            delay?: number;
+        };
+    };
+    disabled: {
+        type: BooleanConstructor;
+        default: any;
+    };
+    ghost: {
+        type: BooleanConstructor;
+        default: any;
+    };
+    block: {
+        type: BooleanConstructor;
+        default: any;
+    };
+    danger: {
+        type: BooleanConstructor;
+        default: any;
+    };
+    icon: import("vue-types").VueTypeValidableDef<any, import("vue-types").ValidatorFunction<any>>;
+    href: StringConstructor;
+    target: StringConstructor;
+    title: StringConstructor;
+    onClick: {
+        type: PropType<MouseEventHandler | MouseEventHandler[]>;
+    };
+    onMousedown: {
+        type: PropType<MouseEventHandler | MouseEventHandler[]>;
+    };
+};
+export type ButtonProps = Partial<ExtractPropTypes<ReturnType<typeof buttonProps>>>;
+export default buttonProps;

package/ant/button/index.d.ts

@@ -0,0 +1,12 @@
+import type { Plugin } from 'vue';
+import Button from './button';
+import ButtonGroup from './button-group';
+import type { ButtonProps, ButtonShape, ButtonType } from './buttonTypes';
+import type { ButtonGroupProps } from './button-group';
+import type { SizeType as ButtonSize } from '../config-provider';
+export type { ButtonProps, ButtonShape, ButtonType, ButtonGroupProps, ButtonSize };
+export { ButtonGroup };
+declare const _default: typeof Button & Plugin & {
+    readonly Group: typeof ButtonGroup;
+};
+export default _default;

package/ant/button/style/group.d.ts

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

package/ant/button/style/index.d.ts

@@ -0,0 +1,10 @@
+import type { FullToken } from '../../theme/internal';
+/** Component only token. Which will handle additional calculation of alias token */
+export interface ComponentToken {
+}
+export interface ButtonToken extends FullToken<'Button'> {
+    colorOutlineDefault: string;
+    buttonPaddingHorizontal: number;
+}
+declare const _default: (_prefixCls?: import("vue").Ref<string>) => import("../../theme/internal").UseComponentStyleResult;
+export default _default;

package/ant/calendar/style/index.d.ts

@@ -0,0 +1,21 @@
+import type { CSSObject } from '../../_util/cssinjs';
+import type { PickerPanelToken } from '../../date-picker/style';
+import type { InputToken } from '../../input/style';
+import type { FullToken } from '../../theme/internal';
+export interface ComponentToken {
+    yearControlWidth: number;
+    monthControlWidth: number;
+    miniContentHeight: number;
+}
+interface CalendarToken extends InputToken<FullToken<'Calendar'>>, PickerPanelToken {
+    calendarCls: string;
+    calendarFullBg: string;
+    calendarFullPanelBg: string;
+    calendarItemActiveBg: string;
+    dateValueHeight: number;
+    weekHeight: number;
+    dateContentHeight: number;
+}
+export declare const genCalendarStyles: (token: CalendarToken) => CSSObject;
+declare const _default: (_prefixCls?: import("vue").Ref<string>) => import("../../theme/internal").UseComponentStyleResult;
+export default _default;

package/ant/config-provider/DisabledContext.d.ts

@@ -0,0 +1,4 @@
+import type { Ref } from 'vue';
+export type DisabledType = boolean | undefined;
+export declare const useInjectDisabled: () => Ref<DisabledType, DisabledType>;
+export declare const useProviderDisabled: (disabled: Ref<DisabledType>) => Ref<DisabledType, DisabledType>;

package/ant/config-provider/SizeContext.d.ts

@@ -0,0 +1,4 @@
+import type { Ref } from 'vue';
+export type SizeType = 'small' | 'middle' | 'large' | undefined;
+export declare const useInjectSize: () => Ref<SizeType, SizeType>;
+export declare const useProviderSize: (size: Ref<SizeType>) => Ref<SizeType, SizeType>;