@witchcraft/spellcraft 0.0.1

package/dist/helpers/shortcutSwapChords.js

@@ -0,0 +1,118 @@
+import { crop } from "@alanscodelog/utils/crop";
+import { Err, Ok } from "@alanscodelog/utils/Result";
+import { KnownError } from "./KnownError.js";
+import { setShortcutProp } from "../core/setShortcutProp.js";
+import { defaultStringifier } from "../defaults/Stringifier.js";
+import { SHORTCUT_ERROR } from "../types/index.js";
+import { equalsKeys } from "../utils/equalsKeys.js";
+function setForceUnequalOnAll(shortcuts, val, save = false) {
+  const was = save ? [] : void 0;
+  for (let i = 0; i < shortcuts.length; i++) {
+    const shortcut = shortcuts[i];
+    if (save) was.push(shortcut.forceUnequal);
+    setShortcutProp(shortcut, "forceUnequal", typeof val === "boolean" ? val : val[i], {});
+  }
+  return was;
+}
+function canSwapChords(shortcuts, manager, chainA, chainB, filter) {
+  let can = Ok(true);
+  const shortcutsClone = { ...shortcuts, entries: [...shortcuts.entries.map((_) => ({ ..._ }))] };
+  const managerClone = { ...manager, shortcuts: shortcutsClone };
+  const { shortcutsA, shortcutsB } = getToSwap(shortcutsClone, manager, chainA, chainB, filter);
+  const wasA = setForceUnequalOnAll(shortcutsA, true, true);
+  for (const shortcutB of shortcutsB) {
+    const newChain = [...chainA, ...shortcutB.chain.slice(chainA.length, shortcutB.chain.length)];
+    const res = setShortcutProp(shortcutB, "chain", newChain, managerClone);
+    if (res.isError) {
+      can = res;
+      break;
+    }
+  }
+  setForceUnequalOnAll(shortcutsA, wasA);
+  if (can.isOk) {
+    const wasB = setForceUnequalOnAll(shortcutsB, true, true);
+    for (const shortcutA of shortcutsA) {
+      const newChain = [...chainB, ...shortcutA.chain.slice(chainB.length, shortcutA.chain.length)];
+      const res = setShortcutProp(shortcutA, "chain", newChain, managerClone);
+      if (res.isError) {
+        can = res;
+        break;
+      }
+    }
+    setForceUnequalOnAll(shortcutsB, wasB);
+  }
+  return can;
+}
+function assertChordsNotEmpty(chord, keys, { stringifier: s = defaultStringifier } = {}) {
+  let found;
+  if (chord.length === 0 || chord.find((ks) => ks.length === 0)) {
+    found = chord;
+  }
+  if (found) {
+    return Err(new KnownError(
+      SHORTCUT_ERROR.INVALID_SWAP_CHORDS,
+      `Cannot swap with empty chord, but ${s.stringify(chord, { keys })} contains an empty chord.`,
+      { chord }
+    ));
+  }
+  return Ok(true);
+}
+function assertCorrectSwapParameters(keys, chordsA, chordsB, {
+  stringifier: s = defaultStringifier
+} = {}) {
+  const canA = assertChordsNotEmpty(chordsA, keys, { stringifier: s });
+  if (canA.isError) {
+    return canA;
+  }
+  const canB = assertChordsNotEmpty(chordsB, keys, { stringifier: s });
+  if (canB.isError) {
+    return canB;
+  }
+  if (equalsKeys(chordsA, chordsB, keys, chordsB.length) || equalsKeys(chordsB, chordsA, keys, chordsA.length)) {
+    return Err(new KnownError(SHORTCUT_ERROR.INVALID_SWAP_CHORDS, crop`
+			The chords to swap cannot share starting chords.
+			Chords:
+			${s.stringify(chordsA, { keys })}
+			${s.stringify(chordsB, { keys })}
+			`, { chordsA, chordsB }));
+  }
+  return Ok(true);
+}
+function getToSwap(shortcuts, manager, chainA, chainB, filter) {
+  let shortcutsA = shortcuts.entries.filter((shortcut) => equalsKeys(shortcut.chain, chainA, manager.keys, chainA.length));
+  let shortcutsB = shortcuts.entries.filter((shortcut) => equalsKeys(shortcut.chain, chainB, manager.keys, chainB.length));
+  if (filter) {
+    shortcutsA = shortcutsA.filter(filter);
+    shortcutsB = shortcutsB.filter(filter);
+  }
+  return { shortcutsA, shortcutsB };
+}
+export function shortcutSwapChords(shortcuts, chainA, chainB, manager, {
+  check = true
+} = {}, filter) {
+  const res = assertCorrectSwapParameters(manager.keys, chainA, chainB);
+  if (res.isError) {
+    return res;
+  }
+  if (check) {
+    const res2 = canSwapChords(shortcuts, manager, chainA, chainB, filter);
+    if (res2.isError) {
+      return res2;
+    }
+  }
+  if (check === "only") {
+    return Ok(true);
+  }
+  const { shortcutsA, shortcutsB } = getToSwap(shortcuts, manager, chainA, chainB, filter);
+  const wasA = setForceUnequalOnAll(shortcutsA, true, true);
+  for (const shortcutB of shortcutsB) {
+    setShortcutProp(shortcutB, "chain", [...chainA, ...shortcutB.chain.slice(chainA.length, shortcutB.chain.length)], manager, { check: false });
+  }
+  setForceUnequalOnAll(shortcutsA, wasA);
+  const wasB = setForceUnequalOnAll(shortcutsA, true, true);
+  for (const shortcutA of shortcutsA) {
+    setShortcutProp(shortcutA, "chain", [...chainB, ...shortcutA.chain.slice(chainB.length, shortcutA.chain.length)], manager, { check: false });
+  }
+  setForceUnequalOnAll(shortcutsA, wasB, true);
+  return Ok(true);
+}

