@witchcraft/spellcraft 0.0.1

package/src/core/setShortcutProp.ts

@@ -0,0 +1,89 @@
+import { castType } from "@alanscodelog/utils/castType"
+import { Err, Ok, type Result } from "@alanscodelog/utils/Result"
+
+import { addShortcut } from "./addShortcut.js"
+import { removeShortcut } from "./removeShortcut.js"
+
+import { isValidChain } from "../internal/isValidChain.js"
+import { isValidCommand } from "../internal/isValidCommand.js"
+import { type CanHookErrors, type CanHookShortcutProps, type Hooks, type Manager, type MultipleErrors, type Shortcut, SHORTCUT_ERROR, type Shortcuts, type ShortcutSetEntries } from "../types/index.js"
+
+
+const canHookable: CanHookShortcutProps[] = ["chain", "command", "condition", "enabled"]
+
+/* Sets a settable shortcut property.
+ *
+ * You should not use this to set properties the manager manages (those tagged with @Managed in the docs) unless you've forgone using the manager.
+ */
+
+
+export function setShortcutProp<
+	TEntries extends ShortcutSetEntries,
+	TProp extends keyof ShortcutSetEntries,
+	TEntry extends TEntries[TProp],
+	THooks extends Manager["hooks"],
+	TCheck extends boolean | "only" = true
+>(
+	/** Shortcut is mutated if check is not "only". */
+	shortcut: Shortcut,
+	prop: TProp,
+	val: TEntry["val"],
+	manager: (TEntry["manager"] extends never ? unknown : TEntry["manager"]) & { hooks?: THooks },
+	{ check = true as TCheck }: { check?: TCheck } = {}
+):
+Result<
+	TCheck extends "only" ? true : Shortcut,
+	MultipleErrors<
+		TEntry["error"]
+	>
+	| CanHookErrors<Manager["hooks"] extends never ? never : THooks, "canSetShortcutProp">
+> {
+	if (check) {
+		switch (prop) {
+			case "chain": {
+				castType<TEntries["chain"]["val"]>(val)
+				castType<TEntries["chain"]["manager"]>(manager)
+
+				const res = isValidChain(val, manager)
+				if (res.isError) return res
+
+				const shortcutsShallowClone: Shortcuts = { ...manager.shortcuts, entries: [...manager.shortcuts.entries] }
+				const managerClone = { ...manager, shortcuts: shortcutsShallowClone } as any as Manager
+				// todo better way
+				const resRemove = removeShortcut(shortcut, managerClone)
+				// we could be setting a shortcut not in the set
+				if (resRemove.isError && "code" in resRemove.error && resRemove.error.code !== SHORTCUT_ERROR.MISSING) return resRemove as any
+				const resAdd = addShortcut({ ...shortcut, chain: val }, managerClone)
+				if (resAdd.isError) return resAdd as any
+				break
+			}
+			case "command": {
+				castType<TEntries["command"]["val"]>(val)
+				castType<TEntries["command"]["manager"]>(manager)
+
+				const res = isValidCommand(val, manager, shortcut)
+				if (res.isError) return res
+				break
+			}
+			default: {
+				break
+			}
+		}
+		if (manager?.hooks && "canSetShortcutProp" in manager.hooks && canHookable.includes(prop as any)) {
+			const canHook = (manager.hooks as Hooks).canSetShortcutProp?.(shortcut, prop as any, val)
+			if (canHook instanceof Error) {
+				return Err(canHook) as any
+			}
+		}
+	}
+	if (check === "only") {
+		return Ok(true) satisfies Result<true, never> as any
+	}
+	shortcut[prop] = val as any
+
+	(manager?.hooks as Hooks)?.onSetShortcutProp?.(shortcut, prop, val)
+	manager?.hooks?.onSetShortcutProp?.(shortcut, prop, val)
+
+	return Ok(shortcut) satisfies Result<Shortcut, never> as any
+}
+

package/src/core/setShortcutsProp.ts

