@vc-shell/framework 1.0.341 → 1.1.0-alpha.10

package/dist/shared/components/draggable-dashboard/composables/useCellSizeCalculator.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"useCellSizeCalculator.d.ts","sourceRoot":"","sources":["../../../../../shared/components/draggable-dashboard/composables/useCellSizeCalculator.ts"],"names":[],"mappings":"AAAA,OAAO,EAAO,KAAK,GAAG,EAAE,MAAM,KAAK,CAAC;AAEpC;;GAEG;AACH,MAAM,WAAW,QAAQ;IACvB,KAAK,EAAE,MAAM,CAAC;IACd,MAAM,EAAE,MAAM,CAAC;CAChB;AAQD;;;;;;;;GAQG;AACH,wBAAgB,qBAAqB,CAAC,WAAW,EAAE,MAAM;mCAcjB,WAAW,GAAG,IAAI,aAAY,OAAO,KAAU,QAAQ;sBAgCtE,IAAI;kCAUU,MAAM,KAAG,OAAO;uCAeX,WAAW,KAAG,IAAI;;EAwB7D"}

package/dist/shared/components/draggable-dashboard/composables/useCollisionDetection.d.ts

@@ -0,0 +1,27 @@
+import type { IDashboardWidget, DashboardWidgetPosition } from "../types";
+/**
+ * Composables for detecting and handling collisions between widgets
+ *
+ * Provides functions for checking widget intersections and calculating
+ * new positions for displaced widgets
+ *
+ * @returns An object with functions for working with collisions
+ */
+export declare function useCollisionDetection(): {
+    displacedWidgets: import("vue").Ref<Map<string, {
+        x: number;
+        y: number;
+    }> & Omit<Map<string, DashboardWidgetPosition>, keyof Map<any, any>>, Map<string, DashboardWidgetPosition> | (Map<string, {
+        x: number;
+        y: number;
+    }> & Omit<Map<string, DashboardWidgetPosition>, keyof Map<any, any>>)>;
+    intersect: (widgetA: IDashboardWidget, posA: DashboardWidgetPosition, widgetB: IDashboardWidget, posB: DashboardWidgetPosition) => boolean;
+    updateDisplacedWidgets: (draggedWidget: IDashboardWidget | null, previewPosition: DashboardWidgetPosition | null, widgets: IDashboardWidget[], layout: Map<string, DashboardWidgetPosition>) => void;
+    clearDisplacedWidgets: () => void;
+    isWidgetDisplaced: (widgetId: string) => boolean;
+    getDisplacedPosition: (widgetId: string) => {
+        x: number;
+        y: number;
+    } | undefined;
+};
+//# sourceMappingURL=useCollisionDetection.d.ts.map

package/dist/shared/components/draggable-dashboard/composables/useCollisionDetection.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"useCollisionDetection.d.ts","sourceRoot":"","sources":["../../../../../shared/components/draggable-dashboard/composables/useCollisionDetection.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,gBAAgB,EAAE,uBAAuB,EAAE,MAAM,UAAU,CAAC;AAE1E;;;;;;;GAOG;AACH,wBAAgB,qBAAqB;;;;;;;;yBAcxB,gBAAgB,QACnB,uBAAuB,WACpB,gBAAgB,QACnB,uBAAuB,KAC5B,OAAO;4CAoCO,gBAAgB,GAAG,IAAI,mBACrB,uBAAuB,GAAG,IAAI,WACtC,gBAAgB,EAAE,UACnB,IAAI,MAAM,EAAE,uBAAuB,CAAC;;kCAgIT,MAAM;qCAUH,MAAM;;;;EAY/C"}

package/dist/shared/components/draggable-dashboard/composables/useDashboardDragAndDrop.d.ts

