@witchcraft/spellcraft 0.0.1

package/dist/core/setCommandProp.d.ts

@@ -0,0 +1,17 @@
+import { type Result } from "@alanscodelog/utils/Result";
+import { type CanHookErrors, type Command, type CommandSetEntries, type Manager, type MultipleErrors } from "../types/index.js";
+/**
+ * Sets a settable command property.
+ *
+ * You should not use this to set key state the manager manages (those tagged with @Managed in the docs) unless you've forgone using the manager.
+ *
+ * Note that while the manager argument is always required, for unmanaged properties you can pass {} and for most others you can pass a partial manager if needed. This is because it's very difficult to keep the heavy per prop types and allow the manager to be optional in these cases.
+ *
+ */
+export declare function setCommandProp<TEntries extends CommandSetEntries, TProp extends keyof CommandSetEntries, TEntry extends TEntries[TProp], THooks extends Manager["hooks"], TCheck extends boolean | "only" = true>(
+/** Command is mutated if check is not "only". */
+command: Command, prop: TProp, val: TEntry["val"], manager: (TEntry["manager"] extends never ? unknown : TEntry["manager"]) & {
+    hooks?: THooks;
+}, { check }?: {
+    check?: TCheck;
+}): Result<TCheck extends "only" ? true : Command, MultipleErrors<TEntry["error"]> | CanHookErrors<Manager["hooks"] extends never ? never : THooks, "canSetCommandProp">>;

package/dist/core/setCommandProp.js

@@ -0,0 +1,96 @@
+import { castType } from "@alanscodelog/utils/castType";
+import { crop } from "@alanscodelog/utils/crop";
+import { indent } from "@alanscodelog/utils/indent";
+import { Err, Ok } from "@alanscodelog/utils/Result";
+import { setCommandsProp } from "./setCommandsProp.js";
+import { setShortcutProp } from "./setShortcutProp.js";
+import { KnownError } from "../helpers/KnownError.js";
+import { errorTextAdd } from "../internal/errorTextAdd.js";
+import { SHORTCUT_ERROR } from "../types/index.js";
+const canHookable = ["condition", "execute"];
+export function setCommandProp(command, prop, val, manager, {
+  check = true
+} = {}) {
+  if (check) {
+    switch (prop) {
+      case "name": {
+        castType(manager);
+        castType(val);
+        const s = manager.options.stringifier;
+        const existing = manager.commands.entries[val];
+        if (existing) {
+          return Err(new KnownError(
+            SHORTCUT_ERROR.DUPLICATE_COMMAND,
+            errorTextAdd(
+              "Command",
+              val,
+              s.stringify(existing),
+              s.stringify(command)
+            ),
+            { existing, self: manager.commands }
+          ));
+        }
+        const managerClone = {
+          ...manager,
+          commands: {
+            ...manager.commands,
+            entries: {
+              ...manager.commands.entries,
+              [val]: { ...command, name: val }
+            }
+          }
+        };
+        const shortcutErrors = [];
+        for (const shortcut of manager.shortcuts.entries) {
+          if (shortcut.command === command.name) {
+            const res = setShortcutProp(shortcut, "command", val, managerClone, { check: "only" });
+            if (res.isError) shortcutErrors.push(res.error);
+          }
+        }
+        if (shortcutErrors.length > 0) {
+          return Err(new KnownError(
+            SHORTCUT_ERROR.MULTIPLE_ERRORS,
+            crop`
+							Received multiple errors attempting to change command name from ${command.name} to ${val}: 
+							${indent(shortcutErrors.map((_) => _.message).join("\n"), 7)}
+							`,
+            { errors: shortcutErrors }
+          ));
+        }
+        break;
+      }
+      default:
+        break;
+    }
+    if (manager?.hooks && "canSetCommandProp" in manager.hooks && canHookable.includes(prop)) {
+      const canHook = manager.hooks.canSetCommandProp?.(command, prop, val);
+      if (canHook instanceof Error) {
+        return Err(canHook);
+      }
+    }
+  }
+  if (check === "only") {
+    return Ok(true);
+  }
+  if (prop === "name") {
+    castType(manager);
+    castType(val);
+    setCommandsProp("entries@add", { ...command, name: val }, manager).unwrap();
+    const old = command.name;
+    const oldCommand = manager.commands.entries[old];
+    for (const shortcut of manager.shortcuts.entries) {
+      if (shortcut.command === old) {
+        setShortcutProp(shortcut, "command", val, manager).unwrap();
+      }
+    }
+    if (manager.commands.entries[old]) {
+      setCommandsProp("entries@remove", oldCommand, manager).unwrap();
+    }
+  } else {
+    command[prop] = val;
+  }
+  if (manager?.hooks && "onSetCommandProp" in manager.hooks) {
+    manager?.hooks?.onSetCommandProp?.(command, prop, val);
+  }
+  return Ok(command);
+}