@@ -0,0 +1,124 @@
+import { castType } from "@alanscodelog/utils/castType"
+import { Err, Ok, type Result } from "@alanscodelog/utils/Result"
+
+import { doesShortcutConflict } from "../helpers/doesShortcutConflict.js"
+import { equalsShortcut } from "../helpers/equalsShortcut.js"
+import { isValidShortcut } from "../helpers/isValidShortcut.js"
+import { KnownError } from "../helpers/KnownError.js"
+import { errorTextAdd } from "../internal/errorTextAdd.js"
+import { errorTextRemove } from "../internal/errorTextRemove.js"
+import { type CanHookErrors, type CanHookShortcutsProps, type Manager, type MultipleErrors, type Shortcut, SHORTCUT_ERROR, type Shortcuts, type ShortcutsSetEntries } from "../types/index.js"
+
+
+const canHookable: CanHookShortcutsProps[] = ["entries@add", "entries@remove"]
+/**
+ * Sets a settable {@link Shortcuts} property.
+ */
+export function setShortcutsProp<
+	TEntries extends ShortcutsSetEntries,
+	TProp extends keyof ShortcutsSetEntries,
+	TEntry extends TEntries[TProp],
+	THooks extends Manager["hooks"],
+	TCheck extends boolean | "only" = true
+>(
+	prop: TProp,
+	val: TEntry["val"],
+	/** Shortcuts is mutated if check is not "only". */
+	manager: TEntry["manager"] & { hooks?: THooks },
+	{
+		check = true as TCheck
+	}: { check?: TCheck } = {}
+): Result<
+	TCheck extends "only" ? true : Shortcut,
+	MultipleErrors<TEntry["error"]>
+	| CanHookErrors<Manager["hooks"] extends never ? never : THooks, "canSetShortcutsProp">
+> {
+	const s = manager.options.stringifier
+	const shortcuts = manager.shortcuts
+	if (check) {
+		switch (prop) {
+			case "entries@add": {
+				castType<TEntries["entries@add"]["val"]>(val)
+				castType<TEntries["entries@add"]["manager"]>(manager)
+
+				const shortcut = val as any as Shortcut
+				const existing = (shortcuts.entries).find(_ =>
+					equalsShortcut(shortcut, _, manager, { ignoreCommand: true })
+					|| doesShortcutConflict(_, shortcut, manager)
+				)
+
+				if (existing) {
+					return Err(new KnownError(
+						SHORTCUT_ERROR.DUPLICATE_SHORTCUT,
+						errorTextAdd(
+							"Shortcut",
+							s.stringify(existing.chain, manager),
+							s.stringify(existing, manager),
+							s.stringify(shortcut, manager)
+						),
+						{ existing: (existing as any), self: shortcuts }
+					))
+				}
+				const isValid = isValidShortcut(shortcut, manager)
+				if (isValid.isError) return isValid
+				break
+			}
+			case "entries@remove": {
+				const shortcut = val as any as Shortcut
+				// note we don't ignore the command here, we want to find an exact match
+				const existing = (shortcuts.entries).find(_ =>
+					_ === shortcut || equalsShortcut(shortcut, _, manager, { ignoreCommand: false })
+				)
+				if (existing === undefined) {
+					return Err(new KnownError(
+						SHORTCUT_ERROR.MISSING,
+						errorTextRemove(
+							"Shortcut",
+							s.stringify(shortcut, manager),
+							s.stringifyList("shortcuts", shortcuts.entries, manager)
+						),
+						{ entry: shortcut, self: shortcuts }
+					))
+				}
+				break
+			}
+
+			default: break
+		}
+		if (manager?.hooks && "canSetShortcutsProp" in manager.hooks && canHookable.includes(prop as any)) {
+			const canHook = manager.hooks.canSetShortcutsProp?.(shortcuts, prop as any, val as any)
+			if (canHook instanceof Error) {
+				return Err(canHook) as any
+			}
+		}
+	}
+
+	if (check === "only") {
+		return Ok(true) satisfies Result<true, never> as any
+	}
+
+	switch (prop) {
+		case "entries@add": {
+			const shortcut = val
+			shortcuts.entries.push(shortcut)
+			break
+		}
+		case "entries@remove": {
+			const shortcut = val
+			const i = shortcuts.entries.findIndex(_ => _ === shortcut || equalsShortcut(shortcut, _, manager, { ignoreCommand: false }))
+			if (i < 0) {
+				throw new Error("If used correctly, shortcut should exist at this point, but it does not.")
+			}
+			shortcuts.entries.splice(i, 1)
+			break
+		}
+		default:
+			(shortcuts as any)[prop] = val
+			break
+	}
+
+	manager.hooks?.onSetShortcutsProp?.(shortcuts, prop as any, val as any)
+
+	return Ok(shortcuts) satisfies Result<Shortcuts, never> as any
+}
+