package/dist/helpers/virtualPress.d.ts

@@ -0,0 +1,13 @@
+import type { Manager } from "../types/index.js";
+/**
+ * The manager is not designed to react to setting a key's pressed state directly only to events to then set the key state.
+ *
+ * So this method is provided to allow a "virtual" press (i.e. by some method that is not a real key press such as directly clicking on a visual representation of the key), without having to use the Emulator.
+ *
+ * It takes care of changing the key press state, and adding the key to the chain.
+ *
+ * Note that it is more simplistic and less "precise" than the emulator. It will ignore the type of toggles (native toggles will be treated as emulated). If using {@link Manager.options.updateStateOnAllEvents}, you will probably want to temporarily disable it or the state of the key press might get immediately reset.
+ *
+ * There is also {@link virtualRelease} and {@link virtualToggle}.
+ */
+export declare function virtualPress(manager: Manager, keyIdOrVariant: string): void;

package/dist/helpers/virtualPress.js

@@ -0,0 +1,15 @@
+import { getKeyFromIdOrVariant } from "./getKeyFromIdOrVariant.js";
+import { addToChain } from "../internal/addToChain.js";
+import { setKeysState } from "../internal/setKeysState.js";
+export function virtualPress(manager, keyIdOrVariant) {
+  const res = getKeyFromIdOrVariant(keyIdOrVariant, manager.keys);
+  if (res.isError) {
+    manager.options.cb(manager, res.error);
+    return;
+  }
+  const key = res.value[0];
+  const keys = [key.id];
+  manager.listener?.({ isKeydown: true, keys, manager });
+  setKeysState(keys, manager, true, { ignoreToggleType: true });
+  addToChain(manager, keys, void 0);
+}

package/dist/helpers/virtualRelease.d.ts

@@ -0,0 +1,5 @@
+import type { Manager } from "../types/index.js";
+/**
+ * See {@link virtualPress}
+ */
+export declare function virtualRelease(manager: Manager, keyIdOrVariant: string): void;

