@witchcraft/layout 0.0.4 → 0.0.6

package/dist/runtime/drag/CloseAction.d.ts

@@ -0,0 +1,33 @@
+import type { DragState, IDragAction } from "./types.js";
+import { getCloseFrameInfo } from "../layout/getCloseFrameInfo.js";
+import type { CloseDeco } from "../types/index.js";
+import type { KnownError } from "../utils/KnownError.js";
+export type CloseInfo = Exclude<ReturnType<typeof getCloseFrameInfo>, KnownError>;
+export declare class CloseAction implements IDragAction {
+    name: "close";
+    state: {
+        allowed: true;
+        force: boolean;
+        res: CloseInfo;
+        cacheKey: string | undefined;
+    } | {
+        allowed: false;
+        force: boolean;
+        res: CloseInfo | undefined;
+        cacheKey: string | undefined;
+    };
+    handleEvent: (e: PointerEvent | KeyboardEvent, state: DragState) => boolean | "force";
+    updateCloseDecos: (decos: CloseDeco[]) => void;
+    hooks: {
+        onStart?: (active: boolean) => void;
+        onCancel?: () => void;
+        onError?: (e: KnownError) => void;
+    };
+    constructor(handleEvent: CloseAction["handleEvent"], updateCloseDecos: CloseAction["updateCloseDecos"], hooks?: CloseAction["hooks"]);
+    reset(): void;
+    updateDecos(state: DragState): void;
+    canHandleRequest(e: PointerEvent | KeyboardEvent, state: DragState): boolean;
+    onDragChange(_type: "start" | "end" | "move", _e: PointerEvent | undefined, state: DragState): boolean;
+    onDragApply(state: DragState): boolean;
+    cancel(): void;
+}

package/dist/runtime/drag/DragActionHandler.d.ts

@@ -0,0 +1,42 @@
+import type { RecordFromArray } from "@alanscodelog/utils";
+import type { DragChangeHandler, DragState, IDragAction } from "./types.js";
+/**
+ * Handles the lifecycle of a drag actions {@link IDragAction} and provides additional hooks.
+ *
+ * The first action instance that can handle the request is passed control of the event handlers until the request changes.
+ */
+export declare class DragActionHandler<TRawDragActions extends IDragAction[], TDragActions extends RecordFromArray<TRawDragActions, "name"> = RecordFromArray<TRawDragActions, "name">> {
+    activeAction?: keyof TDragActions;
+    actions: TDragActions;
+    eventCanceller: (() => void) | undefined;
+    boundCancel: () => void;
+    defaultOnDragChange: DragChangeHandler;
+    hooks: {
+        /** Called while dragging during dragChange events. You can use this to update the dragging edges. */
+        onRecalculate?: () => void;
+        /**
+         * Called before searching for a matching action. Useful for re-initializing state.
+         *
+         * Is passed a `cancel` function if you want to cancel the current drag action.
+         */
+        onEvent?: (e: PointerEvent | KeyboardEvent | undefined, cancel: () => void) => void;
+        /** Called when the action requested changes. */
+        onRequestChange?: (type: keyof TDragActions | undefined) => void;
+        /** Called when the drag action ends either because it was completed or cancelled. */
+        onEnd?: (context: {
+            cancelled: boolean;
+            applied: boolean;
+        }) => void;
+    };
+    constructor(
+    /**
+     * Default onDragChange handler for when no action can handle the request.
+     *
+     * Should return true to allow the edges to be moved, or false to prevent it.
+     */
+    defaultOnDragChange: DragChangeHandler, actions: TRawDragActions, hooks?: DragActionHandler<TRawDragActions, TDragActions>["hooks"]);
+    eventHandler(e: KeyboardEvent | PointerEvent, state: DragState, forceRecalculateEdges: () => void): undefined;
+    onDragChange<T extends "start" | "move" | "end">(type: T, e: T extends "end" ? PointerEvent | undefined : PointerEvent, state: DragState, forceRecalculateEdges: () => void, cancel?: () => void): boolean | undefined;
+    onDragApply(state: DragState, forceRecalculateEdges: () => void): boolean;
+    cancel(): void;
+}

