@king-one/antdv 1.0.22 → 1.0.24

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/{lib → 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;

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

@@ -0,0 +1,163 @@
+import { SFCWithInstall } from '../utils/install';
+import { CreateComponentPublicInstance, ExtractPropTypes, PropType, ComponentOptionsMixin, VNodeProps, AllowedComponentProps, ComponentCustomProps, ComponentOptionsBase } from 'vue';
+import { VVirtualListItemData, VVirtualListScrollToOptions } from 'vueuc';
+import { InterScrollParams } from './src/types';
+export * from './src/types';
+export declare const KVirtualList: SFCWithInstall<{
+    new (...args: any[]): CreateComponentPublicInstance<Readonly< ExtractPropTypes<{
+        readonly items: {
+            readonly type: PropType< VVirtualListItemData[]>;
+            readonly default: () => never[];
+        };
+        readonly itemSize: {
+            readonly type: NumberConstructor;
+            readonly required: true;
+        };
+        readonly itemResizable: BooleanConstructor;
+        readonly paddingTop: {
+            readonly type: PropType<number | string>;
+            readonly default: 0;
+        };
+        readonly paddingBottom: {
+            readonly type: PropType<number | string>;
+            readonly default: 0;
+        };
+        readonly keyField: {
+            readonly type: StringConstructor;
+            readonly default: "key";
+        };
+        readonly xScrollable: BooleanConstructor;
+        readonly onScroll: PropType<(params: InterScrollParams) => void>;
+        readonly onWheel: PropType<(event: WheelEvent) => void>;
+        readonly onResize: PropType<(entry: ResizeObserverEntry) => void>;
+    }>>, {
+        getScrollContainer: () => HTMLElement | null | undefined;
+        getScrollContent: () => HTMLElement | null | undefined;
+        scrollTo: (options: VVirtualListScrollToOptions | number, y?: number) => void;
+    }, unknown, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, VNodeProps & AllowedComponentProps & ComponentCustomProps & Readonly< ExtractPropTypes<{
+        readonly items: {
+            readonly type: PropType< VVirtualListItemData[]>;
+            readonly default: () => never[];
+        };
+        readonly itemSize: {
+            readonly type: NumberConstructor;
+            readonly required: true;
+        };
+        readonly itemResizable: BooleanConstructor;
+        readonly paddingTop: {
+            readonly type: PropType<number | string>;
+            readonly default: 0;
+        };
+        readonly paddingBottom: {
+            readonly type: PropType<number | string>;
+            readonly default: 0;
+        };
+        readonly keyField: {
+            readonly type: StringConstructor;
+            readonly default: "key";
+        };
+        readonly xScrollable: BooleanConstructor;
+        readonly onScroll: PropType<(params: InterScrollParams) => void>;
+        readonly onWheel: PropType<(event: WheelEvent) => void>;
+        readonly onResize: PropType<(entry: ResizeObserverEntry) => void>;
+    }>>, {
+        readonly xScrollable: boolean;
+        readonly items: VVirtualListItemData[];
+        readonly itemResizable: boolean;
+        readonly paddingTop: string | number;
+        readonly paddingBottom: string | number;
+        readonly keyField: string;
+    }, true, {}, {}, {
+        P: {};
+        B: {};
+        D: {};
+        C: {};
+        M: {};
+        Defaults: {};
+    }, Readonly< ExtractPropTypes<{
+        readonly items: {
+            readonly type: PropType< VVirtualListItemData[]>;
+            readonly default: () => never[];
+        };
+        readonly itemSize: {
+            readonly type: NumberConstructor;
+            readonly required: true;
+        };
+        readonly itemResizable: BooleanConstructor;
+        readonly paddingTop: {
+            readonly type: PropType<number | string>;
+            readonly default: 0;
+        };
+        readonly paddingBottom: {
+            readonly type: PropType<number | string>;
+            readonly default: 0;
+        };
+        readonly keyField: {
+            readonly type: StringConstructor;
+            readonly default: "key";
+        };
+        readonly xScrollable: BooleanConstructor;
+        readonly onScroll: PropType<(params: InterScrollParams) => void>;
+        readonly onWheel: PropType<(event: WheelEvent) => void>;
+        readonly onResize: PropType<(entry: ResizeObserverEntry) => void>;
+    }>>, {
+        getScrollContainer: () => HTMLElement | null | undefined;
+        getScrollContent: () => HTMLElement | null | undefined;
+        scrollTo: (options: VVirtualListScrollToOptions | number, y?: number) => void;
+    }, {}, {}, {}, {
+        readonly xScrollable: boolean;
+        readonly items: VVirtualListItemData[];
+        readonly itemResizable: boolean;
+        readonly paddingTop: string | number;
+        readonly paddingBottom: string | number;
+        readonly keyField: string;
+    }>;
+    __isFragment?: never;
+    __isTeleport?: never;
+    __isSuspense?: never;
+} & ComponentOptionsBase<Readonly< ExtractPropTypes<{
+    readonly items: {
+        readonly type: PropType< VVirtualListItemData[]>;
+        readonly default: () => never[];
+    };
+    readonly itemSize: {
+        readonly type: NumberConstructor;
+        readonly required: true;
+    };
+    readonly itemResizable: BooleanConstructor;
+    readonly paddingTop: {
+        readonly type: PropType<number | string>;
+        readonly default: 0;
+    };
+    readonly paddingBottom: {
+        readonly type: PropType<number | string>;
+        readonly default: 0;
+    };
+    readonly keyField: {
+        readonly type: StringConstructor;
+        readonly default: "key";
+    };
+    readonly xScrollable: BooleanConstructor;
+    readonly onScroll: PropType<(params: InterScrollParams) => void>;
+    readonly onWheel: PropType<(event: WheelEvent) => void>;
+    readonly onResize: PropType<(entry: ResizeObserverEntry) => void>;
+}>>, {
+    getScrollContainer: () => HTMLElement | null | undefined;
+    getScrollContent: () => HTMLElement | null | undefined;
+    scrollTo: (options: VVirtualListScrollToOptions | number, y?: number) => void;
+}, unknown, {}, {}, ComponentOptionsMixin, ComponentOptionsMixin, {}, string, {
+    readonly xScrollable: boolean;
+    readonly items: VVirtualListItemData[];
+    readonly itemResizable: boolean;
+    readonly paddingTop: string | number;
+    readonly paddingBottom: string | number;
+    readonly keyField: string;
+}, {}, string, {}> & VNodeProps & AllowedComponentProps & ComponentCustomProps & (new () => {
+    $slots: {
+        default?(_: {
+            item: any;
+            index: any;
+        }): any;
+    };
+})>;
+export default KVirtualList;

package/dist/{es → types}/components/virtual-list/src/types.d.ts

@@ -1,5 +1,5 @@
-import type { VirtualListInst, VirtualListItemData } from 'vueuc';
-import type { PropType } from 'vue';
+import { VirtualListInst, VirtualListItemData } from 'vueuc';
+import { PropType } from 'vue';
 export interface InterScrollParams {
     viewportItems: any[];
     scrollTop: number;