package/src/defaults/KeysSorter.ts

@@ -0,0 +1,55 @@
+import { getKeyFromIdOrVariant } from "../helpers/getKeyFromIdOrVariant.js"
+import { keyOrder } from "../internal/keyOrder.js"
+import { type IKeysSorter, KEY_SORT_POS, type Keys, type KeySortPos } from "../types/index.js"
+
+
+/**
+ * The default class based implementation of the {@link IKeysSorter} interface.
+ *
+ * Creates a keys sorter for shortcut chains.
+ *
+ * Can either be passed some (object) enum of KeySortPos or it's keys with the values changed, for example:
+ * ```ts
+ * const MyKeySortPos = {
+ * 	[KEY_SORT_POS.modmouse]: 0,
+ * 	[KEY_SORT_POS.mod]: 1,
+ * 	// or
+ * 	modmouse: 0,
+ * 	mod: 1,
+ * 	//...
+ * }
+ *
+ * const mySorter = new KeysSorter(MyKeySortPos)
+ * new Shortcut([...keys], {sorter: mySorter})
+ * ```
+ * They way this works is the enum should contain every possible combination of key "types". All sort does is determine the type and use it's position in the enum to know where to sort it. If two keys are of the same type, they are sorted alphabetically by their id.
+ *
+ * Or you can extend from the class and implement a custom sort function.
+ *
+ * Ideally a single sorter should be created and shared amongst all instances. This is already taken care of if you do not pass a custom sorter, a default sorter instance is re-used throughout.
+ *
+ * The order of the default sorter can be changed without creating a new class by importing it early and changing it's `order` property.
+ */
+export class KeysSorter implements IKeysSorter {
+	private _sort(aId: string, bId: string, keys: Keys, order: KeySortPos): number {
+		const a = getKeyFromIdOrVariant(aId, keys).unwrap()[0]
+		const b = getKeyFromIdOrVariant(bId, keys).unwrap()[0]
+		// -1 = a b
+		if (keyOrder(a, order) < keyOrder(b, order)) return -1
+		// 1 = b a
+		if (keyOrder(b, order) < keyOrder(a, order)) return 1
+		return aId.localeCompare(bId) // => alphabetical
+	}
+
+	order: KeySortPos
+
+	constructor(order: KeysSorter["order"] = KEY_SORT_POS) {
+		this.order = order
+	}
+
+	sort(keyList: string[], keys: Keys): string[] {
+		return keyList.sort((a, b) => this._sort!(a, b, keys, this.order))
+	}
+}
+
+export const defaultSorter = new KeysSorter()

package/src/defaults/Stringifier.ts

