@witchcraft/layout 0.0.5 → 0.0.6

package/dist/module.json

@@ -1,7 +1,7 @@
 {
   "name": "@witchcraft/layout",
   "configKey": "witchcraftLayout",
-  "version": "0.0.5",
+  "version": "0.0.6",
   "builder": {
     "@nuxt/module-builder": "1.0.2",
     "unbuild": "unknown"

package/dist/runtime/components/LayoutDecos.d.vue.ts

@@ -0,0 +1,8 @@
+import { type CloseDeco, type LayoutFrames, type SplitDeco } from "../types/index.js";
+type __VLS_Props = {
+    frames: LayoutFrames;
+    splitDecos: SplitDeco[];
+    closeDecos: CloseDeco[];
+};
+declare const _default: import("vue").DefineComponent<__VLS_Props, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<__VLS_Props> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
+export default _default;

package/dist/runtime/components/LayoutDecos.vue.d.ts

@@ -0,0 +1,8 @@
+import { type CloseDeco, type LayoutFrames, type SplitDeco } from "../types/index.js";
+type __VLS_Props = {
+    frames: LayoutFrames;
+    splitDecos: SplitDeco[];
+    closeDecos: CloseDeco[];
+};
+declare const _default: import("vue").DefineComponent<__VLS_Props, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<__VLS_Props> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
+export default _default;

package/dist/runtime/components/LayoutEdges.d.vue.ts

@@ -0,0 +1,27 @@
+import { type Edge, type IntersectionEntry, type LayoutFrame, type LayoutWindow } from "../types/index.js";
+type __VLS_Props = {
+    edges: Edge[];
+    intersections: IntersectionEntry[];
+    /** The owning window, needed so we can correctly scale coordinates. */
+    win: LayoutWindow;
+    /** The active frame, used to render the active edges. Calculate it from the `frames` returned by `useFrames` composable because otherwise it will be the wrong size while dragging. */
+    activeFrame?: LayoutFrame;
+    draggingEdge?: Edge;
+    draggingIntersection?: IntersectionEntry;
+};
+declare const _default: import("vue").DefineComponent<__VLS_Props, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
+    dragStart: (e: PointerEvent, args_1: {
+        edge?: Edge;
+        intersection?: IntersectionEntry;
+    }) => any;
+}, string, import("vue").PublicProps, Readonly<__VLS_Props> & Readonly<{
+    onDragStart?: ((e: PointerEvent, args_1: {
+        edge?: Edge;
+        intersection?: IntersectionEntry;
+    }) => any) | undefined;
+}>, {
+    activeFrame: LayoutFrame;
+    draggingEdge: Edge;
+    draggingIntersection: IntersectionEntry;
+}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
+export default _default;

package/dist/runtime/components/LayoutEdges.vue.d.ts

@@ -0,0 +1,27 @@
+import { type Edge, type IntersectionEntry, type LayoutFrame, type LayoutWindow } from "../types/index.js";
+type __VLS_Props = {
+    edges: Edge[];
+    intersections: IntersectionEntry[];
+    /** The owning window, needed so we can correctly scale coordinates. */
+    win: LayoutWindow;
+    /** The active frame, used to render the active edges. Calculate it from the `frames` returned by `useFrames` composable because otherwise it will be the wrong size while dragging. */
+    activeFrame?: LayoutFrame;
+    draggingEdge?: Edge;
+    draggingIntersection?: IntersectionEntry;
+};
+declare const _default: import("vue").DefineComponent<__VLS_Props, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
+    dragStart: (e: PointerEvent, args_1: {
+        edge?: Edge;
+        intersection?: IntersectionEntry;
+    }) => any;
+}, string, import("vue").PublicProps, Readonly<__VLS_Props> & Readonly<{
+    onDragStart?: ((e: PointerEvent, args_1: {
+        edge?: Edge;
+        intersection?: IntersectionEntry;
+    }) => any) | undefined;
+}>, {
+    activeFrame: LayoutFrame;
+    draggingEdge: Edge;
+    draggingIntersection: IntersectionEntry;
+}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
+export default _default;

package/dist/runtime/components/LayoutFrame.d.vue.ts

