@hb-hellotech/hb-ui 1.0.2 → 1.1.0

package/dist/components/{business-comp/list-page-comp → business_comp/list_page_comp}/hb_list_btns_act/src/type.d.ts

@@ -1,5 +1,5 @@
 import type { ExtractPropTypes, PropType } from 'vue';
-import type { LocalShowList_intf } from '../../../../../components/business-comp/list-page-comp/hb_form_item_filter_modal/src/type';
+import type { LocalShowList_intf } from '../../../../../components/business_comp/list_page_comp/hb_form_item_filter_modal/src/type';
 export declare const HbListBtnsProps: {
     readonly formItems: {
         readonly type: PropType<LocalShowList_intf[]>;

package/dist/components/{business-comp/list-page-comp → business_comp/list_page_comp}/hb_list_page_act/src/type.d.ts

@@ -1,5 +1,5 @@
 import type { ExtractPropTypes, PropType } from 'vue';
-import type { LocalShowList_intf } from '../../../../../components/business-comp/list-page-comp/hb_form_item_filter_modal/src/type';
+import type { LocalShowList_intf } from '../../../../../components/business_comp/list_page_comp/hb_form_item_filter_modal/src/type';
 export interface Breadcrumbs_intf {
     label: string;
     value: string;

package/dist/components/{business-comp/list-page-comp → business_comp/list_page_comp}/index.d.ts

@@ -8,6 +8,6 @@ import HbMutilpleSelectModal from './hb_form_select_modal';
 import HbTableAct from './hb_list_table_act';
 import HbLibListTable from './hb_list_table';
 import HbTableColumnSet from './hb_list_table_colums_set';
-import HbLibCopy from '../../../components/func-comp/hb_func_comp_copy';
+import HbLibCopy from '../../../components/func_comp/hb_func_comp_copy';
 export { HbListForm as HbLibListForm, HbListPageAct as HbLibListPageAct, HbListBtnsAct as HbLibListBtnsAct, HbListPageContainer as HbLibListPageContainer, HbListMultiSelect as HbLibListMultiSelect, HbMutilpleSelectModal as HbLibMutilpleSelectModal, HbTableAct as HbLibTableAct, HbFormItemFilterModal as HbLibFormItemFilterModal, HbTableColumnSet as HbLibTableColumnSet, HbLibListTable, HbLibCopy, };
 //# sourceMappingURL=index.d.ts.map

package/dist/components/{func-comp → func_comp}/hb_func_comp_copy/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["index.ts"],"names":[],"mappings":"AAEA,cAAc,YAAY,CAAC;AAI3B,QAAA,MAAM,MAAM,EAAE,GAAuB,CAAC;AAEtC,eAAe,MAAM,CAAC;AAEtB,MAAM,MAAM,YAAY,GAAG,YAAY,CAAC,OAAO,MAAM,CAAC,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["index.ts"],"names":[],"mappings":"AAEA,cAAc,YAAY,CAAC;AAE3B,QAAA,MAAM,MAAM,EAAE,GAAuB,CAAC;AAEtC,eAAe,MAAM,CAAC;AAEtB,MAAM,MAAM,YAAY,GAAG,YAAY,CAAC,OAAO,MAAM,CAAC,CAAC"}

package/dist/components/{func-comp → func_comp}/hb_func_comp_copy/src/type.d.ts

@@ -34,5 +34,16 @@ export declare const HbCopyProps: {
         readonly default: "ab";
     };
 };
+export interface HbCopyProps_Intf {
+    cpText?: string;
+    K?: string;
+    V?: string;
+    L?: string;
+    data?: any[];
+    tooltipTitle?: string;
+    copySuccessTip?: string;
+    cpStyle?: Record<string, any>;
+    classType?: string;
+}
 export type HbCopyPropsType = ExtractPropTypes<typeof HbCopyProps>;
 //# sourceMappingURL=type.d.ts.map

package/dist/components/func_comp/hb_func_comp_copy/src/type.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"type.d.ts","sourceRoot":"","sources":["type.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,gBAAgB,EAAE,QAAQ,EAAE,MAAM,KAAK,CAAC;AAEtD,eAAO,MAAM,WAAW;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;CA0Cd,CAAC;AAEX,MAAM,WAAW,gBAAgB;IAC/B,MAAM,CAAC,EAAE,MAAM,CAAC;IAChB,CAAC,CAAC,EAAE,MAAM,CAAC;IACX,CAAC,CAAC,EAAE,MAAM,CAAC;IACX,CAAC,CAAC,EAAE,MAAM,CAAC;IACX,IAAI,CAAC,EAAE,GAAG,EAAE,CAAC;IACb,YAAY,CAAC,EAAE,MAAM,CAAC;IACtB,cAAc,CAAC,EAAE,MAAM,CAAC;IACxB,OAAO,CAAC,EAAE,MAAM,CAAC,MAAM,EAAE,GAAG,CAAC,CAAC;IAC9B,SAAS,CAAC,EAAE,MAAM,CAAC;CACpB;AACD,MAAM,MAAM,eAAe,GAAG,gBAAgB,CAAC,OAAO,WAAW,CAAC,CAAC"}

package/dist/components/func_comp/hb_func_comp_drag/index.d.ts

@@ -0,0 +1,443 @@
+export * from './src/type';
+declare const HbDragInstall: ({
+    new (...args: any[]): import("vue").CreateComponentPublicInstanceWithMixins<Readonly<import("vue").ExtractPropTypes<{
+        readonly dragList: {
+            readonly type: import("vue").PropType<import("./src/type").DragItems_Intf[]>;
+            readonly required: true;
+        };
+        readonly childrenType: {
+            readonly type: import("vue").PropType<import("./src/type").ChildrenType>;
+            readonly default: "html";
+        };
+        readonly dragClass: {
+            readonly type: StringConstructor;
+            readonly default: "drag-item";
+        };
+        readonly ghostClass: {
+            readonly type: StringConstructor;
+            readonly default: null;
+        };
+        readonly chosenClass: {
+            readonly type: StringConstructor;
+            readonly default: null;
+        };
+        readonly sort: {
+            readonly type: BooleanConstructor;
+            readonly default: true;
+        };
+        readonly handle: {
+            readonly type: StringConstructor;
+            readonly default: "";
+        };
+        readonly filter: {
+            readonly type: StringConstructor;
+            readonly default: "";
+        };
+        readonly draggable: {
+            readonly type: StringConstructor;
+            readonly default: "";
+        };
+    }>> & Readonly<{
+        "onUpdate:dragList"?: ((...args: any[]) => any) | undefined;
+        onHandleDragStart?: ((...args: any[]) => any) | undefined;
+        onHandleDragEnd?: ((...args: any[]) => any) | undefined;
+        onHandleDragAdd?: ((...args: any[]) => any) | undefined;
+        onHandleDragRemove?: ((...args: any[]) => any) | undefined;
+    }>, {
+        props: any;
+        localData: import("vue").ShallowRef<any[], any[]>;
+        bem: {
+            b: (block?: string | undefined) => string;
+            e: (element: string) => string;
+            m: (modifier: string) => string;
+            be: (block: string, element: string) => string;
+            em: (element: string, modifier: string) => string;
+            bem: (block: string, element: string, modifier: string) => string;
+            is: (name: string, state: string | boolean) => string;
+        };
+        emits: (event: "update:dragList" | "handleDragStart" | "handleDragEnd" | "handleDragAdd" | "handleDragRemove", ...args: any[]) => void;
+        handleDragStart: (e: any) => void;
+        handleDragEnd: (e: any) => void;
+        handleDragAdd: (e: any) => void;
+        handleDragRemove: (e: any) => void;
+        readonly draggable: import("vue").DefineComponent<{
+            list: {
+                type: ArrayConstructor;
+                required: boolean;
+                default: any;
+            };
+            modelValue: {
+                type: ArrayConstructor;
+                required: boolean;
+                default: any;
+            };
+            itemKey: {
+                type: (StringConstructor | FunctionConstructor)[];
+                required: boolean;
+            };
+            clone: {
+                type: FunctionConstructor;
+                default: (original: any) => any;
+            };
+            tag: {
+                type: StringConstructor;
+                default: string;
+            };
+            move: {
+                type: FunctionConstructor;
+                default: any;
+            };
+            componentData: {
+                type: ObjectConstructor;
+                required: boolean;
+                default: any;
+            };
+        }, unknown, {
+            error: boolean;
+        }, {
+            realList(): any;
+            getKey(): any;
+        }, {
+            getUnderlyingVm(domElement: any): any;
+            getUnderlyingPotencialDraggableComponent(htmElement: any): any;
+            emitChanges(evt: any): void;
+            alterList(onList: any): void;
+            spliceList(): void;
+            updatePosition(oldIndex: any, newIndex: any): void;
+            getRelatedContextFromMoveEvent({ to, related }: {
+                to: any;
+                related: any;
+            }): any;
+            getVmIndexFromDomIndex(domIndex: any): any;
+            onDragStart(evt: any): void;
+            onDragAdd(evt: any): void;
+            onDragRemove(evt: any): void;
+            onDragUpdate(evt: any): void;
+            computeFutureIndex(relatedContext: any, evt: any): any;
+            onDragMove(evt: any, originalEvent: any): any;
+            onDragEnd(): void;
+        }, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, any[], any, import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps, Readonly<{
+            move: Function;
+            tag: string;
+            clone: Function;
+            list: unknown[];
+            modelValue: unknown[];
+            componentData: Record<string, any>;
+        } & {
+            itemKey?: string | Function | undefined;
+        }>, {
+            move: Function;
+            tag: string;
+            clone: Function;
+            list: unknown[];
+            modelValue: unknown[];
+            componentData: Record<string, any>;
+        }, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
+    }, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, ("update:dragList" | "handleDragStart" | "handleDragEnd" | "handleDragAdd" | "handleDragRemove")[], import("vue").PublicProps, {
+        readonly sort: boolean;
+        readonly filter: string;
+        readonly childrenType: import("./src/type").ChildrenType;
+        readonly dragClass: string;
+        readonly ghostClass: string;
+        readonly chosenClass: string;
+        readonly handle: string;
+        readonly draggable: string;
+    }, true, {}, {}, import("vue").GlobalComponents, import("vue").GlobalDirectives, string, {}, any, import("vue").ComponentProvideOptions, {
+        P: {};
+        B: {};
+        D: {};
+        C: {};
+        M: {};
+        Defaults: {};
+    }, Readonly<import("vue").ExtractPropTypes<{
+        readonly dragList: {
+            readonly type: import("vue").PropType<import("./src/type").DragItems_Intf[]>;
+            readonly required: true;
+        };
+        readonly childrenType: {
+            readonly type: import("vue").PropType<import("./src/type").ChildrenType>;
+            readonly default: "html";
+        };
+        readonly dragClass: {
+            readonly type: StringConstructor;
+            readonly default: "drag-item";
+        };
+        readonly ghostClass: {
+            readonly type: StringConstructor;
+            readonly default: null;
+        };
+        readonly chosenClass: {
+            readonly type: StringConstructor;
+            readonly default: null;
+        };
+        readonly sort: {
+            readonly type: BooleanConstructor;
+            readonly default: true;
+        };
+        readonly handle: {
+            readonly type: StringConstructor;
+            readonly default: "";
+        };
+        readonly filter: {
+            readonly type: StringConstructor;
+            readonly default: "";
+        };
+        readonly draggable: {
+            readonly type: StringConstructor;
+            readonly default: "";
+        };
+    }>> & Readonly<{
+        "onUpdate:dragList"?: ((...args: any[]) => any) | undefined;
+        onHandleDragStart?: ((...args: any[]) => any) | undefined;
+        onHandleDragEnd?: ((...args: any[]) => any) | undefined;
+        onHandleDragAdd?: ((...args: any[]) => any) | undefined;
+        onHandleDragRemove?: ((...args: any[]) => any) | undefined;
+    }>, {
+        props: any;
+        localData: import("vue").ShallowRef<any[], any[]>;
+        bem: {
+            b: (block?: string | undefined) => string;
+            e: (element: string) => string;
+            m: (modifier: string) => string;
+            be: (block: string, element: string) => string;
+            em: (element: string, modifier: string) => string;
+            bem: (block: string, element: string, modifier: string) => string;
+            is: (name: string, state: string | boolean) => string;
+        };
+        emits: (event: "update:dragList" | "handleDragStart" | "handleDragEnd" | "handleDragAdd" | "handleDragRemove", ...args: any[]) => void;
+        handleDragStart: (e: any) => void;
+        handleDragEnd: (e: any) => void;
+        handleDragAdd: (e: any) => void;
+        handleDragRemove: (e: any) => void;
+        readonly draggable: import("vue").DefineComponent<{
+            list: {
+                type: ArrayConstructor;
+                required: boolean;
+                default: any;
+            };
+            modelValue: {
+                type: ArrayConstructor;
+                required: boolean;
+                default: any;
+            };
+            itemKey: {
+                type: (StringConstructor | FunctionConstructor)[];
+                required: boolean;
+            };
+            clone: {
+                type: FunctionConstructor;
+                default: (original: any) => any;
+            };
+            tag: {
+                type: StringConstructor;
+                default: string;
+            };
+            move: {
+                type: FunctionConstructor;
+                default: any;
+            };
+            componentData: {
+                type: ObjectConstructor;
+                required: boolean;
+                default: any;
+            };
+        }, unknown, {
+            error: boolean;
+        }, {
+            realList(): any;
+            getKey(): any;
+        }, {
+            getUnderlyingVm(domElement: any): any;
+            getUnderlyingPotencialDraggableComponent(htmElement: any): any;
+            emitChanges(evt: any): void;
+            alterList(onList: any): void;
+            spliceList(): void;
+            updatePosition(oldIndex: any, newIndex: any): void;
+            getRelatedContextFromMoveEvent({ to, related }: {
+                to: any;
+                related: any;
+            }): any;
+            getVmIndexFromDomIndex(domIndex: any): any;
+            onDragStart(evt: any): void;
+            onDragAdd(evt: any): void;
+            onDragRemove(evt: any): void;
+            onDragUpdate(evt: any): void;
+            computeFutureIndex(relatedContext: any, evt: any): any;
+            onDragMove(evt: any, originalEvent: any): any;
+            onDragEnd(): void;
+        }, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, any[], any, import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps, Readonly<{
+            move: Function;
+            tag: string;
+            clone: Function;
+            list: unknown[];
+            modelValue: unknown[];
+            componentData: Record<string, any>;
+        } & {
+            itemKey?: string | Function | undefined;
+        }>, {
+            move: Function;
+            tag: string;
+            clone: Function;
+            list: unknown[];
+            modelValue: unknown[];
+            componentData: Record<string, any>;
+        }, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
+    }, {}, {}, {}, {
+        readonly sort: boolean;
+        readonly filter: string;
+        readonly childrenType: import("./src/type").ChildrenType;
+        readonly dragClass: string;
+        readonly ghostClass: string;
+        readonly chosenClass: string;
+        readonly handle: string;
+        readonly draggable: string;
+    }>;
+    __isFragment?: undefined;
+    __isTeleport?: undefined;
+    __isSuspense?: undefined;
+} & import("vue").ComponentOptionsBase<Readonly<import("vue").ExtractPropTypes<{
+    readonly dragList: {
+        readonly type: import("vue").PropType<import("./src/type").DragItems_Intf[]>;
+        readonly required: true;
+    };
+    readonly childrenType: {
+        readonly type: import("vue").PropType<import("./src/type").ChildrenType>;
+        readonly default: "html";
+    };
+    readonly dragClass: {
+        readonly type: StringConstructor;
+        readonly default: "drag-item";
+    };
+    readonly ghostClass: {
+        readonly type: StringConstructor;
+        readonly default: null;
+    };
+    readonly chosenClass: {
+        readonly type: StringConstructor;
+        readonly default: null;
+    };
+    readonly sort: {
+        readonly type: BooleanConstructor;
+        readonly default: true;
+    };
+    readonly handle: {
+        readonly type: StringConstructor;
+        readonly default: "";
+    };
+    readonly filter: {
+        readonly type: StringConstructor;
+        readonly default: "";
+    };
+    readonly draggable: {
+        readonly type: StringConstructor;
+        readonly default: "";
+    };
+}>> & Readonly<{
+    "onUpdate:dragList"?: ((...args: any[]) => any) | undefined;
+    onHandleDragStart?: ((...args: any[]) => any) | undefined;
+    onHandleDragEnd?: ((...args: any[]) => any) | undefined;
+    onHandleDragAdd?: ((...args: any[]) => any) | undefined;
+    onHandleDragRemove?: ((...args: any[]) => any) | undefined;
+}>, {
+    props: any;
+    localData: import("vue").ShallowRef<any[], any[]>;
+    bem: {
+        b: (block?: string | undefined) => string;
+        e: (element: string) => string;
+        m: (modifier: string) => string;
+        be: (block: string, element: string) => string;
+        em: (element: string, modifier: string) => string;
+        bem: (block: string, element: string, modifier: string) => string;
+        is: (name: string, state: string | boolean) => string;
+    };
+    emits: (event: "update:dragList" | "handleDragStart" | "handleDragEnd" | "handleDragAdd" | "handleDragRemove", ...args: any[]) => void;
+    handleDragStart: (e: any) => void;
+    handleDragEnd: (e: any) => void;
+    handleDragAdd: (e: any) => void;
+    handleDragRemove: (e: any) => void;
+    readonly draggable: import("vue").DefineComponent<{
+        list: {
+            type: ArrayConstructor;
+            required: boolean;
+            default: any;
+        };
+        modelValue: {
+            type: ArrayConstructor;
+            required: boolean;
+            default: any;
+        };
+        itemKey: {
+            type: (StringConstructor | FunctionConstructor)[];
+            required: boolean;
+        };
+        clone: {
+            type: FunctionConstructor;
+            default: (original: any) => any;
+        };
+        tag: {
+            type: StringConstructor;
+            default: string;
+        };
+        move: {
+            type: FunctionConstructor;
+            default: any;
+        };
+        componentData: {
+            type: ObjectConstructor;
+            required: boolean;
+            default: any;
+        };
+    }, unknown, {
+        error: boolean;
+    }, {
+        realList(): any;
+        getKey(): any;
+    }, {
+        getUnderlyingVm(domElement: any): any;
+        getUnderlyingPotencialDraggableComponent(htmElement: any): any;
+        emitChanges(evt: any): void;
+        alterList(onList: any): void;
+        spliceList(): void;
+        updatePosition(oldIndex: any, newIndex: any): void;
+        getRelatedContextFromMoveEvent({ to, related }: {
+            to: any;
+            related: any;
+        }): any;
+        getVmIndexFromDomIndex(domIndex: any): any;
+        onDragStart(evt: any): void;
+        onDragAdd(evt: any): void;
+        onDragRemove(evt: any): void;
+        onDragUpdate(evt: any): void;
+        computeFutureIndex(relatedContext: any, evt: any): any;
+        onDragMove(evt: any, originalEvent: any): any;
+        onDragEnd(): void;
+    }, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, any[], any, import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps, Readonly<{
+        move: Function;
+        tag: string;
+        clone: Function;
+        list: unknown[];
+        modelValue: unknown[];
+        componentData: Record<string, any>;
+    } & {
+        itemKey?: string | Function | undefined;
+    }>, {
+        move: Function;
+        tag: string;
+        clone: Function;
+        list: unknown[];
+        modelValue: unknown[];
+        componentData: Record<string, any>;
+    }, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
+}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, ("update:dragList" | "handleDragStart" | "handleDragEnd" | "handleDragAdd" | "handleDragRemove")[], "update:dragList" | "handleDragStart" | "handleDragEnd" | "handleDragAdd" | "handleDragRemove", {
+    readonly sort: boolean;
+    readonly filter: string;
+    readonly childrenType: import("./src/type").ChildrenType;
+    readonly dragClass: string;
+    readonly ghostClass: string;
+    readonly chosenClass: string;
+    readonly handle: string;
+    readonly draggable: string;
+}, {}, string, {}, import("vue").GlobalComponents, import("vue").GlobalDirectives, string, import("vue").ComponentProvideOptions> & import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps & import("vue").Plugin<any[], any[]>) & Record<string, any>;
+export default HbDragInstall;
+export type HbDragInstance = InstanceType<typeof HbDragInstall>;
+//# sourceMappingURL=index.d.ts.map

package/dist/components/func_comp/hb_func_comp_drag/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["index.ts"],"names":[],"mappings":"AAEA,cAAc,YAAY,CAAC;AAE3B,QAAA,MAAM,aAAa;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;mSAAsB,CAAC;AAC1C,eAAe,aAAa,CAAC;AAE7B,MAAM,MAAM,cAAc,GAAG,YAAY,CAAC,OAAO,aAAa,CAAC,CAAC"}

package/dist/components/func_comp/hb_func_comp_drag/src/index.vue.d.ts

@@ -0,0 +1,182 @@
+declare const _sfc_main: import("vue").DefineComponent<import("vue").ExtractPropTypes<{
+    readonly dragList: {
+        readonly type: import("vue").PropType<import("./type").DragItems_Intf[]>;
+        readonly required: true;
+    };
+    readonly childrenType: {
+        readonly type: import("vue").PropType<import("./type").ChildrenType>;
+        readonly default: "html";
+    };
+    readonly dragClass: {
+        readonly type: StringConstructor;
+        readonly default: "drag-item";
+    };
+    readonly ghostClass: {
+        readonly type: StringConstructor;
+        readonly default: null;
+    };
+    readonly chosenClass: {
+        readonly type: StringConstructor;
+        readonly default: null;
+    };
+    readonly sort: {
+        readonly type: BooleanConstructor;
+        readonly default: true;
+    };
+    readonly handle: {
+        readonly type: StringConstructor;
+        readonly default: "";
+    };
+    readonly filter: {
+        readonly type: StringConstructor;
+        readonly default: "";
+    };
+    readonly draggable: {
+        readonly type: StringConstructor;
+        readonly default: "";
+    };
+}>, {
+    props: any;
+    localData: import("vue").ShallowRef<any[], any[]>;
+    bem: {
+        b: (block?: string | undefined) => string;
+        e: (element: string) => string;
+        m: (modifier: string) => string;
+        be: (block: string, element: string) => string;
+        em: (element: string, modifier: string) => string;
+        bem: (block: string, element: string, modifier: string) => string;
+        is: (name: string, state: string | boolean) => string;
+    };
+    emits: (event: "update:dragList" | "handleDragStart" | "handleDragEnd" | "handleDragAdd" | "handleDragRemove", ...args: any[]) => void;
+    handleDragStart: (e: any) => void;
+    handleDragEnd: (e: any) => void;
+    handleDragAdd: (e: any) => void;
+    handleDragRemove: (e: any) => void;
+    readonly draggable: import("vue").DefineComponent<{
+        list: {
+            type: ArrayConstructor;
+            required: boolean;
+            default: any;
+        };
+        modelValue: {
+            type: ArrayConstructor;
+            required: boolean;
+            default: any;
+        };
+        itemKey: {
+            type: (StringConstructor | FunctionConstructor)[];
+            required: boolean;
+        };
+        clone: {
+            type: FunctionConstructor;
+            default: (original: any) => any;
+        };
+        tag: {
+            type: StringConstructor;
+            default: string;
+        };
+        move: {
+            type: FunctionConstructor;
+            default: any;
+        };
+        componentData: {
+            type: ObjectConstructor;
+            required: boolean;
+            default: any;
+        };
+    }, unknown, {
+        error: boolean;
+    }, {
+        realList(): any;
+        getKey(): any;
+    }, {
+        getUnderlyingVm(domElement: any): any;
+        getUnderlyingPotencialDraggableComponent(htmElement: any): any;
+        emitChanges(evt: any): void;
+        alterList(onList: any): void;
+        spliceList(): void;
+        updatePosition(oldIndex: any, newIndex: any): void;
+        getRelatedContextFromMoveEvent({ to, related }: {
+            to: any;
+            related: any;
+        }): any;
+        getVmIndexFromDomIndex(domIndex: any): any;
+        onDragStart(evt: any): void;
+        onDragAdd(evt: any): void;
+        onDragRemove(evt: any): void;
+        onDragUpdate(evt: any): void;
+        computeFutureIndex(relatedContext: any, evt: any): any;
+        onDragMove(evt: any, originalEvent: any): any;
+        onDragEnd(): void;
+    }, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, any[], any, import("vue").VNodeProps & import("vue").AllowedComponentProps & import("vue").ComponentCustomProps, Readonly<{
+        move: Function;
+        tag: string;
+        clone: Function;
+        list: unknown[];
+        modelValue: unknown[];
+        componentData: Record<string, any>;
+    } & {
+        itemKey?: string | Function | undefined;
+    }>, {
+        move: Function;
+        tag: string;
+        clone: Function;
+        list: unknown[];
+        modelValue: unknown[];
+        componentData: Record<string, any>;
+    }, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
+}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, ("update:dragList" | "handleDragStart" | "handleDragEnd" | "handleDragAdd" | "handleDragRemove")[], "update:dragList" | "handleDragStart" | "handleDragEnd" | "handleDragAdd" | "handleDragRemove", import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
+    readonly dragList: {
+        readonly type: import("vue").PropType<import("./type").DragItems_Intf[]>;
+        readonly required: true;
+    };
+    readonly childrenType: {
+        readonly type: import("vue").PropType<import("./type").ChildrenType>;
+        readonly default: "html";
+    };
+    readonly dragClass: {
+        readonly type: StringConstructor;
+        readonly default: "drag-item";
+    };
+    readonly ghostClass: {
+        readonly type: StringConstructor;
+        readonly default: null;
+    };
+    readonly chosenClass: {
+        readonly type: StringConstructor;
+        readonly default: null;
+    };
+    readonly sort: {
+        readonly type: BooleanConstructor;
+        readonly default: true;
+    };
+    readonly handle: {
+        readonly type: StringConstructor;
+        readonly default: "";
+    };
+    readonly filter: {
+        readonly type: StringConstructor;
+        readonly default: "";
+    };
+    readonly draggable: {
+        readonly type: StringConstructor;
+        readonly default: "";
+    };
+}>> & Readonly<{
+    "onUpdate:dragList"?: ((...args: any[]) => any) | undefined;
+    onHandleDragStart?: ((...args: any[]) => any) | undefined;
+    onHandleDragEnd?: ((...args: any[]) => any) | undefined;
+    onHandleDragAdd?: ((...args: any[]) => any) | undefined;
+    onHandleDragRemove?: ((...args: any[]) => any) | undefined;
+}>, {
+    readonly sort: boolean;
+    readonly filter: string;
+    readonly childrenType: import("./type").ChildrenType;
+    readonly dragClass: string;
+    readonly ghostClass: string;
+    readonly chosenClass: string;
+    readonly handle: string;
+    readonly draggable: string;
+}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
+export default _sfc_main;
+//# sourceMappingURL=index.vue.d.ts.map

package/dist/components/func_comp/hb_func_comp_drag/src/index.vue.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.vue.d.ts","sourceRoot":"","sources":["index.vue.ts"],"names":[],"mappings":"AAOA,QAAA,MAAM,SAAS;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;yBA0Ba,GAAG;uBAIL,GAAG;uBAIH,GAAG;0BAIA,GAAG;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;4EAU9B,CAAA;AACF,eAAe,SAAS,CAAA"}