@@ -0,0 +1,234 @@
+import { castType } from "@alanscodelog/utils/castType"
+import { crop } from "@alanscodelog/utils/crop"
+import { dedupe } from "@alanscodelog/utils/dedupe"
+import { isArray } from "@alanscodelog/utils/isArray"
+import { isObject } from "@alanscodelog/utils/isObject"
+import { pretty } from "@alanscodelog/utils/pretty"
+import { unreachable } from "@alanscodelog/utils/unreachable"
+
+import { getKeyFromIdOrVariant } from "../helpers/getKeyFromIdOrVariant.js"
+import { getLabel } from "../helpers/getLabel.js"
+import type { Command, Condition, DefaultStringifierOptions, IStringifier, Key, Manager, Shortcut } from "../types/index.js"
+
+
+/**
+ * The default class based implementation of the {@link IStringifier} interface.
+ *
+ * It can be passed (and a default instance is passed by default) to most functions to specify how to stringify items in errors.
+ *
+ * The default method `stringify` can be called with any key, chord, chain, shortcut, etc. and calls the respective {@link DefaultStringifierOptions} method depending on the type property or in the case of chains, chords, and keys, the array depth.
+ *
+ * That method called then calls any others it needs (e.g. if you pass a shortcut, it will call `stringifyShortcut` which will call `stringifyCommand`, `stringifyCondition`, and `stringifyChain`, which will call `stringifyChord` and so on)
+ *
+ * These can be customized by changing the options of the default instance (see Customizing below). These options are methods that describe in simpler term how items should be joined, without handling all the logic (the class pieces it all together)
+ *
+ * For chains the default method uses a key's label and combines keys inside chords with `+` and the chords of shortcut chains with a space ` `.
+ * ```
+ * Key+Key Key+Key+Key
+ * ^Chord^ ^Chord    ^
+ * ^Chain            ^
+ * ```
+ *
+ * For shortcuts, the default is:
+ * ```
+ * Shortcut Key+Key Key+Key+Key (command: command_name, condition: condition_text)
+ * ```
+ * If the condition or command are undefined:
+ * 	- For command it will still say it's undefined.
+ * 	- The condition is removed entirely if it's undefined.
+ * ```
+ * Shortcut Key+Key Key+Key+Key (command: undefined)
+ * ```
+ *
+ * `stringifyLists` returns a lists joined by a comma and new line:
+ *
+ * ```
+ * 	 item,
+ * 	 item
+ * ```
+ *
+ * ## Customizing
+ * Ideally a single stringifier should be created and shared amongst all instances. This is already taken care of if you do not pass a custom stringifier, a default stringifier instance is re-used throughout. Unless you're implementing your own {@link IStringifier}, you should not need to pass the default one around.
+ *
+ * You can just import it early and change it's options.
+ */
+
+export class Stringifier implements IStringifier {
+	opts: DefaultStringifierOptions
+
+	constructor(opts: DefaultStringifierOptions = {}) {
+		this.opts = opts
+	}
+
+	stringify(
+		entry: string | string[] | string[][],
+		manager: Pick<Manager, "keys">
+	): string
+
+	stringify(
+		entry: Shortcut,
+		manager: Pick<Manager, "keys" | "commands">
+	): string
+
+	stringify(
+		entry: Key | Key[] | Command | Condition,
+	): string
+
+	stringify(
+		entry: string | string[] | string[][] | Key | Key[] | Shortcut | Command | Condition,
+		manager?: Pick<Manager, "keys" | "commands"> | Pick<Manager, "keys">
+
+	): string {
+		if (isObject(entry) && "type" in entry) {
+			switch (entry.type) {
+				case "key": return this.stringifyKey(entry)
+				case "shortcut": return this.stringifyShortcut(entry, manager as any)
+				case "command": return this.stringifyCommand(entry as any, manager as any)
+				case "condition": return this.stringifyCondition(entry)
+			}
+		} else {
+			if (isArray(entry)) {
+				if (entry.length === 0) return this.stringifyChord([] as any)
+				// not getting correctly narrow :/
+				if (!isArray(entry[0])) {
+					castType<string[] | Key[]>(entry)
+					return this.stringifyChord(entry as any, manager!)
+				}
+				castType<string[][] | Key[][]>(entry)
+				return this.stringifyChain(entry as any, manager!)
+			} else {
+				return this.stringifyKey(entry, manager!)
+			}
+		}
+
+		unreachable()
+	}
+
+	stringifyPropertyValue(entry: any): string {
+		let res = ""
+		try {
+			res = this.stringify(entry)
+			return res
+		// eslint-disable-next-line @typescript-eslint/no-unused-vars
+		} catch (e) {
+			// ignore
+		}
+		const type = typeof entry
+
+		switch (type) {
+			case "string": return entry
+			case "number":
+			case "boolean":
+				return `${entry}`
+			case "function":
+				return `function "${entry.constructor.name}"`
+			case "object":
+				return pretty(entry)
+			default:
+				return entry.toString()
+		}
+	}
+
+
+	protected stringifyShortcut(
+		shortcut: Shortcut,
+		manager: Pick<Manager, "keys" | "commands">
+	): string {
+		if (this.opts.shortcut) return this.opts.shortcut(shortcut)
+		const command = `command: ${this.stringifyCommand(shortcut.command ? manager.commands.entries[shortcut.command] : undefined)}`
+		const chain = this.stringifyChain(shortcut.chain.map(chord => chord.map(id => manager.keys.entries[id] ?? manager.keys.toggles[id] ?? id)) as any, manager)
+		const condition = this.stringifyCondition(shortcut.condition)
+		return crop`Shortcut ${chain} (${command}${shortcut.condition ? `, ${condition}` : ""})`
+	}
+
+	protected stringifyCondition(condition?: Condition): string {
+		if (this.opts.condition) return this.opts.condition(condition)
+		return condition ? `condition: "${condition?.text}"` : `condition: undefined`
+	}
+
+	stringifyCommand(name: string, manager: Pick<Manager, "commands">): string
+
+	stringifyCommand(command?: Command): string
+
+	stringifyCommand(nameOrCommand?: string | Command | undefined, manager?: Pick<Manager, "commands">): string {
+		const command = typeof nameOrCommand === "string"
+			? manager!.commands.entries[nameOrCommand]
+			: nameOrCommand
+
+		if (this.opts.command) return this.opts.command(command)
+		return command ? command.name : "(None)"
+	}
+
+	protected stringifyKey(key: Key): string
+
+	protected stringifyKey(key: string, manager: Pick<Manager, "keys">): string
+
+	protected stringifyKey(keyOrId: Key | string, manager?: Pick<Manager, "keys">): string {
+		if (typeof keyOrId === "string") {
+			const res = getKeyFromIdOrVariant(keyOrId, manager!.keys)
+			const key = res.isOk ? res.value[0] : undefined
+			if (key) {
+				if (this.opts.key) return this.opts.key(keyOrId, key)
+				return getLabel(keyOrId, key)
+			} else {
+				if (this.opts.key) return this.opts.key(keyOrId)
+				return keyOrId
+			}
+		} else {
+			if (this.opts.key) return this.opts.key(keyOrId.id, keyOrId)
+			return getLabel(keyOrId.id, keyOrId)
+		}
+	}
+
+	protected stringifyChord(chord: Key[]): string
+
+	protected stringifyChord(chord: string[], manager: Pick<Manager, "keys">): string
+
+	protected stringifyChord(chord: Key[] | string[], manager?: Pick<Manager, "keys">): string {
+		const stringified = dedupe(chord.map(key => this.stringifyKey(key satisfies string | Key as any, manager!)), { mutate: true })
+		if (this.opts.chord) return this.opts.chord(stringified)
+		return stringified.join("+")
+	}
+
+	protected stringifyChain(chain: Key[][]): string
+
+	protected stringifyChain(chain: string[][], manager: Pick<Manager, "keys">): string
+
+	protected stringifyChain(chain: Key[][] | string[][], manager?: Pick<Manager, "keys">): string {
+		const stringified = chain.map(chord => this.stringifyChord(chord satisfies string[] | Key[] as any, manager!))
+
+		if (this.opts.chain) return this.opts.chain(stringified)
+		return stringified.join(" ")
+	}
+
+	stringifyList(type: "keys", entries: Key[]): string
+
+	stringifyList(type: "commands", entries: Command[]): string
+
+	stringifyList(type: "keys", entries: string[], manager: Pick<Manager, "keys">): string
+
+	stringifyList(type: "commands", entries: string[], manager: Pick<Manager, "commands">): string
+
+	stringifyList(type: "shortcuts", entries: Shortcut[], manager: Pick<Manager, "keys" | "commands">): string
+
+	stringifyList(
+		type: "keys" | "commands" | "shortcuts",
+		entries: Key[] | Command[] | Shortcut[] | string[],
+		manager?: Pick<Manager, "commands"> | Pick<Manager, "keys"> | Pick<Manager, "keys">
+	): string {
+		let stringified: string[]
+		if (typeof entries[0] === "string") {
+			stringified = (entries as string[]).map(entry => type === "keys"
+				? this.stringify(entry, manager as any)
+				: this.stringifyCommand(entry, manager as any)
+			)
+		} else {
+			stringified = (entries as any[]).map(entry => this.stringify(entry, manager as any))
+		}
+		if (this.opts.list) return this.opts.list(stringified, type)
+		return stringified.join(",\n")
+	}
+}
+
+export const defaultStringifier = new Stringifier()
+