@@ -0,0 +1,376 @@
+import type { IDashboardWidget, DashboardWidgetPosition } from "../types";
+/**
+ * Composables for managing the dragging of widgets on the dashboard
+ *
+ * Provides functions for handling drag events, updating widget positions, and handling collisions
+ *
+ * @param updateWidgetPosition Function to update the position of a widget in the store
+ * @param getGridRows Function to get the number of rows in the grid
+ * @returns An object with functions and state for managing the dragging
+ */
+export declare function useDashboardDragAndDrop(updateWidgetPosition: (widgetId: string, position: DashboardWidgetPosition) => void, getGridRows?: () => number): {
+    draggedWidget: import("vue").Ref<{
+        id: string;
+        name?: string | undefined;
+        component: import("vue").FunctionalComponent<any, {}, any, {}> | {
+            new (...args: any[]): any;
+            __isFragment?: undefined;
+            __isTeleport?: undefined;
+            __isSuspense?: undefined;
+        } | {
+            [x: string]: any;
+            setup?: ((this: void, props: import("@vue/shared").LooseRequired<any>, ctx: {
+                attrs: {
+                    [x: string]: unknown;
+                };
+                slots: Readonly<{
+                    [name: string]: import("vue").Slot<any> | undefined;
+                }>;
+                emit: ((event: unknown, ...args: any[]) => void) | ((event: string, ...args: any[]) => void);
+                expose: <Exposed extends Record<string, any> = Record<string, any>>(exposed?: Exposed | undefined) => void;
+            }) => any) | undefined;
+            name?: string | undefined;
+            template?: string | object | undefined;
+            render?: Function | undefined;
+            components?: Record<string, import("vue").Component<any, any, any, import("vue").ComputedOptions, import("vue").MethodOptions, {}, any>> | undefined;
+            directives?: Record<string, import("vue").Directive<any, any, string, string>> | undefined;
+            inheritAttrs?: boolean | undefined;
+            emits?: any;
+            slots?: {} | undefined;
+            expose?: string[] | undefined;
+            serverPrefetch?: (() => void | Promise<any>) | undefined;
+            compilerOptions?: {
+                isCustomElement?: ((tag: string) => boolean) | undefined;
+                whitespace?: "preserve" | "condense" | undefined;
+                comments?: boolean | undefined;
+                delimiters?: [string, string] | undefined;
+            } | undefined;
+            call?: ((this: unknown, ...args: unknown[]) => never) | undefined;
+            __isFragment?: undefined;
+            __isTeleport?: undefined;
+            __isSuspense?: undefined;
+            __defaults?: {} | undefined;
+            compatConfig?: {
+                GLOBAL_MOUNT?: boolean | "suppress-warning" | undefined;
+                GLOBAL_MOUNT_CONTAINER?: boolean | "suppress-warning" | undefined;
+                GLOBAL_EXTEND?: boolean | "suppress-warning" | undefined;
+                GLOBAL_PROTOTYPE?: boolean | "suppress-warning" | undefined;
+                GLOBAL_SET?: boolean | "suppress-warning" | undefined;
+                GLOBAL_DELETE?: boolean | "suppress-warning" | undefined;
+                GLOBAL_OBSERVABLE?: boolean | "suppress-warning" | undefined;
+                GLOBAL_PRIVATE_UTIL?: boolean | "suppress-warning" | undefined;
+                CONFIG_SILENT?: boolean | "suppress-warning" | undefined;
+                CONFIG_DEVTOOLS?: boolean | "suppress-warning" | undefined;
+                CONFIG_KEY_CODES?: boolean | "suppress-warning" | undefined;
+                CONFIG_PRODUCTION_TIP?: boolean | "suppress-warning" | undefined;
+                CONFIG_IGNORED_ELEMENTS?: boolean | "suppress-warning" | undefined;
+                CONFIG_WHITESPACE?: boolean | "suppress-warning" | undefined;
+                CONFIG_OPTION_MERGE_STRATS?: boolean | "suppress-warning" | undefined;
+                INSTANCE_SET?: boolean | "suppress-warning" | undefined;
+                INSTANCE_DELETE?: boolean | "suppress-warning" | undefined;
+                INSTANCE_DESTROY?: boolean | "suppress-warning" | undefined;
+                INSTANCE_EVENT_EMITTER?: boolean | "suppress-warning" | undefined;
+                INSTANCE_EVENT_HOOKS?: boolean | "suppress-warning" | undefined;
+                INSTANCE_CHILDREN?: boolean | "suppress-warning" | undefined;
+                INSTANCE_LISTENERS?: boolean | "suppress-warning" | undefined;
+                INSTANCE_SCOPED_SLOTS?: boolean | "suppress-warning" | undefined;
+                INSTANCE_ATTRS_CLASS_STYLE?: boolean | "suppress-warning" | undefined;
+                OPTIONS_DATA_FN?: boolean | "suppress-warning" | undefined;
+                OPTIONS_DATA_MERGE?: boolean | "suppress-warning" | undefined;
+                OPTIONS_BEFORE_DESTROY?: boolean | "suppress-warning" | undefined;
+                OPTIONS_DESTROYED?: boolean | "suppress-warning" | undefined;
+                WATCH_ARRAY?: boolean | "suppress-warning" | undefined;
+                PROPS_DEFAULT_THIS?: boolean | "suppress-warning" | undefined;
+                V_ON_KEYCODE_MODIFIER?: boolean | "suppress-warning" | undefined;
+                CUSTOM_DIR?: boolean | "suppress-warning" | undefined;
+                ATTR_FALSE_VALUE?: boolean | "suppress-warning" | undefined;
+                ATTR_ENUMERATED_COERCION?: boolean | "suppress-warning" | undefined;
+                TRANSITION_CLASSES?: boolean | "suppress-warning" | undefined;
+                TRANSITION_GROUP_ROOT?: boolean | "suppress-warning" | undefined;
+                COMPONENT_ASYNC?: boolean | "suppress-warning" | undefined;
+                COMPONENT_FUNCTIONAL?: boolean | "suppress-warning" | undefined;
+                COMPONENT_V_MODEL?: boolean | "suppress-warning" | undefined;
+                RENDER_FUNCTION?: boolean | "suppress-warning" | undefined;
+                FILTERS?: boolean | "suppress-warning" | undefined;
+                PRIVATE_APIS?: boolean | "suppress-warning" | undefined;
+                MODE?: 2 | 3 | ((comp: import("vue").Component<any, any, any, import("vue").ComputedOptions, import("vue").MethodOptions, {}, any> | null) => 2 | 3) | undefined;
+            } | undefined;
+            data?: ((this: any, vm: any) => any) | undefined;
+            computed?: import("vue").ComputedOptions | undefined;
+            methods?: import("vue").MethodOptions | undefined;
+            watch?: {
+                [x: string]: (string | import("vue").WatchCallback | ({
+                    handler: string | import("vue").WatchCallback;
+                } & import("vue").WatchOptions<boolean>)) | (string | import("vue").WatchCallback | ({
+                    handler: string | import("vue").WatchCallback;
+                } & import("vue").WatchOptions<boolean>))[];
+            } | undefined;
+            provide?: import("vue").ComponentProvideOptions | undefined;
+            inject?: {} | string[] | undefined;
+            filters?: Record<string, Function> | undefined;
+            mixins?: any[] | undefined;
+            extends?: any;
+            beforeCreate?: (() => void) | undefined;
+            created?: (() => void) | undefined;
+            beforeMount?: (() => void) | undefined;
+            mounted?: (() => void) | undefined;
+            beforeUpdate?: (() => void) | undefined;
+            updated?: (() => void) | undefined;
+            activated?: (() => void) | undefined;
+            deactivated?: (() => void) | undefined;
+            beforeDestroy?: (() => void) | undefined;
+            beforeUnmount?: (() => void) | undefined;
+            destroyed?: (() => void) | undefined;
+            unmounted?: (() => void) | undefined;
+            renderTracked?: ((e: import("vue").DebuggerEvent) => void) | undefined;
+            renderTriggered?: ((e: import("vue").DebuggerEvent) => void) | undefined;
+            errorCaptured?: ((err: unknown, instance: import("vue").ComponentPublicInstance<{}, {}, {}, {}, {}, {}, {}, {}, false, import("vue").ComponentOptionsBase<any, any, any, any, any, any, any, any, any, {}, {}, string, {}, {}, {}, string, import("vue").ComponentProvideOptions>, {}, {}, "", {}, any> | null, info: string) => boolean | void) | undefined;
+            delimiters?: [string, string] | undefined;
+            __differentiator?: string | number | symbol | undefined;
+            __isBuiltIn?: boolean | undefined;
+            __file?: string | undefined;
+            __name?: string | undefined;
+            i18n?: {
+                locale?: string | undefined;
+                fallbackLocale?: string | false | string[] | {
+                    [x: string]: string[];
+                } | undefined;
+                messages?: {
+                    [x: string]: import("@intlify/core-base").LocaleMessage<import("vue-i18n").VueMessageType>;
+                } | undefined;
+                flatJson?: boolean | undefined;
+                datetimeFormats?: {
+                    [x: string]: import("vue-i18n").IntlDateTimeFormat;
+                } | undefined;
+                numberFormats?: {
+                    [x: string]: import("vue-i18n").IntlNumberFormat;
+                } | undefined;
+                availableLocales?: string[] | undefined;
+                modifiers?: import("vue-i18n").LinkedModifiers<import("vue-i18n").VueMessageType> | undefined;
+                formatter?: {
+                    interpolate: (message: string, values: any, path: string) => any[] | null;
+                } | undefined;
+                missing?: import("vue-i18n").MissingHandler | undefined;
+                fallbackRoot?: boolean | undefined;
+                silentTranslationWarn?: boolean | RegExp | undefined;
+                silentFallbackWarn?: boolean | RegExp | undefined;
+                formatFallbackMessages?: boolean | undefined;
+                preserveDirectiveContent?: boolean | undefined;
+                warnHtmlInMessage?: import("vue-i18n").WarnHtmlInMessageLevel | undefined;
+                escapeParameterHtml?: boolean | undefined;
+                sharedMessages?: import("vue-i18n").LocaleMessages<import("vue-i18n").VueMessageType> | undefined;
+                pluralizationRules?: import("@intlify/core-base").PluralizationRules | undefined;
+                postTranslation?: import("vue-i18n").PostTranslationHandler<import("vue-i18n").VueMessageType> | undefined;
+                sync?: boolean | undefined;
+                messageResolver?: import("vue-i18n").MessageResolver | undefined;
+            } | undefined;
+            __i18n?: {
+                locale: string;
+                resource: import("vue-i18n").LocaleMessages<import("vue-i18n").VueMessageType>;
+            }[] | undefined;
+            __INTLIFY_META__?: string | undefined;
+        };
+        props?: Record<string, unknown> | undefined;
+        size: {
+            width: number;
+            height: number;
+        };
+        position?: {
+            x: number;
+            y: number;
+        } | undefined;
+    } | null, IDashboardWidget | {
+        id: string;
+        name?: string | undefined;
+        component: import("vue").FunctionalComponent<any, {}, any, {}> | {
+            new (...args: any[]): any;
+            __isFragment?: undefined;
+            __isTeleport?: undefined;
+            __isSuspense?: undefined;
+        } | {
+            [x: string]: any;
+            setup?: ((this: void, props: import("@vue/shared").LooseRequired<any>, ctx: {
+                attrs: {
+                    [x: string]: unknown;
+                };
+                slots: Readonly<{
+                    [name: string]: import("vue").Slot<any> | undefined;
+                }>;
+                emit: ((event: unknown, ...args: any[]) => void) | ((event: string, ...args: any[]) => void);
+                expose: <Exposed extends Record<string, any> = Record<string, any>>(exposed?: Exposed | undefined) => void;
+            }) => any) | undefined;
+            name?: string | undefined;
+            template?: string | object | undefined;
+            render?: Function | undefined;
+            components?: Record<string, import("vue").Component<any, any, any, import("vue").ComputedOptions, import("vue").MethodOptions, {}, any>> | undefined;
+            directives?: Record<string, import("vue").Directive<any, any, string, string>> | undefined;
+            inheritAttrs?: boolean | undefined;
+            emits?: any;
+            slots?: {} | undefined;
+            expose?: string[] | undefined;
+            serverPrefetch?: (() => void | Promise<any>) | undefined;
+            compilerOptions?: {
+                isCustomElement?: ((tag: string) => boolean) | undefined;
+                whitespace?: "preserve" | "condense" | undefined;
+                comments?: boolean | undefined;
+                delimiters?: [string, string] | undefined;
+            } | undefined;
+            call?: ((this: unknown, ...args: unknown[]) => never) | undefined;
+            __isFragment?: undefined;
+            __isTeleport?: undefined;
+            __isSuspense?: undefined;
+            __defaults?: {} | undefined;
+            compatConfig?: {
+                GLOBAL_MOUNT?: boolean | "suppress-warning" | undefined;
+                GLOBAL_MOUNT_CONTAINER?: boolean | "suppress-warning" | undefined;
+                GLOBAL_EXTEND?: boolean | "suppress-warning" | undefined;
+                GLOBAL_PROTOTYPE?: boolean | "suppress-warning" | undefined;
+                GLOBAL_SET?: boolean | "suppress-warning" | undefined;
+                GLOBAL_DELETE?: boolean | "suppress-warning" | undefined;
+                GLOBAL_OBSERVABLE?: boolean | "suppress-warning" | undefined;
+                GLOBAL_PRIVATE_UTIL?: boolean | "suppress-warning" | undefined;
+                CONFIG_SILENT?: boolean | "suppress-warning" | undefined;
+                CONFIG_DEVTOOLS?: boolean | "suppress-warning" | undefined;
+                CONFIG_KEY_CODES?: boolean | "suppress-warning" | undefined;
+                CONFIG_PRODUCTION_TIP?: boolean | "suppress-warning" | undefined;
+                CONFIG_IGNORED_ELEMENTS?: boolean | "suppress-warning" | undefined;
+                CONFIG_WHITESPACE?: boolean | "suppress-warning" | undefined;
+                CONFIG_OPTION_MERGE_STRATS?: boolean | "suppress-warning" | undefined;
+                INSTANCE_SET?: boolean | "suppress-warning" | undefined;
+                INSTANCE_DELETE?: boolean | "suppress-warning" | undefined;
+                INSTANCE_DESTROY?: boolean | "suppress-warning" | undefined;
+                INSTANCE_EVENT_EMITTER?: boolean | "suppress-warning" | undefined;
+                INSTANCE_EVENT_HOOKS?: boolean | "suppress-warning" | undefined;
+                INSTANCE_CHILDREN?: boolean | "suppress-warning" | undefined;
+                INSTANCE_LISTENERS?: boolean | "suppress-warning" | undefined;
+                INSTANCE_SCOPED_SLOTS?: boolean | "suppress-warning" | undefined;
+                INSTANCE_ATTRS_CLASS_STYLE?: boolean | "suppress-warning" | undefined;
+                OPTIONS_DATA_FN?: boolean | "suppress-warning" | undefined;
+                OPTIONS_DATA_MERGE?: boolean | "suppress-warning" | undefined;
+                OPTIONS_BEFORE_DESTROY?: boolean | "suppress-warning" | undefined;
+                OPTIONS_DESTROYED?: boolean | "suppress-warning" | undefined;
+                WATCH_ARRAY?: boolean | "suppress-warning" | undefined;
+                PROPS_DEFAULT_THIS?: boolean | "suppress-warning" | undefined;
+                V_ON_KEYCODE_MODIFIER?: boolean | "suppress-warning" | undefined;
+                CUSTOM_DIR?: boolean | "suppress-warning" | undefined;
+                ATTR_FALSE_VALUE?: boolean | "suppress-warning" | undefined;
+                ATTR_ENUMERATED_COERCION?: boolean | "suppress-warning" | undefined;
+                TRANSITION_CLASSES?: boolean | "suppress-warning" | undefined;
+                TRANSITION_GROUP_ROOT?: boolean | "suppress-warning" | undefined;
+                COMPONENT_ASYNC?: boolean | "suppress-warning" | undefined;
+                COMPONENT_FUNCTIONAL?: boolean | "suppress-warning" | undefined;
+                COMPONENT_V_MODEL?: boolean | "suppress-warning" | undefined;
+                RENDER_FUNCTION?: boolean | "suppress-warning" | undefined;
+                FILTERS?: boolean | "suppress-warning" | undefined;
+                PRIVATE_APIS?: boolean | "suppress-warning" | undefined;
+                MODE?: 2 | 3 | ((comp: import("vue").Component<any, any, any, import("vue").ComputedOptions, import("vue").MethodOptions, {}, any> | null) => 2 | 3) | undefined;
+            } | undefined;
+            data?: ((this: any, vm: any) => any) | undefined;
+            computed?: import("vue").ComputedOptions | undefined;
+            methods?: import("vue").MethodOptions | undefined;
+            watch?: {
+                [x: string]: (string | import("vue").WatchCallback | ({
+                    handler: string | import("vue").WatchCallback;
+                } & import("vue").WatchOptions<boolean>)) | (string | import("vue").WatchCallback | ({
+                    handler: string | import("vue").WatchCallback;
+                } & import("vue").WatchOptions<boolean>))[];
+            } | undefined;
+            provide?: import("vue").ComponentProvideOptions | undefined;
+            inject?: {} | string[] | undefined;
+            filters?: Record<string, Function> | undefined;
+            mixins?: any[] | undefined;
+            extends?: any;
+            beforeCreate?: (() => void) | undefined;
+            created?: (() => void) | undefined;
+            beforeMount?: (() => void) | undefined;
+            mounted?: (() => void) | undefined;
+            beforeUpdate?: (() => void) | undefined;
+            updated?: (() => void) | undefined;
+            activated?: (() => void) | undefined;
+            deactivated?: (() => void) | undefined;
+            beforeDestroy?: (() => void) | undefined;
+            beforeUnmount?: (() => void) | undefined;
+            destroyed?: (() => void) | undefined;
+            unmounted?: (() => void) | undefined;
+            renderTracked?: ((e: import("vue").DebuggerEvent) => void) | undefined;
+            renderTriggered?: ((e: import("vue").DebuggerEvent) => void) | undefined;
+            errorCaptured?: ((err: unknown, instance: import("vue").ComponentPublicInstance<{}, {}, {}, {}, {}, {}, {}, {}, false, import("vue").ComponentOptionsBase<any, any, any, any, any, any, any, any, any, {}, {}, string, {}, {}, {}, string, import("vue").ComponentProvideOptions>, {}, {}, "", {}, any> | null, info: string) => boolean | void) | undefined;
+            delimiters?: [string, string] | undefined;
+            __differentiator?: string | number | symbol | undefined;
+            __isBuiltIn?: boolean | undefined;
+            __file?: string | undefined;
+            __name?: string | undefined;
+            i18n?: {
+                locale?: string | undefined;
+                fallbackLocale?: string | false | string[] | {
+                    [x: string]: string[];
+                } | undefined;
+                messages?: {
+                    [x: string]: import("@intlify/core-base").LocaleMessage<import("vue-i18n").VueMessageType>;
+                } | undefined;
+                flatJson?: boolean | undefined;
+                datetimeFormats?: {
+                    [x: string]: import("vue-i18n").IntlDateTimeFormat;
+                } | undefined;
+                numberFormats?: {
+                    [x: string]: import("vue-i18n").IntlNumberFormat;
+                } | undefined;
+                availableLocales?: string[] | undefined;
+                modifiers?: import("vue-i18n").LinkedModifiers<import("vue-i18n").VueMessageType> | undefined;
+                formatter?: {
+                    interpolate: (message: string, values: any, path: string) => any[] | null;
+                } | undefined;
+                missing?: import("vue-i18n").MissingHandler | undefined;
+                fallbackRoot?: boolean | undefined;
+                silentTranslationWarn?: boolean | RegExp | undefined;
+                silentFallbackWarn?: boolean | RegExp | undefined;
+                formatFallbackMessages?: boolean | undefined;
+                preserveDirectiveContent?: boolean | undefined;
+                warnHtmlInMessage?: import("vue-i18n").WarnHtmlInMessageLevel | undefined;
+                escapeParameterHtml?: boolean | undefined;
+                sharedMessages?: import("vue-i18n").LocaleMessages<import("vue-i18n").VueMessageType> | undefined;
+                pluralizationRules?: import("@intlify/core-base").PluralizationRules | undefined;
+                postTranslation?: import("vue-i18n").PostTranslationHandler<import("vue-i18n").VueMessageType> | undefined;
+                sync?: boolean | undefined;
+                messageResolver?: import("vue-i18n").MessageResolver | undefined;
+            } | undefined;
+            __i18n?: {
+                locale: string;
+                resource: import("vue-i18n").LocaleMessages<import("vue-i18n").VueMessageType>;
+            }[] | undefined;
+            __INTLIFY_META__?: string | undefined;
+        };
+        props?: Record<string, unknown> | undefined;
+        size: {
+            width: number;
+            height: number;
+        };
+        position?: {
+            x: number;
+            y: number;
+        } | undefined;
+    } | null>;
+    previewPosition: import("vue").Ref<{
+        x: number;
+        y: number;
+    } | null, DashboardWidgetPosition | {
+        x: number;
+        y: number;
+    } | null>;
+    displacedWidgets: import("vue").Ref<Map<string, {
+        x: number;
+        y: number;
+    }> & Omit<Map<string, DashboardWidgetPosition>, keyof Map<any, any>>, Map<string, DashboardWidgetPosition> | (Map<string, {
+        x: number;
+        y: number;
+    }> & Omit<Map<string, DashboardWidgetPosition>, keyof Map<any, any>>)>;
+    isDragging: import("vue").Ref<boolean, boolean>;
+    handleMouseDown: (event: MouseEvent | TouchEvent, widget: IDashboardWidget, element: HTMLElement) => void;
+    setGridContainer: (container: HTMLElement) => void;
+    isWidgetDisplaced: (widgetId: string) => boolean;
+    getDisplacedPosition: (widgetId: string) => {
+        x: number;
+        y: number;
+    } | undefined;
+};
+//# sourceMappingURL=useDashboardDragAndDrop.d.ts.map