package/dist/helpers/virtualRelease.js

@@ -0,0 +1,15 @@
+import { getKeyFromIdOrVariant } from "./getKeyFromIdOrVariant.js";
+import { removeFromChain } from "../internal/removeFromChain.js";
+import { setKeysState } from "../internal/setKeysState.js";
+export function virtualRelease(manager, keyIdOrVariant) {
+  const res = getKeyFromIdOrVariant(keyIdOrVariant, manager.keys);
+  if (res.isError) {
+    manager.options.cb(manager, res.error);
+    return;
+  }
+  const key = res.value[0];
+  const keys = [key.id];
+  manager.listener?.({ isKeydown: false, keys, manager });
+  setKeysState(keys, manager, false);
+  removeFromChain(manager, keys, void 0);
+}

package/dist/helpers/virtualToggle.d.ts

@@ -0,0 +1,7 @@
+import type { Manager } from "../types/index.js";
+/**
+ * Calls {@link virtualRelease} if the key is pressed.
+ *
+ * Calls {@link virtualPress} if the key is released.
+ */
+export declare function virtualToggle(manager: Manager, keyIdOrVariant: string): void;

package/dist/helpers/virtualToggle.js

@@ -0,0 +1,16 @@
+import { getKeyFromIdOrVariant } from "./getKeyFromIdOrVariant.js";
+import { virtualPress } from "./virtualPress.js";
+import { virtualRelease } from "./virtualRelease.js";
+export function virtualToggle(manager, keyIdOrVariant) {
+  const res = getKeyFromIdOrVariant(keyIdOrVariant, manager.keys);
+  if (res.isError) {
+    manager.options.cb(manager, res.error);
+    return;
+  }
+  const key = res.value[0];
+  if (key.pressed) {
+    virtualRelease(manager, keyIdOrVariant);
+  } else {
+    virtualPress(manager, keyIdOrVariant);
+  }
+}

package/dist/internal/addToChain.d.ts

@@ -0,0 +1,3 @@
+import { type Result } from "@alanscodelog/utils/Result";
+import type { AnyInputEvent, Manager, ManagerSetEntries, MultipleErrors } from "../types/index.js";
+export declare function addToChain(manager: Manager, keysList: string[], e?: AnyInputEvent): Result<true, MultipleErrors<ManagerSetEntries["state.chain"]["error"]>>;

package/dist/internal/addToChain.js

@@ -0,0 +1,27 @@
+import { Ok } from "@alanscodelog/utils/Result";
+import { checkTrigger } from "./checkTrigger.js";
+import { setManagerProp } from "../core/setManagerProp.js";
+import { cloneChain } from "../utils/cloneChain.js";
+export function addToChain(manager, keysList, e) {
+  const sorter = manager.options.sorter;
+  if (manager.state.isAwaitingKeyup) return Ok(true);
+  if (keysList.length === 0) return Ok(true);
+  if (manager.state.nextIsChord) {
+    setManagerProp(manager, "state.chain", cloneChain([...manager.state.chain, []])).unwrap();
+    setManagerProp(manager, "state.nextIsChord", false);
+  }
+  const length = manager.state.chain.length - 1;
+  const lastChord = [...manager.state.chain[length] ?? []];
+  for (const id of keysList) {
+    if (!lastChord.includes(id)) {
+      lastChord.push(id);
+      const res = setManagerProp(manager, "state.chain", cloneChain([
+        ...manager.state.chain.slice(0, length),
+        sorter.sort(lastChord, manager.keys)
+      ]));
+      if (res.isError) return res;
+      checkTrigger(manager, e);
+    }
+  }
+  return Ok(true);
+}

package/dist/internal/areValidKeys.d.ts

