@king-one/antdv 1.0.22 → 1.0.23

package/dist/types/components/collapse-transtion/index.d.ts

@@ -0,0 +1,41 @@
+import { SFCWithInstall } from '../utils/install';
+import { CreateComponentPublicInstance, ExtractPropTypes, PropType, ComponentOptionsMixin, VNodeProps, AllowedComponentProps, ComponentCustomProps, ComponentOptionsBase } from 'vue';
+export * from './src/types';
+export declare const KCollapseTranstion: SFCWithInstall<{
+    new (...args: any[]): CreateComponentPublicInstance<Readonly< ExtractPropTypes<{
+        readonly mode: {
+            readonly type: PropType<"horizontal" | "vertical">;
+            readonly required: true;
+        };
+    }>>, {}, unknown, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, VNodeProps & AllowedComponentProps & ComponentCustomProps & Readonly< ExtractPropTypes<{
+        readonly mode: {
+            readonly type: PropType<"horizontal" | "vertical">;
+            readonly required: true;
+        };
+    }>>, {}, true, {}, {}, {
+        P: {};
+        B: {};
+        D: {};
+        C: {};
+        M: {};
+        Defaults: {};
+    }, Readonly< ExtractPropTypes<{
+        readonly mode: {
+            readonly type: PropType<"horizontal" | "vertical">;
+            readonly required: true;
+        };
+    }>>, {}, {}, {}, {}, {}>;
+    __isFragment?: never;
+    __isTeleport?: never;
+    __isSuspense?: never;
+} & ComponentOptionsBase<Readonly< ExtractPropTypes<{
+    readonly mode: {
+        readonly type: PropType<"horizontal" | "vertical">;
+        readonly required: true;
+    };
+}>>, {}, unknown, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, {}, {}, string, {}> & VNodeProps & AllowedComponentProps & ComponentCustomProps & (new () => {
+    $slots: {
+        default?(_: {}): any;
+    };
+})>;
+export default KCollapseTranstion;

package/dist/types/components/collapse-transtion/src/collapse-transtion.vue.d.ts

@@ -0,0 +1,27 @@
+import { DefineComponent, PropType, ComponentOptionsMixin, PublicProps, ExtractPropTypes } from 'vue';
+declare function __VLS_template(): {
+    slots: {
+        default?(_: {}): any;
+    };
+    refs: {};
+    attrs: Partial<{}>;
+};
+type __VLS_TemplateResult = ReturnType<typeof __VLS_template>;
+declare const __VLS_component: DefineComponent<{
+    readonly mode: {
+        readonly type: PropType<"horizontal" | "vertical">;
+        readonly required: true;
+    };
+}, {}, unknown, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, PublicProps, Readonly< ExtractPropTypes<{
+    readonly mode: {
+        readonly type: PropType<"horizontal" | "vertical">;
+        readonly required: true;
+    };
+}>>, {}, {}>;
+declare const _default: __VLS_WithTemplateSlots<typeof __VLS_component, __VLS_TemplateResult["slots"]>;
+export default _default;
+type __VLS_WithTemplateSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};

package/dist/{es → types}/components/collapse-transtion/src/types.d.ts