package/dist/core/setCommandsProp.d.ts

@@ -0,0 +1,15 @@
+import { type Result } from "@alanscodelog/utils/Result";
+import { type CanHookErrors, type Command, type CommandsSetEntries, type Manager, type MultipleErrors } from "../types/index.js";
+/**
+ * Sets a settable command property.
+ *
+ * You should not use this to set command state the manager manages (those tagged with @Managed in the docs) unless you've forgone using the manager.
+ *
+ */
+export declare function setCommandsProp<TEntries extends CommandsSetEntries, TProp extends keyof CommandsSetEntries, TEntry extends TEntries[TProp], THooks extends Manager["hooks"], TCheck extends boolean | "only" = true>(prop: TProp, val: TEntry["val"], 
+/** Commands is mutated if check is not "only". */
+manager: TEntry["manager"] & {
+    hooks?: THooks;
+}, { check }?: {
+    check?: TCheck;
+}): Result<TCheck extends "only" ? true : Command, MultipleErrors<TEntry["error"]> | CanHookErrors<Manager["hooks"] extends never ? never : THooks, "canSetCommandsProp">>;

package/dist/core/setCommandsProp.js

@@ -0,0 +1,94 @@
+import { castType } from "@alanscodelog/utils/castType";
+import { Err, Ok } from "@alanscodelog/utils/Result";
+import { KnownError } from "../helpers/KnownError.js";
+import { errorTextAdd } from "../internal/errorTextAdd.js";
+import { errorTextInUse } from "../internal/errorTextInUse.js";
+import { errorTextRemove } from "../internal/errorTextRemove.js";
+import { SHORTCUT_ERROR } from "../types/index.js";
+const canHookable = ["entries@add", "entries@remove"];
+export function setCommandsProp(prop, val, manager, {
+  check = true
+} = {}) {
+  const commands = manager.commands;
+  const s = manager.options.stringifier;
+  if (check) {
+    switch (prop) {
+      case "entries@add": {
+        castType(val);
+        castType(manager);
+        const command = val;
+        const existing = commands.entries[command.name];
+        if (existing) {
+          return Err(new KnownError(
+            SHORTCUT_ERROR.DUPLICATE_COMMAND,
+            errorTextAdd(
+              "Command",
+              s.stringifyCommand(existing.name, manager),
+              s.stringifyCommand(existing.name, manager),
+              s.stringifyCommand(command.name, manager)
+            ),
+            { existing, self: commands }
+          ));
+        }
+        break;
+      }
+      case "entries@remove": {
+        castType(val);
+        castType(manager);
+        const command = val;
+        if (!commands.entries[command.name]) {
+          return Err(new KnownError(
+            SHORTCUT_ERROR.MISSING,
+            errorTextRemove(
+              "Command",
+              s.stringify(command),
+              s.stringifyList("commands", Object.values(commands.entries))
+            ),
+            { entry: command.name, self: commands }
+          ));
+        }
+        const inUseShortcuts = manager.shortcuts.entries.filter((shortcut) => shortcut.command === command.name);
+        if (inUseShortcuts.length > 0) {
+          return Err(new KnownError(
+            SHORTCUT_ERROR.COMMAND_IN_USE,
+            errorTextInUse(
+              "command",
+              s.stringify(command),
+              s.stringifyList("shortcuts", inUseShortcuts, manager)
+            ),
+            { inUseShortcuts }
+          ));
+        }
+        break;
+      }
+      default:
+        break;
+    }
+    if (manager?.hooks && "canSetCommandsProp" in manager.hooks && canHookable.includes(prop)) {
+      const canHook = manager.hooks?.canSetCommandsProp?.(commands, prop, val);
+      if (canHook instanceof Error) {
+        return Err(canHook);
+      }
+    }
+  }
+  if (check === "only") {
+    return Ok(true);
+  }
+  switch (prop) {
+    case "entries@add": {
+      const command = val;
+      commands.entries[command.name] = command;
+      break;
+    }
+    case "entries@remove": {
+      const command = val;
+      delete commands.entries[command.name];
+      break;
+    }
+    default:
+      commands[prop] = val;
+      break;
+  }
+  manager.hooks?.onSetCommandsProp?.(commands, prop, val);
+  return Ok(commands);
+}

