@witchcraft/layout 0.0.4 → 0.0.6

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

@@ -0,0 +1,13 @@
+/**
+ * Given a number (e.g. the x coordinate in px), and the max value it could be (e.g. the max width of it's container in px), returns it's position as a scaled percentage.
+ *
+ * ```
+ * -----------
+ * |    *    |
+ * -----------
+ *      |    ^100px
+ *      ^ 50px
+ * // returns 50 / 100 * scale or 50000 (50%)
+ * ```
+ */
+export declare function numberToScaledPercent(num: number, max: number, scale?: number): number;

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

@@ -0,0 +1,2 @@
+import type { LayoutWindow, PxSize, Size } from "../types/index.js";
+export declare function numberToScaledSize(win: LayoutWindow, size: PxSize | number, scale?: number): Size;

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

@@ -0,0 +1,2 @@
+import type { Direction, EdgeSide, ExtendedDirection, ExtendedEdgeSide, Point, Size } from "../types/index.js";
+export declare function oppositeSide<T extends Direction | EdgeSide | ExtendedDirection | ExtendedEdgeSide | keyof Point | keyof Size>(dir: T): T;

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

@@ -0,0 +1,2 @@
+import type { Direction, Edge, LayoutFrame } from "../types/index.js";
+export declare function resizeByEdge(touchingFrames: LayoutFrame[], edge: Edge, dir: Direction, newPos: number, distance: number): void;

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

@@ -0,0 +1,3 @@
+import type { Direction, EdgeSide } from "../types/index.js";
+/** Converts a side to a direction (relative to a frame's center) */
+export declare function sideToDirection(side: EdgeSide): Direction;

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

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

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

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

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

@@ -0,0 +1,3 @@
+import type { HasOpposite } from "../types/index.js";
+/** Converts the given side/dir into a coordinate key (x/y) */
+export declare function toCoord<T extends HasOpposite>(dir: T): T extends "left" | "right" | "horizontal" ? "x" : "y";

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

@@ -0,0 +1,3 @@
+export declare function toId(item: {
+    id: string;
+} | string): string;

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

@@ -0,0 +1,2 @@
+import type { LayoutWindow, Point } from "../types/index.js";
+export declare function toWindowCoord(win: LayoutWindow, e: Pick<PointerEvent, "clientX" | "clientY">, snapAmount?: Point): Point;

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

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

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

@@ -0,0 +1,2 @@
+import type { LayoutWindow, PxPos, PxSize } from "../types/index.js";
+export declare function updateWindowWithEvent(win: LayoutWindow, event: PxPos & PxSize): void;

package/dist/runtime/index.d.ts

@@ -0,0 +1,5 @@
+export * from "./types/index.js";
+export * from "./layout/index.js";
+export * from "./helpers/index.js";
+export * from "./utils/KnownError.js";
+export * from "./settings.js";

package/dist/runtime/layout/closeFrame.d.ts

@@ -0,0 +1,5 @@
+import type { Direction, Edge, EdgeSide, LAYOUT_ERROR, LayoutFrame, LayoutWindow, Size } from "../types/index.js";
+import type { KnownError } from "../utils/KnownError.js";
+export declare function closeFrame<T extends "edge" | "dir">(win: LayoutWindow, visualEdges: Edge[], frame: LayoutFrame, 
+/** See {@link getCloseFrameInfo} */
+closeDirOrSide: (T extends "dir" ? Direction : EdgeSide), closeBy?: T, force?: boolean, minSize?: Size): LayoutFrame[] | KnownError<typeof LAYOUT_ERROR.CANT_CLOSE_NEARBY_FRAMES_TOO_SMALL | typeof LAYOUT_ERROR.CANT_CLOSE_NO_DRAG_EDGE | typeof LAYOUT_ERROR.CANT_CLOSE_SINGLE_FRAME | typeof LAYOUT_ERROR.CANT_CLOSE_WITHOUT_FORCE>;

package/dist/runtime/layout/closeFrames.d.ts

@@ -0,0 +1,2 @@
+import type { LayoutFrame, LayoutWindow } from "../types/index.js";
+export declare function closeFrames(win: LayoutWindow, deletedFrames: LayoutFrame[], modifiedFrames: LayoutFrame[]): void;

package/dist/runtime/layout/createSplitDecoEdge.d.ts

@@ -0,0 +1,2 @@
+import type { LayoutFrame, Point, RawSplitDeco, Size, SplitDecoShapes } from "../types/index.js";
+export declare function createSplitDecoEdge(frames: Record<string, LayoutFrame>, deco: RawSplitDeco, snapAmount?: Point, minSize?: Size): SplitDecoShapes;