@@ -1,4 +1,4 @@
-import type { ExtractPropTypes, PropType } from 'vue';
+import { ExtractPropTypes, PropType } from 'vue';
 export declare const collapseProps: {
     readonly mode: {
         readonly type: PropType<"horizontal" | "vertical">;

package/dist/{lib → types}/components/form/component/form.d.ts

@@ -1,5 +1,5 @@
-import type { RuleItem } from 'async-validator';
-import type { PropType } from 'vue';
+import { RuleItem } from 'async-validator';
+import { PropType } from 'vue';
 export declare const formType: {
     readonly model: {
         readonly type: ObjectConstructor;

package/dist/types/components/form/component/form.vue.d.ts

@@ -0,0 +1,32 @@
+import { DefineComponent, PropType, ComponentOptionsMixin, PublicProps, ExtractPropTypes } from 'vue';
+import { RuleItem } from 'async-validator';
+declare function __VLS_template(): {
+    slots: {
+        default?(_: {}): any;
+    };
+    refs: {};
+    attrs: Partial<{}>;
+};
+type __VLS_TemplateResult = ReturnType<typeof __VLS_template>;
+declare const __VLS_component: DefineComponent<{
+    readonly model: {
+        readonly type: ObjectConstructor;
+    };
+    readonly rules: {
+        readonly type: PropType<Record<string, RuleItem[]>>;
+    };
+}, {}, unknown, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, PublicProps, Readonly< ExtractPropTypes<{
+    readonly model: {
+        readonly type: ObjectConstructor;
+    };
+    readonly rules: {
+        readonly type: PropType<Record<string, RuleItem[]>>;
+    };
+}>>, {}, {}>;
+declare const _default: __VLS_WithTemplateSlots<typeof __VLS_component, __VLS_TemplateResult["slots"]>;
+export default _default;
+type __VLS_WithTemplateSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};

package/dist/types/components/form/index.d.ts

@@ -0,0 +1,50 @@
+import { SFCWithInstall } from '../utils/install';
+import { CreateComponentPublicInstance, ExtractPropTypes, PropType, ComponentOptionsMixin, VNodeProps, AllowedComponentProps, ComponentCustomProps, ComponentOptionsBase } from 'vue';
+import { RuleItem } from 'async-validator';
+export * from './component/form';
+export declare const KForm: SFCWithInstall<{
+    new (...args: any[]): CreateComponentPublicInstance<Readonly< ExtractPropTypes<{
+        readonly model: {
+            readonly type: ObjectConstructor;
+        };
+        readonly rules: {
+            readonly type: PropType<Record<string, RuleItem[]>>;
+        };
+    }>>, {}, unknown, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, VNodeProps & AllowedComponentProps & ComponentCustomProps & Readonly< ExtractPropTypes<{
+        readonly model: {
+            readonly type: ObjectConstructor;
+        };
+        readonly rules: {
+            readonly type: PropType<Record<string, RuleItem[]>>;
+        };
+    }>>, {}, true, {}, {}, {
+        P: {};
+        B: {};
+        D: {};
+        C: {};
+        M: {};
+        Defaults: {};
+    }, Readonly< ExtractPropTypes<{
+        readonly model: {
+            readonly type: ObjectConstructor;
+        };
+        readonly rules: {
+            readonly type: PropType<Record<string, RuleItem[]>>;
+        };
+    }>>, {}, {}, {}, {}, {}>;
+    __isFragment?: never;
+    __isTeleport?: never;
+    __isSuspense?: never;
+} & ComponentOptionsBase<Readonly< ExtractPropTypes<{
+    readonly model: {
+        readonly type: ObjectConstructor;
+    };
+    readonly rules: {
+        readonly type: PropType<Record<string, RuleItem[]>>;
+    };
+}>>, {}, unknown, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, {}, {}, string, {}> & VNodeProps & AllowedComponentProps & ComponentCustomProps & (new () => {
+    $slots: {
+        default?(_: {}): any;
+    };
+})>;
+export default KForm;

package/dist/{lib → types}/components/index.d.ts

@@ -2,3 +2,5 @@ export * from './form';
 export * from './virtual-list';
 export * from './collapse-transtion';
 export * from './pro-dialog';
+export * from './scroll-bar';
+export * from './scale-virtual-list';

package/dist/{lib → types}/components/pro-dialog/hooks/useProDialog.d.ts

@@ -1,9 +1,10 @@
+import { Ref } from 'vue';
 export interface DialogMethods {
     openDialog: () => void;
     closeDialog: () => void;
 }
 export declare function useProDialog(): {
-    dialogVisible: import("vue").Ref<boolean>;
+    dialogVisible: Ref<boolean>;
     openDialog: () => void;
     closeDialog: () => void;
 };

package/dist/types/components/pro-dialog/index.d.ts

@@ -0,0 +1,26 @@
+import { SFCWithInstall } from '../utils/install';
+import { DefineComponent, PropType, ComponentOptionsMixin, PublicProps, ExtractPropTypes } from 'vue';
+import { ModalProps } from 'ant-design-vue';
+export * from './hooks/useProDialog';
+export * from './src/types';
+export declare const KProDialog: SFCWithInstall<DefineComponent<{
+    dialogProps: {
+        readonly type: PropType<Omit< ModalProps, "open">>;
+    };
+    modelValue: {
+        type: PropType<boolean>;
+        required: true;
+    };
+}, {}, unknown, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {
+    "update:modelValue": (modelValue: boolean) => void;
+}, string, PublicProps, Readonly< ExtractPropTypes<{
+    dialogProps: {
+        readonly type: PropType<Omit< ModalProps, "open">>;
+    };
+    modelValue: {
+        type: PropType<boolean>;
+        required: true;
+    };
+}>> & {
+    "onUpdate:modelValue"?: ((modelValue: boolean) => any) | undefined;
+}, {}, {}>>;

package/dist/types/components/pro-dialog/src/pro-dialog.vue.d.ts

@@ -0,0 +1,24 @@
+import { DefineComponent, PropType, ComponentOptionsMixin, PublicProps, ExtractPropTypes } from 'vue';
+import { ModalProps } from 'ant-design-vue';
+declare const _default: DefineComponent<{
+    dialogProps: {
+        readonly type: PropType<Omit< ModalProps, "open">>;
+    };
+    modelValue: {
+        type: PropType<boolean>;
+        required: true;
+    };
+}, {}, unknown, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {
+    "update:modelValue": (modelValue: boolean) => void;
+}, string, PublicProps, Readonly< ExtractPropTypes<{
+    dialogProps: {
+        readonly type: PropType<Omit< ModalProps, "open">>;
+    };
+    modelValue: {
+        type: PropType<boolean>;
+        required: true;
+    };
+}>> & {
+    "onUpdate:modelValue"?: ((modelValue: boolean) => any) | undefined;
+}, {}, {}>;
+export default _default;

package/dist/types/components/pro-dialog/src/types.d.ts

@@ -0,0 +1,7 @@
+import { ModalProps } from 'ant-design-vue';
+import { PropType } from 'vue';
+export declare const proDialogProps: {
+    readonly dialogProps: {
+        readonly type: PropType<Omit<ModalProps, "open">>;
+    };
+};

package/dist/types/components/scale-virtual-list/component/scale-virtual-list.vue.d.ts

@@ -0,0 +1,28 @@
+import { VirtualListProps, VirtualListSlot } from './types';
+import { DefineComponent, ComponentOptionsMixin, PublicProps, ExtractPropTypes, PropType } from 'vue';
+declare function __VLS_template(): {
+    slots: Readonly<VirtualListSlot> & VirtualListSlot;
+    refs: {};
+    attrs: Partial<{}>;
+};
+type __VLS_TemplateResult = ReturnType<typeof __VLS_template>;
+declare const __VLS_component: DefineComponent<__VLS_TypePropsToOption<VirtualListProps>, {
+    scrollTo: (index: number) => void;
+    scaleTo: (s: number) => void;
+}, unknown, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, PublicProps, Readonly< ExtractPropTypes<__VLS_TypePropsToOption<VirtualListProps>>>, {}, {}>;
+declare const _default: __VLS_WithTemplateSlots<typeof __VLS_component, __VLS_TemplateResult["slots"]>;
+export default _default;
+type __VLS_NonUndefinedable<T> = T extends undefined ? never : T;
+type __VLS_TypePropsToOption<T> = {
+    [K in keyof T]-?: {} extends Pick<T, K> ? {
+        type: PropType<__VLS_NonUndefinedable<T[K]>>;
+    } : {
+        type: PropType<T[K]>;
+        required: true;
+    };
+};
+type __VLS_WithTemplateSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};

package/dist/types/components/scale-virtual-list/component/types.d.ts

@@ -0,0 +1,11 @@
+import { UseVirtualListItem, UseVirtualListOptions } from '../hooks/useVirtualList';
+export interface VirtualListProps {
+    list: Array<any>;
+    option: UseVirtualListOptions;
+}
+export interface VirtualListSlot {
+    default: (props: {
+        item: UseVirtualListItem<any>;
+        index: number;
+    }) => any;
+}

package/dist/types/components/scale-virtual-list/hooks/useVirtualList.d.ts

@@ -0,0 +1,70 @@
+import { MaybeRef } from '@vueuse/shared';
+import { ComputedRef, Ref, StyleValue } from 'vue-demi';
+interface UseVirtualListState {
+    start: number;
+    end: number;
+    current: number;
+    scale: number;
+}
+type RefState = Ref<UseVirtualListState>;
+type UseVirtualListItemSize = number | ((index: number) => number);
+export interface UseHorizontalVirtualListOptions extends UseVirtualListOptionsBase {
+    /**
+     * item width, accept a pixel value or a function that returns the width
+     *
+     * @default 0
+     */
+    itemWidth: UseVirtualListItemSize;
+}
+export interface UseVerticalVirtualListOptions extends UseVirtualListOptionsBase {
+    /**
+     * item height, accept a pixel value or a function that returns the height
+     *
+     * @default 0
+     */
+    itemHeight: UseVirtualListItemSize;
+}
+export interface UseVirtualListOptionsBase {
+    /**
+     * the extra buffer items outside of the view area
+     *
+     * @default 5
+     */
+    overscan?: number;
+}
+export type UseVirtualListOptions = UseHorizontalVirtualListOptions | UseVerticalVirtualListOptions;
+export interface UseVirtualListItem<T> {
+    data: T;
+    index: number;
+}
+export interface UseVirtualListReturn<T> {
+    state: RefState;
+    list: Ref<UseVirtualListItem<T>[]>;
+    scrollTo: (index: number) => void;
+    scaleTo: (s: number) => void;
+    containerProps: {
+        ref: Ref<HTMLElement | null>;
+        onScroll: () => void;
+        style: StyleValue;
+    };
+    wrapperProps: ComputedRef<{
+        style: {
+            height: string;
+            marginTop: string;
+            transform: string;
+            transformOrigin: string;
+        } | {
+            width: string;
+            height: string;
+            marginLeft: string;
+            display: string;
+            transform: string;
+            transformOrigin: string;
+        };
+    }>;
+}
+/**
+ * Please consider using [`vue-virtual-scroller`](https://github.com/Akryum/vue-virtual-scroller) if you are looking for more features.
+ */
+export declare function useVirtualList<T = any>(list: MaybeRef<T[]>, options: UseVirtualListOptions): UseVirtualListReturn<T>;
+export {};

package/dist/types/components/scale-virtual-list/index.d.ts

@@ -0,0 +1,67 @@
+import { SFCWithInstall } from '../utils/install';
+import { CreateComponentPublicInstance, ExtractPropTypes, PropType, ComponentOptionsMixin, VNodeProps, AllowedComponentProps, ComponentCustomProps, ComponentOptionsBase } from 'vue';
+import { UseVirtualListOptions } from './hooks/useVirtualList';
+import { VirtualListSlot } from './component/types';
+export * from './style/index';
+export * from './component/types';
+export declare const KScaleVirtualList: SFCWithInstall<{
+    new (...args: any[]): CreateComponentPublicInstance<Readonly< ExtractPropTypes<{
+        list: {
+            type: PropType<any[]>;
+            required: true;
+        };
+        option: {
+            type: PropType<UseVirtualListOptions>;
+            required: true;
+        };
+    }>>, {
+        scrollTo: (index: number) => void;
+        scaleTo: (s: number) => void;
+    }, unknown, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, VNodeProps & AllowedComponentProps & ComponentCustomProps & Readonly< ExtractPropTypes<{
+        list: {
+            type: PropType<any[]>;
+            required: true;
+        };
+        option: {
+            type: PropType<UseVirtualListOptions>;
+            required: true;
+        };
+    }>>, {}, true, {}, {}, {
+        P: {};
+        B: {};
+        D: {};
+        C: {};
+        M: {};
+        Defaults: {};
+    }, Readonly< ExtractPropTypes<{
+        list: {
+            type: PropType<any[]>;
+            required: true;
+        };
+        option: {
+            type: PropType<UseVirtualListOptions>;
+            required: true;
+        };
+    }>>, {
+        scrollTo: (index: number) => void;
+        scaleTo: (s: number) => void;
+    }, {}, {}, {}, {}>;
+    __isFragment?: never;
+    __isTeleport?: never;
+    __isSuspense?: never;
+} & ComponentOptionsBase<Readonly< ExtractPropTypes<{
+    list: {
+        type: PropType<any[]>;
+        required: true;
+    };
+    option: {
+        type: PropType<UseVirtualListOptions>;
+        required: true;
+    };
+}>>, {
+    scrollTo: (index: number) => void;
+    scaleTo: (s: number) => void;
+}, unknown, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, {}, {}, string, {}> & VNodeProps & AllowedComponentProps & ComponentCustomProps & (new () => {
+    $slots: Readonly< VirtualListSlot> & VirtualListSlot;
+})>;
+export default KScaleVirtualList;

package/dist/types/components/scroll-bar/index.d.ts

@@ -0,0 +1,36 @@
+import { SFCWithInstall } from '../utils/install';
+import { DefineComponent, PropType, Ref, ComputedRef, ComponentOptionsMixin, PublicProps, ExtractPropTypes } from 'vue';
+export * from './src/types';
+export declare const KScrollBar: SFCWithInstall<DefineComponent<{
+    readonly container: PropType<() => HTMLElement | null | undefined>;
+    readonly content: PropType<() => HTMLElement | null | undefined>;
+    readonly onScroll: PropType<(e: Event) => void>;
+    readonly xScrollable: BooleanConstructor;
+}, {
+    sync: () => void;
+    handleContentResize: () => void;
+    handleContainerResize: () => void;
+    contentRef: Ref<HTMLElement | null>;
+    yRailRef: Ref<HTMLElement | null>;
+    xRailRef: Ref<HTMLElement | null>;
+    containerRef: Ref<HTMLElement | null>;
+    contentHeightRef: Ref<Nullable<number>>;
+    containerHeightRef: Ref<Nullable<number>>;
+    needYBarRef: ComputedRef<boolean>;
+    needXBarRef: ComputedRef<boolean>;
+    yBarSizePxRef: ComputedRef<string>;
+    handleYScrollMouseDown: (e: MouseEvent) => void;
+    handleXScrollMouseDown: (e: MouseEvent) => void;
+    yBarTopPxRef: ComputedRef<string>;
+    handleScroll: (e: Event) => void;
+    xBarSizePxRef: ComputedRef<string>;
+    xBarLeftPxRef: ComputedRef<string>;
+}, unknown, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, PublicProps, Readonly< ExtractPropTypes<{
+    readonly container: PropType<() => HTMLElement | null | undefined>;
+    readonly content: PropType<() => HTMLElement | null | undefined>;
+    readonly onScroll: PropType<(e: Event) => void>;
+    readonly xScrollable: BooleanConstructor;
+}>>, {
+    readonly xScrollable: boolean;
+}, {}>>;
+export default KScrollBar;

package/dist/types/components/scroll-bar/src/scroll-bar.d.ts

@@ -0,0 +1,34 @@
+import { DefineComponent, PropType, Ref, ComputedRef, ComponentOptionsMixin, PublicProps, ExtractPropTypes } from 'vue';
+declare const _default: DefineComponent<{
+    readonly container: PropType<() => HTMLElement | null | undefined>;
+    readonly content: PropType<() => HTMLElement | null | undefined>;
+    readonly onScroll: PropType<(e: Event) => void>;
+    readonly xScrollable: BooleanConstructor;
+}, {
+    sync: () => void;
+    handleContentResize: () => void;
+    handleContainerResize: () => void;
+    contentRef: Ref<HTMLElement | null>;
+    yRailRef: Ref<HTMLElement | null>;
+    xRailRef: Ref<HTMLElement | null>;
+    containerRef: Ref<HTMLElement | null>;
+    contentHeightRef: Ref<Nullable<number>>;
+    containerHeightRef: Ref<Nullable<number>>;
+    needYBarRef: ComputedRef<boolean>;
+    needXBarRef: ComputedRef<boolean>;
+    yBarSizePxRef: ComputedRef<string>;
+    handleYScrollMouseDown: (e: MouseEvent) => void;
+    handleXScrollMouseDown: (e: MouseEvent) => void;
+    yBarTopPxRef: ComputedRef<string>;
+    handleScroll: (e: Event) => void;
+    xBarSizePxRef: ComputedRef<string>;
+    xBarLeftPxRef: ComputedRef<string>;
+}, unknown, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, PublicProps, Readonly< ExtractPropTypes<{
+    readonly container: PropType<() => HTMLElement | null | undefined>;
+    readonly content: PropType<() => HTMLElement | null | undefined>;
+    readonly onScroll: PropType<(e: Event) => void>;
+    readonly xScrollable: BooleanConstructor;
+}>>, {
+    readonly xScrollable: boolean;
+}, {}>;
+export default _default;

package/dist/{es → types}/components/scroll-bar/src/types.d.ts

@@ -1,4 +1,4 @@
-import type { PropType } from 'vue';
+import { PropType } from 'vue';
 export declare const scrollbarProps: {
     readonly container: PropType<() => HTMLElement | null | undefined>;
     readonly content: PropType<() => HTMLElement | null | undefined>;

package/dist/{es → types}/components/utils/install.d.ts

@@ -1,4 +1,4 @@
-import type { App, Directive, Plugin } from 'vue';
+import { App, Directive, Plugin } from 'vue';
 export type SFCWithInstall<T> = T & Plugin;
 export declare function withInstall<T>(main: T): SFCWithInstall<T>;
 export declare function withInstallDirectives<T extends Directive>(main: T, name: string): {

package/dist/types/components/utils/tool.d.ts

@@ -0,0 +1 @@
+export declare function rafThrottle(fn: (...arg: any[]) => any): (this: any, ...args: any[]) => void;