@voidhash/mimic-react 0.0.1 → 0.0.3

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

@@ -0,0 +1,78 @@
+import { CommandDispatch, CommanderSlice } from "./types.cjs";
+import { StoreApi, UseBoundStore } from "zustand";
+
+//#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 { UndoRedoState, UseUndoRedoKeyboardOptions, useCommander, useUndoRedo, useUndoRedoKeyboard };
+//# sourceMappingURL=hooks.d.cts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"hooks.d.cts","names":[],"sources":["../../src/zustand-commander/hooks.ts"],"sourcesContent":[],"mappings":";;;;;;;;AAsHA;AAiCA;;;;;;;AAiDA;AAiBA;AAAmD,iBA5HnC,YA4HmC,CAAA,eA5HP,cA4HO,CAAA,CAAA,KAAA,EA3H1C,aA2H0C,CA3H5B,QA2H4B,CA3HnB,MA2HmB,CAAA,CAAA,CAAA,EA1HhD,eA0HgD,CA1HhC,MA0HgC,CAAA;;;;AAExC,UArGM,aAAA,CAqGN;EAA+B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBApE1B,2BAA2B,uBAClC,cAAc,SAAS,WAC7B;;;;UA+Cc,0BAAA;;;;;;;;;;;;;;;;iBAiBD,mCAAmC,uBAC1C,cAAc,SAAS,oBACrB"}

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

@@ -0,0 +1,78 @@
+import { CommandDispatch, CommanderSlice } from "./types.mjs";
+import { StoreApi, UseBoundStore } from "zustand";
+
+//#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 { UndoRedoState, UseUndoRedoKeyboardOptions, useCommander, useUndoRedo, useUndoRedoKeyboard };
+//# sourceMappingURL=hooks.d.mts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"hooks.d.mts","names":[],"sources":["../../src/zustand-commander/hooks.ts"],"sourcesContent":[],"mappings":";;;;;;;;AAsHA;AAiCA;;;;;;;AAiDA;AAiBA;AAAmD,iBA5HnC,YA4HmC,CAAA,eA5HP,cA4HO,CAAA,CAAA,KAAA,EA3H1C,aA2H0C,CA3H5B,QA2H4B,CA3HnB,MA2HmB,CAAA,CAAA,CAAA,EA1HhD,eA0HgD,CA1HhC,MA0HgC,CAAA;;;;AAExC,UArGM,aAAA,CAqGN;EAA+B;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;iBApE1B,2BAA2B,uBAClC,cAAc,SAAS,WAC7B;;;;UA+Cc,0BAAA;;;;;;;;;;;;;;;;iBAiBD,mCAAmC,uBAC1C,cAAc,SAAS,oBACrB"}

package/dist/zustand-commander/hooks.mjs