package/dist/runtime/drag/DragDirectionStore.d.ts

@@ -0,0 +1,20 @@
+import type { Direction, Orientation, Point } from "../types/index.js";
+export declare class DragDirectionStore {
+    hooks: {
+        onUpdate: (directions: Record<Orientation, Direction | undefined>) => void;
+    };
+    constructor(hooks: DragDirectionStore["hooks"]);
+    lastPoint: Point | undefined;
+    dragDirection: Record<Orientation, Direction | undefined>;
+    lesser: {
+        x: Direction;
+        y: Direction;
+    };
+    greater: {
+        x: Direction;
+        y: Direction;
+    };
+    reset(): void;
+    update(point: Point): boolean;
+    getDragDirection(coord: "x" | "y", point: Point): Direction | false;
+}

package/dist/runtime/drag/SplitAction.d.ts

@@ -0,0 +1,32 @@
+import type { DragState, IDragAction } from "./types.js";
+import { getFrameSplitInfo } from "../layout/getFrameSplitInfo.js";
+import type { SplitDeco } from "../types/index.js";
+import type { KnownError } from "../utils/KnownError.js";
+export type SplitInfo = Exclude<ReturnType<typeof getFrameSplitInfo>, KnownError>;
+export declare class SplitAction implements IDragAction {
+    name: "split";
+    state: {
+        allowed: false;
+        res: SplitInfo | undefined;
+        cacheKey: string | undefined;
+    } | {
+        allowed: true;
+        res: SplitInfo;
+        cacheKey: string | undefined;
+    };
+    handleEvent: (e: PointerEvent | KeyboardEvent, state: DragState) => boolean;
+    updateSplitDecos: (decos: SplitDeco[]) => void;
+    hooks: {
+        onStart?: () => void;
+        onCancel?: () => void;
+        onError?: (e: KnownError) => void;
+    };
+    constructor(handleEvent: SplitAction["handleEvent"], updateSplitDecos: SplitAction["updateSplitDecos"], hooks?: SplitAction["hooks"]);
+    reset(): void;
+    updateDecos(state: DragState): void;
+    canHandleRequest(e: PointerEvent | KeyboardEvent, state: DragState): boolean;
+    calculateSplitRequest(state: DragState): boolean;
+    onDragChange(_type: "start" | "end" | "move", _e: PointerEvent | undefined, state: DragState): true;
+    onDragApply(state: DragState): boolean;
+    cancel(): void;
+}

package/dist/runtime/drag/types.d.ts