@@ -0,0 +1,36 @@
+import { type PropType } from "vue";
+import { type LayoutFrame } from "../types/index.js";
+declare var __VLS_8: {};
+type __VLS_Slots = {} & {
+    default?: (props: typeof __VLS_8) => any;
+};
+declare const __VLS_component: import("vue").DefineComponent<import("vue").ExtractPropTypes<{
+    frame: {
+        type: PropType<LayoutFrame>;
+        required: true;
+    };
+    isActiveFrame: {
+        type: BooleanConstructor;
+        required: true;
+    };
+}>, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {} & {
+    focus: () => any;
+}, string, import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
+    frame: {
+        type: PropType<LayoutFrame>;
+        required: true;
+    };
+    isActiveFrame: {
+        type: BooleanConstructor;
+        required: true;
+    };
+}>> & Readonly<{
+    onFocus?: (() => any) | undefined;
+}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
+declare const _default: __VLS_WithSlots<typeof __VLS_component, __VLS_Slots>;
+export default _default;
+type __VLS_WithSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};

package/dist/runtime/components/LayoutFrame.vue.d.ts

@@ -0,0 +1,36 @@
+import { type PropType } from "vue";
+import { type LayoutFrame } from "../types/index.js";
+declare var __VLS_8: {};
+type __VLS_Slots = {} & {
+    default?: (props: typeof __VLS_8) => any;
+};
+declare const __VLS_component: import("vue").DefineComponent<import("vue").ExtractPropTypes<{
+    frame: {
+        type: PropType<LayoutFrame>;
+        required: true;
+    };
+    isActiveFrame: {
+        type: BooleanConstructor;
+        required: true;
+    };
+}>, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {} & {
+    focus: () => any;
+}, string, import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
+    frame: {
+        type: PropType<LayoutFrame>;
+        required: true;
+    };
+    isActiveFrame: {
+        type: BooleanConstructor;
+        required: true;
+    };
+}>> & Readonly<{
+    onFocus?: (() => any) | undefined;
+}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
+declare const _default: __VLS_WithSlots<typeof __VLS_component, __VLS_Slots>;
+export default _default;
+type __VLS_WithSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};

package/dist/runtime/components/LayoutShapeSquare.d.vue.ts

@@ -0,0 +1,36 @@
+import { type PropType } from "vue";
+import type { BaseSquareCss } from "../types/index.js";
+declare var __VLS_1: {};
+type __VLS_Slots = {} & {
+    default?: (props: typeof __VLS_1) => any;
+};
+declare const __VLS_component: import("vue").DefineComponent<import("vue").ExtractPropTypes<{
+    style: {
+        type: StringConstructor;
+        required: false;
+        default: string;
+    };
+    css: {
+        type: PropType<BaseSquareCss>;
+        required: true;
+    };
+}>, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
+    style: {
+        type: StringConstructor;
+        required: false;
+        default: string;
+    };
+    css: {
+        type: PropType<BaseSquareCss>;
+        required: true;
+    };
+}>> & Readonly<{}>, {
+    style: string;
+}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
+declare const _default: __VLS_WithSlots<typeof __VLS_component, __VLS_Slots>;
+export default _default;
+type __VLS_WithSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};

package/dist/runtime/components/LayoutShapeSquare.vue.d.ts

@@ -0,0 +1,36 @@
+import { type PropType } from "vue";
+import type { BaseSquareCss } from "../types/index.js";
+declare var __VLS_1: {};
+type __VLS_Slots = {} & {
+    default?: (props: typeof __VLS_1) => any;
+};
+declare const __VLS_component: import("vue").DefineComponent<import("vue").ExtractPropTypes<{
+    style: {
+        type: StringConstructor;
+        required: false;
+        default: string;
+    };
+    css: {
+        type: PropType<BaseSquareCss>;
+        required: true;
+    };
+}>, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<import("vue").ExtractPropTypes<{
+    style: {
+        type: StringConstructor;
+        required: false;
+        default: string;
+    };
+    css: {
+        type: PropType<BaseSquareCss>;
+        required: true;
+    };
+}>> & Readonly<{}>, {
+    style: string;
+}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
+declare const _default: __VLS_WithSlots<typeof __VLS_component, __VLS_Slots>;
+export default _default;
+type __VLS_WithSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};

package/dist/runtime/components/LayoutWindow.d.vue.ts

