@witchcraft/layout 0.0.1

package/src/runtime/layout/getCloseFrameInfo.ts

@@ -0,0 +1,193 @@
+import { pushIfNotIn } from "@alanscodelog/utils/pushIfNotIn"
+import { readable } from "@alanscodelog/utils/readable"
+import { unreachable } from "@alanscodelog/utils/unreachable"
+
+import { findFramesTouchingEdge } from "./findFramesTouchingEdge.js"
+import { findVisualEdge } from "./findVisualEdge.js"
+
+import { cloneFrame } from "../helpers/cloneFrame.js"
+import { dirToSide } from "../helpers/dirToSide.js"
+import { findFrameDraggableEdges } from "../helpers/findFrameDraggableEdges.js"
+import { getEdgeOrientation } from "../helpers/getEdgeOrientation.js"
+import { oppositeSide } from "../helpers/oppositeSide.js"
+import { getMarginSize } from "../settings.js"
+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 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 = "dir" as any as T,
+	force: boolean = false,
+	minSize: Size = getMarginSize()
+): { 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
+	> {
+	if (frames.length === 1) {
+		return new KnownError(LAYOUT_ERROR.CANT_CLOSE_SINGLE_FRAME,
+			`Can't close frame ${frame.id}, it is the last frame in the window.`,
+			{ frame })
+	}
+	const side = closeBy === "dir"
+		? oppositeSide(dirToSide(closeDirOrSide as Direction))
+		: closeDirOrSide as EdgeSide
+	const sideOpposite = oppositeSide(side)
+
+	const draggableEdges = findFrameDraggableEdges(frame, visualEdges, !force, [side])
+	if (!draggableEdges) return new KnownError(LAYOUT_ERROR.CANT_CLOSE_NO_DRAG_EDGE, `Could not find draggable edge for frame ${frame.id}`, { frame })
+	const { edge: frameEdge } = draggableEdges[0]
+
+	const visualEdge = findVisualEdge(visualEdges, frameEdge)
+	if (visualEdge === undefined) unreachable()
+	const direction = oppositeSide(getEdgeOrientation(visualEdge))
+	const entriesInVisualEdges = findFramesTouchingEdge(visualEdge, frames)
+
+	if (entriesInVisualEdges.length === 0) unreachable()
+	const sizeKey = direction === "horizontal" ? "width" : "height"
+	const coordKey = direction === "horizontal" ? "x" : "y"
+	const thisFrameSize = frame[sizeKey]
+	const frameSizes: number[] = []
+	const oppositeSideEntries: typeof entriesInVisualEdges = []
+	const sameSideEntries: typeof entriesInVisualEdges = []
+
+	for (const _ of entriesInVisualEdges) {
+		if (_.side === side) {
+			sameSideEntries.push(_)
+			const size = _.frame[sizeKey]
+			pushIfNotIn(frameSizes, [size])
+		} else {
+			oppositeSideEntries.push(_)
+		}
+	}
+
+	frameSizes.sort((a, b) => a - b)
+
+	const smallest: number = frameSizes[0]
+	const secondSmallest: number | undefined = frameSizes[1]
+
+	if (smallest < thisFrameSize) {
+		const nearbyErrorFrames = sameSideEntries.filter(_ => _.frame[sizeKey] < thisFrameSize).map(_ => _.frame)
+		return new KnownError(
+			LAYOUT_ERROR.CANT_CLOSE_NEARBY_FRAMES_TOO_SMALL,
+			// it's too complicated to calculate, happens in last example, if we get frame B, frame A is smaller
+			// attempting to resize it is very complicated
+			`Cannot close ${frame.id}, nearby affected frame/s ${readable(nearbyErrorFrames.map(_ => _.id))} are smaller than this one, we cannot calculate how to close it.`,
+			{ frame, nearbyFrames: nearbyErrorFrames, minSize }
+		)
+	}
+	if (thisFrameSize !== smallest) { unreachable() }
+	if (secondSmallest) {
+		if (secondSmallest - smallest < minSize[sizeKey]) {
+			const nearbyErrorFrames = sameSideEntries.filter(_ => frame[sizeKey] < minSize[sizeKey]).map(_ => _.frame)
+			return new KnownError(
+				LAYOUT_ERROR.CANT_CLOSE_NEARBY_FRAMES_TOO_SMALL,
+				`Closing this frame ${frame.id} would leave the following frame/s ${readable(nearbyErrorFrames.map(_ => _.id))} below the minimum size specified.`,
+				{ frame, nearbyFrames: nearbyErrorFrames, minSize }
+			)
+		}
+	}
+	const modifiedFrames = []
+	const deletedFrames = []
+	const moveAmount = thisFrameSize
+
+	for (const entry of sameSideEntries) {
+		if (entry.frame[sizeKey] > thisFrameSize) {
+			const clone = cloneFrame(entry.frame)
+			if (side === "top" || side === "left") {
+				clone[coordKey] += moveAmount
+			}
+			clone[sizeKey] -= moveAmount
+			modifiedFrames.push(clone)
+		} else if (entry.frame[sizeKey] === thisFrameSize) deletedFrames.push(entry.frame)
+		else unreachable()
+	}
+	if (deletedFrames.length > 1 && !force) {
+		return new KnownError(
+			LAYOUT_ERROR.CANT_CLOSE_WITHOUT_FORCE,
+			`Cannot close in this direction, there are multiple frames in the same direction (${readable(deletedFrames.map(_ => _.id))}). Use force: true to close them.`,
+			{ frame, minSize, framesRequiredToBeDeleted: deletedFrames }
+		)
+	}
+	for (const entry of oppositeSideEntries) {
+		const clone = cloneFrame(entry.frame)
+		if (sideOpposite === "top" || sideOpposite === "left") {
+			clone[coordKey] -= moveAmount
+		}
+		clone[sizeKey] += moveAmount
+		modifiedFrames.push(clone)
+	}
+	return { modifiedFrames, deletedFrames }
+}

package/src/runtime/layout/getFrameSplitInfo.ts

@@ -0,0 +1,65 @@
+import { findSafeSplitEdgeAndPosition } from "./findSafeSplitEdge.js"
+import { frameCreate } from "./frameCreate.js"
+
+import { cloneFrame } from "../helpers/cloneFrame.js"
+import { getMarginSize, getSnapPoint } from "../settings.js"
+import {
+	type Direction,
+	LAYOUT_ERROR,
+	type LayoutFrame,
+	type Point,
+	type Size
+} from "../types/index.js"
+import { KnownError } from "../utils/KnownError.js"
+
+export function getFrameSplitInfo(
+	frame: LayoutFrame,
+	dir: Direction,
+	dragPointOrPosition: Point | number | "midpoint" = "midpoint",
+	minSize: Size = getMarginSize(),
+	snapAmount: Point = getSnapPoint()
+) {
+	frame = cloneFrame(frame)
+	let newFrame = { ...frame }
+	const isHorz = dir === "left" || dir === "right"
+
+	const sizeKey: "width" | "height" = isHorz ? "width" : "height"
+	const posKey: "x" | "y" = isHorz ? "x" : "y"
+
+	const position = dragPointOrPosition === "midpoint"
+		? (isHorz ? frame.x + (frame.width / 2) : frame.y + (frame.height / 2))
+		: typeof dragPointOrPosition === "number"
+			? dragPointOrPosition
+			: dragPointOrPosition[isHorz ? "x" : "y"]
+
+	const safePosition = findSafeSplitEdgeAndPosition(
+		frame,
+		dir,
+		position,
+		snapAmount,
+		minSize
+	)
+
+	const newSize = dir === "right" || dir === "down"
+		? (frame[sizeKey] + frame[posKey]) - safePosition.position
+		: safePosition.position - frame[posKey]
+
+	if (newSize < minSize[sizeKey]) {
+		return new KnownError(
+			LAYOUT_ERROR.CANT_SPLIT_FRAME_TOO_SMALL,
+			`Can't split frame ${frame.id} in direction ${dir}, frame is too small to be split.`,
+			{ frame, newSize, minSize: minSize[sizeKey] }
+		)
+	}
+
+	newFrame[sizeKey] = newSize
+	frame[sizeKey] -= newSize
+	if (dir === "right" || dir === "down") {
+		newFrame[posKey] = safePosition.position
+	} else {
+		frame[posKey] = safePosition.position
+	}
+
+	newFrame = frameCreate({ ...newFrame, id: undefined })
+	return { splitFrame: frame, newFrame }
+}

package/src/runtime/layout/getFrameTo.ts

@@ -0,0 +1,65 @@
+import { getMaxInt } from "../settings.js"
+import type { EdgeSide, LayoutFrame } from "../types/index.js"
+
+export function getFrameTo(
+	side: EdgeSide,
+	frame: LayoutFrame,
+	frames: LayoutFrame[]
+): LayoutFrame | undefined {
+	const max = getMaxInt()
+	if ((side === "top" && frame.y === 0)
+		|| (side === "left" && frame.y === 0)
+		|| (side === "right" && frame.x + frame.width === max)
+		|| (side === "bottom" && frame.x + frame.height === max)) return undefined
+
+	let candidate: LayoutFrame | undefined
+	let candidateDistance = Infinity
+	const midPointX = frame.x + Math.round(frame.width / 2)
+	const midPointY = frame.y + Math.round(frame.height / 2)
+	const dir = side === "top" || side === "bottom" ? "horizontal" : "vertical"
+	const midPoint = dir === "horizontal" ? midPointX : midPointY
+	for (const other of frames) {
+		if (frame.id === other.id) continue
+		const isOutOfRange = dir === "horizontal"
+			? other.x + other.width <= frame.x || other.x >= frame.x + frame.width
+			: other.y + other.height <= frame.y || other.y >= frame.y + frame.height
+		if (isOutOfRange) continue
+
+		const otherMidPoint = dir === "horizontal"
+			? other.x + Math.round(other.width / 2)
+			: other.y + Math.round(other.height / 2)
+		const otherDist = Math.abs(midPoint - otherMidPoint)
+		switch (side) {
+			case "left":
+				if (other.x + other.width !== frame.x) continue
+				break
+			case "right":
+				if (other.x !== frame.x + frame.width) continue
+				break
+			case "top":
+				if (other.y + other.height !== frame.y) continue
+				break
+			case "bottom":
+				if (other.y !== frame.y + frame.height) continue
+				break
+		}
+		if (otherDist < candidateDistance) {
+			candidate = other
+			candidateDistance = otherDist
+		} else if (otherDist === candidateDistance && candidate) {
+			// future customizable preference?
+			if (dir === "vertical") {
+				// prefer top
+				if (other.y > candidate.y) {
+					candidate = other
+				}
+			} else {
+				// prefer left
+				if (other.x > candidate.x) {
+					candidate = other
+				}
+			}
+		}
+	}
+	return candidate
+}

package/src/runtime/layout/index.ts

@@ -0,0 +1,24 @@
+/* Autogenerated Index */
+
+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/src/runtime/layout/isPointInFrame.ts

@@ -0,0 +1,7 @@
+import { inRange } from "../helpers/inRange.js"
+import type { LayoutFrame, Point } from "../types/index.js"
+
+export function isPointInFrame(frame: LayoutFrame, point: Point): boolean {
+	return inRange(point.x, frame.x, frame.x + frame.width)
+		&& inRange(point.y, frame.y, frame.y + frame.height)
+}

package/src/runtime/layout/layoutAddWindow.ts

@@ -0,0 +1,6 @@
+import type { Layout, LayoutWindow } from "../types/index.js"
+
+export function layoutAddWindow(layout: Layout, win: LayoutWindow): LayoutWindow {
+	layout.windows[win.id] = win
+	return win
+}

package/src/runtime/layout/layoutCreate.ts

@@ -0,0 +1,12 @@
+import type { z } from "zod"
+
+import type { Layout, zLayoutCreate } from "../types/index.js"
+
+// todo ability to init with windows and checks
+export function layoutCreate(opts: z.infer<typeof zLayoutCreate> = {}): Layout {
+	return {
+		windows: {},
+		activeWindow: undefined,
+		...opts
+	} satisfies Layout
+}

package/src/runtime/layout/layoutRemoveWindow.ts

@@ -0,0 +1,7 @@
+import { toId } from "../helpers/toId.js"
+import type { Layout, LayoutWindow } from "../types/index.js"
+
+export function layoutRemoveWindow(layout: Layout, win: LayoutWindow | string): void {
+	const id = toId(win)
+	delete layout.windows[id]
+}

package/src/runtime/layout/resizeFrame.ts

@@ -0,0 +1,106 @@
+import { findFramesTouchingEdge } from "./findFramesTouchingEdge.js"
+
+import { clampNumber } from "../helpers/clampNumber.js"
+import { frameToEdges } from "../helpers/frameToEdges.js"
+import { getEdgeOrientation } from "../helpers/getEdgeOrientation.js"
+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"
+import type { Edge, ExtendedDirection, LayoutFrame, LayoutWindow, Size } from "../types/index.js"
+
+export function resizeFrame(
+	win: LayoutWindow,
+	frame: LayoutFrame,
+	dir: ExtendedDirection,
+	/** Scaled */
+	distance: Size,
+	/** Scaled */
+	minSize: Size = getMarginSize()
+): boolean {
+	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]
+
+	let divideDistance = false
+	if (resizeEdges.length === 2) {
+		divideDistance = true
+	}
+	let ok = false
+	const edgeDirection = getEdgeOrientation(resizeEdges[0])
+	const margin = minSize[edgeDirection === "vertical" ? "width" : "height"]
+
+	let dist = distance[edgeDirection === "vertical" ? "width" : "height"]
+	if (divideDistance) { dist /= 2 }
+
+	for (const resizeEdge of resizeEdges) {
+		// simple resize dir
+		const _dir = dir === "horizontal"
+			? (resizeEdge === frameEdges.left ? "left" : "right")
+			: dir === "vertical"
+				? (resizeEdge === frameEdges.top ? "up" : "down")
+				: dir
+
+		let frameEdge = resizeEdge
+
+		const visualEdges = getVisualEdges(Object.values(win.frames), { separateByDir: true })
+		const edges = visualEdges[edgeDirection]
+
+		const isWinEdge = isWindowEdge(frameEdge, edgeDirection)
+
+		if (isWinEdge) {
+			if (edgeDirection === "horizontal") {
+				frameEdge = frameEdge === frameEdges.top ? frameEdges.bottom : frameEdges.top
+			} else {
+				frameEdge = frameEdge === frameEdges.right ? frameEdges.left : frameEdges.right
+			}
+		}
+
+		let foundEdge: Edge | undefined
+		for (const edge of edges) {
+			if (edgeDirection === "horizontal") {
+				const isInRange = frameEdge.startX >= edge.startX && frameEdge.endX <= edge.endX
+				if (isInRange && frameEdge.startY === edge.startY) {
+					foundEdge = edge
+					break
+				}
+			} else {
+				const isInRange = frameEdge.startY >= edge.startY && frameEdge.endY <= edge.endY
+				if (isInRange && frameEdge.startX === edge.startX) {
+					foundEdge = edge
+					break
+				}
+			}
+		}
+
+		if (!foundEdge) {
+			distance = originalDistance
+			continue
+		}
+
+		const touchingFrames = findFramesTouchingEdge(foundEdge, Object.values(win.frames))?.map(_ => _.frame)
+		const posX = foundEdge.startX + (_dir === "left" ? -dist : dist)
+		const posY = foundEdge.startY + (_dir === "up" ? -dist : dist)
+
+		const wantedPos = edgeDirection === "horizontal" ? posY : posX
+		const limitInDir = getResizeLimit(foundEdge, touchingFrames, _dir, dist, margin)
+		const reverseClamp = (_dir === "right" || _dir === "down")
+		const pos = reverseClamp
+			? clampNumber(wantedPos, -Infinity, limitInDir)
+			: clampNumber(wantedPos, limitInDir, Infinity)
+		resizeByEdge(touchingFrames, foundEdge, _dir, pos, dist)
+		ok = true
+	}
+	return ok
+}

