@witchcraft/spellcraft 0.0.1

package/dist/core/Emulator.js

@@ -0,0 +1,153 @@
+import { EmulatedEvent } from "./EmulatedEvent.js";
+const mouseButtons = ["0", "1", "2", "3", "4", "5"];
+const mouseButtonsDown = mouseButtons.map((b) => `${b}+`);
+const mouseButtonsUp = mouseButtons.map((b) => `${b}-`);
+const wheelKeys = ["wheelUp", "wheelDown"];
+export class Emulator {
+  validKeys;
+  constructor(keys) {
+    this.validKeys = keys;
+  }
+  listeners = {
+    keydown: [],
+    keyup: [],
+    wheel: [],
+    mousedown: [],
+    mouseenter: [],
+    mouseup: []
+  };
+  initiated = false;
+  addEventListener(type, func) {
+    this.listeners[type].push(func);
+    this.initiated = true;
+  }
+  removeEventListener(type, func) {
+    const i = this.listeners[type].indexOf(func);
+    if (i === -1) throw new Error(`Listener ${type} could not be found.`);
+    this.listeners[type].splice(i, 1);
+  }
+  mouseenter(modifiers = []) {
+    const event = new EmulatedEvent("mouseenter", {}, modifiers);
+    this._dispatch("mouseenter", event);
+  }
+  /**
+   *
+   * Emulate pressing/releasing keys.
+   *
+   * ```ts
+   * // press and release a
+   * emulator.fire("KeyA")
+   * // hold A down
+   * emulator.fire("KeyA+")
+   * // release A
+   * emulator.fire("KeyA-")
+   * // press Ctrl+A
+   * emulator.fire("Ctrl+ KeyA Ctrl-")
+   *
+   * // to truly simulate pressing native modifiers, pass all modifiers pressed as an array
+   * emulator.fire("Ctrl+ KeyA Ctrl-", ["ControlLeft"])
+   *
+   * // emulate a modifier state change out of focus
+   * // e.g. user focuses out, holds control+A, and focuses back
+   * // only KeyA would fire
+   *	emulator.fire("KeyA+", ["ControlLeft"])
+   * // they release both in focus
+   * emulater.fire("KeyA- Ctrl-")
+   *
+   * // to simulate them releasing out of focus again you will have to add a delay since no events would fire
+   * delay(1000)
+   *
+   * ```
+   *
+   * Keys should be a {@link KeyboardEvent.code} (though this is not validated) seperated by one or more whitespace characters*. For buttons `0-5` can be used. For wheel events, you can pass `wheelUp/Down` to set the deltaY respectively which is how the manager gets the direction.
+   *
+   * `+` and `-` are used to indicate keydown and keyup respectively (except for wheel events*). This can seem confusing but think of the signs as adding/removing from the set of currently held keys. If no `+/-` is given, both are fired.
+   *
+   * There is no need to handle toggle keys in any special way. You should fire the root code normally (e.g. `emulator.fire("Capslock")` or `emulator.fire("Capslock+ Capslock-")`)
+   *
+   * \* Multiple whitespace characters have no real meaning, but in tests usually I use them to more easily delimite chords.
+   * \*\* Wheel events do not have keyup/keydown so passing `wheelUp+/-` will incorrectly create a keyboard event.
+   *
+   * Note: While the emulator is aware of correct mouse/wheel names, it does not check key names are valid.
+   */
+  fire(str, modifiers = [], validKeys) {
+    if (!this.initiated) {
+      console.warn("No manager attached to the emulator.");
+      return;
+    }
+    const keys = str.split(/(\s+)/).filter((part) => part.trim() !== "");
+    for (const key of keys) {
+      if (mouseButtons.includes(key)) {
+        this.press("mouse", key, modifiers, validKeys);
+        this.release("mouse", key, modifiers, validKeys);
+      } else if (mouseButtonsDown.includes(key)) {
+        this.press("mouse", key[0], modifiers, validKeys);
+      } else if (mouseButtonsUp.includes(key)) {
+        this.release("mouse", key[0], modifiers, validKeys);
+      } else if (wheelKeys.includes(key)) {
+        this.press("wheel", key, modifiers, validKeys);
+      } else if (key.endsWith("+")) {
+        this.press("key", key.slice(0, key.length - 1), modifiers, validKeys);
+      } else if (key.endsWith("-")) {
+        this.release("key", key.slice(0, key.length - 1), modifiers, validKeys);
+      } else {
+        this.press("key", key, modifiers, validKeys);
+        this.release("key", key, modifiers, validKeys);
+      }
+    }
+  }
+  press(type, key, modifiers = [], validKeys) {
+    this._checkIsValidKey(key, validKeys);
+    switch (type) {
+      case "mouse":
+        {
+          const event = new EmulatedEvent("mousedown", { button: Number.parseInt(key, 10) }, modifiers);
+          this._dispatch("mousedown", event);
+        }
+        break;
+      case "wheel":
+        {
+          const event = new EmulatedEvent("wheel", { deltaY: key === "wheelDown" ? 1 : 0 }, modifiers);
+          this._dispatch("wheel", event);
+        }
+        break;
+      case "key":
+        {
+          const event = new EmulatedEvent("keydown", { code: key }, modifiers);
+          this._dispatch("keydown", event);
+        }
+        break;
+    }
+  }
+  release(type, key, modifiers = [], validKeys) {
+    this._checkIsValidKey(key, validKeys);
+    switch (type) {
+      case "mouse":
+        {
+          const event = new EmulatedEvent("mouseup", { button: Number.parseInt(key, 10) }, modifiers);
+          this._dispatch("mouseup", event);
+        }
+        break;
+      case "key":
+        {
+          const event = new EmulatedEvent("keyup", { code: key }, modifiers);
+          this._dispatch("keyup", event);
+        }
+        break;
+    }
+  }
+  _checkIsValidKey(key, validKeys) {
+    const valid = validKeys ?? this.validKeys;
+    if (valid) {
+      const match = Object.values(valid.entries).find((k) => k.id === key || k.toggleOnId === key || k.toggleOffId === key || k.variants?.includes(key));
+      if (match === void 0) {
+        throw new Error(`Emulator was asked to fire key not in valid keys array. ${key}`);
+      }
+    }
+  }
+  _dispatch(type, event) {
+    for (const listener of this.listeners[type]) {
+      listener(event);
+    }
+  }
+}