package/dist/shared/components/draggable-dashboard/composables/useDashboardDragAndDrop.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"useDashboardDragAndDrop.d.ts","sourceRoot":"","sources":["../../../../../shared/components/draggable-dashboard/composables/useDashboardDragAndDrop.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,gBAAgB,EAAE,uBAAuB,EAAE,MAAM,UAAU,CAAC;AAY1E;;;;;;;;GAQG;AACH,wBAAgB,uBAAuB,CACrC,oBAAoB,EAAE,CAAC,QAAQ,EAAE,MAAM,EAAE,QAAQ,EAAE,uBAAuB,KAAK,IAAI,EACnF,WAAW,CAAC,EAAE,MAAM,MAAM;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;6BA0NM,UAAU,GAAG,UAAU,UAAU,gBAAgB,WAAW,WAAW;kCAgFlE,WAAW;;;;;;EAmBjD"}

package/dist/shared/components/draggable-dashboard/composables/useDashboardGrid.d.ts

@@ -0,0 +1,20 @@
+import type { IDashboardWidget } from "../types";
+/**
+ * Main composable for managing the dashboard
+ *
+ * Combines functionality for working with the grid, widget placement, and layout persistence
+ *
+ * @returns An object with functions for working with the dashboard
+ */
+export declare function useDashboardGrid(): {
+    widgets: import("vue").ComputedRef<import("../../../../core/services/dashboard-service").DashboardWidget[]>;
+    layout: import("vue").ComputedRef<Map<string, import("../../../../core/services/dashboard-service").DashboardWidgetPosition>>;
+    GRID_COLUMNS: number;
+    getGridRows: () => number;
+    saveLayoutToLocalStorage: () => void;
+    loadLayoutFromLocalStorage: () => boolean;
+    arrangeWidgetsInRows: (widgetsToArrange: IDashboardWidget[]) => void;
+    initializeWithBuiltInPositions: () => boolean;
+    initializeLayout: () => void;
+};
+//# sourceMappingURL=useDashboardGrid.d.ts.map