@@ -0,0 +1,7 @@
+import { type Result } from "@alanscodelog/utils/Result";
+import type { Manager, MultipleErrors, PickManager, Shortcut } from "../types/index.js";
+import { SHORTCUT_ERROR } from "../types/index.js";
+/**
+ * @internal
+ */
+export declare function areValidKeys(chain: string[][] | Shortcut, manager: Pick<Manager, "keys"> & PickManager<"options", "stringifier">): Result<true, MultipleErrors<typeof SHORTCUT_ERROR.UNKNOWN_KEY>>;

package/dist/internal/areValidKeys.js

@@ -0,0 +1,28 @@
+import { crop } from "@alanscodelog/utils/crop";
+import { Err, Ok } from "@alanscodelog/utils/Result";
+import { getKeyFromIdOrVariant } from "../helpers/getKeyFromIdOrVariant.js";
+import { KnownError } from "../helpers/KnownError.js";
+import { SHORTCUT_ERROR } from "../types/index.js";
+export function areValidKeys(chain, manager) {
+  const s = manager.options.stringifier;
+  const keys = manager.keys;
+  const shortcut = "type" in chain ? chain : void 0;
+  chain = "type" in chain ? chain.chain : chain;
+  const unknownKeys = [];
+  for (const key of chain.flat()) {
+    const res = getKeyFromIdOrVariant(key, keys);
+    if (res.isError) {
+      unknownKeys.push(key);
+    }
+  }
+  if (unknownKeys.length > 0) {
+    const stringified = s.stringifyList("keys", unknownKeys, { keys });
+    return Err(new KnownError(SHORTCUT_ERROR.UNKNOWN_KEY, crop`
+			${s.stringify(shortcut ?? chain, manager)} contains unknown keys: ${stringified}
+			`, {
+      shortcut: shortcut ?? { chain },
+      keys: unknownKeys
+    }));
+  }
+  return Ok(true);
+}

package/dist/internal/areValidVariants.d.ts

@@ -0,0 +1,4 @@
+import { type Result } from "@alanscodelog/utils/Result";
+import { KnownError } from "../helpers/KnownError.js";
+import { type Key, type KeysSetEntries, SHORTCUT_ERROR } from "../types/index.js";
+export declare function areValidVariants(key: Key, manager: KeysSetEntries["entries@add"]["manager"]): Result<true, KnownError<typeof SHORTCUT_ERROR.INVALID_VARIANT_PAIR>>;

package/dist/internal/areValidVariants.js

@@ -0,0 +1,45 @@
+import { crop } from "@alanscodelog/utils/crop";
+import { Err, Ok } from "@alanscodelog/utils/Result";
+import { getKeyFromIdOrVariant } from "../helpers/getKeyFromIdOrVariant.js";
+import { KnownError } from "../helpers/KnownError.js";
+import { SHORTCUT_ERROR } from "../types/index.js";
+export function areValidVariants(key, manager) {
+  const keys = manager.keys;
+  const s = manager.options.stringifier;
+  const existingVariants = keys.variants?.[key.id]?.map((id) => keys.entries[id]) ?? [];
+  const keysVariants = key.variants ? key.variants.flatMap((id) => {
+    const res = getKeyFromIdOrVariant(id, keys);
+    if (res.isOk) return res.value;
+    return [];
+  }) : [];
+  const variants = [...existingVariants, ...keysVariants];
+  for (const k of variants) {
+    if (!!key.isToggle !== !!k.isToggle) {
+      const stringKey = s.stringify(key, manager);
+      const stringOtherKey = s.stringify(k, manager);
+      return Err(new KnownError(SHORTCUT_ERROR.INVALID_VARIANT_PAIR, crop`
+				Key ${stringKey} specifies a variant or matches an existing key's variant (${stringOtherKey}), but their functionality is not the same.
+
+				Key ${stringKey} "isToggle" is "${key.isToggle}" while key ${stringOtherKey} "isToggle" is "${k.isToggle}".
+			`, {
+        variants,
+        key,
+        otherKey: k
+      }));
+    }
+    if (!!key.isModifier !== !!k.isModifier) {
+      const stringKey = s.stringify(key, manager);
+      const stringOtherKey = s.stringify(k, manager);
+      return Err(new KnownError(SHORTCUT_ERROR.INVALID_VARIANT_PAIR, crop`
+				Key ${stringKey} specifies a variant or matches an existing key's variant (${stringOtherKey}), but their functionality is not the same.
+
+				Key ${stringKey} "isModifier" is "${key.isModifier}" while key ${stringOtherKey} "isModifier" is "${k.isModifier}".
+			`, {
+        variants,
+        key,
+        otherKey: k
+      }));
+    }
+  }
+  return Ok(true);
+}