package/dist/core/ShortcutManagerManager.d.ts

@@ -0,0 +1,103 @@
+import type { DeepPartial } from "@alanscodelog/utils";
+import { type Result } from "@alanscodelog/utils/Result";
+import type { Manager, PickManager } from "../types/index.js";
+export declare class ShortcutManagerManager {
+    storageKeys: {
+        /** Prefix for all keys. */
+        prefix: string;
+        /** @default "shortcut-manager:names" */
+        managerNames: string;
+        /** @default "shortcut-manager:manager." */
+        managerPrefix: string;
+        /** @default "shortcut-manager:active" */
+        activeManager: string;
+    };
+    readonly managerNames: string[];
+    readonly managers: Readonly<Record<string, Manager>>;
+    readonly activeManagerName: string;
+    /** A debounced version of the save function. Is already bound to the instance. */
+    debouncedSave: (name: string) => void;
+    storage: {
+        setItem: (key: string, value: string) => void;
+        getItem: (key: string) => string | null;
+        removeItem: (key: string) => void;
+    };
+    /**
+     * All new managers will be created using this function. It should be capable of taking as little information as `{name}` (when a new manager is created) and returining a full manger.
+     *
+     * It's suggested you not do validation here, use the `onParse` hook instead.
+     *
+     * If you return an error, `onError` will be called, and no manager will be created.
+     */
+    createManager: (raw: Partial<Omit<Manager, "options" | "hooks" | "listener" | "state">> & {
+        options: PickManager<"options", "enableShortcuts" | "enableListeners" | "updateStateOnAllEvents">;
+    }, isNew: boolean) => Manager | Error;
+    hooks: {
+        /**
+         * Called on any errors loading/saving/etc, should be used to notify the user.
+         */
+        onError: (err: Error) => void;
+        /**
+         * Called when a manager is parsed from storage after being sucessfully JSON.parsed.
+         *
+         * You can validate the parsed object here so it's in the correct shape to pass to `createManager`.
+         *
+         * If you return an error, `onError` will be called and `createManager` will be skipped.
+         */
+        onParse?: (parsed: object) => undefined | Error;
+        /**
+         * Called when a manager is saved or exported. It's called with the cloned version of the manager that has been stripped of properties that should not be saved (see {@link managerToStorableClone}).
+         *
+         * You can delete/add properties here (it will not modify the original manager).
+         */
+        onSave?: (clone: DeepPartial<Manager>) => void;
+        /**
+         * Called when a manager is exported. Can be used to actually do the export.
+         */
+        onExport?: (res: object) => void;
+        /**
+         * Called when a manager is set. Can be used to update your state.
+         */
+        onSetManager?: (name: string, clone: Manager) => void;
+        /**
+         * Called when the manager names are set. Can be used to update your state.
+         */
+        onSetManagerNames?: (names: string[]) => void;
+        /**
+         * Called when the active manager is set. Can be used to update your state.
+         */
+        onSetActiveManager?: (name: string) => void;
+    };
+    constructor(createManager: ShortcutManagerManager["createManager"], hooks: ShortcutManagerManager["hooks"], { storageKeys, storage }?: {
+        storageKeys?: Partial<ShortcutManagerManager["storageKeys"]>;
+        storage?: ShortcutManagerManager["storage"];
+    });
+    init(): void;
+    setManager(name: string, clone?: any): void;
+    setManagerNames(names: string[]): void;
+    setActiveManager(name: string): void;
+    protected addManager(name: string, clone: any): void;
+    protected removeManager(name: string): void;
+    protected storageSaveManager(name: string, clone: any): void;
+    protected storageRemoveManager(name: string): void;
+    protected storageReadManager(name: string, { force }?: {
+        force?: boolean;
+    }): Result<Manager, Error>;
+    parseJsonManager(raw: string): Result<any, Error>;
+    load(manager: Manager, { doActivate }?: {
+        doActivate?: boolean;
+    }): void;
+    protected loadOrCreateDefault(): void;
+    save(name: string): void;
+    protected notifyIfError<T extends Result<any, Error>>(res: T): T;
+    changeManager(name: string, opts?: {
+        force?: boolean;
+    }): Result<void, Error>;
+    deleteManager(name: string): Result<void, Error>;
+    renameManager(name: string): void;
+    duplicateManager(oldName: string, newName: string): Result<Manager, Error>;
+    exportManagers(names: string[]): Result<object, Error>;
+    importManagers(content: string): Result<void, Error>;
+    /** Clears all managers and resets the state. `init` must be called again if you want to use the class instance again. */
+    clearAll(): void;
+}