@@ -0,0 +1,92 @@
+import type { Direction, Edge, IntersectionEntry, LayoutFrame, LayoutWindow, Orientation, Point } from "../types/index.js";
+export type DragState = {
+    /** The current directions in the corresponding orientations that the user is dragging in. */
+    dragDirections: Record<Orientation, Direction | undefined>;
+    /** The curren point (in scaled window coordinates) the user is dragging at. */
+    dragPoint?: Point;
+    /** Whether the user is currently dragging. Is true during all drag events. */
+    isDragging: boolean;
+    /**
+     * The edges that are currently being dragged. There are multiple edges if they drag an intersection since what's actually happening is we're just dragging the closest horizontal and vertical edges.
+     */
+    draggingEdges: Edge[];
+    /**
+     * The intersection that is currently being dragged.
+     */
+    draggingIntersection?: IntersectionEntry;
+    /** The "visual" edges that can be displayed for dragging. See {@link getVisualEdges} */
+    visualEdges: Edge[];
+    /**
+     * The frames touching the currently dragged edges. Each entry corresponds to the frames touching the corresponding dragging edge.
+     *
+     * So you can use the index in draggingEdges to get the corresponding frames.
+     */
+    touchingFrames: Record<string, LayoutFrame>[];
+    /**
+     * Same as touchingFrames, but with the frames in an array.
+     */
+    touchingFramesArrays: LayoutFrame[][];
+    /**
+     * All the frames, with/without the currently dragged frames depending on if `showDragging` is true.
+     */
+    frames: Record<string, LayoutFrame>;
+    /**
+     * The frame that is currently being hovered over (according to whether `dragPoint` in in the frame or not).
+     */
+    dragHoveredFrame: LayoutFrame | undefined;
+    /**
+     * A list of corner intersections. Frames can also be dragged by these.
+     */
+    intersections: IntersectionEntry[];
+    /**
+     * Whether the drag was initiated from a point along the window edge.
+     */
+    isDraggingFromWindowEdge: boolean;
+    win: LayoutWindow;
+};
+/**
+ * Note that the return type only affects the `move` event but is also typed as `boolean` for other events for ease of use.
+ */
+export interface DragChangeHandler {
+    <T extends "start" | "move" | "end">(type: T, e: T extends "end" ? PointerEvent | undefined : PointerEvent, state: DragState, forceRecalculateEdges: () => void, cancel: () => void): boolean | undefined;
+}
+/**
+ * A drag action describes when and how to handle a drag event.
+ *
+ * For example, there are the default split/close actions that can be triggered in certain situations. This could be when holding down a modifier or key, or some other condition (e.g. the user is dragging a specific edge).
+ *
+ * Each action should handle it's configuration and saving/caching any state it needs. See {@link SplitAction} and {@link CloseAction} for examples.
+ */
+export interface IDragAction {
+    /** A unique name for your action. */
+    name: string;
+    /**
+     * 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;
+    /**
+     *
+     * Is called after `onDragChange("end")` with the same event. Might not be called if the request was cancelled.
+     *
+     * You should apply your action if possible and return whether it was applied.
+     *
+     * This is also a good place to reset your state.
+     */
+    onDragApply: (state: DragState, forceRecalculateEdges: () => void) => boolean;
+    /**
+     * Should return true if it should handle the "request"/event (e.g. some modifier is being pressed => user is requesting x action).
+     *
+     * The user is not necessarily dragging at this point, though they might also change actions mid drag. So it does not necessarily mean the event is allowed.
+     *
+     * Here is where you should initiate your state. Don't allow the action by default unless it can always be allowed.
+     */
+    canHandleRequest(e: KeyboardEvent | PointerEvent, state: DragState, forceRecalculateEdges: () => void): boolean;
+    /**
+     * Called when a user cancels the drag action.
+     *
+     * You should reset your state here.
+     */
+    cancel(): void;
+}

package/dist/runtime/helpers/addPointsToIntersection.d.ts

@@ -0,0 +1,2 @@
+import type { Intersections, Point } from "../types/index.js";
+export declare function addPointsToIntersection(intersections: Intersections, points: Point[]): void;

package/dist/runtime/helpers/assertEdgeSorted.d.ts

@@ -0,0 +1,2 @@
+import type { Edge } from "../types/index.js";
+export declare function assertEdgeSorted(edge: Edge): void;

package/dist/runtime/helpers/assertItemIn.d.ts

@@ -0,0 +1 @@
+export declare function assertItemIn<T extends Record<string, any>>(entries: T, id: keyof T | string | undefined): asserts id is keyof T;

package/dist/runtime/helpers/assertItemNotIn.d.ts

@@ -0,0 +1 @@
+export declare function assertItemNotIn(entries: Record<string, any>, id: string | undefined): void;

package/dist/runtime/helpers/assertLayoutHasActiveWindow.d.ts

@@ -0,0 +1,4 @@
+import type { Layout } from "../types/index.js";
+export declare function assertLayoutHasActiveWindow(layout: Layout): asserts layout is Omit<Layout, "activeWindow"> & {
+    activeWindow: NonNullable<Layout["activeWindow"]>;
+};

package/dist/runtime/helpers/assertValidWinAndFrame.d.ts

@@ -0,0 +1,5 @@
+import type { Layout, LayoutFrame, LayoutWindow } from "../types/index.js";
+export declare function assertValidWinAndFrame(layout: Layout, win?: LayoutWindow, frame?: LayoutFrame): {
+    win: LayoutWindow;
+    frame: LayoutFrame;
+};

package/dist/runtime/helpers/assertValidWinAndFrameIds.d.ts

