@witchcraft/spellcraft 0.0.1

package/src/core/createKeys.ts

@@ -0,0 +1,68 @@
+import { Ok, type Result } from "@alanscodelog/utils/Result"
+
+import { addKey } from "./addKey.js"
+
+import { defaultStringifier } from "../defaults/Stringifier.js"
+import { calculateLayoutSize } from "../helpers/calculateLayoutSize.js"
+import type { Key, Keys, MultipleErrors, PickManager, SHORTCUT_ERROR } from "../types/index.js"
+
+
+export function createKeys<
+	TKey extends
+	Key = Key,
+	TKeys extends
+	(TKey)[] = (TKey)[],
+	TEntries extends
+	Record<TKeys[number]["id"], Key> = Record<TKeys[number]["id"], Key>,
+	// causing issues
+	// RecordFromArray<TKeys, "id", Key> =
+	// RecordFromArray<TKeys, "id", Key>,
+	TCheck extends boolean | "only" = true
+>(
+	entries: TKeys,
+	manager: PickManager<"options", "stringifier"> = {
+		options: { stringifier: defaultStringifier }
+	},
+	rawKeys: Partial<Pick<Keys, "autoManageLayout" | "layout">> = {} as any,
+	{
+		check = true as TCheck
+	}: { check?: TCheck } = {}
+): Result<
+	TCheck extends "only" ? true : Keys<TEntries>,
+	MultipleErrors<
+			typeof SHORTCUT_ERROR.DUPLICATE_KEY
+	>
+> {
+	const keysList = entries
+	const keys: Keys = {
+		type: "keys",
+		// prevent multiple calculations when initially adding keys
+		autoManageLayout: false,
+		...rawKeys,
+		layout: { y: 0, x: 0, ...(rawKeys.layout ?? {}) },
+		entries: {},
+		nativeToggleKeys: [],
+		nativeModifierKeys: [],
+		variants: {},
+		toggles: {}
+	}
+	// clone anything addKey might touch, see below
+	const managerClone = { ...manager, keys }
+	if (check) {
+		for (const key of keysList) {
+			// this one is a bit weird
+			// we don't use check = "only" because we actually want keys.entries to be modified to error on duplicate keys
+			// the entire keys object isn't the user's rawKey copy anymore anyways
+			const res = addKey(key, managerClone)
+			if (res.isError) return res as any
+		}
+	}
+	if (check === "only") return Ok(true) satisfies Result<true, never> as any
+
+
+	if (rawKeys?.autoManageLayout) {
+		keys.autoManageLayout = true
+		keys.layout = calculateLayoutSize(keys)
+	}
+	return Ok(keys) satisfies Result<Keys, never> as any
+}

package/src/core/createManager.ts