package/dist/core/setKeyProp.d.ts

@@ -0,0 +1,16 @@
+import { type Result } from "@alanscodelog/utils/Result";
+import type { CanHookErrors, Key, KeySetEntries, Manager, MultipleErrors } from "../types/index.js";
+/**
+ * Sets a settable key property.
+ *
+ * You should not use this to set key state the manager manages (those tagged with @Managed in the docs) unless you've forgone using the manager.
+ *
+ * Note that while the manager argument is always required, for unmanaged properties you can pass {} and for most others you can pass a partial manager if needed. This is because it's very difficult to keep the heavy per prop types and allow the manager to be optional in these cases.
+ */
+export declare function setKeyProp<TEntries extends KeySetEntries, TProp extends keyof KeySetEntries, TEntry extends TEntries[TProp], THooks extends Manager["hooks"], TCheck extends boolean | "only" = true>(
+/** Key is mutated if check is not "only". */
+key: Key, prop: TProp, val: TEntry["val"], manager: (TEntry["manager"] extends never ? unknown : TEntry["manager"]) & {
+    hooks?: THooks;
+}, { check }?: {
+    check?: TCheck;
+}): Result<TCheck extends "only" ? true : Key, MultipleErrors<TEntry["error"]> | CanHookErrors<THooks extends never ? never : THooks, "canSetKeyProp">>;

package/dist/core/setKeyProp.js

@@ -0,0 +1,47 @@
+import { castType } from "@alanscodelog/utils/castType";
+import { crop } from "@alanscodelog/utils/crop";
+import { Err, Ok } from "@alanscodelog/utils/Result";
+import { set } from "@alanscodelog/utils/set";
+import { KnownError } from "../helpers/KnownError.js";
+import { SHORTCUT_ERROR } from "../types/index.js";
+const canHookable = ["x", "y", "width", "height", "label", "enabled", "render", "classes"];
+export function setKeyProp(key, prop, val, manager, {
+  check = true
+} = {}) {
+  if (check) {
+    switch (prop) {
+      case "toggleOnPressed":
+      case "toggleOffPressed":
+      case "pressed": {
+        castType(manager);
+        const s = manager.options.stringifier;
+        if (!key.enabled && val === true) {
+          return Err(
+            new KnownError(SHORTCUT_ERROR.CANNOT_SET_WHILE_DISABLED, crop`
+							The "${prop}" property cannot be set to true while a key is disabled. (Key: ${s.stringify(key, manager)})
+						`, { key })
+          );
+        }
+        break;
+      }
+      default:
+        break;
+    }
+    if (manager?.hooks && "canSetKeyProp" in manager.hooks && canHookable.includes(prop)) {
+      const canHook = manager.hooks.canSetKeyProp?.(key, prop, val);
+      if (canHook instanceof Error) {
+        return Err(canHook);
+      }
+    }
+  }
+  if (check === "only") {
+    return Ok(true);
+  }
+  if (prop.includes(".")) {
+    set(key, prop.split("."), val);
+  } else {
+    key[prop] = val;
+  }
+  manager?.hooks?.onSetKeyProp?.(key, prop, val);
+  return Ok(key);
+}

package/dist/core/setKeysProp.d.ts

@@ -0,0 +1,10 @@
+import { type Result } from "@alanscodelog/utils/Result";
+import { type CanHookErrors, type Key, type KeysSetEntries, type Manager, type MultipleErrors } from "../types/index.js";
+/**
+ * Sets a settable {@link Keys} property.
+ */
+export declare function setKeysProp<TEntries extends KeysSetEntries, TProp extends keyof KeysSetEntries, TEntry extends TEntries[TProp], THooks extends Manager["hooks"], TCheck extends boolean | "only" = true>(prop: TProp, val: TEntry["val"], manager: TEntry["manager"] & {
+    hooks?: THooks;
+}, { check }?: {
+    check?: TCheck;
+}): Result<TCheck extends "only" ? true : Key, MultipleErrors<TEntry["error"]> | CanHookErrors<Manager["hooks"] extends never ? never : THooks, "canSetKeysProp">>;

package/dist/core/setKeysProp.js