@@ -0,0 +1,108 @@
+import { type DragState, type IDragAction } from "../drag/types.js";
+import { type LayoutWindow } from "../types/index.js";
+type __VLS_Props = {
+    additionalDragActions?: IDragAction[];
+    splitKeyHandler?: (e: PointerEvent | KeyboardEvent, state: DragState) => boolean;
+    closeKeyHandler?: (e: PointerEvent | KeyboardEvent, state: DragState) => boolean;
+    usageInstructions?: Record<string, string | undefined>;
+    instructionsTeleportTo: string | undefined;
+    /**
+     * You might need to temporarily disable updating the window size while transitioning, depending on your layout.
+     *
+     * For example, if the component is in a flex container, during transition, there will be two components, and it will suddenly jump in size to being 1/2 the height. We can avoid this by using the known height (from win), but to do so, we can't let this component update the size while transitioning.
+     *
+     * When this is turned back on again, it will trigger an update. You can also trigger updates manually with the exposed updateWindowSize function.
+     */
+    allowWindowSizeUpdate?: boolean;
+};
+declare function updateWindowSize(): void;
+type __VLS_PublicProps = __VLS_Props & {
+    "win": LayoutWindow;
+};
+declare var __VLS_9: any, __VLS_10: {
+    frame: any;
+}, __VLS_22: {};
+type __VLS_Slots = {} & {
+    [K in NonNullable<typeof __VLS_9>]?: (props: typeof __VLS_10) => any;
+} & {
+    'extra-decos'?: (props: typeof __VLS_22) => any;
+};
+declare const __VLS_component: import("vue").DefineComponent<__VLS_PublicProps, {
+    state: import("vue").ComputedRef<{
+        dragDirections: {
+            horizontal: "up" | "down" | "left" | "right" | undefined;
+            vertical: "up" | "down" | "left" | "right" | undefined;
+        };
+        dragPoint: {
+            x: number;
+            y: number;
+        } | undefined;
+        isDragging: boolean;
+        draggingEdges: {
+            startX: number;
+            startY: number;
+            endX: number;
+            endY: number;
+        }[];
+        draggingIntersection: {
+            point: {
+                x: number;
+                y: number;
+            };
+            count: number;
+            sharesEdge: boolean;
+            sharedEdges: {
+                horizontal: {
+                    startX: number;
+                    startY: number;
+                    endX: number;
+                    endY: number;
+                }[];
+                vertical: {
+                    startX: number;
+                    startY: number;
+                    endX: number;
+                    endY: number;
+                }[];
+            };
+            isWindowEdge: boolean;
+        } | undefined;
+        visualEdges: {
+            startX: number;
+            startY: number;
+            endX: number;
+            endY: number;
+        }[];
+        touchingFrames: Record<string, import("../types/index.js").LayoutFrame>[];
+        touchingFramesArrays: import("../types/index.js").LayoutFrame[][];
+        frames: import("../types/index.js").LayoutFrames;
+        dragHoveredFrame: import("../types/index.js").LayoutFrame | undefined;
+        intersections: import("../types/index.js").IntersectionEntry[];
+        isDraggingFromWindowEdge: boolean;
+        win: import("../types/index.js").BaseLayoutWindow;
+    }>;
+    win: import("vue").ModelRef<import("../types/index.js").BaseLayoutWindow, string, import("../types/index.js").BaseLayoutWindow, import("../types/index.js").BaseLayoutWindow>;
+    updateWindowSize: typeof updateWindowSize;
+}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
+    "update:win": (value: import("../types/index.js").BaseLayoutWindow) => any;
+} & {
+    isShowingDrag: (value: boolean) => any;
+    dragState: (value: DragState) => any;
+}, string, import("vue").PublicProps, Readonly<__VLS_PublicProps> & Readonly<{
+    onIsShowingDrag?: ((value: boolean) => any) | undefined;
+    onDragState?: ((value: DragState) => any) | undefined;
+    "onUpdate:win"?: ((value: import("../types/index.js").BaseLayoutWindow) => any) | undefined;
+}>, {
+    additionalDragActions: IDragAction[];
+    splitKeyHandler: (e: PointerEvent | KeyboardEvent, state: DragState) => boolean;
+    closeKeyHandler: (e: PointerEvent | KeyboardEvent, state: DragState) => boolean;
+    usageInstructions: Record<string, string | undefined>;
+    allowWindowSizeUpdate: boolean;
+}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
+declare const _default: __VLS_WithSlots<typeof __VLS_component, __VLS_Slots>;
+export default _default;
+type __VLS_WithSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};