@@ -0,0 +1,209 @@
+import { castType } from "@alanscodelog/utils/castType"
+import { isArray } from "@alanscodelog/utils/isArray"
+import { Ok, type Result } from "@alanscodelog/utils/Result"
+import type { RecordFromArray } from "@alanscodelog/utils/types"
+
+import { createCommand } from "./createCommand.js"
+import { createCommands } from "./createCommands.js"
+import { createKey } from "./createKey.js"
+import { createKeys } from "./createKeys.js"
+import { createManagerOptions } from "./createManagerOptions.js"
+import { createShortcut } from "./createShortcut.js"
+import { createShortcuts } from "./createShortcuts.js"
+
+import type { CanHookErrors, CanHooks, Command, Commands, CommandsSetEntries, Context, Hooks, Key, Keys, KeysSetEntries, Manager, ManagerListener, MultipleErrors, RawCommand, RawKey, RawShortcut, Shortcut, SHORTCUT_ERROR, Shortcuts, ShortcutsSetEntries } from "../types/index.js"
+
+/**
+ * Create a manager which can track key states, layouts, and trigger shortcuts. Basically the brains of the operation.
+ *
+ * First, all the elements of a manager need to be created.
+ * Then you can create the listeners for the manager with {@link createManagerEventListeners}.
+ *
+ * Then these listeners can be attached/removed from elements (or the {@link Emulator})
+ *
+ * You could make several managers for different areas of your application or use single manager and different contexts to differ between them.
+ *
+ * It is easiest to build a manager like so, but the manager also takes in full {@link Keys}/{@link Commands}/{@link Shortcuts} instances, though it's a bit harder to build those first then pass to the manager:
+ * ```ts
+ *
+ * const manager = createManager(
+ * {
+ * 	keys: [
+ * 		createKey("a", ),
+ *			// or using a raw key
+ * 		{id: "b"}
+ * 	],
+ * 	commands: [
+ * 		createCommand("a"),
+ * 		{name: "b", execute() {....}}
+ * 	],
+ * 	shortcuts: [
+ * 		{ chain: [["a"]], command: "a" }
+ * 	]
+ * 	context: createContext({...}),
+ * 	options: {
+ *		// required
+ * 		evaluateCondition() {
+ * 				...
+ * 		}
+ * 	}
+ * }, {
+ * 	// if constructing from raw entries like above, createKeys/Shortcuts can take additional options
+ * 	...,
+ * 		keys: {...},
+ * 		shortcuts:{...}
+ * }).unwrap()
+ *
+ * const listeners = createManagerEventListeners(manager)
+ * attach(document, listeners)
+ * // to remove:
+ * dettach(document, listeners)
+ * ```
+ *
+ * You will then not need to do much else. It will take care of setting the pressed state of keys, the state of the current chord chain (see {@link Manager._chain}), finding a matching shortcut if it exists, and triggering it's command.
+ *
+ * The way this works is that when a key is pressed it's added to the current chord in the chain. If the chain matches a shortcut's chain that can be triggered (it must be enabled, it must have a command and a function to execute, and it's condition and it's command's condition must evaluate to true), the command's execute function is triggered with `isKeydown = true`, see {@link Command.execute}.
+ *
+ * If there are no shortcuts to trigger but there are "potential shortcuts" that start with the current chain and could trigger and current chord contains any non-modifier keys (see {@link Manager.pressedNonModifierKeys}), an empty chord will be added to the chain on the next key pressed and the process repeats.
+ *
+ * If there are no shortcuts and no potential shortcuts, the callback will be called with {@link SHORTCUT_ERROR.NO_MATCHING_SHORTCUT} and you will probably want to clear the chain. When the chain is cleared (see {@link Manager._chain}), the manager will not add/remove keys from the chain until all non-modifier keys are unpressed. Pressed state is still set/tracked though.
+ *
+ * The moment a key is released after a shortcut is triggered, the command's execute function is fired again with `isKeydown = false`.
+ *
+ * If {@link Manager.options.updateStateOnAllEvents} is not disabled and a mouseeneter listener was created, the manager is able to keep the most accurate state of the modifier keys. See {@link Manager.options.updateStateOnAllEvents} for more info.
+ *
+ * For a detailed usage example, see the demo.
+ *
+ * ### Other
+ *
+ * - If you need to emulate keypresses for testing see {@link Emulator}.
+ */
+
+
+export function createManager<
+	THooks extends Hooks,
+	TKeys extends Keys | RawKey[],
+	TShortcuts extends Shortcuts | RawShortcut[],
+	TCommands extends Commands | RawCommand[],
+	TContext extends Context,
+	TListener extends ManagerListener
+>(
+	rawManager: {
+		name?: string
+		options: Partial<Omit<Manager["options"], "evaluateCondition">>
+			& Pick<Manager<any, any, any, any, TContext>["options"], "evaluateCondition">
+		context?: TContext
+		keys?: TKeys
+		shortcuts?: TShortcuts
+		commands?: TCommands
+		hooks?: Partial<THooks>
+		listener?: TListener
+	},
+	additionalOpts: Partial<{
+		keys?: Partial<Pick<Keys, "autoManageLayout" | "layout">>
+		shortcuts?:	Partial<Pick<Shortcuts, "ignoreModifierConflicts" | "ignoreChainConflicts">>
+	}
+	> = {}
+): Result<
+	Manager<
+		THooks,
+		TKeys extends Keys
+			? Extract<TKeys, Keys>
+			: TKeys extends RawKey[]
+				? Keys<RecordFromArray<TKeys, "id", Key>>
+				: never,
+		Shortcuts,
+		TCommands extends Commands
+			? Extract<TCommands, Commands>
+			: TCommands extends RawCommand[]
+				? Commands<RecordFromArray<TCommands, "name", Command>>
+				: never,
+		TContext
+	>,
+	MultipleErrors<
+		| CommandsSetEntries["entries@add"]["error"]
+		| KeysSetEntries["entries@add"]["error"]
+		| ShortcutsSetEntries["entries@add"]["error"]
+		| typeof SHORTCUT_ERROR.INVALID_VARIANT
+	> | CanHookErrors<THooks extends never ? never : THooks, keyof CanHooks>
+> {
+	const options = createManagerOptions(rawManager.options as any)
+	const m = { options }
+	const state = {
+		chain: [],
+		isAwaitingKeyup: false,
+		isRecording: false,
+		untrigger: false,
+		nextIsChord: false
+	} satisfies Manager["state"]
+
+	let keys = rawManager.keys
+
+	if (!keys || isArray(keys)) {
+		castType<RawKey[]>(keys)
+		const keysList: Key[] = []
+		if (keys) {
+			for (const key of keys) {
+				const res = createKey(key.id, key)
+				if (res.isError) return res
+				keysList.push(res.value)
+			}
+		}
+		const res = createKeys(keysList, m, additionalOpts?.keys)
+		if (res.isError) return res
+		keys = res.value satisfies Keys as any
+	}
+
+	let commands = rawManager.commands
+
+	if (!commands || isArray(commands)) {
+		castType<RawCommand[]>(commands)
+		const commandsList: Command[] = []
+		if (commands) {
+			for (const command of commands) {
+				const res = createCommand(command.name, command)
+				commandsList.push(res)
+			}
+		}
+
+		const res = createCommands(commandsList, { options })
+		if (res.isError) return res as any
+		commands = res.value satisfies Commands as any
+	}
+
+	let shortcuts = rawManager.shortcuts
+	if (!shortcuts || isArray(shortcuts)) {
+		castType<RawShortcut[]>(shortcuts)
+		const shortcutsList: Shortcut[] = []
+		const m2 = { ...m, commands: commands as Commands, keys: keys as Keys }
+		if (shortcuts) {
+			for (const shortcut of shortcuts) {
+				const res = createShortcut(shortcut, m2)
+				if (res.isError) return res
+				shortcutsList.push(res.value)
+			}
+		}
+
+		const res = createShortcuts(shortcutsList, {
+			keys: keys! as Keys,
+			commands: commands! as Commands,
+			options
+		}, additionalOpts?.shortcuts)
+		if (res.isError) return res as any
+		shortcuts = res.value satisfies Shortcuts as any
+	}
+
+	const manager: Manager = {
+		...rawManager,
+		name: rawManager.name ?? "manager",
+		type: "manager",
+		keys: keys! as Keys,
+		shortcuts: shortcuts! as Shortcuts,
+		commands: commands! as Commands,
+		options,
+		state,
+		context: rawManager.context!,
+		hooks: rawManager?.hooks as any as THooks
+	}
+	return Ok(manager) as any
+}