package/src/defaults/defaultConditionEquals.ts

@@ -0,0 +1,29 @@
+import type { Condition } from "../types/index.js"
+
+/**
+ * Returns whether the condition passed is equal to this one.
+ *
+ * The default method does a simplistic object check, and otherwise a  check of the `text` property for equality. If both conditions are undefined, note this will return true.
+ *
+ * If you override the default conditionEquals option you will likely want it to just always return false.
+ *
+ * Why? Because unless you're using simple single variable conditions that you can presort to make them uniquely identifiable (i.e. not boolean expressions, e.g. `!a b !c`), this will return A LOT of false negatives.
+ *
+ * Why the false negatives? Because two conditions might be functionally equal but have differing representations (e.g: `a && b`, `b && a`). You might think, lets normalize them all, but normalizing boolean expressions (converting them to CNF) can be dangerous with very long expressions because it can take exponential time.
+ *
+ * Now the main reason for checking the equality of two conditions is to check if two shortcuts might conflict. If we're using boolean expressions it just can't be done safely.
+ *
+ * This is a personal preference, but if we have a method that gives false negatives it can be confusing that some shortcuts immediately error when added because their conditions are simple, while others don't until triggered. The simpler, more consistent alternative is to only have them error on triggering. Aditionally conflicting conditions can be shown on the keyboard layout when then user picks contexts to check against.
+ *
+ * Why use the default implementation at all then? Well, shortcuts aren't the only ones that have conditions, commands can too, but unlike shortcuts, usually it's developers who are in charge of assigning a command's condition, and since they are usually simple, it's more possible to make sure the conditions are unique (e.g. tests could enforce they're unique by converting them all to CNF and pre-checking them for equality).
+ */
+export function defaultConditionEquals<TCondition extends Condition>(
+	conditionA?: TCondition,
+	conditionB?: Condition
+): conditionB is TCondition {
+	// both are the same object or both undefined
+	if (conditionA === conditionB) return true
+	// one if undefined
+	if (!conditionA || !conditionB) return false
+	return conditionA.text === conditionB.text
+}