package/dist/shared/components/draggable-dashboard/composables/useDashboardGrid.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"useDashboardGrid.d.ts","sourceRoot":"","sources":["../../../../../shared/components/draggable-dashboard/composables/useDashboardGrid.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,gBAAgB,EAA2B,MAAM,UAAU,CAAC;AAS1E;;;;;;GAMG;AACH,wBAAgB,gBAAgB;;;;uBAmBN,MAAM;oCAOO,IAAI;sCASF,OAAO;6CASE,gBAAgB,EAAE,KAAG,IAAI;0CAS9B,OAAO;4BAOrB,IAAI;EA0BlC"}

package/dist/shared/components/draggable-dashboard/composables/useDragClone.d.ts

@@ -0,0 +1,15 @@
+/**
+ * Composible for managing a widget clone during dragging
+ *
+ * Provides functions for creating, updating, and deleting a widget clone
+ * during dragging, as well as for animating the transition
+ *
+ * @returns An object with functions for working with the widget clone
+ */
+export declare function useDragClone(): {
+    dragClone: import("vue").Ref<HTMLElement | null, HTMLElement | null>;
+    createDragClone: (element: HTMLElement) => HTMLElement | null;
+    updateDragClonePosition: (deltaX: number, deltaY: number) => void;
+    removeDragClone: () => void;
+};
+//# sourceMappingURL=useDragClone.d.ts.map