package/dist/runtime/layout/createSplitDecoFromDrag.d.ts

@@ -0,0 +1,2 @@
+import type { Direction, LayoutFrame, Point, Size, SplitDeco } from "../types/index.js";
+export declare function createSplitDecoFromDrag(frames: Record<string, LayoutFrame>, frame: LayoutFrame, dragDirection: Direction, dragPoint: Point, snapAmount?: Point, minSize?: Size): SplitDeco;

package/dist/runtime/layout/debugFrame.d.ts

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

package/dist/runtime/layout/findFramesTouchingEdge.d.ts

@@ -0,0 +1,49 @@
+import type { Direction, Edge, EdgeSide, LayoutFrame, Point } from "../types/index.js";
+/**
+ * Given an edge or visualEdge (which might touch/contain several frame edges, see {@link getVisualEdges }), returns the frame edges that match the given criteria. If no criteria is given, just returns all touching frames.
+ *
+ * Useful, for implementing drag related features.
+ *
+ * A visual explanation of the options:
+ * ```
+ * frames (A,B,C,D):
+ * ┌──────────────────┐
+ * │A       ╏B        │
+ * │        ╏         │
+ * ├────────╏         │
+ * │C       ╏─────────┤
+ * │        ╏D        │
+ * │        ╏         │
+ * │      < ╏ > searchDirections
+ * │        ╏         │
+ * │     + referencePoint*
+ * │        ╏         │
+ * └──────────────────┘
+ *          ^visualEdge
+ *
+ * Note the reference point is not on the line. The coordinate used depends on the orientation of the visualEdge.
+ * ```
+ * So given the middle visual edge, the point `+` and the right search direction, would return the left edge of frame D.
+ *
+ * Given the left direction instead it would return C.
+ *
+ * Given no point, and the right direction it would return B and D.
+ */
+export declare function findFramesTouchingEdge(edge: Edge, frames: LayoutFrame[], criteria?: {
+    /**
+     * If a position (e.g. a cursor position) is given, only edges within the corresponding horizontal/vertical range will be returned.
+     *
+     * For example, if the visual edge is vertical, the function will only return edges that contain the y position, ignoring the x position. See the function documentation for a visual example.
+     */
+    referencePoint?: Point;
+    /**
+     * Several frames can lay to either side of a visual edge. This limits the directions in which to look. Otherwise we look in the directions perpendicular to the visual edge.
+     *
+     * See the function documentation for a visual example.
+     */
+    searchDirections?: Direction[];
+}): ({
+    edge: Edge;
+    frame: LayoutFrame;
+    side: EdgeSide;
+})[];

package/dist/runtime/layout/findSafeSplitEdge.d.ts

@@ -0,0 +1,5 @@
+import type { Direction, Edge, LayoutFrame, Point, Size } from "../types/index.js";
+export declare function findSafeSplitEdgeAndPosition(frame: LayoutFrame, dragDirection: Direction, dragPointOrPosition: Point | number, snapAmount?: Point, minSize?: Size): {
+    edge: Edge;
+    position: number;
+};

package/dist/runtime/layout/findVisualEdge.d.ts

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

package/dist/runtime/layout/frameCreate.d.ts

@@ -0,0 +1,3 @@
+import type { BaseLayoutFrame, ExtendedLayoutFrame, LayoutFrame } from "../types/index.js";
+/** Create a new frame. Note that it will always have a new id if it's undefined. */
+export declare function frameCreate(opts?: Partial<BaseLayoutFrame> & Omit<ExtendedLayoutFrame, keyof BaseLayoutFrame>): LayoutFrame;

package/dist/runtime/layout/frameSplit.d.ts

@@ -0,0 +1,16 @@
+import type { LayoutFrame, LayoutWindow } from "../types/index.js";
+/**
+ * Apply a frame split. See {@link getFrameSplitInfo}
+ * ```ts
+ * // undefined if we can't split
+ * const splitInfo = getFrameSplitInfo()
+ * if (splitInfo) {
+ * 	frameSplit(win, splitInfo)
+ *
+ * }
+ * ```
+ */
+export declare function frameSplit(win: LayoutWindow, { splitFrame, newFrame }: {
+    splitFrame: LayoutFrame;
+    newFrame: LayoutFrame;
+}): LayoutFrame | undefined;

package/dist/runtime/layout/getCloseFrameInfo.d.ts

