@voidhash/mimic-react 0.0.1 → 0.0.3

package/dist/zustand-commander/index.mjs

@@ -1,345 +1,5 @@
-import { t as _objectSpread2 } from "../objectSpread2-CxTyNSYl.mjs";
-import { useCallback, useEffect, useMemo } from "react";
-import { useStore } from "zustand";
+import { COMMAND_SYMBOL, UNDOABLE_COMMAND_SYMBOL, isCommand, isUndoableCommand } from "./types.mjs";
+import { clearUndoHistory, createCommander, performRedo, performUndo } from "./commander.mjs";
+import { useCommander, useUndoRedo, useUndoRedoKeyboard } from "./hooks.mjs";
 
-//#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;
-			};
-		};
-	};
-	/**
-	* 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
-//#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
+export { COMMAND_SYMBOL, UNDOABLE_COMMAND_SYMBOL, clearUndoHistory, createCommander, isCommand, isUndoableCommand, performRedo, performUndo, useCommander, useUndoRedo, useUndoRedoKeyboard };

package/dist/zustand-commander/types.cjs

@@ -0,0 +1,28 @@
+
+//#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
+exports.COMMAND_SYMBOL = COMMAND_SYMBOL;
+exports.UNDOABLE_COMMAND_SYMBOL = UNDOABLE_COMMAND_SYMBOL;
+exports.isCommand = isCommand;
+exports.isUndoableCommand = isUndoableCommand;

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

@@ -0,0 +1,195 @@
+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
+export { AnyCommand, AnyUndoableCommand, COMMAND_SYMBOL, Command, CommandContext, CommandDispatch, CommandFn, CommandParams, CommandReturn, CommandStore, Commander, CommanderMiddleware, CommanderOptions, CommanderSlice, ExtractState, RevertFn, UNDOABLE_COMMAND_SYMBOL, UndoEntry, UndoableCommand, isCommand, isUndoableCommand };
+//# sourceMappingURL=types.d.cts.map

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

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