@voidhash/mimic-react 1.0.0-beta.14 → 1.0.0-beta.15

package/.turbo/turbo-build.log

@@ -1,5 +1,5 @@
 
-> @voidhash/mimic-react@1.0.0-beta.14 build /home/runner/work/mimic/mimic/packages/mimic-react
+> @voidhash/mimic-react@1.0.0-beta.15 build /home/runner/work/mimic/mimic/packages/mimic-react
 > tsdown
 
 ℹ tsdown v0.18.2 powered by rolldown v1.0.0-beta.55
@@ -38,7 +38,7 @@
 ℹ [CJS] dist/zustand/middleware.d.cts               2.13 kB │ gzip: 0.85 kB
 ℹ [CJS] dist/zustand/useDraft.d.cts                 1.54 kB │ gzip: 0.66 kB
 ℹ [CJS] 15 files, total: 28.71 kB
-✔ Build complete in 4092ms
+✔ Build complete in 3497ms
 ℹ [ESM] dist/zustand-commander/index.mjs                                         0.53 kB │ gzip: 0.21 kB
 ℹ [ESM] dist/zustand/index.mjs                                                   0.11 kB │ gzip: 0.09 kB
 ℹ [ESM] dist/index.mjs                                                           0.01 kB │ gzip: 0.03 kB
@@ -73,4 +73,4 @@
 ℹ [ESM] dist/zustand/middleware.d.mts                                            2.13 kB │ gzip: 0.85 kB
 ℹ [ESM] dist/zustand/useDraft.d.mts                                              1.54 kB │ gzip: 0.66 kB
 ℹ [ESM] 33 files, total: 97.77 kB
-✔ Build complete in 4138ms
+✔ Build complete in 3504ms

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@voidhash/mimic-react",
-  "version": "1.0.0-beta.14",
+  "version": "1.0.0-beta.15",
   "type": "module",
   "repository": {
     "type": "git",
@@ -37,12 +37,12 @@
     "typescript": "5.8.3",
     "vite-tsconfig-paths": "^5.1.4",
     "vitest": "^3.2.4",
-    "@voidhash/tsconfig": "1.0.0-beta.14"
+    "@voidhash/tsconfig": "1.0.0-beta.15"
   },
   "peerDependencies": {
     "effect": "^3.16.0",
     "react": "^18.0.0 || ^19.0.0",
-    "@voidhash/mimic": "1.0.0-beta.14"
+    "@voidhash/mimic": "1.0.0-beta.15"
   },
   "scripts": {
     "build": "tsdown",

package/tests/zustand-commander/commander.test.ts

@@ -668,6 +668,327 @@ describe("Command Dispatch in Context", () => {
   });
 });
 