package/src/runtime/layout/windowAddFrame.ts

@@ -0,0 +1,10 @@
+import type { LayoutFrame, LayoutWindow } from "../types/index.js"
+
+export function windowAddFrame(win: LayoutWindow, frame: LayoutFrame): LayoutFrame {
+	// todo check can add because of space
+	// avoid duplicates in case of user error
+	// we can't have duplicates because a frame can't be in two positions at once
+	// if we implement frame linking it will have to be some other way
+	win.frames[frame.id] = frame
+	return frame
+}

package/src/runtime/layout/windowCreate.ts

@@ -0,0 +1,18 @@
+import { v4 as uuidv4 } from "uuid"
+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 function windowCreate(opts: z.infer<typeof zWindowCreate> = {}): LayoutWindow {
+	return {
+		frames: {},
+		activeFrame: undefined,
+		pxWidth: 0,
+		pxHeight: 0,
+		pxX: 0,
+		pxY: 0,
+		...opts,
+		id: opts.id ?? uuidv4()
+	}
+}

package/src/runtime/layout/windowRemoveFrame.ts

@@ -0,0 +1,7 @@
+import { toId } from "../helpers/toId.js"
+import type { LayoutFrame, LayoutWindow } from "../types/index.js"
+
+export function windowRemoveFrame(win: LayoutWindow, frame: LayoutFrame | string): void {
+	const id = toId(frame)
+	delete win.frames[id]
+}

package/src/runtime/layout/windowSetActiveFrame.ts

@@ -0,0 +1,7 @@
+import { toId } from "../helpers/toId.js"
+import type { LayoutFrame, LayoutWindow } from "../types/index.js"
+
+export function windowSetActiveFrame(win: LayoutWindow, frame: LayoutFrame | string): void {
+	const id = toId(frame)
+	win.activeFrame = id
+}

package/src/runtime/settings.ts

@@ -0,0 +1,63 @@
+import type { Point, Size } from "./types/index.js"
+
+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
+// todo think of better way :/
+
+export function setScale(scale: number): void {
+	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(): number {
+	return g.maxInt
+}
+
+export function setSnapPercentage(snapPercentage: number | Point): void {
+	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(): Readonly<Point> {
+	return g.snapPoint
+}
+
+export function setMarginPercentage(margin: number | Size): void {
+	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(): Readonly<Size> {
+	return g.marginSize
+}