@@ -0,0 +1,2 @@
+import type { FrameId, LayoutWindows, WindowId } from "../types/index.js";
+export declare function assertValidWinAndFrameIds(windows: LayoutWindows, winId?: WindowId, frameId?: FrameId): void;

package/dist/runtime/helpers/assertWindowHasActiveFrame.d.ts

@@ -0,0 +1,4 @@
+import type { LayoutWindow } from "../types/index.js";
+export declare function assertWindowHasActiveFrame(win: LayoutWindow): asserts win is Omit<LayoutWindow, "activeFrame"> & {
+    activeFrame: NonNullable<LayoutWindow["activeFrame"]>;
+};

package/dist/runtime/helpers/clampNumber.d.ts

@@ -0,0 +1 @@
+export declare function clampNumber(num: number, lowerLimit: number, upperLimit: number): number;

package/dist/runtime/helpers/cloneFrame.d.ts

@@ -0,0 +1,2 @@
+import type { LayoutFrame } from "../types/index.js";
+export declare function cloneFrame(frame: LayoutFrame): LayoutFrame;

package/dist/runtime/helpers/cloneFrames.d.ts

@@ -0,0 +1,2 @@
+import type { LayoutFrame } from "../types/index.js";
+export declare function cloneFrames<T extends Record<string, LayoutFrame> | LayoutFrame[]>(frames: T): T;

package/dist/runtime/helpers/containsEdge.d.ts

@@ -0,0 +1,2 @@
+import type { Edge, Orientation } from "../types/index.js";
+export declare function containsEdge(edge: Edge, limitEdge: Edge, dir?: Orientation): boolean;

package/dist/runtime/helpers/convertLayoutWindowToWorkspace.d.ts

@@ -0,0 +1,2 @@
+import type { LayoutWindow, Workspace } from "../types/index.js";
+export declare function convertLayoutWindowToWorkspace(layout: LayoutWindow | Workspace): Workspace;

package/dist/runtime/helpers/copySize.d.ts

@@ -0,0 +1,2 @@
+import type { Size } from "../types/index.js";
+export declare function copySize<TFrom extends Size, TTo extends Size>(from: TFrom, to: TTo): TTo;

package/dist/runtime/helpers/createEdge.d.ts

@@ -0,0 +1,5 @@
+import type { Edge } from "../types/index.js";
+/**
+ * Ensures the edge given is sorted (start < end coordinates). Mutates given edge if it's not.
+ */
+export declare function createEdge(edge: Edge): Edge;

package/dist/runtime/helpers/dirToOrientation.d.ts

@@ -0,0 +1,2 @@
+import type { Direction, Orientation } from "../types/index.js";
+export declare function dirToOrientation(dir: Direction): Orientation;

package/dist/runtime/helpers/dirToSide.d.ts

@@ -0,0 +1,2 @@
+import type { Direction, EdgeSide } from "../types/index.js";
+export declare function dirToSide<T extends Direction>(dir: T): T extends "up" ? "top" : T extends "down" ? "bottom" : T extends "left" | "right" ? T : EdgeSide;

package/dist/runtime/helpers/doEdgesOverlap.d.ts

@@ -0,0 +1,2 @@
+import type { Edge, Orientation } from "../types/index.js";
+export declare function doEdgesOverlap(edgeA: Edge, edgeB: Edge, dir?: Orientation): boolean;

package/dist/runtime/helpers/doesEdgeContinueEdge.d.ts

@@ -0,0 +1,2 @@
+import type { Edge, Orientation } from "../types/index.js";
+export declare function doesEdgeContinueEdge(edgeA: Edge, edgeB: Edge, dir?: Orientation): boolean;

package/dist/runtime/helpers/edgeToPoints.d.ts

@@ -0,0 +1,2 @@
+import type { Edge, Point } from "../types/index.js";
+export declare function edgeToPoints(edge: Edge): Point[];

package/dist/runtime/helpers/findDraggableEdge.d.ts

@@ -0,0 +1,4 @@
+import type { Edge, Orientation } from "../types/index.js";
+export declare function findDraggableEdge(edge: Edge, edges: Edge[], 
+/** Whether the edge must match exactly and does not "contain/touch" another frame. */
+exact?: boolean, edgeOrientation?: Orientation): Edge | undefined;

