@voidhash/mimic-react 0.0.1 → 0.0.3

package/dist/zustand-commander/index.d.cts

@@ -1,313 +1,4 @@
-import { StoreApi, UseBoundStore } from "zustand";
-
-//#region src/zustand-commander/types.d.ts
-
-/**
- * Symbol used to identify Command objects at runtime.
- */
-declare const COMMAND_SYMBOL: unique symbol;
-/**
- * Symbol used to identify UndoableCommand objects at runtime.
- */
-declare const UNDOABLE_COMMAND_SYMBOL: unique symbol;
-/**
- * Context provided to command functions.
- * Gives access to store state and dispatch capabilities.
- */
-interface CommandContext<TStore> {
-  /**
-   * Get the current store state.
-   */
-  readonly getState: () => TStore;
-  /**
-   * Set partial store state (for local/browser state updates).
-   */
-  readonly setState: (partial: Partial<TStore>) => void;
-  /**
-   * Dispatch another command.
-   * Returns the result of the dispatched command.
-   *
-   * @example
-   * dispatch(otherCommand)({ param: "value" });
-   */
-  readonly dispatch: CommandDispatch<TStore>;
-}
-/**
- * The function signature for a command handler.
- */
-type CommandFn<TStore, TParams, TReturn> = (ctx: CommandContext<TStore>, params: TParams) => TReturn;
-/**
- * The function signature for an undoable command's revert handler.
- * Receives the original params and the result from the forward execution.
- */
-type RevertFn<TStore, TParams, TReturn> = (ctx: CommandContext<TStore>, params: TParams, result: TReturn) => void;
-/**
- * A command that can be dispatched to modify store state.
- * Regular commands do not support undo/redo.
- */
-interface Command<TStore, TParams, TReturn> {
-  readonly [COMMAND_SYMBOL]: true;
-  readonly fn: CommandFn<TStore, TParams, TReturn>;
-}
-/**
- * An undoable command that supports undo/redo.
- * Must provide a revert function that knows how to undo the change.
- */
-interface UndoableCommand<TStore, TParams, TReturn> extends Command<TStore, TParams, TReturn> {
-  readonly [UNDOABLE_COMMAND_SYMBOL]: true;
-  readonly revert: RevertFn<TStore, TParams, TReturn>;
-}
-/**
- * Any command type (regular or undoable).
- */
-type AnyCommand = Command<any, any, any>;
-/**
- * Any undoable command type.
- */
-type AnyUndoableCommand = UndoableCommand<any, any, any>;
-/**
- * Dispatch function that accepts commands and returns a function to call with params.
- * Returns the result of the command execution.
- *
- * @example
- * const result = dispatch(myCommand)({ param: "value" });
- */
-type CommandDispatch<TStore> = <TParams, TReturn>(command: Command<TStore, TParams, TReturn>) => (params: TParams) => TReturn;
-/**
- * An entry in the undo/redo stack.
- * Contains all information needed to revert or redo a command.
- */
-interface UndoEntry<TParams = unknown, TReturn = unknown> {
-  /** The undoable command that was executed */
-  readonly command: AnyUndoableCommand;
-  /** The parameters that were passed to the command */
-  readonly params: TParams;
-  /** The result returned by the command (passed to revert) */
-  readonly result: TReturn;
-  /** Timestamp when the command was executed */
-  readonly timestamp: number;
-}
-/**
- * State slice for undo/redo functionality.
- */
-interface CommanderSlice {
-  readonly _commander: {
-    /** Stack of commands that can be undone */
-    readonly undoStack: ReadonlyArray<UndoEntry>;
-    /** Stack of commands that can be redone */
-    readonly redoStack: ReadonlyArray<UndoEntry>;
-  };
-}
-/**
- * Options for creating a commander.
- */
-interface CommanderOptions {
-  /**
-   * Maximum number of undo entries to keep.
-   * @default 100
-   */
-  readonly maxUndoStackSize?: number;
-}
-/**
- * A commander instance bound to a specific store type.
- * Used to create commands and the middleware.
- */
-interface Commander<TStore> {
-  /**
-   * Create a regular command (no undo support).
-   *
-   * @example
-   * // With params
-   * const addItem = commander.action<{ name: string }>(
-   *   (ctx, params) => {
-   *     // modify state using params.name
-   *   }
-   * );
-   *
-   * // Without params
-   * const clearAll = commander.action((ctx) => {
-   *   // modify state
-   * });
-   */
-  readonly action: {
-    <TParams, TReturn = void>(fn: CommandFn<TStore, TParams, TReturn>): Command<TStore, TParams, TReturn>;
-    <TReturn = void>(fn: CommandFn<TStore, void, TReturn>): Command<TStore, void, TReturn>;
-  };
-  /**
-   * Create an undoable command with undo/redo support.
-   * The revert function is called when undoing the command.
-   *
-   * @example
-   * const moveItem = commander.undoableAction<{ id: string; toIndex: number }, { fromIndex: number }>(
-   *   (ctx, params) => {
-   *     const fromIndex = // get current index
-   *     // perform move
-   *     return { fromIndex }; // return data needed for revert
-   *   },
-   *   (ctx, params, result) => {
-   *     // revert: move back to original position
-   *     ctx.dispatch(moveItem)({ id: params.id, toIndex: result.fromIndex });
-   *   }
-   * );
-   */
-  readonly undoableAction: {
-    <TParams, TReturn>(fn: CommandFn<TStore, TParams, TReturn>, revert: RevertFn<TStore, TParams, TReturn>): UndoableCommand<TStore, TParams, TReturn>;
-    <TReturn>(fn: CommandFn<TStore, void, TReturn>, revert: RevertFn<TStore, void, TReturn>): UndoableCommand<TStore, void, TReturn>;
-  };
-  /**
-   * Zustand middleware that adds commander functionality.
-   * Adds undo/redo stacks to the store state.
-   */
-  readonly middleware: CommanderMiddleware<TStore>;
-}
-/**
- * Type for the commander middleware.
- * Note: TStore is intentionally unused here to match the Commander interface signature.
- * The middleware is generic over T (the inner store type) and adds CommanderSlice.
- */
-type CommanderMiddleware<_TStore> = <T extends object>(config: (set: StoreApi<T & CommanderSlice>["setState"], get: StoreApi<T & CommanderSlice>["getState"], api: StoreApi<T & CommanderSlice>) => T) => (set: StoreApi<T & CommanderSlice>["setState"], get: StoreApi<T & CommanderSlice>["getState"], api: StoreApi<T & CommanderSlice>) => T & CommanderSlice;
-/**
- * Extract the params type from a command.
- */
-type CommandParams<T> = T extends Command<any, infer P, any> ? P : never;
-/**
- * Extract the return type from a command.
- */
-type CommandReturn<T> = T extends Command<any, any, infer R> ? R : undefined;
-/**
- * Extract the store type from a command.
- */
-type CommandStore<T> = T extends Command<infer S, any, any> ? S : never;
-/**
- * Type guard to check if a value is a Command.
- */
-declare function isCommand(value: unknown): value is AnyCommand;
-/**
- * Type guard to check if a command is undoable.
- */
-declare function isUndoableCommand(value: unknown): value is AnyUndoableCommand;
-/**
- * Helper type to extract the state type from a zustand store.
- */
-type ExtractState<TStore> = TStore extends UseBoundStore<StoreApi<infer S>> ? S : TStore extends StoreApi<infer S> ? S : never;
-//#endregion
-//#region src/zustand-commander/commander.d.ts
-/**
- * Creates a commander instance bound to a specific store type.
- *
- * @example
- * ```ts
- * // Create commander for your store type
- * const commander = createCommander<StoreState>();
- *
- * // Define commands
- * const addItem = commander.action(
- *   Schema.Struct({ name: Schema.String }),
- *   (ctx, params) => {
- *     const { mimic } = ctx.getState();
- *     mimic.document.transaction(root => {
- *       // add item
- *     });
- *   }
- * );
- *
- * // Create store with middleware
- * const useStore = create(
- *   commander.middleware(
- *     mimic(document, (set, get) => ({
- *       // your state
- *     }))
- *   )
- * );
- * ```
- */
-declare function createCommander<TStore extends object>(options?: CommanderOptions): Commander<TStore & CommanderSlice>;
-/**
- * Perform an undo operation on the store.
- * Returns true if an undo was performed, false if undo stack was empty.
- */
-declare function performUndo<TStore extends CommanderSlice>(storeApi: StoreApi<TStore>): boolean;
-/**
- * Perform a redo operation on the store.
- * Returns true if a redo was performed, false if redo stack was empty.
- */
-declare function performRedo<TStore extends CommanderSlice>(storeApi: StoreApi<TStore>): boolean;
-/**
- * Clear the undo and redo stacks.
- */
-declare function clearUndoHistory<TStore extends CommanderSlice>(storeApi: StoreApi<TStore>): void;
-//#endregion
-//#region src/zustand-commander/hooks.d.ts
-/**
- * React hook to get a dispatch function for commands.
- * The dispatch function executes commands and manages undo/redo state.
- *
- * @example
- * ```tsx
- * const dispatch = useCommander(useStore);
- *
- * const handleClick = () => {
- *   dispatch(addCard)({ columnId: "col-1", title: "New Card" });
- * };
- * ```
- */
-declare function useCommander<TStore extends CommanderSlice>(store: UseBoundStore<StoreApi<TStore>>): CommandDispatch<TStore>;
-/**
- * State and actions for undo/redo functionality.
- */
-interface UndoRedoState {
-  /** Whether there are actions that can be undone */
-  readonly canUndo: boolean;
-  /** Whether there are actions that can be redone */
-  readonly canRedo: boolean;
-  /** Number of items in the undo stack */
-  readonly undoCount: number;
-  /** Number of items in the redo stack */
-  readonly redoCount: number;
-  /** Undo the last action */
-  readonly undo: () => boolean;
-  /** Redo the last undone action */
-  readonly redo: () => boolean;
-  /** Clear the undo/redo history */
-  readonly clear: () => void;
-}
-/**
- * React hook for undo/redo functionality.
- * Provides state (canUndo, canRedo) and actions (undo, redo, clear).
- *
- * @example
- * ```tsx
- * const { canUndo, canRedo, undo, redo } = useUndoRedo(useStore);
- *
- * return (
- *   <>
- *     <button onClick={undo} disabled={!canUndo}>Undo</button>
- *     <button onClick={redo} disabled={!canRedo}>Redo</button>
- *   </>
- * );
- * ```
- */
-declare function useUndoRedo<TStore extends CommanderSlice>(store: UseBoundStore<StoreApi<TStore>>): UndoRedoState;
-/**
- * Options for the keyboard shortcut hook.
- */
-interface UseUndoRedoKeyboardOptions {
-  /** Enable Ctrl/Cmd+Z for undo (default: true) */
-  readonly enableUndo?: boolean;
-  /** Enable Ctrl/Cmd+Shift+Z or Ctrl+Y for redo (default: true) */
-  readonly enableRedo?: boolean;
-}
-/**
- * React hook that adds keyboard shortcuts for undo/redo.
- * Listens for Ctrl/Cmd+Z (undo) and Ctrl/Cmd+Shift+Z or Ctrl+Y (redo).
- *
- * @example
- * ```tsx
- * // In your app component
- * useUndoRedoKeyboard(useStore);
- * ```
- */
-declare function useUndoRedoKeyboard<TStore extends CommanderSlice>(store: UseBoundStore<StoreApi<TStore>>, options?: UseUndoRedoKeyboardOptions): void;
-//#endregion
-export { type AnyCommand, type AnyUndoableCommand, COMMAND_SYMBOL, type Command, type CommandContext, type CommandDispatch, type CommandFn, type CommandParams, type CommandReturn, type CommandStore, type Commander, type CommanderMiddleware, type CommanderOptions, type CommanderSlice, type ExtractState, type RevertFn, UNDOABLE_COMMAND_SYMBOL, type UndoEntry, type UndoRedoState, type UndoableCommand, type UseUndoRedoKeyboardOptions, clearUndoHistory, createCommander, isCommand, isUndoableCommand, performRedo, performUndo, useCommander, useUndoRedo, useUndoRedoKeyboard };
-//# sourceMappingURL=index.d.cts.map
+import { AnyCommand, AnyUndoableCommand, COMMAND_SYMBOL, Command, CommandContext, CommandDispatch, CommandFn, CommandParams, CommandReturn, CommandStore, Commander, CommanderMiddleware, CommanderOptions, CommanderSlice, ExtractState, RevertFn, UNDOABLE_COMMAND_SYMBOL, UndoEntry, UndoableCommand, isCommand, isUndoableCommand } from "./types.cjs";
+import { clearUndoHistory, createCommander, performRedo, performUndo } from "./commander.cjs";
+import { UndoRedoState, UseUndoRedoKeyboardOptions, useCommander, useUndoRedo, useUndoRedoKeyboard } from "./hooks.cjs";
+export { type AnyCommand, type AnyUndoableCommand, COMMAND_SYMBOL, type Command, type CommandContext, type CommandDispatch, type CommandFn, type CommandParams, type CommandReturn, type CommandStore, type Commander, type CommanderMiddleware, type CommanderOptions, type CommanderSlice, type ExtractState, type RevertFn, UNDOABLE_COMMAND_SYMBOL, type UndoEntry, type UndoRedoState, type UndoableCommand, type UseUndoRedoKeyboardOptions, clearUndoHistory, createCommander, isCommand, isUndoableCommand, performRedo, performUndo, useCommander, useUndoRedo, useUndoRedoKeyboard };