package/dist/internal/checkTrigger.d.ts

@@ -0,0 +1,2 @@
+import { type AnyInputEvent, type Manager } from "../types/index.js";
+export declare function checkTrigger(manager: Manager, e?: AnyInputEvent): void;

package/dist/internal/checkTrigger.js

@@ -0,0 +1,47 @@
+import { checkUntrigger } from "./checkUntrigger.js";
+import { cloneLastChord } from "./cloneLastChord.js";
+import { inChain } from "./inChain.js";
+import { setManagerProp } from "../core/setManagerProp.js";
+import { getTriggerableShortcut } from "../helpers/getTriggerableShortcut.js";
+import { KnownError } from "../helpers/KnownError.js";
+import { SHORTCUT_ERROR } from "../types/index.js";
+import { isTriggerKey } from "../utils/isTriggerKey.js";
+export function checkTrigger(manager, e) {
+  checkUntrigger(manager, e);
+  const hadUntrigger = manager.state.untrigger;
+  const cb = manager.options.cb;
+  if (!manager.options.enableShortcuts) return;
+  const res = getTriggerableShortcut(manager);
+  if (res.isError) {
+    cb(manager, res.error, e);
+  } else if (res.value && res.value !== hadUntrigger) {
+    setManagerProp(manager, "state.untrigger", res.value);
+    setManagerProp(manager, "state.nextIsChord", false);
+    const command = manager.commands.entries[res.value.command];
+    command?.execute?.({
+      isKeydown: true,
+      command,
+      shortcut: res.value,
+      event: e,
+      manager,
+      context: manager.context
+    });
+  }
+  const triggerKey = cloneLastChord(manager.state.chain)?.find((id) => isTriggerKey(manager.keys.entries[id]));
+  const nonTriggerKey = cloneLastChord(manager.state.chain)?.find((id) => !isTriggerKey(manager.keys.entries[id]));
+  if (triggerKey) {
+    if (inChain(manager) || manager.state.isRecording) {
+      setManagerProp(manager, "state.nextIsChord", true);
+      if (nonTriggerKey) {
+        setManagerProp(manager, "state.isAwaitingKeyup", true);
+      }
+    } else if (!manager.state.isRecording && !inChain(manager) && (res.isOk && !res.value) && manager.state.chain.length > 1) {
+      const error = new KnownError(
+        SHORTCUT_ERROR.NO_MATCHING_SHORTCUT,
+        "A chord containing a non-modifier key was pressed while in a chord chain, but no shortcut found to trigger.",
+        { chain: manager.state.chain }
+      );
+      cb(manager, error, e);
+    }
+  }
+}

package/dist/internal/checkUntrigger.d.ts

@@ -0,0 +1,2 @@
+import type { AnyInputEvent, Manager } from "../types/index.js";
+export declare function checkUntrigger(manager: Manager, e?: AnyInputEvent): void;

package/dist/internal/checkUntrigger.js

@@ -0,0 +1,18 @@
+import { setManagerProp } from "../core/setManagerProp.js";
+export function checkUntrigger(manager, e) {
+  if (manager.state.untrigger) {
+    const untrigger = manager.state.untrigger;
+    setManagerProp(manager, "state.untrigger", false);
+    setManagerProp(manager, "state.nextIsChord", false);
+    if (!manager.options.enableShortcuts) return;
+    const command = manager.commands.entries[untrigger.command];
+    command.execute?.({
+      isKeydown: false,
+      command,
+      shortcut: untrigger,
+      event: e,
+      manager,
+      context: manager.context
+    });
+  }
+}