@@ -0,0 +1,73 @@
+import { type Direction, type Edge, type EdgeSide, LAYOUT_ERROR, type LayoutFrame, type Size } from "../types/index.js";
+import { KnownError } from "../utils/KnownError.js";
+/**
+ * Returns the information necessary to close a frame or frames (if force: true).
+ *
+ * Can close by direction or by frame edge.
+ *
+ * - Closing A in the left direction or by it's right edge would close A and expand B.
+ *
+ * - Closing A in the right direction or by it's left edge is not possible, since it's left edge is a window edge.
+ *
+ * ```
+ * ┌──┬──┐
+ * │A │B │
+ * └──┴──┘
+ * ```
+ * A list of possible directions/edges can be given to attempt closing by those directions/edges in that order.
+ *
+ * Frame closing does not always succeed:
+ *
+ * ## `force: false` (default)
+ *
+ * If two frames share a visual edge exactly, they can always be closed to either side.
+ * ```
+ *  🭮  🭬
+ * ┌──┬──┐
+ * │A │B │
+ * └──┴──┘
+ * ```
+ *
+ * ## `force: true`
+ *
+ * If the visual edge contains multiple frames, `force: true` must be specified to be able to close them. Force is not guaranteed to succeed either though.
+ *
+ * There's two main scenarios to consider when we have multiple frames:
+ *
+ * - The frames all share an edge on the closing side. We can force close both without problems.
+ *
+ * So, for example, here A & B can be force closed to the left since they share their left edge (vertically).
+ * ```
+ *    ─🭬
+ * ┌──┬──┐
+ * │A │C │
+ * ├──┤  │
+ * │B │  │
+ * └──┴──┘
+ * ```
+ * - If they do not share an edge to that side, we will attempt to close the frame IF it's the smallest frame and only modify the size of the others.
+ *
+ * For this to succeed, the difference between the smallest frame and the next smallest frame must be greater than the minimum size.
+ *
+ * For example, here, we have frames A, B, and C to the left of the visual edge. A and B are the smallest. A can be closed and the rest modified, but only if the difference between A and B is greater than the minimum size.
+ * ```
+ *         🭮──
+ *┌──────┬──┬──┐
+ *│E     │A │F │
+ *├───┬──┴──┤  │
+ *│F  │B    │  │
+ *├───┴─────┤  │
+ *│C        │  │
+ *└─────────┴──┘
+ * ```
+ */
+export declare function getCloseFrameInfo<T extends "edge" | "dir">(frames: LayoutFrame[], visualEdges: Edge[], frame: LayoutFrame, 
+/**
+ * The direction or edge (if closeBy = "edge") to search for possible closes.
+ *
+ * For example, a frame that touches the right window edge can only be closed "to the right" in the horizontal direction or by it's left edge. Another way to think about it is the left edge is "collapsed" towards the "right".
+ */
+closeDirOrSide: (T extends "dir" ? Direction : EdgeSide), closeBy?: T, force?: boolean, minSize?: Size): {
+    modifiedFrames: LayoutFrame[];
+    deletedFrames: LayoutFrame[];
+} | KnownError<typeof LAYOUT_ERROR.CANT_CLOSE_NEARBY_FRAMES_TOO_SMALL | typeof LAYOUT_ERROR.CANT_CLOSE_NO_DRAG_EDGE | typeof LAYOUT_ERROR.CANT_CLOSE_SINGLE_FRAME | typeof LAYOUT_ERROR.CANT_CLOSE_WITHOUT_FORCE>;

package/dist/runtime/layout/getFrameSplitInfo.d.ts

@@ -0,0 +1,16 @@
+import { type Direction, type LayoutFrame, type Point, type Size } from "../types/index.js";
+import { KnownError } from "../utils/KnownError.js";
+export declare function getFrameSplitInfo(frame: LayoutFrame, dir: Direction, dragPointOrPosition?: Point | number | "midpoint", minSize?: Size, snapAmount?: Point): KnownError<"CANT_SPLIT_FRAME_TOO_SMALL", {
+    frame: LayoutFrame;
+    newSize: number;
+    minSize: number;
+}> | {
+    splitFrame: LayoutFrame;
+    newFrame: {
+        width: number;
+        height: number;
+        x: number;
+        y: number;
+        id: import("../types/index.js").FrameId;
+    };
+};

package/dist/runtime/layout/getFrameTo.d.ts

@@ -0,0 +1,2 @@
+import type { EdgeSide, LayoutFrame } from "../types/index.js";
+export declare function getFrameTo(side: EdgeSide, frame: LayoutFrame, frames: LayoutFrame[]): LayoutFrame | undefined;

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