package/src/core/createManagerEventListeners.ts

@@ -0,0 +1,139 @@
+import { getKeyFromEventCode } from "../helpers/getKeyFromEventCode.js"
+import { addToChain } from "../internal/addToChain.js"
+import { removeFromChain } from "../internal/removeFromChain.js"
+import { setKeysState } from "../internal/setKeysState.js"
+import { updateNativeKeysState } from "../internal/updateNativeKeysState.js"
+import type { EventListenerTypes, EventTypes, Manager } from "../types/index.js"
+
+
+export function createManagerEventListeners<T extends EventTypes, TTypes extends T[]>(
+	manager: Manager,
+	types: TTypes = ["keydown", "keyup", "keypress", "wheel", "mousedown", "mouseup", "mouseenter"] as TTypes,
+	{ debug }: { debug?: true | ((type: EventTypes, e: KeyboardEvent | MouseEvent) => void) } = {}
+): EventListenerTypes<TTypes[number]> {
+	// eslint-disable-next-line no-console
+	const debugFn = debug === true ? console.log : undefined
+	const listeners: Partial<EventListenerTypes<EventTypes>> = {}
+	for (const type of types) {
+		switch (type) {
+			case "keydown": {
+				listeners.keydown = (e: KeyboardEvent): void => {
+					debugFn?.("keydown", e)
+					if (!manager.options.enableListeners) return
+					const keyIds = getKeyFromEventCode(e.code, e, manager.keys.entries)
+					if (keyIds.isError) {
+						manager.options.cb(manager, keyIds.error, e)
+						return
+					}
+
+					const ids = keyIds.value
+					manager.listener?.({ event: e, isKeydown: true, keys: ids, manager })
+					setKeysState(ids, manager, true)
+					updateNativeKeysState(manager, e, ids)
+					const res = addToChain(manager, ids, e)
+					if (res.isError) { manager.options.cb(manager, res.error, e) }
+				}
+				break
+			}
+			case "keyup": {
+				listeners.keyup = (e: KeyboardEvent): void => {
+					debugFn?.("keyup", e)
+					if (!manager.options.enableListeners) return
+					const keyIds = getKeyFromEventCode(e.code, e, manager.keys.entries)
+
+					if (keyIds.isError) {
+						manager.options.cb(manager, keyIds.error, e)
+						return
+					}
+
+					const ids = keyIds.value
+					manager.listener?.({ event: e, isKeydown: false, keys: ids, manager })
+					setKeysState(ids, manager, false)
+					updateNativeKeysState(manager, e, ids)
+					const res = removeFromChain(manager, ids, e)
+					if (res.isError) { manager.options.cb(manager, res.error, e) }
+				}
+				break
+			}
+			case "wheel": {
+				listeners.wheel = (e: WheelEvent): void => {
+					debugFn?.("wheel", e)
+					if (!manager.options.enableListeners) return
+					const dir = e.deltaY < 0 ? "Up" : "Down"
+					const code = `Wheel${dir}`
+					const keyIds = getKeyFromEventCode(code, e, manager.keys.entries, { pressedState: false })
+
+					if (keyIds.isError) {
+						manager.options.cb(manager, keyIds.error, e)
+						return
+					}
+					const ids = keyIds.value
+					manager.listener?.({ event: e, isKeydown: true, keys: ids, manager })
+					setKeysState(ids, manager, true)
+					updateNativeKeysState(manager, e, ids)
+					addToChain(manager, ids, e)
+					manager.listener?.({ event: e, isKeydown: false, keys: ids, manager })
+					setKeysState(ids, manager, false)
+					const res = removeFromChain(manager, ids, e)
+					if (res.isError) { manager.options.cb(manager, res.error, e) }
+				}
+				break
+			}
+			case "mousedown": {
+				listeners.mousedown = (e: MouseEvent): void => {
+					debugFn?.("mousedown", e)
+					if (!manager.options.enableListeners) return
+					const button = e.button.toString()
+
+					const keyIds = getKeyFromEventCode(button, e, manager.keys.entries, { pressedState: false })
+					if (keyIds.isError) {
+						manager.options.cb(manager, keyIds.error, e)
+						return
+					}
+					const ids = keyIds.value
+					manager.listener?.({ event: e, isKeydown: true, keys: ids, manager })
+					setKeysState(ids, manager, true)
+
+					updateNativeKeysState(manager, e, ids)
+					const res = addToChain(manager, ids, e)
+					if (res.isError) { manager.options.cb(manager, res.error, e) }
+				}
+
+				break
+			}
+			case "mouseup": {
+				listeners.mouseup = (e: MouseEvent): void => {
+					debugFn?.("mouseup", e)
+					if (!manager.options.enableListeners) return
+					const button = e.button.toString()
+					const keyIds = getKeyFromEventCode(button, e, manager.keys.entries, { pressedState: true })
+
+					if (keyIds.isError) {
+						manager.options.cb(manager, keyIds.error, e)
+						return
+					}
+					const ids = keyIds.value
+					manager.listener?.({ event: e, isKeydown: false, keys: ids, manager })
+					setKeysState(ids, manager, false)
+					updateNativeKeysState(manager, e, ids)
+					const res = removeFromChain(manager, ids, e)
+					if (res.isError) { manager.options.cb(manager, res.error, e) }
+				}
+
+				break
+			}
+			case "mouseenter": {
+				listeners.mouseenter = (e: MouseEvent): void => {
+					debugFn?.("mouseenter", e)
+					if (!manager.options.enableListeners) return
+					manager.listener?.({ event: e, isKeydown: true, keys: [], manager })
+					updateNativeKeysState(manager, e, [])
+				}
+
+				break
+			}
+		}
+	}
+	return listeners as EventListenerTypes<EventTypes>
+}
+

