@witchcraft/spellcraft 0.0.1

package/dist/core/createContext.d.ts

@@ -0,0 +1,2 @@
+import type { Context, RawContext } from "../types/index.js";
+export declare function createContext<TContext extends RawContext>(value: TContext["value"], rawContext?: Omit<TContext, "value">): Context<TContext["value"]>;

package/dist/core/createContext.js

@@ -0,0 +1,8 @@
+export function createContext(value, rawContext = {}) {
+  const context = {
+    type: "context",
+    ...rawContext,
+    value
+  };
+  return context;
+}

package/dist/core/createKey.d.ts

@@ -0,0 +1,10 @@
+import { type Result } from "@alanscodelog/utils/Result";
+import { type Key, type MultipleErrors, type RawKey, SHORTCUT_ERROR } from "../types/index.js";
+/**
+ * Creates a key.
+ *
+ * @template TId **@internal** See {@link ./README.md Collection Entries}
+ * @param id See {@link Key.id}
+ * @param opts Set {@link Key}.
+ */
+export declare function createKey<TId extends string = string, TKey extends RawKey<TId> = RawKey<TId>>(id: TId, rawKey?: Omit<TKey, "id">): Result<Key<TId>, MultipleErrors<typeof SHORTCUT_ERROR.INVALID_VARIANT>>;

package/dist/core/createKey.js

@@ -0,0 +1,35 @@
+import { Err, Ok } from "@alanscodelog/utils/Result";
+import { KnownError } from "../helpers/KnownError.js";
+import { SHORTCUT_ERROR } from "../types/index.js";
+export function createKey(id, rawKey = {}) {
+  const k = rawKey;
+  const key = {
+    type: "key",
+    id,
+    label: k.label ?? id,
+    classes: [...k.classes ?? []],
+    x: k.x ?? 0,
+    y: k.y ?? 0,
+    width: k.width ?? 0,
+    height: k.height ?? 0,
+    enabled: k.enabled ?? true,
+    pressed: false,
+    isModifier: k.isModifier ?? false,
+    isToggle: k.isToggle ?? false,
+    ...k.isToggle ? {
+      toggleOnId: `${id}On`,
+      toggleOffId: `${id}Off`,
+      toggleOnPressed: false,
+      toggleOffPressed: false
+    } : {},
+    variants: k.variants ?? [],
+    render: k.render ?? true,
+    updateStateOnAllEvents: k.updateStateOnAllEvents ?? true
+  };
+  if (key.variants?.includes(key.id)) {
+    return Err(
+      new KnownError(SHORTCUT_ERROR.INVALID_VARIANT, `A key variant cannot be the key id itself. Attempted to use "${key.id}" in variants:[ ${key.variants.join(",")} ]`, { variants: key.variants, id: key.id })
+    );
+  }
+  return Ok(key);
+}

package/dist/core/createKeys.d.ts

@@ -0,0 +1,5 @@
+import { type Result } from "@alanscodelog/utils/Result";
+import type { Key, Keys, MultipleErrors, PickManager, SHORTCUT_ERROR } from "../types/index.js";
+export declare function createKeys<TKey extends Key = Key, TKeys extends (TKey)[] = (TKey)[], TEntries extends Record<TKeys[number]["id"], Key> = Record<TKeys[number]["id"], Key>, TCheck extends boolean | "only" = true>(entries: TKeys, manager?: PickManager<"options", "stringifier">, rawKeys?: Partial<Pick<Keys, "autoManageLayout" | "layout">>, { check }?: {
+    check?: TCheck;
+}): Result<TCheck extends "only" ? true : Keys<TEntries>, MultipleErrors<typeof SHORTCUT_ERROR.DUPLICATE_KEY>>;

package/dist/core/createKeys.js

@@ -0,0 +1,36 @@
+import { Ok } from "@alanscodelog/utils/Result";
+import { addKey } from "./addKey.js";
+import { defaultStringifier } from "../defaults/Stringifier.js";
+import { calculateLayoutSize } from "../helpers/calculateLayoutSize.js";
+export function createKeys(entries, manager = {
+  options: { stringifier: defaultStringifier }
+}, rawKeys = {}, {
+  check = true
+} = {}) {
+  const keysList = entries;
+  const 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: {}
+  };
+  const managerClone = { ...manager, keys };
+  if (check) {
+    for (const key of keysList) {
+      const res = addKey(key, managerClone);
+      if (res.isError) return res;
+    }
+  }
+  if (check === "only") return Ok(true);
+  if (rawKeys?.autoManageLayout) {
+    keys.autoManageLayout = true;
+    keys.layout = calculateLayoutSize(keys);
+  }
+  return Ok(keys);
+}

package/dist/core/createManager.d.ts