package/dist/core/ShortcutManagerManager.js

@@ -0,0 +1,267 @@
+import { debounce } from "@alanscodelog/utils/debounce";
+import { isArray } from "@alanscodelog/utils/isArray";
+import { keys } from "@alanscodelog/utils/keys";
+import { Err, Ok } from "@alanscodelog/utils/Result";
+import { setReadOnly } from "@alanscodelog/utils/setReadOnly";
+import { managerToStorableClone } from "../helpers/managerToStorableClone.js";
+export class ShortcutManagerManager {
+  storageKeys;
+  managerNames = [];
+  managers = {};
+  activeManagerName = "default";
+  /** A debounced version of the save function. Is already bound to the instance. */
+  debouncedSave;
+  storage;
+  /**
+   * All new managers will be created using this function. It should be capable of taking as little information as `{name}` (when a new manager is created) and returining a full manger.
+   *
+   * It's suggested you not do validation here, use the `onParse` hook instead.
+   *
+   * If you return an error, `onError` will be called, and no manager will be created.
+   */
+  createManager;
+  hooks;
+  constructor(createManager, hooks, {
+    storageKeys = {},
+    storage = localStorage
+  } = {}) {
+    this.createManager = createManager;
+    this.hooks = hooks;
+    storageKeys.prefix ??= "";
+    storageKeys.managerNames ??= "shortcut-manager:names";
+    storageKeys.managerPrefix ??= "shortcut-manager:manager.";
+    storageKeys.activeManager ??= "shortcut-manager:active";
+    if (storageKeys.prefix) {
+      for (const key of keys(storageKeys)) {
+        if (key === "prefix") continue;
+        storageKeys[key] = `${storageKeys.prefix}${storageKeys[key]}`;
+      }
+    }
+    this.storageKeys = storageKeys;
+    this.storage = storage;
+    this.debouncedSave = debounce(this.save.bind(this), 500);
+  }
+  init() {
+    const list = this.storage.getItem(this.storageKeys.managerNames);
+    const active = this.storage.getItem(this.storageKeys.activeManager);
+    this.setManagerNames(list ? JSON.parse(list) : []);
+    if (this.managerNames.length > 0) {
+      const res = this.managerNames.map((m) => {
+        const r = this.storageReadManager(m, { force: true });
+        this.notifyIfError(r);
+        if (r.isOk) {
+          this.load(r.value);
+        }
+        return r;
+      });
+      const ok = res.filter((r) => r.isOk);
+      if (ok.length > 0) {
+        this.loadOrCreateDefault();
+      }
+      if (active && this.managerNames.includes(active)) {
+        this.setActiveManager(active);
+      } else {
+        this.setActiveManager(this.managerNames[0]);
+      }
+    } else {
+      this.loadOrCreateDefault();
+    }
+  }
+  setManager(name, clone) {
+    if (clone === void 0) {
+      delete this.managers[name];
+    } else {
+      setReadOnly(this.managers, name, clone);
+    }
+    this.hooks.onSetManager?.(name, clone);
+  }
+  setManagerNames(names) {
+    setReadOnly(this, "managerNames", names);
+    this.hooks.onSetManagerNames?.(names);
+  }
+  setActiveManager(name) {
+    setReadOnly(this, "activeManagerName", name);
+    this.storage.setItem(this.storageKeys.activeManager, name);
+    this.hooks.onSetActiveManager?.(name);
+  }
+  addManager(name, clone) {
+    this.setManager(name, clone);
+    if (!this.managerNames.includes(name)) {
+      this.setManagerNames([...this.managerNames, name]);
+    }
+  }
+  removeManager(name) {
+    this.setManager(name, void 0);
+    const index = this.managerNames.indexOf(name);
+    if (index === -1) return;
+    this.setManagerNames(this.managerNames.toSpliced(index, 1));
+  }
+  storageSaveManager(name, clone) {
+    this.storage.setItem(`${this.storageKeys.managerPrefix}${name}`, JSON.stringify(clone));
+    if (!this.managerNames.includes(name)) {
+      this.managerNames.push(name);
+      this.storage.setItem(
+        this.storageKeys.managerNames,
+        JSON.stringify(this.managerNames)
+      );
+    }
+  }
+  storageRemoveManager(name) {
+    this.storage.removeItem(`${this.storageKeys.managerPrefix}${name}`);
+    const index = this.managerNames.indexOf(name);
+    if (index > -1) {
+      this.managerNames.splice(index, 1);
+      this.storage.setItem(
+        this.storageKeys.managerNames,
+        JSON.stringify(this.managerNames)
+      );
+    }
+  }
+  storageReadManager(name, { force = false } = {}) {
+    const raw = this.storage.getItem(`${this.storageKeys.managerPrefix}${name}`);
+    if (!raw && !force) {
+      const res = Err(new Error(`No manager found by the name of ${name}.`));
+      return this.notifyIfError(res);
+    }
+    const r = this.createManager(
+      !raw && force ? { name } : this.parseJsonManager(raw).unwrap(),
+      force
+    );
+    if (r instanceof Error) return Err(r);
+    return Ok(r);
+  }
+  parseJsonManager(raw) {
+    if (!raw) {
+      return Err(new Error(`Nothing to parse.`));
+    }
+    try {
+      const parsed = JSON.parse(raw);
+      const res = this.hooks.onParse?.(parsed);
+      if (res instanceof Error) {
+        return this.notifyIfError(Err(res));
+      }
+      if (res === void 0) throw new Error(`onParse must return a value.`);
+      return Ok(res ?? parsed);
+    } catch (e) {
+      return Err(e);
+    }
+  }
+  load(manager, {
+    doActivate = true
+  } = {}) {
+    this.setManager(manager.name, manager);
+    if (doActivate) {
+      this.setActiveManager(manager.name);
+    }
+    this.save(manager.name);
+  }
+  loadOrCreateDefault() {
+    const r = this.storageReadManager("default", { force: true });
+    this.notifyIfError(r);
+    if (r.isOk) {
+      this.load(r.value);
+    }
+  }
+  save(name) {
+    if (!this.managers[name]) {
+      this.notifyIfError(Err(new Error(`Manager ${name} not found`)));
+    }
+    const clone = managerToStorableClone(this.managers[name]);
+    this.hooks.onSave?.(clone);
+    this.storageSaveManager(name, clone);
+  }
+  notifyIfError(res) {
+    if (!res.isOk) {
+      this.hooks.onError?.(res.error);
+    }
+    return res;
+  }
+  changeManager(name, opts = {}) {
+    if (this.managerNames.includes(name)) {
+      this.setActiveManager(name);
+      return Ok();
+    } else {
+      const m = this.storageReadManager(name, opts);
+      if (m.isOk) {
+        this.load(m.value);
+        this.setActiveManager(name);
+      }
+      return Ok();
+    }
+  }
+  deleteManager(name) {
+    const index = this.managerNames.indexOf(name);
+    let nextName = this.managerNames[index - 1] ?? this.managerNames[index + 1] ?? "default";
+    this.storageRemoveManager(name);
+    this.setManager(name, void 0);
+    if (nextName === name) nextName = "default";
+    const res = this.changeManager(nextName, { force: true });
+    this.notifyIfError(res);
+    return res;
+  }
+  renameManager(name) {
+    this.storageRemoveManager(this.activeManagerName);
+    this.setManager(name, this.managers[this.activeManagerName]);
+    this.setManager(this.activeManagerName, void 0);
+    this.setActiveManager(name);
+    this.save(name);
+  }
+  duplicateManager(oldName, newName) {
+    const m = this.managers[oldName];
+    if (!m) {
+      const res = Err(new Error(`No manager found by the name of ${oldName}.`));
+      return this.notifyIfError(res);
+    }
+    const clone = managerToStorableClone(m);
+    clone.name = newName;
+    const instance = this.createManager(clone, false);
+    if (instance instanceof Error) return this.notifyIfError(Err(instance));
+    else if (instance) this.load(instance);
+    return Ok(instance);
+  }
+  exportManagers(names) {
+    const obj = { managers: [] };
+    for (const name of names) {
+      const m = this.managers[name];
+      if (!m) {
+        const res = Err(new Error(`No manager found by the name of ${name}.`));
+        return this.notifyIfError(res);
+      }
+      const clone = managerToStorableClone(m);
+      this.hooks.onSave?.(clone);
+      obj.managers.push(clone);
+    }
+    this.hooks.onExport?.(obj);
+    return Ok(obj);
+  }
+  importManagers(content) {
+    const p = JSON.parse(content);
+    if (!p.managers || !isArray(p.manager)) {
+      return Err(new Error(`Not a valid manager file.`));
+    }
+    const ok = [];
+    for (const parsedM of p.managers) {
+      const m = this.parseJsonManager(JSON.stringify(parsedM));
+      this.notifyIfError(m);
+      if (m.isOk) {
+        const instance = this.createManager(m.value, false);
+        if (instance instanceof Error) return this.notifyIfError(Err(instance));
+        ok.push(instance);
+      }
+    }
+    for (const instance of ok) {
+      this.load(instance);
+    }
+    return Ok();
+  }
+  /** Clears all managers and resets the state. `init` must be called again if you want to use the class instance again. */
+  clearAll() {
+    this.storage.removeItem(this.storageKeys.managerNames);
+    this.storage.removeItem(this.storageKeys.activeManager);
+    for (const name of this.managerNames) {
+      this.storageRemoveManager(name);
+    }
+    this.setManagerNames([]);
+    this.setActiveManager("default");
+  }
+}

