@voidhash/mimic-react 0.0.1 → 0.0.3

package/dist/zustand-commander/commander.cjs

@@ -0,0 +1,187 @@
+const require_objectSpread2 = require('../_virtual/_@oxc-project_runtime@0.103.0/helpers/objectSpread2.cjs');
+const require_types = require('./types.cjs');
+
+//#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 } = require_objectSpread2._objectSpread2(require_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 (require_types.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 require_objectSpread2._objectSpread2(require_objectSpread2._objectSpread2({}, state), {}, { _commander: {
+							undoStack: newUndoStack,
+							redoStack: []
+						} });
+					});
+				}
+				return result;
+			};
+		};
+	};
+	/**
+	* Create a regular command (no undo support).
+	*/
+	function action(fn) {
+		return {
+			[require_types.COMMAND_SYMBOL]: true,
+			fn
+		};
+	}
+	/**
+	* Create an undoable command with undo/redo support.
+	*/
+	function undoableAction(fn, revert) {
+		return {
+			[require_types.COMMAND_SYMBOL]: true,
+			[require_types.UNDOABLE_COMMAND_SYMBOL]: true,
+			fn,
+			revert
+		};
+	}
+	/**
+	* Zustand middleware that adds commander functionality.
+	*/
+	const middleware = (config) => {
+		return (set, get, api) => {
+			_storeApi = api;
+			return require_objectSpread2._objectSpread2(require_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) => require_objectSpread2._objectSpread2(require_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) => require_objectSpread2._objectSpread2(require_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) => require_objectSpread2._objectSpread2(require_objectSpread2._objectSpread2({}, state), {}, { _commander: {
+		undoStack: [],
+		redoStack: []
+	} }));
+}
+
+//#endregion
+exports.clearUndoHistory = clearUndoHistory;
+exports.createCommander = createCommander;
+exports.performRedo = performRedo;
+exports.performUndo = performUndo;

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

@@ -0,0 +1,52 @@
+import { Commander, CommanderOptions, CommanderSlice } from "./types.cjs";
+import { StoreApi } from "zustand";
+
+//#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
+export { clearUndoHistory, createCommander, performRedo, performUndo };
+//# sourceMappingURL=commander.d.cts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"commander.d.cts","names":[],"sources":["../../src/zustand-commander/commander.ts"],"sourcesContent":[],"mappings":";;;;;;AA2MA;;;;;AAwCA;;;;;AAoEA;;;;;;;;;;;;;;;;;;iBArPgB,iDACL,mBACR,UAAU,SAAS;;;;;iBAuIN,2BAA2B,0BAC/B,SAAS;;;;;iBAuCL,2BAA2B,0BAC/B,SAAS;;;;iBAmEL,gCAAgC,0BACpC,SAAS"}

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

@@ -0,0 +1,52 @@
+import { Commander, CommanderOptions, CommanderSlice } from "./types.mjs";
+import { StoreApi } from "zustand";
+
+//#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
+export { clearUndoHistory, createCommander, performRedo, performUndo };
+//# sourceMappingURL=commander.d.mts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"commander.d.mts","names":[],"sources":["../../src/zustand-commander/commander.ts"],"sourcesContent":[],"mappings":";;;;;;AA2MA;;;;;AAwCA;;;;;AAoEA;;;;;;;;;;;;;;;;;;iBArPgB,iDACL,mBACR,UAAU,SAAS;;;;;iBAuIN,2BAA2B,0BAC/B,SAAS;;;;;iBAuCL,2BAA2B,0BAC/B,SAAS;;;;iBAmEL,gCAAgC,0BACpC,SAAS"}

package/dist/zustand-commander/commander.mjs