package/dist/shared/components/draggable-dashboard/composables/useDragClone.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"useDragClone.d.ts","sourceRoot":"","sources":["../../../../../shared/components/draggable-dashboard/composables/useDragClone.ts"],"names":[],"mappings":"AAEA;;;;;;;GAOG;AACH,wBAAgB,YAAY;;+BAUQ,WAAW;sCAoDJ,MAAM,UAAU,MAAM;;EAwBhE"}

package/dist/shared/components/draggable-dashboard/composables/useEventCoordinates.d.ts

@@ -0,0 +1,33 @@
+/**
+ * Interface for event coordinates
+ */
+export interface EventCoordinates {
+    clientX: number;
+    clientY: number;
+}
+/**
+ * Composible for processing event coordinates
+ *
+ * Provides functions for getting coordinates from different types of events,
+ * tracking the initial position, and calculating the offset
+ *
+ * @returns An object with functions for working with event coordinates
+ */
+export declare function useEventCoordinates(): {
+    initialPosition: import("vue").Ref<{
+        clientX: number;
+        clientY: number;
+    }, EventCoordinates | {
+        clientX: number;
+        clientY: number;
+    }>;
+    isTouchDevice: import("vue").Ref<boolean, boolean>;
+    getEventCoordinates: (event: MouseEvent | TouchEvent) => EventCoordinates;
+    saveInitialPosition: (event: MouseEvent | TouchEvent) => void;
+    calculateDelta: (currentCoordinates: EventCoordinates) => {
+        deltaX: number;
+        deltaY: number;
+    };
+    hasMovedBeyondThreshold: (currentCoordinates: EventCoordinates, threshold?: number) => boolean;
+};
+//# sourceMappingURL=useEventCoordinates.d.ts.map