package/dist/runtime/helpers/findFrameDraggableEdges.d.ts

@@ -0,0 +1,7 @@
+import type { Edge, EdgeSide, LayoutFrame } from "../types/index.js";
+export declare function findFrameDraggableEdges(frame: LayoutFrame, edges: Edge[], 
+/** See {@link findDraggableEdge} */
+exact?: boolean, sides?: EdgeSide[]): {
+    edge: Edge;
+    side: EdgeSide;
+}[] | undefined;

package/dist/runtime/helpers/frameToEdges.d.ts

@@ -0,0 +1,2 @@
+import type { Edge, EdgeSide, LayoutFrame } from "../types/index.js";
+export declare function frameToEdges(frame: LayoutFrame, sides?: EdgeSide[]): Record<EdgeSide, Edge>;

package/dist/runtime/helpers/frameToPoints.d.ts

@@ -0,0 +1,19 @@
+import type { LayoutFrame } from "../types/index.js";
+export declare function frameToPoints(frame: LayoutFrame): {
+    tl: {
+        x: number;
+        y: number;
+    };
+    tr: {
+        x: number;
+        y: number;
+    };
+    bl: {
+        x: number;
+        y: number;
+    };
+    br: {
+        x: number;
+        y: number;
+    };
+};

package/dist/runtime/helpers/getEdgeOrientation.d.ts

@@ -0,0 +1,2 @@
+import type { Edge, Orientation } from "../types/index.js";
+export declare function getEdgeOrientation(edge: Edge): Orientation;

package/dist/runtime/helpers/getEdgeSharedDirection.d.ts

@@ -0,0 +1,2 @@
+import type { Edge } from "../types/index.js";
+export declare function getEdgeSharedDirection(edgeA: Edge, edgeB: Edge): false | "horizontal" | "vertical";

package/dist/runtime/helpers/getEdgeSide.d.ts

@@ -0,0 +1,2 @@
+import type { Edge, EdgeSide, LayoutFrame } from "../types/index.js";
+export declare function getEdgeSide<T extends boolean = false>(frame: LayoutFrame, edge: Edge, allowNone?: T): EdgeSide | (T extends true ? undefined : never);

package/dist/runtime/helpers/getFrameById.d.ts

@@ -0,0 +1,2 @@
+import type { FrameId, LayoutFrame, LayoutWindow } from "../types/index.js";
+export declare function getFrameById<T extends boolean = false>(win: LayoutWindow, frameId: FrameId, assert?: T): T extends true ? LayoutFrame : LayoutFrame | undefined;

package/dist/runtime/helpers/getFrameConstant.d.ts

@@ -0,0 +1,2 @@
+import type { LayoutWindow } from "../types/index.js";
+export declare function getFrameConstant<T extends boolean = false>(win: LayoutWindow, constant: "ACTIVE" | string, assert?: T): T extends true ? string : string | undefined;

package/dist/runtime/helpers/getIntersections.d.ts

@@ -0,0 +1,2 @@
+import type { Edge, IntersectionEntry } from "../types/index.js";
+export declare function getIntersections(visualEdges: Edge[]): IntersectionEntry[];

package/dist/runtime/helpers/getIntersectionsCss.d.ts

@@ -0,0 +1,9 @@
+import type { IntersectionEntry, PointCss } from "../types/index.js";
+export declare function getIntersectionsCss(entries: IntersectionEntry[], { intersectionWidth, 
+/** How much to shift the intersections by when it's not on a four corner intersection. Otherwise it tends to look ugly because it overlaps one of the frame edges, this shifts it away from it. */
+shiftAmount }?: {
+    intersectionWidth?: string;
+    shiftAmount?: string;
+}): (PointCss & {
+    _shifted?: true;
+})[];

package/dist/runtime/helpers/getMoveEdgeInfo.d.ts

@@ -0,0 +1,11 @@
+import type { Direction, Edge, LayoutFrame, Point, Size } from "../types/index.js";
+export declare function getMoveEdgeInfo(touchingFrames: LayoutFrame[], edge: Edge, 
+/** Window scaled/snaped position. See {@link toWindowCoord} */
+position: Point, margin?: Size, clamp?: boolean): {
+    x: number;
+    y: number;
+    dir: Direction;
+    isPassedLimit: boolean;
+    pos: number;
+    distance: number;
+};