package/dist/runtime/components/LayoutWindow.vue.d.ts

@@ -0,0 +1,108 @@
+import { type DragState, type IDragAction } from "../drag/types.js";
+import { type LayoutWindow } from "../types/index.js";
+type __VLS_Props = {
+    additionalDragActions?: IDragAction[];
+    splitKeyHandler?: (e: PointerEvent | KeyboardEvent, state: DragState) => boolean;
+    closeKeyHandler?: (e: PointerEvent | KeyboardEvent, state: DragState) => boolean;
+    usageInstructions?: Record<string, string | undefined>;
+    instructionsTeleportTo: string | undefined;
+    /**
+     * You might need to temporarily disable updating the window size while transitioning, depending on your layout.
+     *
+     * For example, if the component is in a flex container, during transition, there will be two components, and it will suddenly jump in size to being 1/2 the height. We can avoid this by using the known height (from win), but to do so, we can't let this component update the size while transitioning.
+     *
+     * When this is turned back on again, it will trigger an update. You can also trigger updates manually with the exposed updateWindowSize function.
+     */
+    allowWindowSizeUpdate?: boolean;
+};
+declare function updateWindowSize(): void;
+type __VLS_PublicProps = __VLS_Props & {
+    "win": LayoutWindow;
+};
+declare var __VLS_9: any, __VLS_10: {
+    frame: any;
+}, __VLS_22: {};
+type __VLS_Slots = {} & {
+    [K in NonNullable<typeof __VLS_9>]?: (props: typeof __VLS_10) => any;
+} & {
+    'extra-decos'?: (props: typeof __VLS_22) => any;
+};
+declare const __VLS_component: import("vue").DefineComponent<__VLS_PublicProps, {
+    state: import("vue").ComputedRef<{
+        dragDirections: {
+            horizontal: "up" | "down" | "left" | "right" | undefined;
+            vertical: "up" | "down" | "left" | "right" | undefined;
+        };
+        dragPoint: {
+            x: number;
+            y: number;
+        } | undefined;
+        isDragging: boolean;
+        draggingEdges: {
+            startX: number;
+            startY: number;
+            endX: number;
+            endY: number;
+        }[];
+        draggingIntersection: {
+            point: {
+                x: number;
+                y: number;
+            };
+            count: number;
+            sharesEdge: boolean;
+            sharedEdges: {
+                horizontal: {
+                    startX: number;
+                    startY: number;
+                    endX: number;
+                    endY: number;
+                }[];
+                vertical: {
+                    startX: number;
+                    startY: number;
+                    endX: number;
+                    endY: number;
+                }[];
+            };
+            isWindowEdge: boolean;
+        } | undefined;
+        visualEdges: {
+            startX: number;
+            startY: number;
+            endX: number;
+            endY: number;
+        }[];
+        touchingFrames: Record<string, import("../types/index.js").LayoutFrame>[];
+        touchingFramesArrays: import("../types/index.js").LayoutFrame[][];
+        frames: import("../types/index.js").LayoutFrames;
+        dragHoveredFrame: import("../types/index.js").LayoutFrame | undefined;
+        intersections: import("../types/index.js").IntersectionEntry[];
+        isDraggingFromWindowEdge: boolean;
+        win: import("../types/index.js").BaseLayoutWindow;
+    }>;
+    win: import("vue").ModelRef<import("../types/index.js").BaseLayoutWindow, string, import("../types/index.js").BaseLayoutWindow, import("../types/index.js").BaseLayoutWindow>;
+    updateWindowSize: typeof updateWindowSize;
+}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {
+    "update:win": (value: import("../types/index.js").BaseLayoutWindow) => any;
+} & {
+    isShowingDrag: (value: boolean) => any;
+    dragState: (value: DragState) => any;
+}, string, import("vue").PublicProps, Readonly<__VLS_PublicProps> & Readonly<{
+    onIsShowingDrag?: ((value: boolean) => any) | undefined;
+    onDragState?: ((value: DragState) => any) | undefined;
+    "onUpdate:win"?: ((value: import("../types/index.js").BaseLayoutWindow) => any) | undefined;
+}>, {
+    additionalDragActions: IDragAction[];
+    splitKeyHandler: (e: PointerEvent | KeyboardEvent, state: DragState) => boolean;
+    closeKeyHandler: (e: PointerEvent | KeyboardEvent, state: DragState) => boolean;
+    usageInstructions: Record<string, string | undefined>;
+    allowWindowSizeUpdate: boolean;
+}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
+declare const _default: __VLS_WithSlots<typeof __VLS_component, __VLS_Slots>;
+export default _default;
+type __VLS_WithSlots<T, S> = T & {
+    new (): {
+        $slots: S;
+    };
+};