package/dist/internal/cloneLastChord.d.ts

@@ -0,0 +1,4 @@
+/**
+ * A copy of the last chord in the chain if it exists.
+ */
+export declare function cloneLastChord(chain: string[][]): string[] | undefined;

package/dist/internal/cloneLastChord.js

@@ -0,0 +1,5 @@
+import { last } from "@alanscodelog/utils/last";
+export function cloneLastChord(chain) {
+  const lastC = last(chain);
+  return lastC ? [...lastC] : void 0;
+}

package/dist/internal/containsPossibleToggleChords.d.ts

@@ -0,0 +1,13 @@
+import { type Result } from "@alanscodelog/utils/Result";
+import { KnownError } from "../helpers/KnownError.js";
+import { type Manager, type PickManager, SHORTCUT_ERROR } from "../types/index.js";
+/**
+ * If you have toggle keys in chords, their are "chains" of the same toggle key that would be physically impossible. For example: `toggle(on) toggle(on)`.
+ *
+ * This guards against that.
+ *
+ * This does NOT guard against duplicates and errors in the same chord, for that see {@link isValidChord}.
+ *
+ * @internal
+ */
+export declare function containsPossibleToggleChords(chain: string[][], manager: Pick<Manager, "keys"> & PickManager<"options", "stringifier">): Result<true, KnownError<typeof SHORTCUT_ERROR.IMPOSSIBLE_TOGGLE_SEQUENCE>>;

package/dist/internal/containsPossibleToggleChords.js

@@ -0,0 +1,65 @@
+import { crop } from "@alanscodelog/utils/crop";
+import { Err, Ok } from "@alanscodelog/utils/Result";
+import { getKeyFromIdOrVariant } from "../helpers/getKeyFromIdOrVariant.js";
+import { KnownError } from "../helpers/KnownError.js";
+import { SHORTCUT_ERROR } from "../types/index.js";
+export function containsPossibleToggleChords(chain, manager) {
+  const keys = manager.keys;
+  const s = manager.options.stringifier;
+  const prevToggles = [];
+  let num = 0;
+  let impossible;
+  for (const chord of chain) {
+    const toggleIds = chord.filter((keyId) => getKeyFromIdOrVariant(keyId, keys).unwrap()[0].isToggle);
+    let found = false;
+    for (let k = 0; k < toggleIds.length; k++) {
+      const currId = toggleIds[k];
+      const prevWithSameRootsIds = prevToggles.map(([prevId, j]) => {
+        const prev = getKeyFromIdOrVariant(prevId, keys).unwrap()[0];
+        const curr = getKeyFromIdOrVariant(currId, keys).unwrap()[0];
+        return prev.id === curr.id || prev.variants?.includes(curr.id) || curr.variants?.includes(prev.id) ? [prevId, j] : void 0;
+      }).filter((key) => key !== void 0);
+      prevWithSameRootsIds.push([currId, num + k]);
+      let canBeOn = true;
+      let canBeOff = true;
+      for (const [keyId, j] of prevWithSameRootsIds) {
+        const key = keys.entries[keyId] ?? keys.toggles[keyId];
+        if (key.id === keyId) {
+          const couldOn = canBeOn;
+          const couldOff = canBeOff;
+          canBeOn = couldOff;
+          canBeOff = couldOn;
+          continue;
+        }
+        const isOff = key.toggleOffId === keyId;
+        const isOn = key.toggleOnId === keyId;
+        if (isOn && !canBeOn || isOff && !canBeOff) {
+          impossible = { keyId, pos: j };
+          break;
+        }
+        canBeOn = isOff;
+        canBeOff = isOn;
+      }
+      if (impossible) {
+        found = true;
+        break;
+      }
+      const currKey = getKeyFromIdOrVariant(currId, keys).unwrap()[0];
+      if (currKey.isToggle) {
+        prevToggles.push([currId, num + k]);
+      }
+      num += chord.length;
+    }
+    if (found) break;
+  }
+  if (impossible) {
+    const prettyShortcut = s.stringify(chain, manager);
+    const { pos, keyId: key } = impossible;
+    const e = Err(new KnownError(SHORTCUT_ERROR.IMPOSSIBLE_TOGGLE_SEQUENCE, crop`
+			Chain "${prettyShortcut}" is impossible.
+			This chain has a toggle key state "${s.stringify(key, manager)}" at key #${pos + 1} that would be impossible to trigger.
+		`, { chain, key: keys.entries[key] ?? keys.toggles[key], i: pos }));
+    return e;
+  }
+  return Ok(true);
+}