package/dist/shared/components/draggable-dashboard/composables/useEventCoordinates.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"useEventCoordinates.d.ts","sourceRoot":"","sources":["../../../../../shared/components/draggable-dashboard/composables/useEventCoordinates.ts"],"names":[],"mappings":"AAEA;;GAEG;AACH,MAAM,WAAW,gBAAgB;IAC/B,OAAO,EAAE,MAAM,CAAC;IAChB,OAAO,EAAE,MAAM,CAAC;CACjB;AAED;;;;;;;GAOG;AACH,wBAAgB,mBAAmB;;;;;;;;;iCAaG,UAAU,GAAG,UAAU,KAAG,gBAAgB;iCAsB1C,UAAU,GAAG,UAAU;yCAUf,gBAAgB;;;;kDAcP,gBAAgB;EAatE"}

package/dist/shared/components/draggable-dashboard/composables/useGridPosition.d.ts

@@ -0,0 +1,57 @@
+import type { DashboardWidgetPosition } from "../types";
+import type { EventCoordinates } from "./useEventCoordinates";
+/**
+ * Interface for the cell size
+ */
+export interface CellSize {
+    cellWidth: number;
+    cellHeight: number;
+}
+/**
+ * Interface for the drag offset
+ */
+export interface DragOffset {
+    x: number;
+    y: number;
+}
+/**
+ * Composible for calculating the position of a widget in the grid
+ *
+ * Provides functions for converting mouse coordinates to grid coordinates,
+ * considering the cell sizes, drag offset, and grid boundaries
+ *
+ * @param gridColumns The number of columns in the grid
+ * @param getGridRows The function for getting the number of rows in the grid
+ * @returns An object with functions for working with the grid position
+ */
+export declare function useGridPosition(gridColumns: number, getGridRows?: () => number): {
+    previewPosition: import("vue").Ref<{
+        x: number;
+        y: number;
+    } | null, DashboardWidgetPosition | {
+        x: number;
+        y: number;
+    } | null>;
+    dragOffset: import("vue").Ref<{
+        x: number;
+        y: number;
+    }, DragOffset | {
+        x: number;
+        y: number;
+    }>;
+    calculateDragOffset: (event: MouseEvent | TouchEvent, element: HTMLElement, cellSize: CellSize) => void;
+    mouseToGridCoordinates: (coords: EventCoordinates, containerRect: DOMRect, cellSize: CellSize, scrollOffset: {
+        left: number;
+        top: number;
+    }) => {
+        gridX: number;
+        gridY: number;
+    };
+    constrainToGrid: (gridX: number, gridY: number, widgetWidth: number, widgetHeight: number) => {
+        gridX: number;
+        gridY: number;
+    };
+    updatePreviewPosition: (position: DashboardWidgetPosition) => DashboardWidgetPosition;
+    resetPosition: () => void;
+};
+//# sourceMappingURL=useGridPosition.d.ts.map