@@ -0,0 +1,144 @@
+import { _objectSpread2 } from "../_virtual/_@oxc-project_runtime@0.103.0/helpers/objectSpread2.mjs";
+import { isUndoableCommand } from "./types.mjs";
+import { clearUndoHistory, performRedo, performUndo } from "./commander.mjs";
+import { useCallback, useEffect, useMemo } from "react";
+import { useStore } from "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 (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 { useCommander, useUndoRedo, useUndoRedoKeyboard };
+//# sourceMappingURL=hooks.mjs.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"hooks.mjs","names":["dispatch: CommandDispatch<TStore>","ctx: CommandContext<TStore>"],"sources":["../../src/zustand-commander/hooks.ts"],"sourcesContent":["/**\n * @voidhash/mimic-react/zustand-commander\n *\n * React hooks for zustand-commander.\n *\n * @since 0.0.1\n */\n\nimport { useCallback, useEffect, useMemo } from \"react\";\nimport { useStore, type StoreApi, type UseBoundStore } from \"zustand\";\nimport { performRedo, performUndo, clearUndoHistory } from \"./commander\";\nimport {\n  isUndoableCommand,\n  type Command,\n  type CommandContext,\n  type CommandDispatch,\n  type CommanderSlice,\n  type ExtractState,\n} from \"./types.js\";\n\n// =============================================================================\n// useCommander Hook\n// =============================================================================\n\n/**\n * Creates a dispatch function for commands.\n * This is for use outside of React components (e.g., in command handlers).\n */\nfunction createDispatchFromApi<TStore extends CommanderSlice>(\n  storeApi: StoreApi<TStore>,\n  maxUndoStackSize = 100\n): CommandDispatch<TStore> {\n  const dispatch: CommandDispatch<TStore> = <TParams, TReturn>(\n    command: Command<TStore, TParams, TReturn>\n  ) => {\n    return (params: TParams): TReturn => {\n      // Create context for the command\n      const ctx: CommandContext<TStore> = {\n        getState: () => storeApi.getState(),\n        setState: (partial) => storeApi.setState(partial as Partial<TStore>),\n        dispatch,\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        storeApi.setState((state: TStore) => {\n          const { undoStack } = state._commander;\n\n          // Add to undo stack, respecting max size\n          const newUndoStack = [\n            ...undoStack,\n            {\n              command,\n              params,\n              result,\n              timestamp: Date.now(),\n            },\n          ].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          } as TStore;\n        });\n      }\n\n      return result;\n    };\n  };\n\n  return dispatch;\n}\n\n/**\n * React hook to get a dispatch function for commands.\n * The dispatch function executes commands and manages undo/redo state.\n *\n * @example\n * ```tsx\n * const dispatch = useCommander(useStore);\n *\n * const handleClick = () => {\n *   dispatch(addCard)({ columnId: \"col-1\", title: \"New Card\" });\n * };\n * ```\n */\nexport function useCommander<TStore extends CommanderSlice>(\n  store: UseBoundStore<StoreApi<TStore>>\n): CommandDispatch<TStore> {\n  // Get the store API\n  const storeApi = useMemo(() => {\n    // UseBoundStore has the StoreApi attached\n    return store as unknown as StoreApi<TStore>;\n  }, [store]);\n\n  // Create a stable dispatch function\n  const dispatch = useMemo(\n    () => createDispatchFromApi<TStore>(storeApi),\n    [storeApi]\n  );\n\n  return dispatch as CommandDispatch<TStore>;\n}\n\n// =============================================================================\n// useUndoRedo Hook\n// =============================================================================\n\n/**\n * State and actions for undo/redo functionality.\n */\nexport interface UndoRedoState {\n  /** Whether there are actions that can be undone */\n  readonly canUndo: boolean;\n  /** Whether there are actions that can be redone */\n  readonly canRedo: boolean;\n  /** Number of items in the undo stack */\n  readonly undoCount: number;\n  /** Number of items in the redo stack */\n  readonly redoCount: number;\n  /** Undo the last action */\n  readonly undo: () => boolean;\n  /** Redo the last undone action */\n  readonly redo: () => boolean;\n  /** Clear the undo/redo history */\n  readonly clear: () => void;\n}\n\n/**\n * React hook for undo/redo functionality.\n * Provides state (canUndo, canRedo) and actions (undo, redo, clear).\n *\n * @example\n * ```tsx\n * const { canUndo, canRedo, undo, redo } = useUndoRedo(useStore);\n *\n * return (\n *   <>\n *     <button onClick={undo} disabled={!canUndo}>Undo</button>\n *     <button onClick={redo} disabled={!canRedo}>Redo</button>\n *   </>\n * );\n * ```\n */\nexport function useUndoRedo<TStore extends CommanderSlice>(\n  store: UseBoundStore<StoreApi<TStore>>\n): UndoRedoState {\n  // Get the store API\n  const storeApi = useMemo(() => {\n    return store as unknown as StoreApi<TStore>;\n  }, [store]);\n\n  // Subscribe to commander state\n  const commanderState = useStore(\n    store,\n    (state: TStore) => state._commander\n  );\n\n  const canUndo = commanderState.undoStack.length > 0;\n  const canRedo = commanderState.redoStack.length > 0;\n  const undoCount = commanderState.undoStack.length;\n  const redoCount = commanderState.redoStack.length;\n\n  const undo = useCallback(() => {\n    return performUndo(storeApi);\n  }, [storeApi]);\n\n  const redo = useCallback(() => {\n    return performRedo(storeApi);\n  }, [storeApi]);\n\n  const clear = useCallback(() => {\n    clearUndoHistory(storeApi);\n  }, [storeApi]);\n\n  return {\n    canUndo,\n    canRedo,\n    undoCount,\n    redoCount,\n    undo,\n    redo,\n    clear,\n  };\n}\n\n// =============================================================================\n// Keyboard Shortcut Hook\n// =============================================================================\n\n/**\n * Options for the keyboard shortcut hook.\n */\nexport interface UseUndoRedoKeyboardOptions {\n  /** Enable Ctrl/Cmd+Z for undo (default: true) */\n  readonly enableUndo?: boolean;\n  /** Enable Ctrl/Cmd+Shift+Z or Ctrl+Y for redo (default: true) */\n  readonly enableRedo?: boolean;\n}\n\n/**\n * React hook that adds keyboard shortcuts for undo/redo.\n * Listens for Ctrl/Cmd+Z (undo) and Ctrl/Cmd+Shift+Z or Ctrl+Y (redo).\n *\n * @example\n * ```tsx\n * // In your app component\n * useUndoRedoKeyboard(useStore);\n * ```\n */\nexport function useUndoRedoKeyboard<TStore extends CommanderSlice>(\n  store: UseBoundStore<StoreApi<TStore>>,\n  options: UseUndoRedoKeyboardOptions = {}\n): void {\n  const { enableUndo = true, enableRedo = true } = options;\n\n  const storeApi = useMemo(() => {\n    return store as unknown as StoreApi<TStore>;\n  }, [store]);\n\n  // Set up keyboard listener\n  useEffect(() => {\n    if (typeof window === \"undefined\") {\n      return;\n    }\n\n    const handleKeyDown = (event: KeyboardEvent) => {\n      const isMac = navigator.platform.toUpperCase().indexOf(\"MAC\") >= 0;\n      const modKey = isMac ? event.metaKey : event.ctrlKey;\n\n      if (!modKey) return;\n\n      // Undo: Ctrl/Cmd + Z (without Shift)\n      if (enableUndo && event.key === \"z\" && !event.shiftKey) {\n        event.preventDefault();\n        performUndo(storeApi);\n        return;\n      }\n\n      // Redo: Ctrl/Cmd + Shift + Z or Ctrl + Y\n      if (enableRedo) {\n        if ((event.key === \"z\" && event.shiftKey) || event.key === \"y\") {\n          event.preventDefault();\n          performRedo(storeApi);\n        }\n      }\n    };\n\n    window.addEventListener(\"keydown\", handleKeyDown);\n    return () => window.removeEventListener(\"keydown\", handleKeyDown);\n  }, [storeApi, enableUndo, enableRedo]);\n}\n"],"mappings":";;;;;;;;;;;;;;;;;;AA4BA,SAAS,sBACP,UACA,mBAAmB,KACM;CACzB,MAAMA,YACJ,YACG;AACH,UAAQ,WAA6B;GAEnC,MAAMC,MAA8B;IAClC,gBAAgB,SAAS,UAAU;IACnC,WAAW,YAAY,SAAS,SAAS,QAA2B;IACpE;IACD;GAGD,MAAM,SAAS,QAAQ,GAAG,KAAK,OAAO;AAGtC,OAAI,kBAAkB,QAAQ,CAC5B,UAAS,UAAU,UAAkB;IACnC,MAAM,EAAE,cAAc,MAAM;IAG5B,MAAM,eAAe,CACnB,GAAG,WACH;KACE;KACA;KACA;KACA,WAAW,KAAK,KAAK;KACtB,CACF,CAAC,MAAM,CAAC,iBAAiB;AAG1B,6CACK,cACH,YAAY;KACV,WAAW;KACX,WAAW,EAAE;KACd;KAEH;AAGJ,UAAO;;;AAIX,QAAO;;;;;;;;;;;;;;;AAgBT,SAAgB,aACd,OACyB;CAEzB,MAAM,WAAW,cAAc;AAE7B,SAAO;IACN,CAAC,MAAM,CAAC;AAQX,QALiB,cACT,sBAA8B,SAAS,EAC7C,CAAC,SAAS,CACX;;;;;;;;;;;;;;;;;;AA6CH,SAAgB,YACd,OACe;CAEf,MAAM,WAAW,cAAc;AAC7B,SAAO;IACN,CAAC,MAAM,CAAC;CAGX,MAAM,iBAAiB,SACrB,QACC,UAAkB,MAAM,WAC1B;AAmBD,QAAO;EACL,SAlBc,eAAe,UAAU,SAAS;EAmBhD,SAlBc,eAAe,UAAU,SAAS;EAmBhD,WAlBgB,eAAe,UAAU;EAmBzC,WAlBgB,eAAe,UAAU;EAmBzC,MAjBW,kBAAkB;AAC7B,UAAO,YAAY,SAAS;KAC3B,CAAC,SAAS,CAAC;EAgBZ,MAdW,kBAAkB;AAC7B,UAAO,YAAY,SAAS;KAC3B,CAAC,SAAS,CAAC;EAaZ,OAXY,kBAAkB;AAC9B,oBAAiB,SAAS;KACzB,CAAC,SAAS,CAAC;EAUb;;;;;;;;;;;;AA2BH,SAAgB,oBACd,OACA,UAAsC,EAAE,EAClC;CACN,MAAM,EAAE,aAAa,MAAM,aAAa,SAAS;CAEjD,MAAM,WAAW,cAAc;AAC7B,SAAO;IACN,CAAC,MAAM,CAAC;AAGX,iBAAgB;AACd,MAAI,OAAO,WAAW,YACpB;EAGF,MAAM,iBAAiB,UAAyB;AAI9C,OAAI,EAHU,UAAU,SAAS,aAAa,CAAC,QAAQ,MAAM,IAAI,IAC1C,MAAM,UAAU,MAAM,SAEhC;AAGb,OAAI,cAAc,MAAM,QAAQ,OAAO,CAAC,MAAM,UAAU;AACtD,UAAM,gBAAgB;AACtB,gBAAY,SAAS;AACrB;;AAIF,OAAI,YACF;QAAK,MAAM,QAAQ,OAAO,MAAM,YAAa,MAAM,QAAQ,KAAK;AAC9D,WAAM,gBAAgB;AACtB,iBAAY,SAAS;;;;AAK3B,SAAO,iBAAiB,WAAW,cAAc;AACjD,eAAa,OAAO,oBAAoB,WAAW,cAAc;IAChE;EAAC;EAAU;EAAY;EAAW,CAAC"}