package/dist/internal/errorTextAdd.d.ts

@@ -0,0 +1 @@
+export declare function errorTextAdd(type: "Key" | "Shortcut" | "Command", existingIdentifier: string, existingEntry: string, newEntry: string): string;

package/dist/internal/errorTextAdd.js

@@ -0,0 +1,11 @@
+import { crop } from "@alanscodelog/utils/crop";
+import { indent } from "@alanscodelog/utils/indent";
+export function errorTextAdd(type, existingIdentifier, existingEntry, newEntry) {
+  return crop`
+		${type} ${existingIdentifier} is already registered.
+			Existing ${type}:
+			${indent(existingEntry.toString(), 3)}
+			New ${type}:
+			${indent(newEntry.toString(), 3)}
+		`;
+}

package/dist/internal/errorTextInUse.d.ts

@@ -0,0 +1 @@
+export declare function errorTextInUse(type: "command" | "key", identifier: string, list: string): string;

package/dist/internal/errorTextInUse.js

@@ -0,0 +1,8 @@
+import { crop } from "@alanscodelog/utils/crop";
+import { indent } from "@alanscodelog/utils/indent";
+export function errorTextInUse(type, identifier, list) {
+  return crop`
+		Cannot remove ${type} ${identifier}, it is in use by the following shortcuts:
+		${indent(list, 2)}
+	`;
+}

package/dist/internal/errorTextRemove.d.ts

@@ -0,0 +1 @@
+export declare function errorTextRemove(type: string, identifier: string, entries: string): string;

package/dist/internal/errorTextRemove.js

@@ -0,0 +1,8 @@
+import { crop } from "@alanscodelog/utils/crop";
+import { indent } from "@alanscodelog/utils/indent";
+export function errorTextRemove(type, identifier, entries) {
+  return crop`
+		${type} ${identifier} does not exist in entries:
+			${indent(entries, 3)}
+		`;
+}

package/dist/internal/getModifierState.d.ts

@@ -0,0 +1,2 @@
+import type { AnyInputEvent, Key, PickManager } from "../types/index.js";
+export declare function getModifierState(key: Key, e: AnyInputEvent, manager: PickManager<"options", "updateStateOnAllEvents">): boolean | null;

package/dist/internal/getModifierState.js

@@ -0,0 +1,7 @@
+export function getModifierState(key, e, manager) {
+  if (!manager.options.updateStateOnAllEvents || !key.updateStateOnAllEvents) return null;
+  for (const code of [key.id, ...key.variants ?? []]) {
+    if ("getModifierState" in e && e.getModifierState(code)) return true;
+  }
+  return false;
+}

package/dist/internal/getPressedKeys.d.ts

@@ -0,0 +1,7 @@
+import type { Manager } from "../types/index.js";
+/**
+ * A list of currently pressed keys for convenience.
+ *
+ * It's just a wrapper around querying the key set for pressed keys.
+ */
+export declare function getPressedKeys(manager: Pick<Manager, "keys">): string[];

package/dist/internal/getPressedKeys.js