+describe("ctx.transaction routing (draft vs document)", () => {
+  it("should route ctx.transaction to document.transaction when no draft is active", () => {
+    const commander = createCommander<TestState>();
+
+    // Track calls to document.transaction
+    const transactionCalls: Array<(root: any) => void> = [];
+    const mockDocument = {
+      transaction: (fn: (root: any) => void) => {
+        transactionCalls.push(fn);
+      },
+    };
+
+    // Create store with mimic slice containing the mock document
+    const store = createStore<TestStore & { mimic: { document: typeof mockDocument } }>(
+      commander.middleware(() => ({
+        count: 0,
+        items: [],
+        selectedId: null,
+        mimic: { document: mockDocument },
+      }))
+    );
+
+    // Create a command that uses ctx.transaction
+    const updateViaTransaction = commander.action<{ value: number }>(
+      (ctx, params) => {
+        ctx.transaction((root: any) => {
+          root.count.set(params.value);
+        });
+      }
+    );
+
+    const storeApi = store as unknown as StoreApi<TestStore & { mimic: { document: typeof mockDocument } }>;
+
+    // Build a proper context with transaction routing
+    const ctx: CommandContext<TestStore> = {
+      getState: () => storeApi.getState(),
+      setState: (partial: Partial<TestStore>) => storeApi.setState(partial as any),
+      dispatch: <TParams, TReturn>(cmd: Command<TestStore, TParams, TReturn>) => {
+        return (params: TParams): TReturn => cmd.fn(ctx, params);
+      },
+      transaction: (fn: (root: any) => void) => {
+        const state = storeApi.getState();
+        const draft = state._commander.activeDraft;
+        if (draft) {
+          draft.update(fn);
+        } else {
+          (state as any).mimic.document.transaction(fn);
+        }
+      },
+    };
+
+    // Execute command - should route to document.transaction
+    updateViaTransaction.fn(ctx, { value: 42 });
+
+    expect(transactionCalls.length).toBe(1);
+  });
+
+  it("should route ctx.transaction to draft.update when draft is active", () => {
+    const commander = createCommander<TestState>();
+
+    // Track calls to both document.transaction and draft.update
+    const documentTransactionCalls: Array<(root: any) => void> = [];
+    const draftUpdateCalls: Array<(root: any) => void> = [];
+
+    const mockDocument = {
+      transaction: (fn: (root: any) => void) => {
+        documentTransactionCalls.push(fn);
+      },
+    };
+
+    const mockDraft = {
+      update: (fn: (root: any) => void) => {
+        draftUpdateCalls.push(fn);
+      },
+      commit: () => {},
+      discard: () => {},
+      id: "mock-draft-id",
+    };
+
+    // Create store with mimic slice
+    const store = createStore<TestStore & { mimic: { document: typeof mockDocument } }>(
+      commander.middleware(() => ({
+        count: 0,
+        items: [],
+        selectedId: null,
+        mimic: { document: mockDocument },
+      }))
+    );
+
+    // Set the active draft
+    store.setState((state) => ({
+      ...state,
+      _commander: {
+        ...state._commander,
+        activeDraft: mockDraft as any,
+      },
+    }));
+
+    // Create a command that uses ctx.transaction
+    const updateViaTransaction = commander.action<{ value: number }>(
+      (ctx, params) => {
+        ctx.transaction((root: any) => {
+          root.count.set(params.value);
+        });
+      }
+    );
+
+    const storeApi = store as unknown as StoreApi<TestStore & { mimic: { document: typeof mockDocument } }>;
+
+    // Build a proper context with transaction routing
+    const ctx: CommandContext<TestStore> = {
+      getState: () => storeApi.getState(),
+      setState: (partial: Partial<TestStore>) => storeApi.setState(partial as any),
+      dispatch: <TParams, TReturn>(cmd: Command<TestStore, TParams, TReturn>) => {
+        return (params: TParams): TReturn => cmd.fn(ctx, params);
+      },
+      transaction: (fn: (root: any) => void) => {
+        const state = storeApi.getState();
+        const draft = state._commander.activeDraft;
+        if (draft) {
+          draft.update(fn);
+        } else {
+          (state as any).mimic.document.transaction(fn);
+        }
+      },
+    };
+
+    // Execute command - should route to draft.update, NOT document.transaction
+    updateViaTransaction.fn(ctx, { value: 42 });
+
+    expect(draftUpdateCalls.length).toBe(1);
+    expect(documentTransactionCalls.length).toBe(0);
+  });
+
+  it("should never call document.transaction while draft is active (explicit verification)", () => {
+    const commander = createCommander<TestState>();
+
+    // Track ALL calls
+    const documentTransactionCalls: Array<{ fn: (root: any) => void; timestamp: number }> = [];
+    const draftUpdateCalls: Array<{ fn: (root: any) => void; timestamp: number }> = [];
+
+    const mockDocument = {
+      transaction: (fn: (root: any) => void) => {
+        documentTransactionCalls.push({ fn, timestamp: Date.now() });
+      },
+    };
+
+    const mockDraft = {
+      update: (fn: (root: any) => void) => {
+        draftUpdateCalls.push({ fn, timestamp: Date.now() });
+      },
+      commit: () => {},
+      discard: () => {},
+      id: "mock-draft-id",
+    };
+
+    // Create store
+    const store = createStore<TestStore & { mimic: { document: typeof mockDocument } }>(
+      commander.middleware(() => ({
+        count: 0,
+        items: [],
+        selectedId: null,
+        mimic: { document: mockDocument },
+      }))
+    );
+
+    const storeApi = store as unknown as StoreApi<TestStore & { mimic: { document: typeof mockDocument } }>;
+
+    // Helper to build context
+    const buildCtx = (): CommandContext<TestStore> => ({
+      getState: () => storeApi.getState(),
+      setState: (partial: Partial<TestStore>) => storeApi.setState(partial as any),
+      dispatch: <TParams, TReturn>(cmd: Command<TestStore, TParams, TReturn>) => {
+        return (params: TParams): TReturn => cmd.fn(buildCtx(), params);
+      },
+      transaction: (fn: (root: any) => void) => {
+        const state = storeApi.getState();
+        const draft = state._commander.activeDraft;
+        if (draft) {
+          draft.update(fn);
+        } else {
+          (state as any).mimic.document.transaction(fn);
+        }
+      },
+    });
+
+    // Command that uses transaction
+    const doUpdate = commander.action<{ value: number }>(
+      (ctx, params) => {
+        ctx.transaction((root: any) => {
+          root.count.set(params.value);
+        });
+      }
+    );
+
+    // Test 1: No draft - should go to document.transaction
+    doUpdate.fn(buildCtx(), { value: 1 });
+    expect(documentTransactionCalls.length).toBe(1);
+    expect(draftUpdateCalls.length).toBe(0);
+
+    // Test 2: Set active draft
+    store.setState((state) => ({
+      ...state,
+      _commander: {
+        ...state._commander,
+        activeDraft: mockDraft as any,
+      },
+    }));
+
+    // Test 3: With draft active - should go to draft.update
+    doUpdate.fn(buildCtx(), { value: 2 });
+    expect(documentTransactionCalls.length).toBe(1); // Still 1 - no new calls
+    expect(draftUpdateCalls.length).toBe(1);
+
+    // Test 4: Multiple updates while draft is active
+    doUpdate.fn(buildCtx(), { value: 3 });
+    doUpdate.fn(buildCtx(), { value: 4 });
+    doUpdate.fn(buildCtx(), { value: 5 });
+
+    expect(documentTransactionCalls.length).toBe(1); // Still 1 - no new calls
+    expect(draftUpdateCalls.length).toBe(4); // 4 draft updates
+
+    // Test 5: Clear draft
+    store.setState((state) => ({
+      ...state,
+      _commander: {
+        ...state._commander,
+        activeDraft: null,
+      },
+    }));
+
+    // Test 6: Without draft - should go back to document.transaction
+    doUpdate.fn(buildCtx(), { value: 6 });
+    expect(documentTransactionCalls.length).toBe(2);
+    expect(draftUpdateCalls.length).toBe(4);
+  });
+
+  it("should route nested command dispatches to draft when active", () => {
+    const commander = createCommander<TestState>();
+
+    const documentTransactionCalls: Array<(root: any) => void> = [];
+    const draftUpdateCalls: Array<(root: any) => void> = [];
+
+    const mockDocument = {
+      transaction: (fn: (root: any) => void) => {
+        documentTransactionCalls.push(fn);
+      },
+    };
+
+    const mockDraft = {
+      update: (fn: (root: any) => void) => {
+        draftUpdateCalls.push(fn);
+      },
+      commit: () => {},
+      discard: () => {},
+      id: "mock-draft-id",
+    };
+
+    const store = createStore<TestStore & { mimic: { document: typeof mockDocument } }>(
+      commander.middleware(() => ({
+        count: 0,
+        items: [],
+        selectedId: null,
+        mimic: { document: mockDocument },
+      }))
+    );
+
+    // Set active draft
+    store.setState((state) => ({
+      ...state,
+      _commander: {
+        ...state._commander,
+        activeDraft: mockDraft as any,
+      },
+    }));
+
+    const storeApi = store as unknown as StoreApi<TestStore & { mimic: { document: typeof mockDocument } }>;
+
+    const buildCtx = (): CommandContext<TestStore> => ({
+      getState: () => storeApi.getState(),
+      setState: (partial: Partial<TestStore>) => storeApi.setState(partial as any),
+      dispatch: <TParams, TReturn>(cmd: Command<TestStore, TParams, TReturn>) => {
+        return (params: TParams): TReturn => cmd.fn(buildCtx(), params);
+      },
+      transaction: (fn: (root: any) => void) => {
+        const state = storeApi.getState();
+        const draft = state._commander.activeDraft;
+        if (draft) {
+          draft.update(fn);
+        } else {
+          (state as any).mimic.document.transaction(fn);
+        }
+      },
+    });
+
+    // Inner command that uses transaction
+    const setCount = commander.action<{ value: number }>(
+      (ctx, params) => {
+        ctx.transaction((root: any) => {
+          root.count.set(params.value);
+        });
+      }
+    );
+
+    // Outer command that dispatches inner command
+    const setMultiple = commander.action<{ values: number[] }>(
+      (ctx, params) => {
+        for (const value of params.values) {
+          ctx.dispatch(setCount)({ value });
+        }
+      }
+    );
+
+    // Execute outer command - all nested transactions should go to draft
+    setMultiple.fn(buildCtx(), { values: [1, 2, 3, 4, 5] });
+
+    expect(draftUpdateCalls.length).toBe(5);
+    expect(documentTransactionCalls.length).toBe(0);
+  });
+});
+
 describe("Undo/Redo Integration", () => {
   it("should handle multiple undo operations", () => {
     const commander = createCommander<TestState>();