package/src/core/createManagerOptions.ts

@@ -0,0 +1,29 @@
+import type { createManager } from "./createManager.js"
+
+import { defaultConditionEquals } from "../defaults/defaultConditionEquals.js"
+import { defaultManagerCallback } from "../defaults/defaultManagerCallback.js"
+import { defaultSorter } from "../defaults/KeysSorter.js"
+import { defaultStringifier } from "../defaults/Stringifier.js"
+import type { Manager } from "../types/index.js"
+
+
+/**
+ * Many methods require some of the manager's options, but not the entire manager. Also it's easier to create a manager from scratch by first creating it's options
+ *
+ * This can be used to create the base manager options.
+ */
+export function createManagerOptions(
+	rawOpts: Parameters<typeof createManager>[0]["options"]
+): Manager["options"] {
+	const options: Manager["options"] = {
+		sorter: defaultSorter,
+		stringifier: defaultStringifier,
+		conditionEquals: defaultConditionEquals,
+		cb: defaultManagerCallback,
+		enableShortcuts: true,
+		enableListeners: true,
+		updateStateOnAllEvents: true,
+		...rawOpts
+	}
+	return options
+}

package/src/core/createShortcut.ts

@@ -0,0 +1,49 @@
+import { Ok, type Result } from "@alanscodelog/utils/Result"
+
+import { isValidShortcut } from "../helpers/isValidShortcut.js"
+import type { ChainError, Command, Condition, Manager, MultipleErrors, PickManager, RawShortcut, Shortcut, SHORTCUT_ERROR } from "../types/index.js"
+
+
+/**
+ * Creates a {@link Shortcut} object from a {@link RawShortcut}.
+ *
+ * If the raw shortcut has no condition, a new blank empty condition is created. If you will be following the suggestion of not having any conditions equal eachother (see {@link ConditionComparer}), you can fallback to passing the same instance of an empty condition without issues.
+ */
+export function createShortcut<
+	TRawCommand extends Command["name"] | Command = Command["name"] | Command,
+	TCommand extends TRawCommand extends string ? Command<TRawCommand> : TRawCommand = TRawCommand extends string ? Command<TRawCommand> : TRawCommand,
+	TCondition extends Condition = Condition
+
+>(
+	rawShortcut: RawShortcut<TRawCommand, TCommand, TCondition>,
+	manager: Pick<Manager, "keys" | "commands">
+		& PickManager<"options", "stringifier" | "sorter">
+): Result<Shortcut<TCommand["name"], TCondition>, MultipleErrors<
+	| ChainError
+	| typeof SHORTCUT_ERROR.UNKNOWN_COMMAND
+>> {
+	const sorter = manager.options.sorter
+
+	const finalChain = []
+	for (const chord of rawShortcut.chain) {
+		const stringChord = chord.map(key => typeof key === "object" ? key.id : key)
+		sorter.sort(stringChord, manager.keys)
+		finalChain.push(stringChord)
+	}
+	const command = typeof rawShortcut.command === "string" ? rawShortcut.command : rawShortcut.command?.name
+
+	const shortcut: Shortcut = {
+		...rawShortcut as any,
+		type: "shortcut",
+		enabled: rawShortcut.enabled ?? true,
+		command,
+		chain: finalChain,
+		condition: rawShortcut.condition ?? { type: "condition", text: "" },
+		forceUnequal: false
+	}
+	const res = isValidShortcut(shortcut, manager)
+	if (res.isError) return res
+
+
+	return Ok(shortcut satisfies Shortcut as any)
+}