package/dist/runtime/helpers/getResizeLimit.d.ts

@@ -0,0 +1,2 @@
+import type { Edge, ExtendedDirection, LayoutFrame } from "../types/index.js";
+export declare function getResizeLimit<TDir extends ExtendedDirection>(edge: Edge, touchingFrames: LayoutFrame[], dir: TDir, amount: number, margin: number): TDir extends "horizontal" ? Record<"left" | "right", number> : TDir extends "vertical" ? Record<"up" | "down", number> : number;

package/dist/runtime/helpers/getShapeSquareCss.d.ts

@@ -0,0 +1,7 @@
+import type { BaseSquare } from "../types/index.js";
+export declare function getShapeSquareCss(obj: BaseSquare, pad?: string): {
+    x: string;
+    y: string;
+    width: string;
+    height: string;
+};

package/dist/runtime/helpers/getSideTouching.d.ts

@@ -0,0 +1,2 @@
+import type { EdgeSide, LayoutFrame } from "../types/index.js";
+export declare function getSideTouching(frameA: LayoutFrame, frameB: LayoutFrame): EdgeSide | undefined;

package/dist/runtime/helpers/getVisualEdgeCss.d.ts

@@ -0,0 +1,7 @@
+import type { Edge, EdgeCss } from "../types/index.js";
+export declare function getVisualEdgeCss(edge: Edge, { translate, edgeWidth, padLongAxis, padShortAxis }?: {
+    translate?: boolean;
+    edgeWidth?: string;
+    padLongAxis?: string;
+    padShortAxis?: string;
+}): EdgeCss;

package/dist/runtime/helpers/getVisualEdges.d.ts

@@ -0,0 +1,48 @@
+import type { Edge, LayoutFrame, Orientation } from "../types/index.js";
+/**
+ * Returns the "visual" edges that can be dragged.
+ *
+ * Visual edges are a combination of all edges shared by frames that must be moved together.
+ *
+ * For example, if we have two frames A and B, they share the center edge, and the function would return this single edge (unless `includeWindowEdges` is true).
+ *
+ * ```
+ * ┌──┰──┐
+ * │A ┃B │ returns   ┃
+ * └──┸──┘
+ * ```
+ * Or in this example, we would get two edges:
+ * - The one shared by A, B, and C, because no frame edge sharing this edge can without also moving the other frames touching the edge.
+ * - The one shared by A and B.
+ *```
+ * ┌──┰──┐
+ * │A ┃C │              ┃
+ * ┝━━┫  │ returns   ━━ ┃
+ * │B ┃  │              ┃
+ * └──┸──┘
+ * ```
+ *
+ * And here, we get four edges, because all four can be moved on their own (moving the edge would only affect the two frames sharing that edge).
+ *```
+ * ┌──┰──┐
+ * │A ┃C │             ┃
+ * ┝━━╋━━┥ returns   ━━ ━━
+ * │B ┃D │             ┃
+ * └──┸──┘
+ * ```
+ *
+ */
+export declare function getVisualEdges<T extends boolean = false>(frames: LayoutFrame[], { separateByDir, includeWindowEdges }?: {
+    /**
+     * Whether the result is separated into horizontal/vertical edges or not.
+     *
+     * @default false
+     */
+    separateByDir?: T;
+    /**
+     * Whether to include edges along the window edges.
+     *
+     * @default false
+     */
+    includeWindowEdges?: boolean;
+}): T extends true ? Record<Orientation, Edge[]> : Edge[];

package/dist/runtime/helpers/getVisualEdgesCss.d.ts

@@ -0,0 +1,3 @@
+import { getVisualEdgeCss } from "./getVisualEdgeCss.js";
+import type { Edge, EdgeCss } from "../types/index.js";
+export declare function getVisualEdgesCss(edges: Edge[], opts?: Parameters<typeof getVisualEdgeCss>[1]): EdgeCss[];