@@ -0,0 +1,81 @@
+import { type Result } from "@alanscodelog/utils/Result";
+import type { RecordFromArray } from "@alanscodelog/utils/types";
+import type { CanHookErrors, CanHooks, Command, Commands, CommandsSetEntries, Context, Hooks, Key, Keys, KeysSetEntries, Manager, ManagerListener, MultipleErrors, RawCommand, RawKey, RawShortcut, 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 declare 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>>;

package/dist/core/createManager.js

@@ -0,0 +1,83 @@
+import { castType } from "@alanscodelog/utils/castType";
+import { isArray } from "@alanscodelog/utils/isArray";
+import { Ok } from "@alanscodelog/utils/Result";
+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";
+export function createManager(rawManager, additionalOpts = {}) {
+  const options = createManagerOptions(rawManager.options);
+  const m = { options };
+  const state = {
+    chain: [],
+    isAwaitingKeyup: false,
+    isRecording: false,
+    untrigger: false,
+    nextIsChord: false
+  };
+  let keys = rawManager.keys;
+  if (!keys || isArray(keys)) {
+    castType(keys);
+    const keysList = [];
+    if (keys) {
+      for (const key of keys) {
+        const res2 = createKey(key.id, key);
+        if (res2.isError) return res2;
+        keysList.push(res2.value);
+      }
+    }
+    const res = createKeys(keysList, m, additionalOpts?.keys);
+    if (res.isError) return res;
+    keys = res.value;
+  }
+  let commands = rawManager.commands;
+  if (!commands || isArray(commands)) {
+    castType(commands);
+    const commandsList = [];
+    if (commands) {
+      for (const command of commands) {
+        const res2 = createCommand(command.name, command);
+        commandsList.push(res2);
+      }
+    }
+    const res = createCommands(commandsList, { options });
+    if (res.isError) return res;
+    commands = res.value;
+  }
+  let shortcuts = rawManager.shortcuts;
+  if (!shortcuts || isArray(shortcuts)) {
+    castType(shortcuts);
+    const shortcutsList = [];
+    const m2 = { ...m, commands, keys };
+    if (shortcuts) {
+      for (const shortcut of shortcuts) {
+        const res2 = createShortcut(shortcut, m2);
+        if (res2.isError) return res2;
+        shortcutsList.push(res2.value);
+      }
+    }
+    const res = createShortcuts(shortcutsList, {
+      keys,
+      commands,
+      options
+    }, additionalOpts?.shortcuts);
+    if (res.isError) return res;
+    shortcuts = res.value;
+  }
+  const manager = {
+    ...rawManager,
+    name: rawManager.name ?? "manager",
+    type: "manager",
+    keys,
+    shortcuts,
+    commands,
+    options,
+    state,
+    context: rawManager.context,
+    hooks: rawManager?.hooks
+  };
+  return Ok(manager);
+}

package/dist/core/createManagerEventListeners.d.ts

@@ -0,0 +1,4 @@
+import type { EventListenerTypes, EventTypes, Manager } from "../types/index.js";
+export declare function createManagerEventListeners<T extends EventTypes, TTypes extends T[]>(manager: Manager, types?: TTypes, { debug }?: {
+    debug?: true | ((type: EventTypes, e: KeyboardEvent | MouseEvent) => void);
+}): EventListenerTypes<TTypes[number]>;

package/dist/core/createManagerEventListeners.js

@@ -0,0 +1,130 @@
+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";
+export function createManagerEventListeners(manager, types = ["keydown", "keyup", "keypress", "wheel", "mousedown", "mouseup", "mouseenter"], { debug } = {}) {
+  const debugFn = debug === true ? console.log : void 0;
+  const listeners = {};
+  for (const type of types) {
+    switch (type) {
+      case "keydown": {
+        listeners.keydown = (e) => {
+          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) => {
+          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) => {
+          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) => {
+          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) => {
+          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) => {
+          debugFn?.("mouseenter", e);
+          if (!manager.options.enableListeners) return;
+          manager.listener?.({ event: e, isKeydown: true, keys: [], manager });
+          updateNativeKeysState(manager, e, []);
+        };
+        break;
+      }
+    }
+  }
+  return listeners;
+}

package/dist/core/createManagerOptions.d.ts

@@ -0,0 +1,8 @@
+import type { createManager } from "./createManager.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 declare function createManagerOptions(rawOpts: Parameters<typeof createManager>[0]["options"]): Manager["options"];

package/dist/core/createManagerOptions.js

@@ -0,0 +1,17 @@
+import { defaultConditionEquals } from "../defaults/defaultConditionEquals.js";
+import { defaultManagerCallback } from "../defaults/defaultManagerCallback.js";
+import { defaultSorter } from "../defaults/KeysSorter.js";
+import { defaultStringifier } from "../defaults/Stringifier.js";
+export function createManagerOptions(rawOpts) {
+  const options = {
+    sorter: defaultSorter,
+    stringifier: defaultStringifier,
+    conditionEquals: defaultConditionEquals,
+    cb: defaultManagerCallback,
+    enableShortcuts: true,
+    enableListeners: true,
+    updateStateOnAllEvents: true,
+    ...rawOpts
+  };
+  return options;
+}

package/dist/core/createShortcut.d.ts

@@ -0,0 +1,8 @@
+import { type Result } from "@alanscodelog/utils/Result";
+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 declare 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>>;

package/dist/core/createShortcut.js

@@ -0,0 +1,24 @@
+import { Ok } from "@alanscodelog/utils/Result";
+import { isValidShortcut } from "../helpers/isValidShortcut.js";
+export function createShortcut(rawShortcut, manager) {
+  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 = {
+    ...rawShortcut,
+    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);
+}

package/dist/core/createShortcuts.d.ts

@@ -0,0 +1,13 @@
+import { type Result } from "@alanscodelog/utils/Result";
+import type { CanHookErrors, Manager, MultipleErrors, PickManager, Shortcut, Shortcuts, ShortcutsSetEntries } from "../types/index.js";
+/**
+ * # Shortcut
+ *
+ * Creates a set of shortcuts.
+ *
+ */
+export declare 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 }?: {
+    check?: boolean | "only";
+}): Result<TCheck extends "only" ? true : Shortcuts, MultipleErrors<ShortcutsSetEntries["entries@add"]["error"]> | CanHookErrors<THooks extends never ? never : THooks, "canSetShortcutsProp">>;