@@ -0,0 +1,185 @@
+import { _objectSpread2 } from "../_virtual/_@oxc-project_runtime@0.103.0/helpers/objectSpread2.mjs";
+import { COMMAND_SYMBOL, UNDOABLE_COMMAND_SYMBOL, isUndoableCommand } from "./types.mjs";
+
+//#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;
+			};
+		};
+	};
+	/**
+	* Create a regular command (no undo support).
+	*/
+	function action(fn) {
+		return {
+			[COMMAND_SYMBOL]: true,
+			fn
+		};
+	}
+	/**
+	* Create an undoable command with undo/redo support.
+	*/
+	function undoableAction(fn, revert) {
+		return {
+			[COMMAND_SYMBOL]: true,
+			[UNDOABLE_COMMAND_SYMBOL]: true,
+			fn,
+			revert
+		};
+	}
+	/**
+	* 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
+export { clearUndoHistory, createCommander, performRedo, performUndo };
+//# sourceMappingURL=commander.mjs.map

package/dist/zustand-commander/commander.mjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"commander.mjs","names":["DEFAULT_OPTIONS: Required<CommanderOptions>","_storeApi: StoreApi<TStore & CommanderSlice> | null","ctx: CommandContext<TStore & CommanderSlice>","entry: UndoEntry<TParams, TReturn>","ctx: CommandContext<TStore>","newEntry: UndoEntry"],"sources":["../../src/zustand-commander/commander.ts"],"sourcesContent":["/**\n * @voidhash/mimic-react/zustand-commander\n *\n * Commander creation and command definition.\n *\n * @since 0.0.1\n */\n\nimport type { StoreApi } from \"zustand\";\nimport {\n  COMMAND_SYMBOL,\n  UNDOABLE_COMMAND_SYMBOL,\n  isUndoableCommand,\n  type Command,\n  type Commander,\n  type CommanderOptions,\n  type CommanderSlice,\n  type CommandContext,\n  type CommandDispatch,\n  type CommandFn,\n  type RevertFn,\n  type UndoableCommand,\n  type UndoEntry,\n} from \"./types.js\";\n\n// =============================================================================\n// Default Options\n// =============================================================================\n\nconst DEFAULT_OPTIONS: Required<CommanderOptions> = {\n  maxUndoStackSize: 100,\n};\n\n// =============================================================================\n// Commander Implementation\n// =============================================================================\n\n/**\n * Creates a commander instance bound to a specific store type.\n *\n * @example\n * ```ts\n * // Create commander for your store type\n * const commander = createCommander<StoreState>();\n *\n * // Define commands\n * const addItem = commander.action(\n *   Schema.Struct({ name: Schema.String }),\n *   (ctx, params) => {\n *     const { mimic } = ctx.getState();\n *     mimic.document.transaction(root => {\n *       // add item\n *     });\n *   }\n * );\n *\n * // Create store with middleware\n * const useStore = create(\n *   commander.middleware(\n *     mimic(document, (set, get) => ({\n *       // your state\n *     }))\n *   )\n * );\n * ```\n */\nexport function createCommander<TStore extends object>(\n  options: CommanderOptions = {}\n): Commander<TStore & CommanderSlice> {\n  const { maxUndoStackSize } = { ...DEFAULT_OPTIONS, ...options };\n\n  // Track the store API once middleware is applied\n  let _storeApi: StoreApi<TStore & CommanderSlice> | null = null;\n\n  /**\n   * Creates the dispatch function for use within command handlers.\n   */\n  const createDispatch = (): CommandDispatch<TStore & CommanderSlice> => {\n    return <TParams, TReturn>(\n      command: Command<TStore & CommanderSlice, TParams, TReturn>\n    ) => {\n      return (params: TParams): TReturn => {\n        if (!_storeApi) {\n          throw new Error(\n            \"Commander: Store not initialized. Make sure to use the commander middleware.\"\n          );\n        }\n\n        // Create context for the command\n        const ctx: CommandContext<TStore & CommanderSlice> = {\n          getState: () => _storeApi!.getState(),\n          setState: (partial) => _storeApi!.setState(partial as any),\n          dispatch: createDispatch(),\n        };\n\n        // Execute the command\n        const result = command.fn(ctx, params);\n\n        // If it's an undoable command, add to undo stack\n        if (isUndoableCommand(command)) {\n          const entry: UndoEntry<TParams, TReturn> = {\n            command,\n            params,\n            result,\n            timestamp: Date.now(),\n          };\n\n          _storeApi.setState((state: TStore & CommanderSlice) => {\n            const { undoStack, redoStack } = state._commander;\n\n            // Add to undo stack, respecting max size\n            const newUndoStack = [...undoStack, entry].slice(-maxUndoStackSize);\n\n            // Clear redo stack when a new command is executed\n            return {\n              ...state,\n              _commander: {\n                undoStack: newUndoStack,\n                redoStack: [],\n              },\n            };\n          });\n        }\n\n        return result;\n      };\n    };\n  };\n\n  /**\n   * Create a regular command (no undo support).\n   */\n  function action<TParams, TReturn = void>(\n    fn: CommandFn<TStore & CommanderSlice, TParams, TReturn>\n  ): Command<TStore & CommanderSlice, TParams, TReturn> {\n    return {\n      [COMMAND_SYMBOL]: true,\n      fn,\n    };\n  }\n\n  /**\n   * Create an undoable command with undo/redo support.\n   */\n  function undoableAction<TParams, TReturn>(\n    fn: CommandFn<TStore & CommanderSlice, TParams, TReturn>,\n    revert: RevertFn<TStore & CommanderSlice, TParams, TReturn>\n  ): UndoableCommand<TStore & CommanderSlice, TParams, TReturn> {\n    return {\n      [COMMAND_SYMBOL]: true,\n      [UNDOABLE_COMMAND_SYMBOL]: true,\n      fn,\n      revert,\n    };\n  }\n\n  /**\n   * Zustand middleware that adds commander functionality.\n   */\n  const middleware = <T extends object>(\n    config: (\n      set: StoreApi<T & CommanderSlice>[\"setState\"],\n      get: StoreApi<T & CommanderSlice>[\"getState\"],\n      api: StoreApi<T & CommanderSlice>\n    ) => T\n  ) => {\n    return (\n      set: StoreApi<T & CommanderSlice>[\"setState\"],\n      get: StoreApi<T & CommanderSlice>[\"getState\"],\n      api: StoreApi<T & CommanderSlice>\n    ): T & CommanderSlice => {\n      // Store the API reference for dispatch\n      _storeApi = api as unknown as StoreApi<TStore & CommanderSlice>;\n\n      // Get user's state\n      const userState = config(set, get, api);\n\n      // Add commander slice\n      return {\n        ...userState,\n        _commander: {\n          undoStack: [],\n          redoStack: [],\n        },\n      };\n    };\n  };\n\n  return {\n    action,\n    undoableAction,\n    middleware: middleware as Commander<TStore & CommanderSlice>[\"middleware\"],\n  };\n}\n\n// =============================================================================\n// Undo/Redo Functions\n// =============================================================================\n\n/**\n * Perform an undo operation on the store.\n * Returns true if an undo was performed, false if undo stack was empty.\n */\nexport function performUndo<TStore extends CommanderSlice>(\n  storeApi: StoreApi<TStore>\n): boolean {\n  const state = storeApi.getState();\n  const { undoStack, redoStack } = state._commander;\n\n  // Pop the last entry from undo stack\n  const entry = undoStack[undoStack.length - 1];\n  if (!entry) {\n    return false;\n  }\n\n  const newUndoStack = undoStack.slice(0, -1);\n\n  // Create context for the revert function\n  const ctx: CommandContext<TStore> = {\n    getState: () => storeApi.getState(),\n    setState: (partial) => storeApi.setState(partial as any),\n    dispatch: createDispatchForUndo(storeApi),\n  };\n\n  // Execute the revert function\n  entry.command.revert(ctx, entry.params, entry.result);\n\n  // Move entry to redo stack\n  storeApi.setState((state: TStore) => ({\n    ...state,\n    _commander: {\n      undoStack: newUndoStack,\n      redoStack: [...redoStack, entry],\n    },\n  }));\n\n  return true;\n}\n\n/**\n * Perform a redo operation on the store.\n * Returns true if a redo was performed, false if redo stack was empty.\n */\nexport function performRedo<TStore extends CommanderSlice>(\n  storeApi: StoreApi<TStore>\n): boolean {\n  const state = storeApi.getState();\n  const { undoStack, redoStack } = state._commander;\n\n  // Pop the last entry from redo stack\n  const entry = redoStack[redoStack.length - 1];\n  if (!entry) {\n    return false;\n  }\n\n  const newRedoStack = redoStack.slice(0, -1);\n\n  // Create context for re-executing the command\n  const ctx: CommandContext<TStore> = {\n    getState: () => storeApi.getState(),\n    setState: (partial) => storeApi.setState(partial as any),\n    dispatch: createDispatchForUndo(storeApi),\n  };\n\n  // Re-execute the command\n  const result = entry.command.fn(ctx, entry.params);\n\n  // Create new entry with potentially new result\n  const newEntry: UndoEntry = {\n    command: entry.command,\n    params: entry.params,\n    result,\n    timestamp: Date.now(),\n  };\n\n  // Move entry back to undo stack\n  storeApi.setState((state: TStore) => ({\n    ...state,\n    _commander: {\n      undoStack: [...undoStack, newEntry],\n      redoStack: newRedoStack,\n    },\n  }));\n\n  return true;\n}\n\n/**\n * Creates a dispatch function for use during undo/redo operations.\n * This dispatch does NOT add to undo stack (to avoid infinite loops).\n */\nfunction createDispatchForUndo<TStore>(\n  storeApi: StoreApi<TStore>\n): CommandDispatch<TStore> {\n  return <TParams, TReturn>(command: Command<TStore, TParams, TReturn>) => {\n    return (params: TParams): TReturn => {\n      const ctx: CommandContext<TStore> = {\n        getState: () => storeApi.getState(),\n        setState: (partial) => storeApi.setState(partial as any),\n        dispatch: createDispatchForUndo(storeApi),\n      };\n\n      // Execute without adding to undo stack\n      return command.fn(ctx, params);\n    };\n  };\n}\n\n/**\n * Clear the undo and redo stacks.\n */\nexport function clearUndoHistory<TStore extends CommanderSlice>(\n  storeApi: StoreApi<TStore>\n): void {\n  storeApi.setState((state: TStore) => ({\n    ...state,\n    _commander: {\n      undoStack: [],\n      redoStack: [],\n    },\n  }));\n}\n\n"],"mappings":"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"}