package/src/core/createShortcuts.ts

@@ -0,0 +1,51 @@
+import { Ok, type Result } from "@alanscodelog/utils/Result"
+
+import { addShortcut } from "./addShortcut.js"
+
+import type { CanHookErrors, Manager, MultipleErrors, PickManager, Shortcut, Shortcuts, ShortcutsSetEntries } from "../types/index.js"
+
+/**
+ * # Shortcut
+ *
+ * Creates a set of shortcuts.
+ *
+ */
+export function createShortcuts<
+	THooks extends Manager["hooks"],
+	TRawShortcuts extends Shortcut[],
+	TCheck extends boolean | "only" = true
+>(
+	shortcutsList: TRawShortcuts,
+	manager: Pick<Manager, "keys" | "commands">
+		& PickManager<"options", | "evaluateCondition" | "conditionEquals" | "stringifier" | "sorter">
+		& { hooks?: THooks },
+	opts?: Partial<Pick<Shortcuts, "ignoreModifierConflicts" | "ignoreChainConflicts">>,
+	{
+		check = true as TCheck
+	}: { check?: boolean | "only" } = {}
+): Result<
+	TCheck extends "only" ? true : Shortcuts,
+	MultipleErrors<
+		ShortcutsSetEntries["entries@add"]["error"]
+	> | CanHookErrors<THooks extends never ? never : THooks, "canSetShortcutsProp">
+> {
+	const shortcuts: Shortcuts = {
+		entries: [],
+		ignoreModifierConflicts: opts?.ignoreModifierConflicts ?? false,
+		ignoreChainConflicts: opts?.ignoreChainConflicts ?? false
+
+	}
+	const managerClone = { ...manager, shortcuts }
+	if (check) {
+		for (const shortcut of shortcutsList) {
+			// we check all first to avoid erroring mid-way through
+			const res = addShortcut(shortcut, managerClone)
+			if (res.isError) return res
+		}
+	}
+	if (check === "only") return Ok(true) satisfies Result<true, never> as any
+
+
+	return Ok(shortcuts) satisfies Result<Shortcuts, never> as any
+}
+