@@ -0,0 +1,22 @@
+export { closeFrame } from "./closeFrame.js";
+export { closeFrames } from "./closeFrames.js";
+export { createSplitDecoEdge } from "./createSplitDecoEdge.js";
+export { createSplitDecoFromDrag } from "./createSplitDecoFromDrag.js";
+export { debugFrame } from "./debugFrame.js";
+export { findFramesTouchingEdge } from "./findFramesTouchingEdge.js";
+export { findSafeSplitEdgeAndPosition } from "./findSafeSplitEdge.js";
+export { findVisualEdge } from "./findVisualEdge.js";
+export { frameCreate } from "./frameCreate.js";
+export { frameSplit } from "./frameSplit.js";
+export { getCloseFrameInfo } from "./getCloseFrameInfo.js";
+export { getFrameSplitInfo } from "./getFrameSplitInfo.js";
+export { getFrameTo } from "./getFrameTo.js";
+export { isPointInFrame } from "./isPointInFrame.js";
+export { layoutAddWindow } from "./layoutAddWindow.js";
+export { layoutCreate } from "./layoutCreate.js";
+export { layoutRemoveWindow } from "./layoutRemoveWindow.js";
+export { resizeFrame } from "./resizeFrame.js";
+export { windowAddFrame } from "./windowAddFrame.js";
+export { windowCreate } from "./windowCreate.js";
+export { windowRemoveFrame } from "./windowRemoveFrame.js";
+export { windowSetActiveFrame } from "./windowSetActiveFrame.js";

package/dist/runtime/layout/isPointInFrame.d.ts

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

package/dist/runtime/layout/layoutAddWindow.d.ts

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

package/dist/runtime/layout/layoutCreate.d.ts

@@ -0,0 +1,3 @@
+import type { z } from "zod";
+import type { Layout, zLayoutCreate } from "../types/index.js";
+export declare function layoutCreate(opts?: z.infer<typeof zLayoutCreate>): Layout;

package/dist/runtime/layout/layoutRemoveWindow.d.ts

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

package/dist/runtime/layout/resizeFrame.d.ts

@@ -0,0 +1,6 @@
+import type { ExtendedDirection, LayoutFrame, LayoutWindow, Size } from "../types/index.js";
+export declare function resizeFrame(win: LayoutWindow, frame: LayoutFrame, dir: ExtendedDirection, 
+/** Scaled */
+distance: Size, 
+/** Scaled */
+minSize?: Size): boolean;

package/dist/runtime/layout/windowAddFrame.d.ts

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

package/dist/runtime/layout/windowCreate.d.ts

@@ -0,0 +1,4 @@
+import type { z } from "zod";
+import type { LayoutWindow, zWindowCreate } from "../types/index.js";
+/** Create a new window. Note that it will always have a new id if it's undefined. */
+export declare function windowCreate(opts?: z.infer<typeof zWindowCreate>): LayoutWindow;

package/dist/runtime/layout/windowRemoveFrame.d.ts

@@ -0,0 +1,2 @@
+import type { LayoutFrame, LayoutWindow } from "../types/index.js";
+export declare function windowRemoveFrame(win: LayoutWindow, frame: LayoutFrame | string): void;

package/dist/runtime/layout/windowSetActiveFrame.d.ts

@@ -0,0 +1,2 @@
+import type { LayoutFrame, LayoutWindow } from "../types/index.js";
+export declare function windowSetActiveFrame(win: LayoutWindow, frame: LayoutFrame | string): void;

package/dist/runtime/settings.d.ts

@@ -0,0 +1,23 @@
+import type { Point, Size } from "./types/index.js";
+export declare const globalOptions: {
+    SCALE: number;
+    maxInt: number;
+    SNAP_PERCENTAGE_X: number;
+    SNAP_PERCENTAGE_Y: number;
+    snapPoint: {
+        x: number;
+        y: number;
+    };
+    MARGIN_PERCENTAGE_WIDTH: number;
+    MARGIN_PERCENTAGE_HEIGHT: number;
+    marginSize: {
+        width: number;
+        height: number;
+    };
+};
+export declare function setScale(scale: number): void;
+export declare function getMaxInt(): number;
+export declare function setSnapPercentage(snapPercentage: number | Point): void;
+export declare function getSnapPoint(): Readonly<Point>;
+export declare function setMarginPercentage(margin: number | Size): void;
+export declare function getMarginSize(): Readonly<Size>;