package/dist/runtime/composables/useFrames.d.ts

@@ -0,0 +1,180 @@
+import type { Ref } from "vue";
+import type { DragChangeHandler, DragState } from "../drag/types.js";
+import type { Edge, IntersectionEntry, LayoutFrame, LayoutWindow } from "../types/index.js";
+export declare function useFrames(win: Ref<LayoutWindow>, 
+/** Whether to show merged the moved frames while dragging. */
+showDragging: Ref<boolean>, handler: {
+    eventHandler: (e: KeyboardEvent, state: DragState, forceRecalculateEdges: () => void) => void;
+    /**
+        * Called when the drag coordinates change (during any event). Should return true to allow the edges to be moved, or false to prevent it.
+        *
+        * Can be used to save some context/info to later apply safely during onDragApply.
+        */
+    onDragChange: DragChangeHandler;
+    /**
+     * Called when drag will be applied. If dragEnd was called with apply false, it will not be called.
+     * Return false to not apply the regular drag end changes (i.e. return false to reset to the position before dragging).
+     */
+    onDragApply: ((state: DragState, forceRecalculateEdges: () => void) => boolean);
+}): {
+    dragStart: (e: PointerEvent, { edge, intersection }: {
+        edge?: Edge;
+        intersection?: IntersectionEntry;
+    }) => void;
+    dragEnd: (e?: PointerEvent, { apply }?: {
+        apply?: boolean;
+    }) => void;
+    cancel: () => void;
+    dragDirections: Ref<{
+        horizontal: "up" | "down" | "left" | "right" | undefined;
+        vertical: "up" | "down" | "left" | "right" | undefined;
+    }, Record<"horizontal" | "vertical", "up" | "down" | "left" | "right" | undefined> | {
+        horizontal: "up" | "down" | "left" | "right" | undefined;
+        vertical: "up" | "down" | "left" | "right" | undefined;
+    }>;
+    dragPoint: Ref<{
+        x: number;
+        y: number;
+    } | undefined, {
+        x: number;
+        y: number;
+    } | undefined>;
+    isDragging: Ref<boolean, boolean>;
+    draggingEdges: Ref<{
+        startX: number;
+        startY: number;
+        endX: number;
+        endY: number;
+    }[], {
+        startX: number;
+        startY: number;
+        endX: number;
+        endY: number;
+    }[] | {
+        startX: number;
+        startY: number;
+        endX: number;
+        endY: number;
+    }[]>;
+    draggingIntersection: Ref<{
+        point: {
+            x: number;
+            y: number;
+        };
+        count: number;
+        sharesEdge: boolean;
+        sharedEdges: {
+            horizontal: {
+                startX: number;
+                startY: number;
+                endX: number;
+                endY: number;
+            }[];
+            vertical: {
+                startX: number;
+                startY: number;
+                endX: number;
+                endY: number;
+            }[];
+        };
+        isWindowEdge: boolean;
+    } | undefined, IntersectionEntry | {
+        point: {
+            x: number;
+            y: number;
+        };
+        count: number;
+        sharesEdge: boolean;
+        sharedEdges: {
+            horizontal: {
+                startX: number;
+                startY: number;
+                endX: number;
+                endY: number;
+            }[];
+            vertical: {
+                startX: number;
+                startY: number;
+                endX: number;
+                endY: number;
+            }[];
+        };
+        isWindowEdge: boolean;
+    } | undefined>;
+    visualEdges: Ref<{
+        startX: number;
+        startY: number;
+        endX: number;
+        endY: number;
+    }[], {
+        startX: number;
+        startY: number;
+        endX: number;
+        endY: number;
+    }[] | {
+        startX: number;
+        startY: number;
+        endX: number;
+        endY: number;
+    }[]>;
+    touchingFrames: Ref<Record<string, LayoutFrame>[], Record<string, LayoutFrame>[]>;
+    touchingFramesArrays: import("vue").ComputedRef<LayoutFrame[][]>;
+    frames: import("vue").ComputedRef<import("../types/index.js").LayoutFrames>;
+    dragHoveredFrame: import("vue").ComputedRef<LayoutFrame | undefined>;
+    intersections: import("vue").ComputedRef<IntersectionEntry[]>;
+    isDraggingFromWindowEdge: Ref<boolean, boolean>;
+    forceRecalculateEdges: () => void;
+    state: import("vue").ComputedRef<{
+        dragDirections: {
+            horizontal: "up" | "down" | "left" | "right" | undefined;
+            vertical: "up" | "down" | "left" | "right" | undefined;
+        };
+        dragPoint: {
+            x: number;
+            y: number;
+        } | undefined;
+        isDragging: boolean;
+        draggingEdges: {
+            startX: number;
+            startY: number;
+            endX: number;
+            endY: number;
+        }[];
+        draggingIntersection: {
+            point: {
+                x: number;
+                y: number;
+            };
+            count: number;
+            sharesEdge: boolean;
+            sharedEdges: {
+                horizontal: {
+                    startX: number;
+                    startY: number;
+                    endX: number;
+                    endY: number;
+                }[];
+                vertical: {
+                    startX: number;
+                    startY: number;
+                    endX: number;
+                    endY: number;
+                }[];
+            };
+            isWindowEdge: boolean;
+        } | undefined;
+        visualEdges: {
+            startX: number;
+            startY: number;
+            endX: number;
+            endY: number;
+        }[];
+        touchingFrames: Record<string, LayoutFrame>[];
+        touchingFramesArrays: LayoutFrame[][];
+        frames: import("../types/index.js").LayoutFrames;
+        dragHoveredFrame: LayoutFrame | undefined;
+        intersections: IntersectionEntry[];
+        isDraggingFromWindowEdge: boolean;
+        win: import("../types/index.js").BaseLayoutWindow;
+    }>;
+};