@@ -0,0 +1,166 @@
+import { castType } from "@alanscodelog/utils/castType";
+import { Err, Ok } from "@alanscodelog/utils/Result";
+import { calculateLayoutSize } from "../helpers/calculateLayoutSize.js";
+import { KnownError } from "../helpers/KnownError.js";
+import { areValidVariants } from "../internal/areValidVariants.js";
+import { errorTextAdd } from "../internal/errorTextAdd.js";
+import { errorTextInUse } from "../internal/errorTextInUse.js";
+import { errorTextRemove } from "../internal/errorTextRemove.js";
+import { SHORTCUT_ERROR } from "../types/index.js";
+import { containsKey } from "../utils/containsKey.js";
+const canHookable = ["entries@add", "entries@remove"];
+export function setKeysProp(prop, val, manager, {
+  check = true
+} = {}) {
+  const keys = manager.keys;
+  if (check) {
+    switch (prop) {
+      case "entries@add": {
+        castType(val);
+        castType(manager);
+        const s = manager.options.stringifier;
+        const key = val;
+        const existing = keys.entries[key.id];
+        if (existing) {
+          return Err(new KnownError(
+            SHORTCUT_ERROR.DUPLICATE_KEY,
+            errorTextAdd(
+              "Key",
+              s.stringify(existing, manager),
+              s.stringify(existing, manager),
+              s.stringify(key, manager)
+            ),
+            { existing, self: keys }
+          ));
+        }
+        const areValidVariantsRes = areValidVariants(key, manager);
+        if (areValidVariantsRes.isError) return areValidVariantsRes;
+        break;
+      }
+      case "entries@remove": {
+        castType(val);
+        castType(manager);
+        const s = manager.options.stringifier;
+        const key = val;
+        if (!keys.entries[key.id]) {
+          return Err(new KnownError(
+            SHORTCUT_ERROR.MISSING,
+            errorTextRemove(
+              "Key",
+              s.stringify(key),
+              s.stringifyList("keys", Object.values(keys.entries))
+            ),
+            { entry: key.id, self: keys }
+          ));
+        }
+        const inUseShortcuts = manager.shortcuts.entries.filter((shortcut) => containsKey(shortcut.chain, key.id, keys));
+        if (inUseShortcuts.length > 0) {
+          return Err(new KnownError(
+            SHORTCUT_ERROR.KEY_IN_USE,
+            errorTextInUse(
+              "key",
+              s.stringify(key),
+              s.stringifyList("shortcuts", inUseShortcuts, manager)
+            ),
+            { inUseShortcuts }
+          ));
+        }
+        break;
+      }
+      default:
+        break;
+    }
+    if (manager.hooks && "canSetKeysProp" in manager.hooks && canHookable.includes(prop)) {
+      const canHook = manager.hooks.canSetKeysProp?.(keys, prop, val);
+      if (canHook instanceof Error) {
+        return Err(canHook);
+      }
+    }
+  }
+  if (check === "only") {
+    return Ok(true);
+  }
+  switch (prop) {
+    case "entries@add": {
+      castType(val);
+      castType(manager);
+      const key = val;
+      keys.entries[key.id] = key;
+      if (key.isToggle === "native") {
+        setKeysProp("nativeToggleKeys", [
+          ...keys.nativeToggleKeys,
+          key.id
+        ], manager).unwrap();
+      }
+      if (key.isModifier === "native") {
+        setKeysProp("nativeModifierKeys", [
+          ...keys.nativeModifierKeys,
+          key.id
+        ], manager).unwrap();
+      }
+      if (key.isToggle) {
+        setKeysProp(`toggles@add@${key.toggleOnId}`, key, manager).unwrap();
+        setKeysProp(`toggles@add@${key.toggleOffId}`, key, manager).unwrap();
+      }
+      if (key.variants) {
+        for (const variant of key.variants) {
+          setKeysProp(`variants@add@${variant}`, key.id, manager).unwrap();
+        }
+      }
+      if (keys.autoManageLayout) {
+        setKeysProp("layout", calculateLayoutSize(keys), manager).unwrap();
+      }
+      break;
+    }
+    case "entries@remove": {
+      const key = val;
+      delete keys.entries[key.id];
+      if (key.isToggle === "native") {
+        setKeysProp("nativeToggleKeys", keys.nativeToggleKeys.filter((k) => k !== key.id), manager).unwrap();
+      }
+      if (key.isModifier === "native") {
+        setKeysProp("nativeModifierKeys", keys.nativeToggleKeys.filter((k) => k !== key.id), manager).unwrap();
+      }
+      if (key.isToggle) {
+        setKeysProp(`toggles@remove@${key.toggleOnId}`, key, manager).unwrap();
+        setKeysProp(`toggles@remove@${key.toggleOffId}`, key, manager).unwrap();
+      }
+      if (key.variants) {
+        for (const variant of key.variants) {
+          setKeysProp(`variants@remove@${variant}`, key.id, manager).unwrap();
+        }
+      }
+      if (keys.autoManageLayout) {
+        setKeysProp("layout", calculateLayoutSize(keys), manager).unwrap();
+      }
+      break;
+    }
+    default:
+      if (prop.startsWith("toggles@add@")) {
+        const name = prop.slice("toggles@add@".length);
+        keys.toggles[name] = val;
+      } else if (prop.startsWith("toggles@remove@")) {
+        const name = prop.slice("toggles@remove@".length);
+        delete keys.toggles[name];
+      } else if (prop.startsWith("variants@add@")) {
+        const variant = prop.slice("variants@add@".length);
+        const existing = keys.variants[variant] ? [...keys.variants[variant]] : [];
+        existing.push(val);
+        keys.variants[variant] = existing;
+      } else if (prop.startsWith("variants@remove@")) {
+        const variant = prop.slice("variants@remove@".length);
+        const existing = keys.variants[variant] ? [...keys.variants[variant]] : [];
+        existing.splice(existing.indexOf(val), 1);
+        if (existing.length > 0) {
+          keys.variants[variant] = existing;
+        } else {
+          delete keys.variants[variant];
+        }
+      } else {
+        keys[prop] = val;
+      }
+      break;
+  }
+  manager.hooks?.onSetKeysProp?.(keys, prop, val);
+  return Ok(keys);
+}