package/src/core/detach.ts

@@ -0,0 +1,21 @@
+import { keys } from "@alanscodelog/utils/keys"
+import type { AnyFunction } from "@alanscodelog/utils/types"
+
+import type { AttachTarget, EventTypes } from "../types/index.js"
+
+/**
+ * Detach the listeners from an element.
+ *
+ * Or you can just use the abort controller returned by {@link attach}.
+ */
+export function detach(
+	el: AttachTarget,
+	listeners: Record<EventTypes, AnyFunction>,
+	/** Listeners need ot be detached with the same options they were attached with. */
+	opts: Partial<Record<EventTypes, AddEventListenerOptions>> = { wheel: { passive: true } }
+): void {
+	for (const name of keys(listeners)) {
+		el.removeEventListener(name, listeners[name], opts[name])
+	}
+}
+

package/src/core/index.ts

@@ -0,0 +1,35 @@
+export * from "../types/index.js"
+export * as helpers from "../helpers/index.js"
+export * as utils from "../helpers/index.js"
+
+/* Autogenerated Index */
+
+export { addCommand } from "./addCommand.js"
+export { addKey } from "./addKey.js"
+export { addShortcut } from "./addShortcut.js"
+export { attach } from "./attach.js"
+export { createCommand } from "./createCommand.js"
+export { createCommands } from "./createCommands.js"
+export { createCondition } from "./createCondition.js"
+export { createContext } from "./createContext.js"
+export { createKey } from "./createKey.js"
+export { createKeys } from "./createKeys.js"
+export { createManager } from "./createManager.js"
+export { createManagerEventListeners } from "./createManagerEventListeners.js"
+export { createManagerOptions } from "./createManagerOptions.js"
+export { createShortcut } from "./createShortcut.js"
+export { createShortcuts } from "./createShortcuts.js"
+export { detach } from "./detach.js"
+export { EmulatedEvent } from "./EmulatedEvent.js"
+export { Emulator } from "./Emulator.js"
+export { removeCommand } from "./removeCommand.js"
+export { removeKey } from "./removeKey.js"
+export { removeShortcut } from "./removeShortcut.js"
+export { setCommandProp } from "./setCommandProp.js"
+export { setCommandsProp } from "./setCommandsProp.js"
+export { setKeyProp } from "./setKeyProp.js"
+export { setKeysProp } from "./setKeysProp.js"
+export { setManagerProp } from "./setManagerProp.js"
+export { setShortcutProp } from "./setShortcutProp.js"
+export { setShortcutsProp } from "./setShortcutsProp.js"
+export { ShortcutManagerManager } from "./ShortcutManagerManager.js"