package/dist/core/addCommand.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 addCommand<THooks extends Manager["hooks"], TCheck extends boolean | "only" = true>(command: Command, manager: CommandsSetEntries["entries@add"]["manager"] & {
+    hooks?: THooks;
+}, opts?: {
+    check?: TCheck;
+}): Result<TCheck extends "only" ? true : Command, MultipleErrors<CommandsSetEntries["entries@add"]["error"]> | CanHookErrors<THooks extends never ? never : THooks, "canSetCommandsProp">>;

package/dist/core/addCommand.js

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

package/dist/core/addKey.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 addKey<THooks extends Manager["hooks"], TCheck extends boolean | "only" = true>(key: Key, manager: KeysSetEntries["entries@add"]["manager"] & {
+    hooks?: THooks;
+}, opts?: {
+    check?: TCheck;
+}): Result<TCheck extends "only" ? true : Key, MultipleErrors<KeysSetEntries["entries@add"]["error"]> | CanHookErrors<THooks extends never ? never : THooks, "canSetKeysProp">>;

package/dist/core/addKey.js

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

package/dist/core/addShortcut.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 addShortcut<THooks extends Manager["hooks"], TCheck extends boolean | "only" = true>(shortcut: Shortcut, manager: ShortcutsSetEntries["entries@add"]["manager"] & {
+    hooks?: THooks;
+}, opts?: {
+    check?: TCheck;
+}): Result<TCheck extends "only" ? true : Shortcut, MultipleErrors<ShortcutsSetEntries["entries@add"]["error"]> | CanHookErrors<THooks extends never ? never : THooks, "canSetShortcutsProp">>;

