@witchcraft/layout 0.1.3 → 0.2.1

package/dist/runtime/layout/index.js

@@ -1,17 +1,26 @@
-export { closeFrame } from "./closeFrame.js";
-export { closeFrames } from "./closeFrames.js";
-export { createSplitDecoEdge } from "./createSplitDecoEdge.js";
+export { applyFrameChanges } from "./applyFrameChanges.js";
 export { createSplitDecoFromDrag } from "./createSplitDecoFromDrag.js";
+export { createSplitDecoShapes } from "./createSplitDecoShapes.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 { getDragZones } from "./getDragZones.js";
+export { getFillEmptySpaceInfo } from "./getFillEmptySpaceInfo.js";
+export { getFrameCollapseInfo } from "./getFrameCollapseInfo.js";
+export { getFrameDockInfo } from "./getFrameDockInfo.js";
+export { getFrameDragZones } from "./getFrameDragZones.js";
+export { getFrameRearrangeInfo } from "./getFrameRearrangeInfo.js";
 export { getFrameSplitInfo } from "./getFrameSplitInfo.js";
+export { getFramesRedistributeInfo } from "./getFramesRedistributeInfo.js";
+export { getFrameSwapInfo } from "./getFrameSwapInfo.js";
 export { getFrameTo } from "./getFrameTo.js";
-export { isPointInFrame } from "./isPointInFrame.js";
+export { getFrameUncollapseInfo } from "./getFrameUncollapseInfo.js";
+export { getFrameUndockInfo } from "./getFrameUndockInfo.js";
+export { getWindowDragZones } from "./getWindowDragZones.js";
+export { isPointInRect } from "./isPointInRect.js";
 export { layoutAddWindow } from "./layoutAddWindow.js";
 export { layoutCreate } from "./layoutCreate.js";
 export { layoutRemoveWindow } from "./layoutRemoveWindow.js";

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

@@ -0,0 +1,7 @@
+import type { Point } from "../types/index.js";
+export declare function isPointInRect(frame: {
+    x: number;
+    y: number;
+    width: number;
+    height: number;
+}, point: Point): boolean;

package/dist/runtime/layout/{isPointInFrame.js → isPointInRect.js}

@@ -1,4 +1,4 @@
 import { inRange } from "../helpers/inRange.js";