package/dist/zustand-commander/index.d.mts

@@ -1,313 +1,4 @@
-import { StoreApi, UseBoundStore } from "zustand";
-
-//#region src/zustand-commander/types.d.ts
-
-/**
- * Symbol used to identify Command objects at runtime.
- */
-declare const COMMAND_SYMBOL: unique symbol;
-/**
- * Symbol used to identify UndoableCommand objects at runtime.
- */
-declare const UNDOABLE_COMMAND_SYMBOL: unique symbol;
-/**
- * Context provided to command functions.
- * Gives access to store state and dispatch capabilities.
- */
-interface CommandContext<TStore> {
-  /**
-   * Get the current store state.
-   */
-  readonly getState: () => TStore;
-  /**
-   * Set partial store state (for local/browser state updates).
-   */
-  readonly setState: (partial: Partial<TStore>) => void;
-  /**
-   * Dispatch another command.
-   * Returns the result of the dispatched command.
-   *
-   * @example
-   * dispatch(otherCommand)({ param: "value" });
-   */
-  readonly dispatch: CommandDispatch<TStore>;
-}
-/**
- * The function signature for a command handler.
- */
-type CommandFn<TStore, TParams, TReturn> = (ctx: CommandContext<TStore>, params: TParams) => TReturn;
-/**
- * The function signature for an undoable command's revert handler.
- * Receives the original params and the result from the forward execution.
- */
-type RevertFn<TStore, TParams, TReturn> = (ctx: CommandContext<TStore>, params: TParams, result: TReturn) => void;
-/**
- * A command that can be dispatched to modify store state.
- * Regular commands do not support undo/redo.
- */
-interface Command<TStore, TParams, TReturn> {
-  readonly [COMMAND_SYMBOL]: true;
-  readonly fn: CommandFn<TStore, TParams, TReturn>;
-}
-/**
- * An undoable command that supports undo/redo.
- * Must provide a revert function that knows how to undo the change.
- */
-interface UndoableCommand<TStore, TParams, TReturn> extends Command<TStore, TParams, TReturn> {
-  readonly [UNDOABLE_COMMAND_SYMBOL]: true;
-  readonly revert: RevertFn<TStore, TParams, TReturn>;
-}
-/**
- * Any command type (regular or undoable).
- */
-type AnyCommand = Command<any, any, any>;
-/**
- * Any undoable command type.
- */
-type AnyUndoableCommand = UndoableCommand<any, any, any>;
-/**
- * Dispatch function that accepts commands and returns a function to call with params.
- * Returns the result of the command execution.
- *
- * @example
- * const result = dispatch(myCommand)({ param: "value" });
- */
-type CommandDispatch<TStore> = <TParams, TReturn>(command: Command<TStore, TParams, TReturn>) => (params: TParams) => TReturn;
-/**
- * An entry in the undo/redo stack.
- * Contains all information needed to revert or redo a command.
- */
-interface UndoEntry<TParams = unknown, TReturn = unknown> {
-  /** The undoable command that was executed */
-  readonly command: AnyUndoableCommand;
-  /** The parameters that were passed to the command */
-  readonly params: TParams;
-  /** The result returned by the command (passed to revert) */
-  readonly result: TReturn;
-  /** Timestamp when the command was executed */
-  readonly timestamp: number;
-}
-/**
- * State slice for undo/redo functionality.
- */
-interface CommanderSlice {
-  readonly _commander: {
-    /** Stack of commands that can be undone */
-    readonly undoStack: ReadonlyArray<UndoEntry>;
-    /** Stack of commands that can be redone */
-    readonly redoStack: ReadonlyArray<UndoEntry>;
-  };
-}
-/**
- * Options for creating a commander.
- */
-interface CommanderOptions {
-  /**
-   * Maximum number of undo entries to keep.
-   * @default 100
-   */
-  readonly maxUndoStackSize?: number;
-}
-/**
- * A commander instance bound to a specific store type.
- * Used to create commands and the middleware.
- */
-interface Commander<TStore> {
-  /**
-   * Create a regular command (no undo support).
-   *
-   * @example
-   * // With params
-   * const addItem = commander.action<{ name: string }>(
-   *   (ctx, params) => {
-   *     // modify state using params.name
-   *   }
-   * );
-   *
-   * // Without params
-   * const clearAll = commander.action((ctx) => {
-   *   // modify state
-   * });
-   */
-  readonly action: {
-    <TParams, TReturn = void>(fn: CommandFn<TStore, TParams, TReturn>): Command<TStore, TParams, TReturn>;
-    <TReturn = void>(fn: CommandFn<TStore, void, TReturn>): Command<TStore, void, TReturn>;
-  };
-  /**
-   * Create an undoable command with undo/redo support.
-   * The revert function is called when undoing the command.
-   *
-   * @example
-   * const moveItem = commander.undoableAction<{ id: string; toIndex: number }, { fromIndex: number }>(
-   *   (ctx, params) => {
-   *     const fromIndex = // get current index
-   *     // perform move
-   *     return { fromIndex }; // return data needed for revert
-   *   },
-   *   (ctx, params, result) => {
-   *     // revert: move back to original position
-   *     ctx.dispatch(moveItem)({ id: params.id, toIndex: result.fromIndex });
-   *   }
-   * );
-   */
-  readonly undoableAction: {
-    <TParams, TReturn>(fn: CommandFn<TStore, TParams, TReturn>, revert: RevertFn<TStore, TParams, TReturn>): UndoableCommand<TStore, TParams, TReturn>;
-    <TReturn>(fn: CommandFn<TStore, void, TReturn>, revert: RevertFn<TStore, void, TReturn>): UndoableCommand<TStore, void, TReturn>;
-  };
-  /**
-   * Zustand middleware that adds commander functionality.
-   * Adds undo/redo stacks to the store state.
-   */
-  readonly middleware: CommanderMiddleware<TStore>;
-}
-/**
- * Type for the commander middleware.
- * Note: TStore is intentionally unused here to match the Commander interface signature.
- * The middleware is generic over T (the inner store type) and adds CommanderSlice.
- */
-type CommanderMiddleware<_TStore> = <T extends object>(config: (set: StoreApi<T & CommanderSlice>["setState"], get: StoreApi<T & CommanderSlice>["getState"], api: StoreApi<T & CommanderSlice>) => T) => (set: StoreApi<T & CommanderSlice>["setState"], get: StoreApi<T & CommanderSlice>["getState"], api: StoreApi<T & CommanderSlice>) => T & CommanderSlice;
-/**
- * Extract the params type from a command.
- */
-type CommandParams<T> = T extends Command<any, infer P, any> ? P : never;
-/**
- * Extract the return type from a command.
- */
-type CommandReturn<T> = T extends Command<any, any, infer R> ? R : undefined;
-/**
- * Extract the store type from a command.
- */
-type CommandStore<T> = T extends Command<infer S, any, any> ? S : never;
-/**
- * Type guard to check if a value is a Command.
- */
-declare function isCommand(value: unknown): value is AnyCommand;
-/**
- * Type guard to check if a command is undoable.
- */
-declare function isUndoableCommand(value: unknown): value is AnyUndoableCommand;
-/**
- * Helper type to extract the state type from a zustand store.
- */
-type ExtractState<TStore> = TStore extends UseBoundStore<StoreApi<infer S>> ? S : TStore extends StoreApi<infer S> ? S : never;
-//#endregion
-//#region src/zustand-commander/commander.d.ts
-/**
- * Creates a commander instance bound to a specific store type.
- *
- * @example
- * ```ts
- * // Create commander for your store type
- * const commander = createCommander<StoreState>();
- *
- * // Define commands
- * const addItem = commander.action(
- *   Schema.Struct({ name: Schema.String }),
- *   (ctx, params) => {
- *     const { mimic } = ctx.getState();
- *     mimic.document.transaction(root => {
- *       // add item
- *     });
- *   }
- * );
- *
- * // Create store with middleware
- * const useStore = create(
- *   commander.middleware(
- *     mimic(document, (set, get) => ({
- *       // your state
- *     }))
- *   )
- * );
- * ```
- */
-declare function createCommander<TStore extends object>(options?: CommanderOptions): Commander<TStore & CommanderSlice>;
-/**
- * Perform an undo operation on the store.
- * Returns true if an undo was performed, false if undo stack was empty.
- */
-declare function performUndo<TStore extends CommanderSlice>(storeApi: StoreApi<TStore>): boolean;
-/**
- * Perform a redo operation on the store.
- * Returns true if a redo was performed, false if redo stack was empty.
- */
-declare function performRedo<TStore extends CommanderSlice>(storeApi: StoreApi<TStore>): boolean;
-/**
- * Clear the undo and redo stacks.
- */
-declare function clearUndoHistory<TStore extends CommanderSlice>(storeApi: StoreApi<TStore>): void;
-//#endregion
-//#region src/zustand-commander/hooks.d.ts
-/**
- * React hook to get a dispatch function for commands.
- * The dispatch function executes commands and manages undo/redo state.
- *
- * @example
- * ```tsx
- * const dispatch = useCommander(useStore);
- *
- * const handleClick = () => {
- *   dispatch(addCard)({ columnId: "col-1", title: "New Card" });
- * };
- * ```
- */
-declare function useCommander<TStore extends CommanderSlice>(store: UseBoundStore<StoreApi<TStore>>): CommandDispatch<TStore>;
-/**
- * State and actions for undo/redo functionality.
- */
-interface UndoRedoState {
-  /** Whether there are actions that can be undone */
-  readonly canUndo: boolean;
-  /** Whether there are actions that can be redone */
-  readonly canRedo: boolean;
-  /** Number of items in the undo stack */
-  readonly undoCount: number;
-  /** Number of items in the redo stack */
-  readonly redoCount: number;
-  /** Undo the last action */
-  readonly undo: () => boolean;
-  /** Redo the last undone action */
-  readonly redo: () => boolean;
-  /** Clear the undo/redo history */
-  readonly clear: () => void;
-}
-/**
- * React hook for undo/redo functionality.
- * Provides state (canUndo, canRedo) and actions (undo, redo, clear).
- *
- * @example
- * ```tsx
- * const { canUndo, canRedo, undo, redo } = useUndoRedo(useStore);
- *
- * return (
- *   <>
- *     <button onClick={undo} disabled={!canUndo}>Undo</button>
- *     <button onClick={redo} disabled={!canRedo}>Redo</button>
- *   </>
- * );
- * ```
- */
-declare function useUndoRedo<TStore extends CommanderSlice>(store: UseBoundStore<StoreApi<TStore>>): UndoRedoState;
-/**
- * Options for the keyboard shortcut hook.
- */
-interface UseUndoRedoKeyboardOptions {
-  /** Enable Ctrl/Cmd+Z for undo (default: true) */
-  readonly enableUndo?: boolean;
-  /** Enable Ctrl/Cmd+Shift+Z or Ctrl+Y for redo (default: true) */
-  readonly enableRedo?: boolean;
-}
-/**
- * React hook that adds keyboard shortcuts for undo/redo.
- * Listens for Ctrl/Cmd+Z (undo) and Ctrl/Cmd+Shift+Z or Ctrl+Y (redo).
- *
- * @example
- * ```tsx
- * // In your app component
- * useUndoRedoKeyboard(useStore);
- * ```
- */
-declare function useUndoRedoKeyboard<TStore extends CommanderSlice>(store: UseBoundStore<StoreApi<TStore>>, options?: UseUndoRedoKeyboardOptions): void;
-//#endregion
-export { type AnyCommand, type AnyUndoableCommand, COMMAND_SYMBOL, type Command, type CommandContext, type CommandDispatch, type CommandFn, type CommandParams, type CommandReturn, type CommandStore, type Commander, type CommanderMiddleware, type CommanderOptions, type CommanderSlice, type ExtractState, type RevertFn, UNDOABLE_COMMAND_SYMBOL, type UndoEntry, type UndoRedoState, type UndoableCommand, type UseUndoRedoKeyboardOptions, clearUndoHistory, createCommander, isCommand, isUndoableCommand, performRedo, performUndo, useCommander, useUndoRedo, useUndoRedoKeyboard };
-//# sourceMappingURL=index.d.mts.map
+import { AnyCommand, AnyUndoableCommand, COMMAND_SYMBOL, Command, CommandContext, CommandDispatch, CommandFn, CommandParams, CommandReturn, CommandStore, Commander, CommanderMiddleware, CommanderOptions, CommanderSlice, ExtractState, RevertFn, UNDOABLE_COMMAND_SYMBOL, UndoEntry, UndoableCommand, isCommand, isUndoableCommand } from "./types.mjs";
+import { clearUndoHistory, createCommander, performRedo, performUndo } from "./commander.mjs";
+import { UndoRedoState, UseUndoRedoKeyboardOptions, useCommander, useUndoRedo, useUndoRedoKeyboard } from "./hooks.mjs";
+export { type AnyCommand, type AnyUndoableCommand, COMMAND_SYMBOL, type Command, type CommandContext, type CommandDispatch, type CommandFn, type CommandParams, type CommandReturn, type CommandStore, type Commander, type CommanderMiddleware, type CommanderOptions, type CommanderSlice, type ExtractState, type RevertFn, UNDOABLE_COMMAND_SYMBOL, type UndoEntry, type UndoRedoState, type UndoableCommand, type UseUndoRedoKeyboardOptions, clearUndoHistory, createCommander, isCommand, isUndoableCommand, performRedo, performUndo, useCommander, useUndoRedo, useUndoRedoKeyboard };