@@ -0,0 +1,18 @@
+export function getPressedKeys(manager) {
+  const res = [];
+  for (const keyId of Object.keys(manager.keys.entries)) {
+    const key = manager.keys.entries[keyId];
+    if (key.pressed) {
+      res.push(key.id);
+    }
+    if (key.isToggle) {
+      if (key.toggleOnPressed) {
+        res.push(key.toggleOnId);
+      }
+      if (key.toggleOffPressed) {
+        res.push(key.toggleOffId);
+      }
+    }
+  }
+  return res;
+}

package/dist/internal/getPressedModifierKeys.d.ts

@@ -0,0 +1,2 @@
+import type { Manager } from "../types/index.js";
+export declare function getPressedModifierKeys(manager: Pick<Manager, "keys">): string[];

package/dist/internal/getPressedModifierKeys.js

@@ -0,0 +1,10 @@
+export function getPressedModifierKeys(manager) {
+  const res = [];
+  for (const keyId of Object.keys(manager.keys.entries)) {
+    const key = manager.keys.entries[keyId];
+    if (key.pressed && key.isModifier) {
+      res.push(key.id);
+    }
+  }
+  return res;
+}

package/dist/internal/getPressedNonModifierKeys.d.ts

@@ -0,0 +1,7 @@
+import type { Manager } from "../types/index.js";
+/**
+ * A list of currently pressed non-modifier keys. They can't be toggle state keys (i.e. `on`/`off`) either.
+ *
+ * This determines whether when we await keyup and when a new chord should be added.
+ */
+export declare function getPressedNonModifierKeys(manager: Pick<Manager, "keys">): string[];

package/dist/internal/getPressedNonModifierKeys.js

@@ -0,0 +1,11 @@
+import { isTriggerKey } from "../utils/isTriggerKey.js";
+export function getPressedNonModifierKeys(manager) {
+  const res = [];
+  for (const keyId of Object.keys(manager.keys.entries)) {
+    const key = manager.keys.entries[keyId];
+    if (key.pressed && isTriggerKey(manager.keys.entries[keyId])) {
+      res.push(key.id);
+    }
+  }
+  return res;
+}

package/dist/internal/inChain.d.ts

@@ -0,0 +1,5 @@
+import type { Manager } from "../types/index.js";
+/**
+    * Returns true if there are shortcuts that could be executed given the state of the manager's chain. That is, except if {@link Manager.isAwaitingKeyup} is true, in which case it returns false.
+ */
+export declare function inChain(manager: Manager): boolean;

package/dist/internal/inChain.js

@@ -0,0 +1,14 @@
+import { shortcutCanExecuteIn } from "../helpers/shortcutCanExecuteIn.js";
+import { equalsKeys } from "../utils/equalsKeys.js";
+export function inChain(manager) {
+  if (manager.state.isAwaitingKeyup) return false;
+  const shortcuts = manager.shortcuts.entries.filter((shortcut) => shortcutCanExecuteIn(shortcut, manager, { allowEmptyCommand: true }) && manager.state.chain.length < shortcut.chain.length && equalsKeys(
+    shortcut.chain,
+    manager.state.chain,
+    manager.keys,
+    manager.state.chain.length,
+    { allowVariants: true }
+  ));
+  if (!shortcuts) return false;
+  return shortcuts.length > 0;
+}

package/dist/internal/isValidChain.d.ts

@@ -0,0 +1,10 @@
+import { type Result } from "@alanscodelog/utils/Result";
+import type { ChainError, Manager, MultipleErrors, PickManager } from "../types/index.js";
+/**
+ * Guards against invalid chains (for various reasons). See the {@link ChainError}.
+ *
+ * Checks {@link areValidKeys}, {@link isValidChord} and {@link containsPossibleToggleChords}
+ *
+ * @internal
+ */
+export declare function isValidChain(chain: string[][], manager: Pick<Manager, "keys"> & PickManager<"options", "stringifier" | "sorter">): Result<true, MultipleErrors<ChainError>>;