package/dist/zustand-commander/hooks.cjs

@@ -0,0 +1,145 @@
+const require_objectSpread2 = require('../_virtual/_@oxc-project_runtime@0.103.0/helpers/objectSpread2.cjs');
+const require_types = require('./types.cjs');
+const require_commander = require('./commander.cjs');
+let react = require("react");
+let zustand = require("zustand");
+
+//#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 (require_types.isUndoableCommand(command)) storeApi.setState((state) => {
+				const { undoStack } = state._commander;
+				const newUndoStack = [...undoStack, {
+					command,
+					params,
+					result,
+					timestamp: Date.now()
+				}].slice(-maxUndoStackSize);
+				return require_objectSpread2._objectSpread2(require_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 = (0, react.useMemo)(() => {
+		return store;
+	}, [store]);
+	return (0, react.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 = (0, react.useMemo)(() => {
+		return store;
+	}, [store]);
+	const commanderState = (0, zustand.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: (0, react.useCallback)(() => {
+			return require_commander.performUndo(storeApi);
+		}, [storeApi]),
+		redo: (0, react.useCallback)(() => {
+			return require_commander.performRedo(storeApi);
+		}, [storeApi]),
+		clear: (0, react.useCallback)(() => {
+			require_commander.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 = (0, react.useMemo)(() => {
+		return store;
+	}, [store]);
+	(0, react.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();
+				require_commander.performUndo(storeApi);
+				return;
+			}
+			if (enableRedo) {
+				if (event.key === "z" && event.shiftKey || event.key === "y") {
+					event.preventDefault();
+					require_commander.performRedo(storeApi);
+				}
+			}
+		};
+		window.addEventListener("keydown", handleKeyDown);
+		return () => window.removeEventListener("keydown", handleKeyDown);
+	}, [
+		storeApi,
+		enableUndo,
+		enableRedo
+	]);
+}
+
+//#endregion
+exports.useCommander = useCommander;
+exports.useUndoRedo = useUndoRedo;
+exports.useUndoRedoKeyboard = useUndoRedoKeyboard;