package/src/defaults/defaultManagerCallback.ts

@@ -0,0 +1,14 @@
+import { setManagerProp } from "../core/setManagerProp.js"
+import type { Manager } from "../types/index.js"
+
+
+/**
+ * The default callback for the manager which logs the error, the event that caused it, and clears the chain.
+ *
+ * @internal
+ */
+export const defaultManagerCallback: Manager["options"]["cb"] = (manager: Manager, error, e): void => {
+	// eslint-disable-next-line no-console
+	console.warn(error, e)
+	setManagerProp(manager, "state.chain", [])
+}

package/src/helpers/KnownError.ts

@@ -0,0 +1,13 @@
+import { TypedError } from "@alanscodelog/utils"
+
+import type { ErrorInfo, ShortcutError, TypeError } from "../types/index.js"
+
+
+/**
+ * Creates a known error that extends the base Error with some extra information.
+ * All the variables used to create the error message are stored in it's info property so you can easily craft your own error messages to show to users.
+ */
+export class KnownError<
+	T extends ShortcutError | TypeError = ShortcutError | TypeError
+	// TInfo extends ErrorInfo<T> = ErrorInfo<T>,
+> extends TypedError<T, ErrorInfo<T>> {}

package/src/helpers/calculateAndSetPositionAndWidth.ts

@@ -0,0 +1,30 @@
+import { setReadOnly } from "@alanscodelog/utils/setReadOnly"
+
+import type { RawKey } from "../types/keys.js"
+
+/**
+ * Auto calculate and set the x positions of a row of raw keys based on their width if set (otherwise width is set to 1). If the key already has an x position it takes priority and "shifts" the rest of the keys.
+ *
+ * Useful for creating layouts.
+ *
+ * This is for *RAW* keys, so it mutates the key directly without going through {@link setKeyProp}
+ */
+export function calculateAndSetPositionAndSize<
+	T extends RawKey
+>(row: T[]): (T & { x: number, width: number, height: 1 })[] {
+	let x = 0
+	for (const key of row) {
+		if (key.x) x = key.x
+		setReadOnly(key, "x", x)
+		if (key.width) {
+			x += key.width
+		} else {
+			setReadOnly(key, "width", 1)
+			x++
+		}
+		if (key.height === undefined) {
+			setReadOnly(key, "height", 1)
+		}
+	}
+	return row as any
+}

package/src/helpers/calculateLayoutSize.ts

@@ -0,0 +1,22 @@
+import type { Key, Keys } from "../types/index.js"
+
+/**
+ * Returns the layout size in key units for a set of {@link Keys}. This will only look at keys which are set to ({@link Key.render}).
+ *
+ * See {@link Keys.autoManageLayout} and {@link Keys.layout}.
+ *
+ * This should be done after creating {@link Keys} then on any user changes to the size/pos properties of keys. You can hook into these changed with the manager's {@link Manager.hooks.onSetKeyProp}.
+ */
+export function calculateLayoutSize(keys: Keys): Keys["layout"] {
+	let x = 0
+	let y = 0
+	for (const key of Object.values<Key>(keys.entries)) {
+		if (key.render) {
+			const xLimit = key.x + key.width
+			x = xLimit > x ? xLimit : x
+			const yLimit = key.y + key.height
+			y = yLimit > y ? yLimit : y
+		}
+	}
+	return { x, y }
+}