package/dist/runtime/helpers/getWinAndFrameById.d.ts

@@ -0,0 +1,10 @@
+import type { AnyUuid, FrameId, Layout, LayoutFrame, LayoutWindow, WindowId } from "../types/index.js";
+export declare function getWinAndFrameById<T extends boolean = false>(layout: Layout, 
+/** winId can be undefined only if frameId is a uuid */
+winId: WindowId | undefined, frameId: AnyUuid | FrameId, assert?: T): T extends true ? {
+    win: LayoutWindow;
+    frame: LayoutFrame;
+} : {
+    win?: LayoutWindow;
+    frame?: LayoutFrame;
+};

package/dist/runtime/helpers/getWinByFrameUuid.d.ts

@@ -0,0 +1,2 @@
+import type { AnyUuid, Layout, LayoutWindow } from "../types/index.js";
+export declare function getWinByFrameUuid<T extends boolean = false>(layout: Layout, frameId: AnyUuid, assert?: T): T extends true ? LayoutWindow : LayoutWindow | undefined;

package/dist/runtime/helpers/getWinById.d.ts

@@ -0,0 +1,2 @@
+import type { Layout, LayoutWindow, WindowId } from "../types/index.js";
+export declare function getWinById<T extends boolean = false>(layout: Layout, winId: WindowId, assert?: T): T extends true ? LayoutWindow : LayoutWindow | undefined;

package/dist/runtime/helpers/getWindowConstant.d.ts

@@ -0,0 +1,2 @@
+import type { Layout } from "../types/index.js";
+export declare function getWindowConstant<T extends boolean = false>(layout: Layout, constant: "ACTIVE" | string | undefined, assert?: T): T extends true ? string : string | undefined;

package/dist/runtime/helpers/inRange.d.ts

@@ -0,0 +1 @@
+export declare function inRange(coord: number, lowerLimit: number, upperLimit: number, inclusive?: boolean): boolean;

package/dist/runtime/helpers/index.d.ts

@@ -0,0 +1,62 @@
+export { addPointsToIntersection } from "./addPointsToIntersection.js";
+export { assertEdgeSorted } from "./assertEdgeSorted.js";
+export { assertItemIn } from "./assertItemIn.js";
+export { assertItemNotIn } from "./assertItemNotIn.js";
+export { assertLayoutHasActiveWindow } from "./assertLayoutHasActiveWindow.js";
+export { assertValidWinAndFrame } from "./assertValidWinAndFrame.js";
+export { assertValidWinAndFrameIds } from "./assertValidWinAndFrameIds.js";
+export { assertWindowHasActiveFrame } from "./assertWindowHasActiveFrame.js";
+export { clampNumber } from "./clampNumber.js";
+export { cloneFrame } from "./cloneFrame.js";
+export { cloneFrames } from "./cloneFrames.js";
+export { containsEdge } from "./containsEdge.js";
+export { convertLayoutWindowToWorkspace } from "./convertLayoutWindowToWorkspace.js";
+export { copySize } from "./copySize.js";
+export { createEdge } from "./createEdge.js";
+export { dirToOrientation } from "./dirToOrientation.js";
+export { dirToSide } from "./dirToSide.js";
+export { doEdgesOverlap } from "./doEdgesOverlap.js";
+export { doesEdgeContinueEdge } from "./doesEdgeContinueEdge.js";
+export { edgeToPoints } from "./edgeToPoints.js";
+export { findDraggableEdge } from "./findDraggableEdge.js";
+export { findFrameDraggableEdges } from "./findFrameDraggableEdges.js";
+export { frameToEdges } from "./frameToEdges.js";
+export { frameToPoints } from "./frameToPoints.js";
+export { getEdgeOrientation } from "./getEdgeOrientation.js";
+export { getEdgeSharedDirection } from "./getEdgeSharedDirection.js";
+export { getEdgeSide } from "./getEdgeSide.js";
+export { getFrameById } from "./getFrameById.js";
+export { getFrameConstant } from "./getFrameConstant.js";
+export { getIntersections } from "./getIntersections.js";
+export { getIntersectionsCss } from "./getIntersectionsCss.js";
+export { getMoveEdgeInfo } from "./getMoveEdgeInfo.js";
+export { getResizeLimit } from "./getResizeLimit.js";
+export { getShapeSquareCss } from "./getShapeSquareCss.js";
+export { getSideTouching } from "./getSideTouching.js";
+export { getVisualEdgeCss } from "./getVisualEdgeCss.js";
+export { getVisualEdges } from "./getVisualEdges.js";
+export { getVisualEdgesCss } from "./getVisualEdgesCss.js";
+export { getWinAndFrameById } from "./getWinAndFrameById.js";
+export { getWinByFrameUuid } from "./getWinByFrameUuid.js";
+export { getWinById } from "./getWinById.js";
+export { getWindowConstant } from "./getWindowConstant.js";
+export { inRange } from "./inRange.js";
+export { isEdgeEqual } from "./isEdgeEqual.js";
+export { isEdgeParallel } from "./isEdgeParallel.js";
+export { isPointEqual } from "./isPointEqual.js";
+export { isSizeAboveMin } from "./isSizeAboveMin.js";
+export { isSizeEqual } from "./isSizeEqual.js";
+export { isWindowEdge } from "./isWindowEdge.js";
+export { isWindowEdgePoint } from "./isWindowEdgePoint.js";
+export { moveEdge } from "./moveEdge.js";
+export { numberToScaledPercent } from "./numberToScaledPercent.js";
+export { numberToScaledSize } from "./numberToScaledSize.js";
+export { oppositeSide } from "./oppositeSide.js";
+export { resizeByEdge } from "./resizeByEdge.js";
+export { sideToDirection } from "./sideToDirection.js";
+export { sideToOrientation } from "./sideToOrientation.js";
+export { splitEdge } from "./splitEdge.js";
+export { toCoord } from "./toCoord.js";
+export { toId } from "./toId.js";
+export { toWindowCoord } from "./toWindowCoord.js";
+export { unionEdges } from "./unionEdges.js";