package/dist/shared/components/draggable-dashboard/composables/useGridPosition.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"useGridPosition.d.ts","sourceRoot":"","sources":["../../../../../shared/components/draggable-dashboard/composables/useGridPosition.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAoB,uBAAuB,EAAE,MAAM,UAAU,CAAC;AAC1E,OAAO,KAAK,EAAE,gBAAgB,EAAE,MAAM,uBAAuB,CAAC;AAE9D;;GAEG;AACH,MAAM,WAAW,QAAQ;IACvB,SAAS,EAAE,MAAM,CAAC;IAClB,UAAU,EAAE,MAAM,CAAC;CACpB;AAED;;GAEG;AACH,MAAM,WAAW,UAAU;IACzB,CAAC,EAAE,MAAM,CAAC;IACV,CAAC,EAAE,MAAM,CAAC;CACX;AAED;;;;;;;;;GASG;AACH,wBAAgB,eAAe,CAAC,WAAW,EAAE,MAAM,EAAE,WAAW,CAAC,EAAE,MAAM,MAAM;;;;;;;;;;;;;;;iCAczC,UAAU,GAAG,UAAU,WAAW,WAAW,YAAY,QAAQ;qCA+B3F,gBAAgB,iBACT,OAAO,YACZ,QAAQ,gBACJ;QAAE,IAAI,EAAE,MAAM,CAAC;QAAC,KAAK,MAAM,CAAA;KAAE;eACjC,MAAM;eAAS,MAAM;;6BAsBxB,MAAM,SACN,MAAM,eACA,MAAM,gBACL,MAAM;eACV,MAAM;eAAS,MAAM;;sCAsBQ,uBAAuB,KAAG,uBAAuB;;EAsB3F"}

package/dist/shared/components/draggable-dashboard/composables/useGridSystem.d.ts

@@ -0,0 +1,22 @@
+import type { IDashboardWidget, DashboardWidgetPosition } from "../types";
+export declare const GRID_COLUMNS = 12;
+export declare const MIN_GRID_ROWS = 12;
+export declare const ROWS_BUFFER = 10;
+/**
+ * Hook for working with the dashboard grid
+ *
+ * Provides basic functions and constants for working with the grid
+ *
+ * @returns An object with functions and constants for working with the grid
+ */
+export declare function useGridSystem(): {
+    GRID_COLUMNS: number;
+    MIN_GRID_ROWS: number;
+    ROWS_BUFFER: number;
+    dynamicRows: import("vue").Ref<number, number>;
+    updateGridRows: (widgets: IDashboardWidget[], layout: Map<string, DashboardWidgetPosition>) => number;
+    hasCollision: (widget: IDashboardWidget, position: DashboardWidgetPosition, widgets: IDashboardWidget[], layout: Map<string, DashboardWidgetPosition>, excludeWidgetId?: string) => boolean;
+    isAreaFree: (x: number, y: number, width: number, height: number, occupiedCells: Set<string>) => boolean;
+    createOccupiedCellsMap: (widgets: IDashboardWidget[], layout: Map<string, DashboardWidgetPosition>, excludeWidgetId?: string) => Set<string>;
+};
+//# sourceMappingURL=useGridSystem.d.ts.map