package/src/core/removeCommand.ts

@@ -0,0 +1,25 @@
+import { Ok, type Result } from "@alanscodelog/utils/Result"
+
+import { setCommandsProp } from "./setCommandsProp.js"
+
+import type { CanHookErrors, Command, CommandsSetEntries, Manager, MultipleErrors } from "../types/index.js"
+
+
+export function removeCommand<
+	THooks extends Manager["hooks"],
+	TCheck extends boolean | "only" = true
+>(
+	command: Command,
+	manager: CommandsSetEntries["entries@remove"]["manager"] & { hooks?: THooks },
+	opts: { check?: TCheck } = {}
+): Result<
+	TCheck extends "only" ? true : Command,
+	MultipleErrors<
+		CommandsSetEntries["entries@remove"]["error"]
+	> | CanHookErrors<THooks extends never ? never : THooks, "canSetCommandsProp">
+> {
+	const res = setCommandsProp("entries@remove", command, manager, opts)
+	if (res.isError) return res
+
+	return Ok(command) satisfies Result<Command, never> as any
+}

package/src/core/removeKey.ts

@@ -0,0 +1,25 @@
+import { Ok, type Result } from "@alanscodelog/utils/Result"
+
+import { setKeysProp } from "./setKeysProp.js"
+
+import type { CanHookErrors, Key, KeysSetEntries, Manager, MultipleErrors } from "../types/index.js"
+
+
+export function removeKey<
+	THooks extends Manager["hooks"],
+	TCheck extends boolean | "only" = true
+>(
+	key: Key,
+	manager: KeysSetEntries["entries@remove"]["manager"] & { hooks?: THooks },
+	opts: { check?: TCheck } = {}
+): Result<
+	TCheck extends "only" ? true : Key,
+	MultipleErrors<
+		KeysSetEntries["entries@remove"]["error"]
+	> | CanHookErrors<THooks extends never ? never : THooks, "canSetKeysProp">
+> {
+	const res = setKeysProp("entries@remove", key, manager, opts)
+	if (res.isError) return res
+	return Ok(key) satisfies Result<Key, never> as any
+}
+

package/src/core/removeShortcut.ts

@@ -0,0 +1,24 @@
+import { Ok, type Result } from "@alanscodelog/utils/Result"
+
+import { setShortcutsProp } from "./setShortcutsProp.js"
+
+import type { CanHookErrors, Manager, MultipleErrors, Shortcut, ShortcutsSetEntries } from "../types/index.js"
+
+
+export function removeShortcut<
+	THooks extends Manager["hooks"],
+	TCheck extends boolean | "only" = true
+>(
+	shortcut: Shortcut,
+	manager: ShortcutsSetEntries["entries@remove"]["manager"] & { hooks?: THooks },
+	opts: { check?: TCheck } = {}
+): Result<
+	TCheck extends "only" ? true : Shortcut,
+	MultipleErrors<
+		ShortcutsSetEntries["entries@remove"]["error"]
+	> | CanHookErrors<THooks extends never ? never : THooks, "canSetShortcutsProp">
+> {
+	const res = setShortcutsProp("entries@remove", shortcut, manager, opts)
+	if (res.isError) return res
+	return Ok(shortcut) satisfies Result<Shortcut, never> as any
+}