@voidhash/mimic-react 0.0.1-alpha.6 → 0.0.1-alpha.8

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

@@ -0,0 +1,325 @@
+import { StoreApi, UseBoundStore } from "zustand";
+import { Schema } from "effect";
+
+//#region src/zustand-commander/types.d.ts
+
+/**
+ * Any Effect Schema type (used for type constraints).
+ */
+type AnyEffectSchema = Schema.Schema<any, any, any>;
+/**
+ * Infer the Type from an Effect Schema.
+ */
+type InferSchemaType<T> = T extends Schema.Schema<infer A, any, any> ? A : never;
+/**
+ * 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>;
+  readonly paramsSchema: AnyEffectSchema | null;
+}
+/**
+ * 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 schema
+   * const addItem = commander.action(
+   *   Schema.Struct({ name: Schema.String }),
+   *   (ctx, params) => {
+   *     // modify state
+   *   }
+   * );
+   *
+   * // Without params
+   * const clearAll = commander.action((ctx) => {
+   *   // modify state
+   * });
+   */
+  readonly action: {
+    <TParamsSchema extends AnyEffectSchema, TReturn = void>(paramsSchema: TParamsSchema, fn: CommandFn<TStore, InferSchemaType<TParamsSchema>, TReturn>): Command<TStore, InferSchemaType<TParamsSchema>, 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(
+   *   Schema.Struct({ id: Schema.String, toIndex: Schema.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: {
+    <TParamsSchema extends AnyEffectSchema, TReturn>(paramsSchema: TParamsSchema, fn: CommandFn<TStore, InferSchemaType<TParamsSchema>, TReturn>, revert: RevertFn<TStore, InferSchemaType<TParamsSchema>, TReturn>): UndoableCommand<TStore, InferSchemaType<TParamsSchema>, 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 AnyEffectSchema, 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 InferSchemaType, 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

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

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.mts","names":[],"sources":["../../src/zustand-commander/types.ts","../../src/zustand-commander/commander.ts","../../src/zustand-commander/hooks.ts"],"sourcesContent":[],"mappings":"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"}

package/dist/zustand-commander/index.mjs

@@ -0,0 +1,355 @@
+import { t as _objectSpread2 } from "../objectSpread2-CxTyNSYl.mjs";
+import { useCallback, useEffect, useMemo } from "react";
+import { useStore } from "zustand";
+
+//#region src/zustand-commander/types.ts
+/**
+* Symbol used to identify Command objects at runtime.
+*/
+const COMMAND_SYMBOL = Symbol.for("zustand-commander/command");
+/**
+* Symbol used to identify UndoableCommand objects at runtime.
+*/
+const UNDOABLE_COMMAND_SYMBOL = Symbol.for("zustand-commander/undoable-command");
+/**
+* Type guard to check if a value is a Command.
+*/
+function isCommand(value) {
+	return typeof value === "object" && value !== null && COMMAND_SYMBOL in value && value[COMMAND_SYMBOL] === true;
+}
+/**
+* Type guard to check if a command is undoable.
+*/
+function isUndoableCommand(value) {
+	return isCommand(value) && UNDOABLE_COMMAND_SYMBOL in value && value[UNDOABLE_COMMAND_SYMBOL] === true;
+}
+
+//#endregion
+//#region src/zustand-commander/commander.ts
+const DEFAULT_OPTIONS = { maxUndoStackSize: 100 };
+/**
+* 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
+*     }))
+*   )
+* );
+* ```
+*/
+function createCommander(options = {}) {
+	const { maxUndoStackSize } = _objectSpread2(_objectSpread2({}, DEFAULT_OPTIONS), options);
+	let _storeApi = null;
+	/**
+	* Creates the dispatch function for use within command handlers.
+	*/
+	const createDispatch = () => {
+		return (command) => {
+			return (params) => {
+				if (!_storeApi) throw new Error("Commander: Store not initialized. Make sure to use the commander middleware.");
+				const ctx = {
+					getState: () => _storeApi.getState(),
+					setState: (partial) => _storeApi.setState(partial),
+					dispatch: createDispatch()
+				};
+				const result = command.fn(ctx, params);
+				if (isUndoableCommand(command)) {
+					const entry = {
+						command,
+						params,
+						result,
+						timestamp: Date.now()
+					};
+					_storeApi.setState((state) => {
+						const { undoStack, redoStack } = state._commander;
+						const newUndoStack = [...undoStack, entry].slice(-maxUndoStackSize);
+						return _objectSpread2(_objectSpread2({}, state), {}, { _commander: {
+							undoStack: newUndoStack,
+							redoStack: []
+						} });
+					});
+				}
+				return result;
+			};
+		};
+	};
+	function action(paramsSchemaOrFn, maybeFn) {
+		if (maybeFn !== void 0) return {
+			[COMMAND_SYMBOL]: true,
+			fn: maybeFn,
+			paramsSchema: paramsSchemaOrFn
+		};
+		if (typeof paramsSchemaOrFn !== "function") throw new Error("Commander: action requires a function");
+		return {
+			[COMMAND_SYMBOL]: true,
+			fn: paramsSchemaOrFn,
+			paramsSchema: null
+		};
+	}
+	function undoableAction(paramsSchemaOrFn, fnOrRevert, maybeRevert) {
+		if (maybeRevert !== void 0) return {
+			[COMMAND_SYMBOL]: true,
+			[UNDOABLE_COMMAND_SYMBOL]: true,
+			fn: fnOrRevert,
+			paramsSchema: paramsSchemaOrFn,
+			revert: maybeRevert
+		};
+		if (typeof paramsSchemaOrFn !== "function") throw new Error("Commander: undoableAction requires a function");
+		return {
+			[COMMAND_SYMBOL]: true,
+			[UNDOABLE_COMMAND_SYMBOL]: true,
+			fn: paramsSchemaOrFn,
+			paramsSchema: null,
+			revert: fnOrRevert
+		};
+	}
+	/**
+	* Zustand middleware that adds commander functionality.
+	*/
+	const middleware = (config) => {
+		return (set, get, api) => {
+			_storeApi = api;
+			return _objectSpread2(_objectSpread2({}, config(set, get, api)), {}, { _commander: {
+				undoStack: [],
+				redoStack: []
+			} });
+		};
+	};
+	return {
+		action,
+		undoableAction,
+		middleware
+	};
+}
+/**
+* Perform an undo operation on the store.
+* Returns true if an undo was performed, false if undo stack was empty.
+*/
+function performUndo(storeApi) {
+	const { undoStack, redoStack } = storeApi.getState()._commander;
+	const entry = undoStack[undoStack.length - 1];
+	if (!entry) return false;
+	const newUndoStack = undoStack.slice(0, -1);
+	const ctx = {
+		getState: () => storeApi.getState(),
+		setState: (partial) => storeApi.setState(partial),
+		dispatch: createDispatchForUndo(storeApi)
+	};
+	entry.command.revert(ctx, entry.params, entry.result);
+	storeApi.setState((state) => _objectSpread2(_objectSpread2({}, state), {}, { _commander: {
+		undoStack: newUndoStack,
+		redoStack: [...redoStack, entry]
+	} }));
+	return true;
+}
+/**
+* Perform a redo operation on the store.
+* Returns true if a redo was performed, false if redo stack was empty.
+*/
+function performRedo(storeApi) {
+	const { undoStack, redoStack } = storeApi.getState()._commander;
+	const entry = redoStack[redoStack.length - 1];
+	if (!entry) return false;
+	const newRedoStack = redoStack.slice(0, -1);
+	const ctx = {
+		getState: () => storeApi.getState(),
+		setState: (partial) => storeApi.setState(partial),
+		dispatch: createDispatchForUndo(storeApi)
+	};
+	const result = entry.command.fn(ctx, entry.params);
+	const newEntry = {
+		command: entry.command,
+		params: entry.params,
+		result,
+		timestamp: Date.now()
+	};
+	storeApi.setState((state) => _objectSpread2(_objectSpread2({}, state), {}, { _commander: {
+		undoStack: [...undoStack, newEntry],
+		redoStack: newRedoStack
+	} }));
+	return true;
+}
+/**
+* Creates a dispatch function for use during undo/redo operations.
+* This dispatch does NOT add to undo stack (to avoid infinite loops).
+*/
+function createDispatchForUndo(storeApi) {
+	return (command) => {
+		return (params) => {
+			const ctx = {
+				getState: () => storeApi.getState(),
+				setState: (partial) => storeApi.setState(partial),
+				dispatch: createDispatchForUndo(storeApi)
+			};
+			return command.fn(ctx, params);
+		};
+	};
+}
+/**
+* Clear the undo and redo stacks.
+*/
+function clearUndoHistory(storeApi) {
+	storeApi.setState((state) => _objectSpread2(_objectSpread2({}, state), {}, { _commander: {
+		undoStack: [],
+		redoStack: []
+	} }));
+}
+
+//#endregion
+//#region src/zustand-commander/hooks.ts
+/**
+* @voidhash/mimic-react/zustand-commander
+*
+* React hooks for zustand-commander.
+*
+* @since 0.0.1
+*/
+/**
+* Creates a dispatch function for commands.
+* This is for use outside of React components (e.g., in command handlers).
+*/
+function createDispatchFromApi(storeApi, maxUndoStackSize = 100) {
+	const dispatch = (command) => {
+		return (params) => {
+			const ctx = {
+				getState: () => storeApi.getState(),
+				setState: (partial) => storeApi.setState(partial),
+				dispatch
+			};
+			const result = command.fn(ctx, params);
+			if (isUndoableCommand(command)) storeApi.setState((state) => {
+				const { undoStack } = state._commander;
+				const newUndoStack = [...undoStack, {
+					command,
+					params,
+					result,
+					timestamp: Date.now()
+				}].slice(-maxUndoStackSize);
+				return _objectSpread2(_objectSpread2({}, state), {}, { _commander: {
+					undoStack: newUndoStack,
+					redoStack: []
+				} });
+			});
+			return result;
+		};
+	};
+	return dispatch;
+}
+/**
+* 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" });
+* };
+* ```
+*/
+function useCommander(store) {
+	const storeApi = useMemo(() => {
+		return store;
+	}, [store]);
+	return useMemo(() => createDispatchFromApi(storeApi), [storeApi]);
+}
+/**
+* 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>
+*   </>
+* );
+* ```
+*/
+function useUndoRedo(store) {
+	const storeApi = useMemo(() => {
+		return store;
+	}, [store]);
+	const commanderState = useStore(store, (state) => state._commander);
+	return {
+		canUndo: commanderState.undoStack.length > 0,
+		canRedo: commanderState.redoStack.length > 0,
+		undoCount: commanderState.undoStack.length,
+		redoCount: commanderState.redoStack.length,
+		undo: useCallback(() => {
+			return performUndo(storeApi);
+		}, [storeApi]),
+		redo: useCallback(() => {
+			return performRedo(storeApi);
+		}, [storeApi]),
+		clear: useCallback(() => {
+			clearUndoHistory(storeApi);
+		}, [storeApi])
+	};
+}
+/**
+* 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);
+* ```
+*/
+function useUndoRedoKeyboard(store, options = {}) {
+	const { enableUndo = true, enableRedo = true } = options;
+	const storeApi = useMemo(() => {
+		return store;
+	}, [store]);
+	useEffect(() => {
+		if (typeof window === "undefined") return;
+		const handleKeyDown = (event) => {
+			if (!(navigator.platform.toUpperCase().indexOf("MAC") >= 0 ? event.metaKey : event.ctrlKey)) return;
+			if (enableUndo && event.key === "z" && !event.shiftKey) {
+				event.preventDefault();
+				performUndo(storeApi);
+				return;
+			}
+			if (enableRedo) {
+				if (event.key === "z" && event.shiftKey || event.key === "y") {
+					event.preventDefault();
+					performRedo(storeApi);
+				}
+			}
+		};
+		window.addEventListener("keydown", handleKeyDown);
+		return () => window.removeEventListener("keydown", handleKeyDown);
+	}, [
+		storeApi,
+		enableUndo,
+		enableRedo
+	]);
+}
+
+//#endregion
+export { COMMAND_SYMBOL, UNDOABLE_COMMAND_SYMBOL, clearUndoHistory, createCommander, isCommand, isUndoableCommand, performRedo, performUndo, useCommander, useUndoRedo, useUndoRedoKeyboard };
+//# sourceMappingURL=index.mjs.map