package/dist/shared/components/draggable-dashboard/composables/useGridSystem.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"useGridSystem.d.ts","sourceRoot":"","sources":["../../../../../shared/components/draggable-dashboard/composables/useGridSystem.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,gBAAgB,EAAE,uBAAuB,EAAE,MAAM,UAAU,CAAC;AAG1E,eAAO,MAAM,YAAY,KAAK,CAAC;AAC/B,eAAO,MAAM,aAAa,KAAK,CAAC;AAChC,eAAO,MAAM,WAAW,KAAK,CAAC;AAE9B;;;;;;GAMG;AACH,wBAAgB,aAAa;;;;;8BAWM,gBAAgB,EAAE,UAAU,IAAI,MAAM,EAAE,uBAAuB,CAAC,KAAG,MAAM;2BA+BhG,gBAAgB,YACd,uBAAuB,WACxB,gBAAgB,EAAE,UACnB,IAAI,MAAM,EAAE,uBAAuB,CAAC,oBAC1B,MAAM,KACvB,OAAO;oBA+Ca,MAAM,KAAK,MAAM,SAAS,MAAM,UAAU,MAAM,iBAAiB,IAAI,MAAM,CAAC,KAAG,OAAO;sCAyBlG,gBAAgB,EAAE,UACnB,IAAI,MAAM,EAAE,uBAAuB,CAAC,oBAC1B,MAAM,KACvB,IAAI,MAAM,CAAC;EA+Bf"}

package/dist/shared/components/draggable-dashboard/composables/useLayoutPersistence.d.ts

@@ -0,0 +1,19 @@
+import type { DashboardWidgetPosition } from "../types";
+/**
+ * Hook for managing the saving and loading of the dashboard layout
+ *
+ * Provides functions for saving and loading the dashboard layout from localStorage
+ *
+ * @param storageKey The key for local storage
+ * @param updateCallback The function for updating the position of the widget
+ * @returns An object with functions for working with the saved layout
+ */
+export declare function useLayoutPersistence(storageKey: string, updateCallback: (widgetId: string, position: DashboardWidgetPosition) => void): {
+    saveLayout: (layout: Map<string, DashboardWidgetPosition>) => void;
+    loadLayout: <T extends {
+        id: string;
+    }>(widgets: T[]) => boolean;
+    clearSavedLayout: () => void;
+    hasSavedLayout: () => boolean;
+};
+//# sourceMappingURL=useLayoutPersistence.d.ts.map

package/dist/shared/components/draggable-dashboard/composables/useLayoutPersistence.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"useLayoutPersistence.d.ts","sourceRoot":"","sources":["../../../../../shared/components/draggable-dashboard/composables/useLayoutPersistence.ts"],"names":[],"mappings":"AACA,OAAO,KAAK,EAAE,uBAAuB,EAAE,MAAM,UAAU,CAAC;AAExD;;;;;;;;GAQG;AACH,wBAAgB,oBAAoB,CAClC,UAAU,EAAE,MAAM,EAClB,cAAc,EAAE,CAAC,QAAQ,EAAE,MAAM,EAAE,QAAQ,EAAE,uBAAuB,KAAK,IAAI;yBAUjD,IAAI,MAAM,EAAE,uBAAuB,CAAC,KAAG,IAAI;;YAsBnC,MAAM;wBAAmB,OAAO;4BAyBvC,IAAI;0BAON,OAAO;EAUnC"}

package/dist/shared/components/draggable-dashboard/composables/useResizeObserver.d.ts

@@ -0,0 +1,18 @@
+/**
+ * Hook for managing ResizeObserver
+ *
+ * Provides functionality for tracking changes in the sizes of elements
+ *
+ * @param callback The function called when the sizes change
+ * @param options Options
+ * @returns An object with methods for working with ResizeObserver
+ */
+export declare function useResizeObserver(callback: (entries: ResizeObserverEntry[]) => void, options?: {
+    debounceMs?: number;
+}): {
+    observe: (element: Element) => void;
+    unobserve: (element: Element) => void;
+    disconnect: () => void;
+    isSupported: boolean;
+};
+//# sourceMappingURL=useResizeObserver.d.ts.map

package/dist/shared/components/draggable-dashboard/composables/useResizeObserver.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"useResizeObserver.d.ts","sourceRoot":"","sources":["../../../../../shared/components/draggable-dashboard/composables/useResizeObserver.ts"],"names":[],"mappings":"AAEA;;;;;;;;GAQG;AACH,wBAAgB,iBAAiB,CAC/B,QAAQ,EAAE,CAAC,OAAO,EAAE,mBAAmB,EAAE,KAAK,IAAI,EAClD,OAAO,CAAC,EAAE;IACR,UAAU,CAAC,EAAE,MAAM,CAAC;CACrB;uBAuCyB,OAAO;yBAiBL,OAAO;;;EAiCpC"}