package/dist/runtime/demo/App.d.vue.ts

@@ -0,0 +1,2 @@
+declare const _default: import("vue").DefineComponent<{}, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<{}> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
+export default _default;

package/dist/runtime/demo/App.vue.d.ts

@@ -0,0 +1,2 @@
+declare const _default: import("vue").DefineComponent<{}, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<{}> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, true, {}, any>;
+export default _default;

package/dist/runtime/demo/DemoControls.d.vue.ts

@@ -0,0 +1,6 @@
+import type { LayoutFrame } from "../types/index.js";
+type __VLS_Props = {
+    frames: LayoutFrame[];
+};
+declare const _default: import("vue").DefineComponent<__VLS_Props, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<__VLS_Props> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
+export default _default;

package/dist/runtime/demo/DemoControls.vue.d.ts

@@ -0,0 +1,6 @@
+import type { LayoutFrame } from "../types/index.js";
+type __VLS_Props = {
+    frames: LayoutFrame[];
+};
+declare const _default: import("vue").DefineComponent<__VLS_Props, {}, {}, {}, {}, import("vue").ComponentOptionsMixin, import("vue").ComponentOptionsMixin, {}, string, import("vue").PublicProps, Readonly<__VLS_Props> & Readonly<{}>, {}, {}, {}, {}, string, import("vue").ComponentProvideOptions, false, {}, any>;
+export default _default;

package/dist/runtime/demo/main.d.ts

@@ -0,0 +1,2 @@
+/** @private */
+import "./tailwind.css";

package/dist/runtime/demo/sharedLayoutInstance.d.ts

@@ -0,0 +1,6 @@
+export declare const app: {
+    layout: {
+        activeWindow?: string | undefined;
+        windows: import("../types/index.js").LayoutWindows;
+    };
+};

package/dist/runtime/demo/tailwind.css

@@ -1 +1 @@
-@import "tailwindcss" source("../");@import "../../../playground/.nuxt/witchcraft-ui.css";@import "../../../playground/.nuxt/witchcraft-layout.css";
+@import "tailwindcss";@import "../../../playground/.nuxt/witchcraft-ui.css";@import "../../../playground/.nuxt/witchcraft-layout.css";