package/dist/core/addShortcut.js

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

package/dist/core/attach.d.ts

@@ -0,0 +1,10 @@
+import type { AnyFunction } from "@alanscodelog/utils/types";
+import type { AttachTarget, EventTypes } from "../types/index.js";
+/**
+ * Attach the event listeners created by {@link createManagerEventListeners} to an element or {@link Emulator} so the manager can listen to the needed event hooks.
+ *
+ * They can be removed with {@link detach} or by aborting the controller returned by the function.
+ */
+export declare function attach(el: AttachTarget, listeners: Record<EventTypes, AnyFunction>, 
+/** Add options to some listeners. An abort controller is added by default. You can use the `*` key to set a default for all. */
+opts?: Partial<Record<EventTypes | "*", AddEventListenerOptions>>): AbortController;

package/dist/core/attach.js

@@ -0,0 +1,13 @@
+import { keys } from "@alanscodelog/utils/keys";
+export function attach(el, listeners, opts = { wheel: { passive: true } }) {
+  const controller = new AbortController();
+  const defaultOpts = opts["*"] ?? {};
+  for (const listenerName of keys(listeners)) {
+    el.addEventListener(listenerName, listeners[listenerName], {
+      signal: controller.signal,
+      ...defaultOpts,
+      ...opts[listenerName]
+    });
+  }
+  return controller;
+}