package/dist/zustand-commander/index.cjs

@@ -1,354 +1,15 @@
-const require_objectSpread2 = require('../objectSpread2-CIP_6jda.cjs');
-let react = require("react");
-let zustand = require("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 } = 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 (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 {
-			[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 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
-//#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 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 performUndo(storeApi);
-		}, [storeApi]),
-		redo: (0, react.useCallback)(() => {
-			return performRedo(storeApi);
-		}, [storeApi]),
-		clear: (0, react.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 = (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();
-				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
-exports.COMMAND_SYMBOL = COMMAND_SYMBOL;
-exports.UNDOABLE_COMMAND_SYMBOL = UNDOABLE_COMMAND_SYMBOL;
-exports.clearUndoHistory = clearUndoHistory;
-exports.createCommander = createCommander;
-exports.isCommand = isCommand;
-exports.isUndoableCommand = isUndoableCommand;
-exports.performRedo = performRedo;
-exports.performUndo = performUndo;
-exports.useCommander = useCommander;
-exports.useUndoRedo = useUndoRedo;
-exports.useUndoRedoKeyboard = useUndoRedoKeyboard;
+const require_types = require('./types.cjs');
+const require_commander = require('./commander.cjs');
+const require_hooks = require('./hooks.cjs');
+
+exports.COMMAND_SYMBOL = require_types.COMMAND_SYMBOL;
+exports.UNDOABLE_COMMAND_SYMBOL = require_types.UNDOABLE_COMMAND_SYMBOL;
+exports.clearUndoHistory = require_commander.clearUndoHistory;
+exports.createCommander = require_commander.createCommander;
+exports.isCommand = require_types.isCommand;
+exports.isUndoableCommand = require_types.isUndoableCommand;
+exports.performRedo = require_commander.performRedo;
+exports.performUndo = require_commander.performUndo;
+exports.useCommander = require_hooks.useCommander;
+exports.useUndoRedo = require_hooks.useUndoRedo;
+exports.useUndoRedoKeyboard = require_hooks.useUndoRedoKeyboard;