package/dist/core/setManagerProp.d.ts

@@ -0,0 +1,34 @@
+import { type Result } from "@alanscodelog/utils/Result";
+import { type CanHookErrors, type Manager, type ManagerSetEntries, type MultipleErrors } from "../types/index.js";
+/**
+ * Safely sets a settable manager 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.
+ *
+ * If you need to set the chain, use {@link safeSetManagerChain}.
+ *
+ * If enabling/disabling {@link Manager.state.isRecording} it's suggested you use {@link safeSetManagerChain} just before.
+ *
+ * # How to set multiple manager properties safely (i.e. batch replace shortcuts/commands/keys)
+ *
+ * This can be an issue because there isn't a way to tell the manager you want to replace *multiple* properties and it might be impossible to, for example, replace commands with a smaller subset but not have it error even if you're planning to replace the shortcuts so they don't contain missing commands.
+ *
+ * To achieve this, you can shallow clone the manager, change all the properties you want directly, then validate it's state by using isValidManager which is what this function does internally.
+ *
+ * Once you know it's valid, detach the old manager and attach the new one.
+ * ```ts
+ * const clone = {...manager, keys: newKeys, shortcuts: newShortcuts}
+ *
+ * if (isValidManager(manager)) {
+ * detach(manager, ...)
+ * 	attach(clone, ...)
+ * }
+ * ```
+ */
+export declare function setManagerProp<TEntries extends ManagerSetEntries, TProp extends keyof ManagerSetEntries, TEntry extends TEntries[TProp], THooks extends Manager["hooks"], TCheck extends boolean | "only" = true>(
+/** Manager is mutate if check is not "only" */
+manager: TEntry["manager"] & {
+    hooks?: THooks;
+}, prop: TProp, val: TEntry["val"], { check }?: {
+    check?: TCheck;
+}): Result<TCheck extends "only" ? true : Manager, MultipleErrors<TEntry["error"]> | CanHookErrors<Manager["hooks"] extends never ? never : THooks, "canSetManagerProp">>;

package/dist/core/setManagerProp.js