package/dist/core/createShortcuts.js

@@ -0,0 +1,20 @@
+import { Ok } from "@alanscodelog/utils/Result";
+import { addShortcut } from "./addShortcut.js";
+export function createShortcuts(shortcutsList, manager, opts, {
+  check = true
+} = {}) {
+  const shortcuts = {
+    entries: [],
+    ignoreModifierConflicts: opts?.ignoreModifierConflicts ?? false,
+    ignoreChainConflicts: opts?.ignoreChainConflicts ?? false
+  };
+  const managerClone = { ...manager, shortcuts };
+  if (check) {
+    for (const shortcut of shortcutsList) {
+      const res = addShortcut(shortcut, managerClone);
+      if (res.isError) return res;
+    }
+  }
+  if (check === "only") return Ok(true);
+  return Ok(shortcuts);
+}

package/dist/core/detach.d.ts

@@ -0,0 +1,10 @@
+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 declare 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>>): void;

package/dist/core/detach.js

@@ -0,0 +1,6 @@
+import { keys } from "@alanscodelog/utils/keys";
+export function detach(el, listeners, opts = { wheel: { passive: true } }) {
+  for (const name of keys(listeners)) {
+    el.removeEventListener(name, listeners[name], opts[name]);
+  }
+}

package/dist/core/index.d.ts

@@ -0,0 +1,32 @@
+export * from "../types/index.js";
+export * as helpers from "../helpers/index.js";
+export * as utils from "../helpers/index.js";
+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/dist/core/index.js

@@ -0,0 +1,32 @@
+export * from "../types/index.js";
+export * as helpers from "../helpers/index.js";
+export * as utils from "../helpers/index.js";
+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/dist/core/removeCommand.d.ts

@@ -0,0 +1,7 @@
+import { type Result } from "@alanscodelog/utils/Result";
+import type { CanHookErrors, Command, CommandsSetEntries, Manager, MultipleErrors } from "../types/index.js";
+export declare 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">>;

package/dist/core/removeCommand.js

@@ -0,0 +1,7 @@
+import { Ok } from "@alanscodelog/utils/Result";
+import { setCommandsProp } from "./setCommandsProp.js";
+export function removeCommand(command, manager, opts = {}) {
+  const res = setCommandsProp("entries@remove", command, manager, opts);
+  if (res.isError) return res;
+  return Ok(command);
+}

package/dist/core/removeKey.d.ts

@@ -0,0 +1,7 @@
+import { type Result } from "@alanscodelog/utils/Result";
+import type { CanHookErrors, Key, KeysSetEntries, Manager, MultipleErrors } from "../types/index.js";
+export declare 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">>;

package/dist/core/removeKey.js

@@ -0,0 +1,7 @@
+import { Ok } from "@alanscodelog/utils/Result";
+import { setKeysProp } from "./setKeysProp.js";
+export function removeKey(key, manager, opts = {}) {
+  const res = setKeysProp("entries@remove", key, manager, opts);
+  if (res.isError) return res;
+  return Ok(key);
+}

package/dist/core/removeShortcut.d.ts

@@ -0,0 +1,7 @@
+import { type Result } from "@alanscodelog/utils/Result";
+import type { CanHookErrors, Manager, MultipleErrors, Shortcut, ShortcutsSetEntries } from "../types/index.js";
+export declare 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">>;

package/dist/core/removeShortcut.js

@@ -0,0 +1,7 @@
+import { Ok } from "@alanscodelog/utils/Result";
+import { setShortcutsProp } from "./setShortcutsProp.js";
+export function removeShortcut(shortcut, manager, opts = {}) {
+  const res = setShortcutsProp("entries@remove", shortcut, manager, opts);
+  if (res.isError) return res;
+  return Ok(shortcut);
+}