package/dist/core/createCommand.d.ts

@@ -0,0 +1,4 @@
+import type { Command, CommandExecute, RawCommand } from "../types/index.js";
+export declare function createCommand<TName extends string = string, TCommand extends RawCommand<TName> = RawCommand<TName>>(name: TName, rawCommand?: Omit<TCommand, "name" | "execute"> & {
+    execute: CommandExecute<TName>;
+}): Command;

package/dist/core/createCommand.js

@@ -0,0 +1,11 @@
+export function createCommand(name, rawCommand = {}) {
+  const command = {
+    ...rawCommand,
+    type: "command",
+    name,
+    execute: rawCommand.execute,
+    description: rawCommand.description ?? "",
+    condition: rawCommand.condition ?? { type: "condition", text: "" }
+  };
+  return command;
+}

package/dist/core/createCommands.d.ts

@@ -0,0 +1,11 @@
+import { type Result } from "@alanscodelog/utils/Result";
+import type { CanHookErrors, Command, Commands, CommandsSetEntries, Manager, MultipleErrors, PickManager } from "../types/index.js";
+/**
+ * # Commands
+ * Creates a set of commands.
+ */
+export declare function createCommands<THooks extends Manager["hooks"], TEntries extends Record<string, Command>, TCheck extends boolean | "only" = true>(commandsList: Command[], manager?: PickManager<"options", "stringifier"> & {
+    hooks?: THooks;
+}, { check }?: {
+    check?: TCheck;
+}): Result<TCheck extends "only" ? true : Commands<TEntries>, MultipleErrors<CommandsSetEntries["entries@add"]["error"]> | CanHookErrors<THooks extends never ? never : THooks, "canSetCommandsProp">>;

package/dist/core/createCommands.js

@@ -0,0 +1,20 @@
+import { Ok } from "@alanscodelog/utils/Result";
+import { addCommand } from "./addCommand.js";
+import { defaultStringifier } from "../defaults/Stringifier.js";
+export function createCommands(commandsList, manager = {
+  options: { stringifier: defaultStringifier }
+}, { check = true } = {}) {
+  const commands = {
+    type: "commands",
+    entries: {}
+  };
+  const managerClone = { ...manager, commands };
+  if (check) {
+    for (const command of commandsList) {
+      const res = addCommand(command, managerClone);
+      if (res.isError) return res;
+    }
+  }
+  if (check === "only") return Ok(true);
+  return Ok(commands);
+}

package/dist/core/createCondition.d.ts

@@ -0,0 +1,7 @@
+import type { Condition } from "../types/index.js";
+export declare function createCondition<TTextCondition extends string, TReturn extends Condition>(rawCondition: TTextCondition, 
+/**
+ * Optionally modify the shape of the condition and add your own properties.
+ * For example, you can append a parsed AST like representation of the condition.
+ */
+parse?: (raw: TTextCondition, condition: Condition) => TReturn): TReturn;

package/dist/core/createCondition.js

@@ -0,0 +1,11 @@
+export function createCondition(rawCondition, parse) {
+  let condition = {
+    ...rawCondition,
+    type: "condition",
+    text: rawCondition ?? ""
+  };
+  if (parse) {
+    condition = parse(rawCondition, condition);
+  }
+  return condition;
+}