package/dist/runtime/helpers/isEdgeEqual.d.ts

@@ -0,0 +1,2 @@
+import type { Edge, Orientation } from "../types/index.js";
+export declare function isEdgeEqual(edgeA: Edge, edgeB: Edge, orientation?: Orientation): boolean;

package/dist/runtime/helpers/isEdgeParallel.d.ts

@@ -0,0 +1,2 @@
+import type { Edge, Orientation } from "../types/index.js";
+export declare function isEdgeParallel(edgeA: Edge, edgeB: Edge, dir?: Orientation): boolean;

package/dist/runtime/helpers/isPointEqual.d.ts

@@ -0,0 +1,2 @@
+import type { Point } from "../types/index.js";
+export declare function isPointEqual(pointA: Point, pointB: Point): boolean;

package/dist/runtime/helpers/isSizeAboveMin.d.ts

@@ -0,0 +1,2 @@
+import type { Size } from "../types/index.js";
+export declare function isSizeAboveMin(size: Size, min: Size): boolean;

package/dist/runtime/helpers/isSizeEqual.d.ts

@@ -0,0 +1,2 @@
+import type { Size } from "../types/index.js";
+export declare function isSizeEqual(sizeA: Size, sizeB: Size): boolean;

package/dist/runtime/helpers/isWindowEdge.d.ts

@@ -0,0 +1,2 @@
+import type { Edge, Orientation } from "../types/index.js";
+export declare function isWindowEdge(edge: Edge, edgeDirection?: Orientation): boolean;

package/dist/runtime/helpers/isWindowEdgePoint.d.ts

@@ -0,0 +1,2 @@
+import type { Point } from "../types/index.js";
+export declare function isWindowEdgePoint(point: Point): boolean;

package/dist/runtime/helpers/moveEdge.d.ts

@@ -0,0 +1,4 @@
+import type { Edge, LayoutFrame, Point, Size } from "../types/index.js";
+export declare function moveEdge(touchingFrames: LayoutFrame[] | undefined, edge: Edge | undefined, 
+/** Window scaled/snaped position. See {@link toWindowCoord} */
+position: Point, margin?: Size): void;