@@ -0,0 +1,54 @@
+import { castType } from "@alanscodelog/utils/castType";
+import { Err, Ok } from "@alanscodelog/utils/Result";
+import { set } from "@alanscodelog/utils/set";
+import { unreachable } from "@alanscodelog/utils/unreachable";
+import { isValidManager } from "../helpers/isValidManager.js";
+import { areValidKeys } from "../internal/areValidKeys.js";
+import { SHORTCUT_ERROR } from "../types/index.js";
+import { cloneChain } from "../utils/cloneChain.js";
+const canHookable = ["state.chain", "shortcuts", "commands", "keys"];
+export function setManagerProp(manager, prop, val, { check = true } = {}) {
+  if (check) {
+    switch (prop) {
+      case "state.chain": {
+        castType(val);
+        castType(manager);
+        const resIsValid = areValidKeys(val, manager);
+        if (resIsValid.isError) return resIsValid;
+        break;
+      }
+      case "commands":
+      case "keys":
+      case "shortcuts": {
+        castType(val);
+        castType(manager);
+        const managerClone = { ...manager, [prop]: val };
+        const res = isValidManager(managerClone);
+        if (res.isError && res.error.code === SHORTCUT_ERROR.INVALID_MANAGER) unreachable();
+        if (res.isError) return res;
+        break;
+      }
+      default:
+        break;
+    }
+    if (manager?.hooks && "canSetManagerProp" in manager.hooks && canHookable.includes(prop)) {
+      const canHook = manager.hooks?.canSetManagerProp?.(manager, prop, val);
+      if (canHook instanceof Error) {
+        return Err(canHook);
+      }
+    }
+  }
+  if (check === "only") {
+    return Ok(true);
+  }
+  if (prop.includes(".")) {
+    if (prop === "state.chain") {
+      val = cloneChain(val);
+    }
+    set(manager, prop.split("."), val);
+  } else {
+    manager[prop] = val;
+  }
+  manager.hooks?.onSetManagerProp?.(manager, prop, val);
+  return Ok(manager);
+}

package/dist/core/setShortcutProp.d.ts

@@ -0,0 +1,9 @@
+import { type Result } from "@alanscodelog/utils/Result";
+import { type CanHookErrors, type Manager, type MultipleErrors, type Shortcut, type ShortcutSetEntries } from "../types/index.js";
+export declare 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 }?: {
+    check?: TCheck;
+}): Result<TCheck extends "only" ? true : Shortcut, MultipleErrors<TEntry["error"]> | CanHookErrors<Manager["hooks"] extends never ? never : THooks, "canSetShortcutProp">>;

package/dist/core/setShortcutProp.js

@@ -0,0 +1,50 @@
+import { castType } from "@alanscodelog/utils/castType";
+import { Err, Ok } 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 { SHORTCUT_ERROR } from "../types/index.js";
+const canHookable = ["chain", "command", "condition", "enabled"];
+export function setShortcutProp(shortcut, prop, val, manager, { check = true } = {}) {
+  if (check) {
+    switch (prop) {
+      case "chain": {
+        castType(val);
+        castType(manager);
+        const res = isValidChain(val, manager);
+        if (res.isError) return res;
+        const shortcutsShallowClone = { ...manager.shortcuts, entries: [...manager.shortcuts.entries] };
+        const managerClone = { ...manager, shortcuts: shortcutsShallowClone };
+        const resRemove = removeShortcut(shortcut, managerClone);
+        if (resRemove.isError && "code" in resRemove.error && resRemove.error.code !== SHORTCUT_ERROR.MISSING) return resRemove;
+        const resAdd = addShortcut({ ...shortcut, chain: val }, managerClone);
+        if (resAdd.isError) return resAdd;
+        break;
+      }
+      case "command": {
+        castType(val);
+        castType(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)) {
+      const canHook = manager.hooks.canSetShortcutProp?.(shortcut, prop, val);
+      if (canHook instanceof Error) {
+        return Err(canHook);
+      }
+    }
+  }
+  if (check === "only") {
+    return Ok(true);
+  }
+  shortcut[prop] = val;
+  manager?.hooks?.onSetShortcutProp?.(shortcut, prop, val);
+  manager?.hooks?.onSetShortcutProp?.(shortcut, prop, val);
+  return Ok(shortcut);
+}

package/dist/core/setShortcutsProp.d.ts

@@ -0,0 +1,12 @@
+import { type Result } from "@alanscodelog/utils/Result";
+import { type CanHookErrors, type Manager, type MultipleErrors, type Shortcut, type ShortcutsSetEntries } from "../types/index.js";
+/**
+ * Sets a settable {@link Shortcuts} property.
+ */
+export declare 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 }?: {
+    check?: TCheck;
+}): Result<TCheck extends "only" ? true : Shortcut, MultipleErrors<TEntry["error"]> | CanHookErrors<Manager["hooks"] extends never ? never : THooks, "canSetShortcutsProp">>;