-export function isPointInFrame(frame, point) {
+export function isPointInRect(frame, point) {
   return inRange(point.x, frame.x, frame.x + frame.width) && inRange(point.y, frame.y, frame.y + frame.height);
 }

package/dist/runtime/layout/resizeFrame.js

@@ -6,8 +6,8 @@ import { getResizeLimit } from "../helpers/getResizeLimit.js";
 import { getVisualEdges } from "../helpers/getVisualEdges.js";
 import { isWindowEdge } from "../helpers/isWindowEdge.js";
 import { resizeByEdge } from "../helpers/resizeByEdge.js";
-import { getMarginSize } from "../settings.js";
-export function resizeFrame(win, frame, dir, distance, minSize = getMarginSize()) {
+import { settings } from "../settings.js";
+export function resizeFrame(win, frame, dir, distance, minSize = settings.minSizeScaled) {
   const originalDistance = distance;
   const frameEdges = frameToEdges(frame);
   const resizeEdges = dir === "up" ? [frameEdges.top] : dir === "down" ? [frameEdges.bottom] : dir === "vertical" ? [frameEdges.top, frameEdges.bottom] : dir === "left" ? [frameEdges.left] : dir === "right" ? [frameEdges.right] : [frameEdges.left, frameEdges.right];

package/dist/runtime/settings.d.ts

@@ -1,23 +1,48 @@
 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: {
+export declare class Settings {
+    private _scale;
+    private _maxInt;
+    get scale(): number;
+    set scale(v: number);
+    get maxInt(): number;
+    private _snapPoint;
+    private _snapPointScaled;
+    get snapPoint(): number | Point;
+    set snapPoint(v: number | Point);
+    get snapPointScaled(): {
         x: number;
         y: number;
     };
-    MARGIN_PERCENTAGE_WIDTH: number;
-    MARGIN_PERCENTAGE_HEIGHT: number;
-    marginSize: {
+    private _minSize;
+    private _minSizeScaled;
+    get minSize(): number | Size;
+    set minSize(v: number | Size);
+    get minSizeScaled(): {
         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>;
+    private _collapseSize;
+    private _collapseSizeScaled;
+    get collapseSize(): number | Size;
+    set collapseSize(v: number | Size);
+    get collapseSizeScaled(): {
+        width: number;
+        height: number;
+    };
+    private _maxPerpendicularLength;
+    private _maxPerpendicularLengthScaled;
+    get maxPerpendicularLength(): number | Size;
+    set maxPerpendicularLength(v: number | Size);
+    get maxPerpendicularLengthScaled(): {
+        width: number;
+        height: number;
+    };
+    private _scalePoint;
+    private _scaleSize;
+    private _recalcAll;
+    zoneSizes: {
+        frameEdgePx: number;
+        windowEdgePx: number;
+    };
+}
+export declare const settings: Settings;

package/dist/runtime/settings.js

@@ -1,54 +1,96 @@
-const g = {
-  SCALE: 3,
-  maxInt: 100 * 10 ** 3,
-  SNAP_PERCENTAGE_X: 0.5,
-  SNAP_PERCENTAGE_Y: 0.5,
-  snapPoint: { x: Math.round(0.5 * 10 ** 3), y: Math.round(0.5 * 10 ** 3) },
-  MARGIN_PERCENTAGE_WIDTH: 10 ** 3,
-  MARGIN_PERCENTAGE_HEIGHT: 10 ** 3,
-  marginSize: { width: 10 ** 3, height: 10 ** 3 }
-};
-export const globalOptions = g;
-export function setScale(scale) {
-  const max = 100 * 10 ** scale;
-  if (!Number.isSafeInteger(max)) {
-    throw new TypeError("Scale too high. Precision will be lost!");
-  }
-  g.SCALE = scale;
-  g.maxInt = max;
-}
-export function getMaxInt() {
-  return g.maxInt;
-}
-export function setSnapPercentage(snapPercentage) {
-  if (typeof snapPercentage === "number") {
-    g.SNAP_PERCENTAGE_X = snapPercentage;
-    g.SNAP_PERCENTAGE_Y = snapPercentage;
-  } else {
-    g.SNAP_PERCENTAGE_X = snapPercentage.x;
-    g.SNAP_PERCENTAGE_Y = snapPercentage.y;
-  }
-  g.snapPoint = {
-    x: Math.round(g.SNAP_PERCENTAGE_X * 10 ** g.SCALE),
-    y: Math.round(g.SNAP_PERCENTAGE_Y * 10 ** g.SCALE)
-  };
-}
-export function getSnapPoint() {
-  return g.snapPoint;
-}
-export function setMarginPercentage(margin) {
-  if (typeof margin === "number") {
-    g.MARGIN_PERCENTAGE_WIDTH = margin;
-    g.MARGIN_PERCENTAGE_HEIGHT = margin;
-  } else {
-    g.MARGIN_PERCENTAGE_WIDTH = margin.width;
-    g.MARGIN_PERCENTAGE_HEIGHT = margin.height;
-  }
-  g.marginSize = {
-    width: Math.round(g.MARGIN_PERCENTAGE_WIDTH * 10 ** g.SCALE),
-    height: Math.round(g.MARGIN_PERCENTAGE_HEIGHT * 10 ** g.SCALE)
-  };
-}
-export function getMarginSize() {
-  return g.marginSize;
+export class Settings {
+  _scale = 3;
+  _maxInt = 100 * 10 ** 3;
+  get scale() {
+    return this._scale;
+  }
+  set scale(v) {
+    this._scale = v;
+    this._maxInt = 100 * 10 ** v;
+    this._recalcAll();
+  }
+  get maxInt() {
+    return this._maxInt;
+  }
+  _snapPoint = { x: 0.5, y: 0.5 };
+  _snapPointScaled = { x: Math.round(0.5 * 10 ** 3), y: Math.round(0.5 * 10 ** 3) };
+  get snapPoint() {
+    return this._snapPoint;
+  }
+  set snapPoint(v) {
+    if (typeof v === "number") {
+      this._snapPoint = { x: v, y: v };
+    } else {
+      this._snapPoint = { x: v.x, y: v.y };
+    }
+    this._snapPointScaled = this._scalePoint(this._snapPoint);
+  }
+  get snapPointScaled() {
+    return this._snapPointScaled;
+  }
+  _minSize = { width: 10 ** 3, height: 10 ** 3 };
+  _minSizeScaled = { width: 10 ** 3, height: 10 ** 3 };
+  get minSize() {
+    return this._minSize;
+  }
+  set minSize(v) {
+    if (typeof v === "number") {
+      this._minSize = { width: v, height: v };
+    } else {
+      this._minSize = { width: v.width, height: v.height };
+    }
+    this._minSizeScaled = this._scaleSize(this._minSize);
+  }
+  get minSizeScaled() {
+    return this._minSizeScaled;
+  }
+  _collapseSize = { width: 0, height: 0 };
+  _collapseSizeScaled = { width: 0, height: 0 };
+  get collapseSize() {
+    return this._collapseSize;
+  }
+  set collapseSize(v) {
+    if (typeof v === "number") {
+      this._collapseSize = { width: v, height: v };
+    } else {
+      this._collapseSize = { width: v.width, height: v.height };
+    }
+    this._collapseSizeScaled = this._scaleSize(this._collapseSize);
+  }
+  get collapseSizeScaled() {
+    return this._collapseSizeScaled;
+  }
+  _maxPerpendicularLength = { width: 20, height: 20 };
+  _maxPerpendicularLengthScaled = { width: Math.round(20 * 10 ** 3), height: Math.round(20 * 10 ** 3) };
+  get maxPerpendicularLength() {
+    return this._maxPerpendicularLength;
+  }
+  set maxPerpendicularLength(v) {
+    if (typeof v === "number") {
+      this._maxPerpendicularLength = { width: v, height: v };
+    } else {
+      this._maxPerpendicularLength = { ...v };
+    }
+    this._maxPerpendicularLengthScaled = this._scaleSize(this._maxPerpendicularLength);
+  }
+  get maxPerpendicularLengthScaled() {
+    return this._maxPerpendicularLengthScaled;
+  }
+  _scalePoint(p) {
+    const m = 10 ** this._scale;
+    return { x: Math.round(p.x * m), y: Math.round(p.y * m) };
+  }
+  _scaleSize(s) {
+    const m = 10 ** this._scale;
+    return { width: Math.round(s.width * m), height: Math.round(s.height * m) };
+  }
+  _recalcAll() {
+    this.snapPoint = this._snapPoint;
+    this.minSize = this._minSize;
+    this.collapseSize = this._collapseSize;
+    this.maxPerpendicularLength = this._maxPerpendicularLength;
+  }
+  // ==== px sized, don't require recalc
+  zoneSizes = { frameEdgePx: 40, windowEdgePx: 20 };
 }
+export const settings = new Settings();