patch-recorder 0.0.0 → 0.1.0

package/README.md

@@ -9,8 +9,9 @@
 - ✅ **Accurate patches** - JSON Patch (RFC 6902) compliant
 - ✅ **Type safety** - Full TypeScript support
 - ✅ **Immediate patch generation** - Patches generated as mutations occur
-- ✅ **Optional optimization** - Can compress/merge redundant patches
+- ✅ **Optimization enabled by default** - Automatically compresses/merges redundant patches
 - ✅ **Full collection support** - Works with objects, arrays, Maps, and Sets
+- ✅ **Item ID tracking** - Optionally include item IDs in remove/replace patches
 
 ## Installation
 
@@ -55,9 +56,9 @@ Unlike mutative or immer, **patch-recorder mutates the original object in place*
 - Perfect for scenarios where you need both mutation tracking AND direct object manipulation
 
 **Performance:**
-- Similar performance to mutative for most operations
-- Slightly faster for object and Map operations
-- Comparable performance for large array operations
+- Substantially faster than mutative (1.1x to 650x depending on operation)
+- Especially dramatic speedups for array index and Map operations
+- Consistent performance improvements across all data types
 
 ```typescript
 // With patch-recorder
@@ -76,7 +77,15 @@ const patches = recordPatches(state, (draft) => {
 
 Records JSON patches from mutations applied to the state.
 
-#### Parameters
+### `create(state, mutate, options?)`
+
+Mutative-compatible API for easy switching between mutative and patch-recorder. Returns `[state, patches]` tuple like mutative does.
+
+**Key difference from mutative:** Unlike mutative which creates a new state copy, this mutates the original object in place. The returned `state` is the same reference as the input state.
+
+**Note:** The `enablePatches` option is forced to `true` by default for full mutative compatibility (patches are always returned).
+
+#### Parameters (both functions)
 
 - **`state`** (`T extends NonPrimitive`): The state object to mutate and record patches from
 - **`mutate`** `(state: Draft<T>) => void`: Callback function that performs mutations on the draft
@@ -84,32 +93,26 @@ Records JSON patches from mutations applied to the state.
 
 #### Options
 
-```typescript
-interface RecordPatchesOptions {
-  /**
-   * Return paths as arrays (default: true) or strings
-   */
-  pathAsArray?: boolean;
-  
-  /**
-   * Include array length in patches (default: true)
-   */
-  arrayLengthAssignment?: boolean;
-  
-  /**
-   * Optimize patches by merging redundant operations (default: false)
-   */
-  optimize?: boolean;
-}
-```
+For `recordPatches`:
+
+- **`pathAsArray`** (boolean, default: `true`) - Return paths as arrays or strings
+- **`arrayLengthAssignment`** (boolean, default: `true`) - When `true`, includes length patches when array shrinks (pop, shift, splice delete). When `false`, omits length patches entirely. Aligned with mutative's behavior.
+- **`compressPatches`** (boolean, default: `true`) - Compress patches by merging redundant operations
+- **`getItemId`** (object, optional) - Configuration for extracting item IDs (see [Item ID Tracking](#item-id-tracking))
+
+For `create` (additional options for mutative compatibility):
+- **`enablePatches`** (boolean, default: `true`) - Always true, patches are always returned
 
 #### Returns
 
-`Patches<true>` - Array of JSON patches
+- **`recordPatches`**: Returns `Patches<true>` - Array of JSON patches
+- **`create`**: Returns `[T, Patches<true>]` - Tuple of mutated state and patches
 
 ## Usage Examples
 
-### Basic Object Mutations
+### Using `recordPatches`
+
+#### Basic Object Mutations
 
 ```typescript
 const state = { count: 0, name: 'test' };
@@ -167,11 +170,12 @@ console.log(patches);
 //   { op: 'replace', path: ['items', 1], value: 10 },
 //   { op: 'remove', path: ['items', 0] },
 //   { op: 'replace', path: ['items', 0], value: 2 },
-//   { op: 'replace', path: ['items', 1], value: 3 },
-//   { op: 'replace', path: ['items', 'length'], value: 3 }
+//   { op: 'replace', path: ['items', 1], value: 3 }
 // ]
 ```
 
+**Note:** Array length patches are included only when the array shrinks (pop, shift, splice delete operations) to optimize performance. This aligns with mutative's behavior. When the array grows (push, unshift, splice add operations), length patches are omitted as the length change is implied by the add operations themselves.
+
 ### Map Operations
 
 ```typescript
@@ -208,28 +212,156 @@ console.log(patches);
 // ]
 ```
 
+### Using `create` (Mutative-compatible API)
+
+The `create` function provides the same API as mutative for easy switching:
+
+```typescript
+import {create} from 'patch-recorder';
+
+const state = { user: { name: 'John' } };
+
+const [nextState, patches] = create(state, (draft) => {
+  draft.user.name = 'Jane';
+});
+
+console.log(nextState.user.name); // 'Jane' (mutated in place!)
+console.log(nextState === state); // true (same reference - unlike mutative)
+console.log(patches);
+// [{ op: 'replace', path: ['user', 'name'], value: 'Jane' }]
+```
+
+#### Easy Migration from Mutative
+
+```typescript
+// Before (with mutative)
+import {create} from 'mutative';
+const [newState, patches] = create(state, mutate, {enablePatches: true});
+// newState !== state (mutative creates a copy)
+
+// After (with patch-recorder) - EXACT SAME CODE!
+import {create} from 'patch-recorder';
+const [nextState, patches] = create(state, mutate, {enablePatches: true});
+// nextState === state (patch-recorder mutates in place)
+```
+
+**No code changes needed** - just change the import! The `enablePatches` option is forced to `true` by default, so it's always enabled.
+
 ### Using Options
 
+For `recordPatches`:
+
 ```typescript
 const state = { value: 1 };
 
 // Use string paths instead of arrays
-const patches2 = recordPatches(state, (draft) => {
+const patches = recordPatches(state, (draft) => {
   draft.value = 3;
 }, { pathAsArray: false });
-console.log(patches2);
+console.log(patches);
 // [{ op: 'replace', path: '/value', value: 3 }]
 
-// Optimize patches (merge redundant operations)
-const patches3 = recordPatches(state, (draft) => {
+// Compress patches (merge redundant operations) - enabled by default
+const patches = recordPatches(state, (draft) => {
   draft.value = 4;
   draft.value = 5;
   draft.value = 5; // no-op
-}, { optimize: true });
-console.log(patches3);
+});
+// To disable compression:
+// const patches = recordPatches(state, (draft) => { ... }, { compressPatches: false });
+console.log(patches);
 // [{ op: 'replace', path: ['value'], value: 5 }]
+
+// For create function, you also have to pass enablePatches (it's always true)
+const [nextState, patches] = create(state, (draft) => {
+  draft.value = 5;
+}, { enablePatches: true, pathAsArray: false, compressPatches: true });
+```
+
+### Item ID Tracking
+
+When working with arrays, the patch path only tells you the index, not which item was affected. The `getItemId` option allows you to include item IDs in `remove` and `replace` patches, making it easier to track which items changed.
+
+```typescript
+const state = {
+  users: [
+    { id: 'user-1', name: 'Alice' },
+    { id: 'user-2', name: 'Bob' },
+    { id: 'user-3', name: 'Charlie' },
+  ]
+};
+
+const patches = recordPatches(state, (draft) => {
+  draft.users.splice(1, 1); // Remove Bob
+}, {
+  getItemId: {
+    users: (user) => user.id  // Extract ID from each user
+  }
+});
+
+console.log(patches);
+// [{ op: 'remove', path: ['users', 1], id: 'user-2' }]
+// Without getItemId, you'd only know index 1 was removed, not that it was Bob
+```
+
+#### Configuration Structure
+
+The `getItemId` option is an object that mirrors your data structure:
+
+```typescript
+recordPatches(state, mutate, {
+  getItemId: {
+    // Top-level arrays
+    items: (item) => item.id,
+    users: (user) => user.userId,
+    
+    // Nested paths - use nested objects
+    app: {
+      data: {
+        todos: (todo) => todo._id
+      }
+    },
+    
+    // Maps - same as arrays
+    entityMap: (entity) => entity.internalId
+  }
+});
 ```
 
+#### Works with Maps and Sets too
+
+```typescript
+const state = {
+  entityMap: new Map([
+    ['key1', { internalId: 'entity-1', data: 'value1' }],
+  ]),
+  itemSet: new Set([
+    { id: 'set-item-1', value: 1 }
+  ])
+};
+
+const patches = recordPatches(state, (draft) => {
+  draft.entityMap.delete('key1');
+}, {
+  getItemId: {
+    entityMap: (entity) => entity.internalId
+  }
+});
+
+console.log(patches);
+// [{ op: 'remove', path: ['entityMap', 'key1'], id: 'entity-1' }]
+```
+
+#### When IDs are included
+
+- **`remove`** patches always include `id` when configured
+- **`replace`** patches include `id` (of the OLD value being replaced)
+- **`add`** patches do NOT include `id` (the value already contains it)
+
+#### ID can be undefined/null
+
+If the `getItemId` function returns `undefined` or `null`, the `id` field is omitted from the patch. This is useful when some items might not have IDs.
+
 ## Comparison with Mutative
 
 | Feature | Mutative | patch-recorder |
@@ -238,8 +370,27 @@ console.log(patches3);
 | Memory overhead | ❌ Yes (copies) | ✅ No |
 | Patch accuracy | ✅ Excellent | ✅ Excellent |
 | Type safety | ✅ Excellent | ✅ Excellent |
-| API similarity | ✅ Similar | ✅ Similar |
+| API compatibility | - | ✅ `create()` function provides same API |
 | Use case | Immutable state | Mutable with tracking |
+| Performance | Fast | 1.1-650x faster |
+
+### Easy Migration
+
+```typescript
+// Switching from mutative to patch-recorder is simple:
+// Just change the import - no other changes needed!
+
+// Before
+import {create} from 'mutative';
+const [nextState, patches] = create(state, mutate, {enablePatches: true});
+
+// After - EXACT SAME CODE!
+import {create} from 'patch-recorder';
+const [nextState, patches] = create(state, mutate, {enablePatches: true});
+
+// Note: patch-recorder mutates in place, so nextState === state
+// If you rely on immutability, you may need to clone before mutation
+```
 
 ### When to Use patch-recorder
 
@@ -262,12 +413,12 @@ patch-recorder provides substantial performance improvements over mutative while
 
 | Operation | Mutative | patch-recorder | Speedup |
 |-----------|----------|----------------|---------|
-| Simple object mutation | 0.0272ms | 0.0110ms | **2.48x** |
-| Medium nested object | 0.0268ms | 0.0114ms | **2.35x** |
-| Large nested object | 0.0094ms | 0.0040ms | **2.38x** |
-| Array push (100k elements) | 3.277ms | 1.155ms | **2.84x** |
-| Array index (100k elements) | 2.966ms | 0.004ms | **826x** |
-| Map operations (100k entries) | 11.384ms | 0.011ms | **1,067x** |
+| Simple object mutation | 0.0215ms | 0.0148ms | **1.45x** |
+| Medium nested object | 0.0254ms | 0.0221ms | **1.15x** |
+| Large nested object | 0.0088ms | 0.0078ms | **1.13x** |
+| Array push (100k elements) | 3.0311ms | 0.6809ms | **4.45x** |
+| Array index (100k elements) | 2.6097ms | 0.0069ms | **380x** |
+| Map operations (100k entries) | 10.4033ms | 0.0160ms | **650x** |
 
 **Memory Usage:**
 - **Mutative**: Creates copies (memory overhead proportional to state size)
@@ -277,17 +428,17 @@ patch-recorder provides substantial performance improvements over mutative while
 
 The benchmark results reveal patch-recorder's massive advantage for operations that would require copying large data structures:
 
-- **Object mutations** (2.35-2.48x faster) - Consistent speedups due to simpler proxy overhead
-- **Array push** (2.84x faster) - Avoids copying entire arrays on mutation
-- **Array index assignment** (826x faster) - **Massive speedup** by not copying 100k-element arrays
-- **Map operations** (1,067x faster) - **Incredible speedup** by not copying 100k-entry Maps
+- **Object mutations** (1.13-1.45x faster) - Consistent speedups due to simpler proxy overhead
+- **Array push** (4.45x faster) - Avoids copying entire arrays on mutation
+- **Array index assignment** (380x faster) - **Massive speedup** by not copying 100k-element arrays
+- **Map operations** (650x faster) - **Incredible speedup** by not copying 100k-entry Maps
 
 **Why the dramatic differences?**
 - patch-recorder mutates in place, so array index assignment and Map operations don't require copying
 - mutative's copy-on-write approach is elegant but incurs significant overhead for large collections
 - The advantage scales with data size - the larger the collection, the bigger the speedup
 
-**Note on mutative's performance:** Mutative is impressively fast for object mutations and offers excellent immutability guarantees. Its speedups of 2-3x for objects are reasonable trade-offs for immutable state management.
+**Note on mutative's performance:** Mutative is impressively fast for object mutations and offers excellent immutability guarantees. Its speedups of ~1.1-1.5x for objects are reasonable trade-offs for immutable state management.
 
 ### Run Benchmarks
 
@@ -326,7 +477,7 @@ npm run benchmark
 ### Optimization Tips
 
 1. **Lazy proxy creation**: Only creates proxies for accessed properties
-2. **Patch compression**: Reduces redundant patches via `optimize` option
+2. **Patch compression**: Reduces redundant patches via `compressPatches` option
 
 ## License
 

package/dist/arrays.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"arrays.d.ts","sourceRoot":"","sources":["../src/arrays.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAC,aAAa,EAAC,MAAM,YAAY,CAAC;AAK9C;;GAEG;AACH,wBAAgB,cAAc,CAC7B,GAAG,EAAE,GAAG,EAAE,EACV,IAAI,EAAE,MAAM,EACZ,IAAI,EAAE,CAAC,MAAM,GAAG,MAAM,CAAC,EAAE,EACzB,KAAK,EAAE,aAAa,CAAC,GAAG,CAAC,GACvB,GAAG,CA2DL"}
+{"version":3,"file":"arrays.d.ts","sourceRoot":"","sources":["../src/arrays.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAC,aAAa,EAAC,MAAM,YAAY,CAAC;AAoC9C;;GAEG;AACH,wBAAgB,cAAc,CAC7B,GAAG,EAAE,GAAG,EAAE,EACV,IAAI,EAAE,MAAM,EACZ,IAAI,EAAE,CAAC,MAAM,GAAG,MAAM,CAAC,EAAE,EACzB,KAAK,EAAE,aAAa,CAAC,GAAG,CAAC,GACvB,GAAG,CA4CL"}

package/dist/arrays.js

@@ -1,42 +1,57 @@
 import { generateAddPatch, generateDeletePatch, generateReplacePatch } from './patches.js';
 import { createProxy } from './proxy.js';
+// Module-level Sets for O(1) lookup instead of O(n) array includes
+const MUTATING_METHODS = new Set([
+    'push',
+    'pop',
+    'shift',
+    'unshift',
+    'splice',
+    'sort',
+    'reverse',
+]);
+const NON_MUTATING_METHODS = new Set([
+    'map',
+    'filter',
+    'reduce',
+    'reduceRight',
+    'forEach',
+    'find',
+    'findIndex',
+    'some',
+    'every',
+    'includes',
+    'indexOf',
+    'lastIndexOf',
+    'slice',
+    'concat',
+    'join',
+    'flat',
+    'flatMap',
+    'at',
+]);
 /**
  * Handle array method calls and property access
  */
 export function handleArrayGet(obj, prop, path, state) {
     // Mutating methods
-    const mutatingMethods = ['push', 'pop', 'shift', 'unshift', 'splice', 'sort', 'reverse'];
-    if (mutatingMethods.includes(prop)) {
+    if (MUTATING_METHODS.has(prop)) {
         return (...args) => {
-            const oldValue = [...obj]; // Snapshot before mutation
+            // Optimized: only copy what's needed for each method
+            const oldLength = obj.length;
+            let oldValue = null;
+            // Only create full copy for sort/reverse which need the entire old array
+            if (prop === 'sort' || prop === 'reverse') {
+                oldValue = [...obj];
+            }
             const result = Array.prototype[prop].apply(obj, args);
             // Generate patches based on the method
-            generateArrayPatches(state, obj, prop, args, result, path, oldValue);
+            generateArrayPatches(state, obj, prop, args, result, path, oldValue, oldLength);
             return result;
         };
     }
     // Non-mutating methods - just return them bound to the array
-    const nonMutatingMethods = [
-        'map',
-        'filter',
-        'reduce',
-        'reduceRight',
-        'forEach',
-        'find',
-        'findIndex',
-        'some',
-        'every',
-        'includes',
-        'indexOf',
-        'lastIndexOf',
-        'slice',
-        'concat',
-        'join',
-        'flat',
-        'flatMap',
-        'at',
-    ];
-    if (nonMutatingMethods.includes(prop)) {
+    if (NON_MUTATING_METHODS.has(prop)) {
         return Array.prototype[prop].bind(obj);
     }
     // Property access
@@ -57,85 +72,70 @@ export function handleArrayGet(obj, prop, path, state) {
 /**
  * Generate patches for array mutations
  */
-function generateArrayPatches(state, obj, method, args, result, path, oldValue) {
+function generateArrayPatches(state, obj, method, args, result, path, oldValue, oldLength) {
     switch (method) {
         case 'push': {
             // Generate add patches for each new element
-            const startIndex = oldValue.length;
+            // oldLength is the starting index before push
             args.forEach((value, i) => {
-                const index = startIndex + i;
+                const index = oldLength + i;
                 generateAddPatch(state, [...path, index], value);
             });
-            // Generate length patch if option is enabled
-            if (state.options.arrayLengthAssignment !== false) {
-                generateReplacePatch(state, [...path, 'length'], obj.length);
-            }
+            // No length patch when array grows (aligned with mutative)
             break;
         }
         case 'pop': {
-            // Generate remove patch for the removed element
-            const removedIndex = oldValue.length - 1;
-            generateDeletePatch(state, [...path, removedIndex], result);
-            // Generate length patch if option is enabled
             if (state.options.arrayLengthAssignment !== false) {
-                generateReplacePatch(state, [...path, 'length'], obj.length);
+                // Generate length replace patch (mutative uses this instead of remove)
+                generateReplacePatch(state, [...path, 'length'], obj.length, oldLength);
+            }
+            else {
+                // When arrayLengthAssignment is false, generate remove patch for last element
+                generateDeletePatch(state, [...path, oldLength - 1], result);
             }
             break;
         }
         case 'shift': {
-            // Generate remove patch for the removed element
+            // Remove first element (shifted elements are handled automatically by JSON Patch spec)
+            // We don't have oldValue here, but the result of shift() is the removed element
             generateDeletePatch(state, [...path, 0], result);
-            // Shift is complex - we need to update all remaining elements
-            // Update all shifted elements (after the shift, each element moves to index - 1)
-            for (let i = 0; i < obj.length; i++) {
-                generateReplacePatch(state, [...path, i], oldValue[i + 1]);
-            }
-            // Generate length patch if option is enabled
-            if (state.options.arrayLengthAssignment !== false) {
-                generateReplacePatch(state, [...path, 'length'], obj.length);
-            }
             break;
         }
         case 'unshift': {
-            // Add new elements at the beginning
+            // Add new elements at the beginning (shifted elements are handled automatically by JSON Patch spec)
             args.forEach((value, i) => {
                 generateAddPatch(state, [...path, i], value);
             });
-            // Update all existing elements
-            for (let i = 0; i < oldValue.length; i++) {
-                generateReplacePatch(state, [...path, i + args.length], oldValue[i]);
-            }
-            // Generate length patch if option is enabled
-            if (state.options.arrayLengthAssignment !== false) {
-                generateReplacePatch(state, [...path, 'length'], obj.length);
-            }
             break;
         }
         case 'splice': {
-            const [start, deleteCount, ...addItems] = args;
-            // Generate remove patches for deleted items
-            for (let i = 0; i < deleteCount; i++) {
-                generateDeletePatch(state, [...path, start], oldValue[start]);
+            const [start, deleteCount = 0, ...addItems] = args;
+            const actualStart = start < 0 ? Math.max(oldLength + start, 0) : Math.min(start, oldLength);
+            const actualDeleteCount = Math.min(deleteCount, oldLength - actualStart);
+            const minCount = Math.min(actualDeleteCount, addItems.length);
+            // For splice, we need the old values for delete operations
+            // Since we don't have oldValue, we need to track what was deleted
+            // The result of splice() is the array of deleted elements
+            const deletedElements = result;
+            // First minCount elements: replace (overlap between add and delete)
+            for (let i = 0; i < minCount; i++) {
+                generateReplacePatch(state, [...path, actualStart + i], addItems[i], deletedElements[i]);
             }
-            // Generate add patches for new items
-            addItems.forEach((item, i) => {
-                generateAddPatch(state, [...path, start + i], item);
-            });
-            // If there are both deletions and additions, update the shifted elements
-            const itemsToShift = oldValue.length - start - deleteCount;
-            for (let i = 0; i < itemsToShift; i++) {
-                generateReplacePatch(state, [...path, start + addItems.length + i], oldValue[start + deleteCount + i]);
+            // Remaining add items: add
+            for (let i = minCount; i < addItems.length; i++) {
+                generateAddPatch(state, [...path, actualStart + i], addItems[i]);
             }
-            // Generate length patch if option is enabled
-            if (state.options.arrayLengthAssignment !== false) {
-                generateReplacePatch(state, [...path, 'length'], obj.length);
+            // Remaining delete items: remove (generate in reverse order)
+            for (let i = actualDeleteCount - 1; i >= minCount; i--) {
+                generateDeletePatch(state, [...path, actualStart + i], deletedElements[i]);
             }
             break;
         }
         case 'sort':
         case 'reverse': {
             // These reorder the entire array - generate full replace
-            generateReplacePatch(state, path, [...obj]);
+            // oldValue contains the array before the mutation
+            generateReplacePatch(state, path, [...obj], oldValue);
             break;
         }
     }

package/dist/arrays.js.map

@@ -1 +1 @@
-{"version":3,"file":"arrays.js","sourceRoot":"","sources":["../src/arrays.ts"],"names":[],"mappings":"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"}
+{"version":3,"file":"arrays.js","sourceRoot":"","sources":["../src/arrays.ts"],"names":[],"mappings":"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"}

package/dist/index.d.ts

@@ -17,5 +17,28 @@ import type { NonPrimitive, Draft, RecordPatchesOptions, Patches } from './types
  * console.log(patches); // [{ op: 'replace', path: ['user', 'name'], value: 'Jane' }]
  */
 export declare function recordPatches<T extends NonPrimitive>(state: T, mutate: (state: Draft<T>) => void, options?: RecordPatchesOptions): Patches<true>;
+/**
+ * Mutative-compatible API for easy switching between mutative and patch-recorder.
+ * Returns [state, patches] tuple like mutative does.
+ *
+ * Unlike mutative, this mutates the original object in place (state === originalState).
+ * The returned state is the same reference as the input state for API compatibility.
+ *
+ * @param state - The state to mutate and record patches from
+ * @param mutate - A function that receives a draft of the state and applies mutations
+ * @param options - Configuration options (enablePatches is forced but ignored - patches are always returned)
+ * @returns Tuple [state, patches] where state is the mutated state (same reference as input)
+ *
+ * @example
+ * const state = { user: { name: 'John' } };
+ * const [nextState, patches] = create(state, (draft) => {
+ *   draft.user.name = 'Jane';
+ * }, {enabledPatches: true});
+ * console.log(nextState === state); // true (mutated in place!)
+ * console.log(patches); // [{ op: 'replace', path: ['user', 'name'], value: 'Jane' }]
+ */
+export declare function create<T extends NonPrimitive>(state: T, mutate: (state: Draft<T>) => void, options?: RecordPatchesOptions & {
+    enablePatches: true;
+}): [T, Patches<true>];
 export type { NonPrimitive, Draft, RecordPatchesOptions, Patches, Patch, Operation, } from './types.js';
 //# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EACX,YAAY,EACZ,KAAK,EACL,oBAAoB,EACpB,OAAO,EAGP,MAAM,YAAY,CAAC;AAEpB;;;;;;;;;;;;;;;;GAgBG;AACH,wBAAgB,aAAa,CAAC,CAAC,SAAS,YAAY,EACnD,KAAK,EAAE,CAAC,EACR,MAAM,EAAE,CAAC,KAAK,EAAE,KAAK,CAAC,CAAC,CAAC,KAAK,IAAI,EACjC,OAAO,GAAE,oBAAyB,GAChC,OAAO,CAAC,IAAI,CAAC,CA4Bf;AAGD,YAAY,EACX,YAAY,EACZ,KAAK,EACL,oBAAoB,EACpB,OAAO,EACP,KAAK,EACL,SAAS,GACT,MAAM,YAAY,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAEA,OAAO,KAAK,EACX,YAAY,EACZ,KAAK,EACL,oBAAoB,EACpB,OAAO,EAGP,MAAM,YAAY,CAAC;AAEpB;;;;;;;;;;;;;;;;GAgBG;AACH,wBAAgB,aAAa,CAAC,CAAC,SAAS,YAAY,EACnD,KAAK,EAAE,CAAC,EACR,MAAM,EAAE,CAAC,KAAK,EAAE,KAAK,CAAC,CAAC,CAAC,KAAK,IAAI,EACjC,OAAO,GAAE,oBAAyB,GAChC,OAAO,CAAC,IAAI,CAAC,CA4Bf;AAGD;;;;;;;;;;;;;;;;;;;GAmBG;AACH,wBAAgB,MAAM,CAAC,CAAC,SAAS,YAAY,EAC5C,KAAK,EAAE,CAAC,EACR,MAAM,EAAE,CAAC,KAAK,EAAE,KAAK,CAAC,CAAC,CAAC,KAAK,IAAI,EACjC,OAAO,GAAE,oBAAoB,GAAG;IAAC,aAAa,EAAE,IAAI,CAAA;CAAyB,GAC3E,CAAC,CAAC,EAAE,OAAO,CAAC,IAAI,CAAC,CAAC,CAKpB;AAGD,YAAY,EACX,YAAY,EACZ,KAAK,EACL,oBAAoB,EACpB,OAAO,EACP,KAAK,EACL,SAAS,GACT,MAAM,YAAY,CAAC"}

package/dist/index.js

@@ -35,10 +35,36 @@ export function recordPatches(state, mutate, options = {}) {
     const proxy = createProxy(state, [], recorderState);
     // Apply mutations
     mutate(proxy);
-    // Return patches (optionally optimized)
-    if (options.optimize) {
+    // Return patches (optionally compressed)
+    if (options.compressPatches !== false) {
         return compressPatches(recorderState.patches);
     }
     return recorderState.patches;
 }
+/**
+ * Mutative-compatible API for easy switching between mutative and patch-recorder.
+ * Returns [state, patches] tuple like mutative does.
+ *
+ * Unlike mutative, this mutates the original object in place (state === originalState).
+ * The returned state is the same reference as the input state for API compatibility.
+ *
+ * @param state - The state to mutate and record patches from
+ * @param mutate - A function that receives a draft of the state and applies mutations
+ * @param options - Configuration options (enablePatches is forced but ignored - patches are always returned)
+ * @returns Tuple [state, patches] where state is the mutated state (same reference as input)
+ *
+ * @example
+ * const state = { user: { name: 'John' } };
+ * const [nextState, patches] = create(state, (draft) => {
+ *   draft.user.name = 'Jane';
+ * }, {enabledPatches: true});
+ * console.log(nextState === state); // true (mutated in place!)
+ * console.log(patches); // [{ op: 'replace', path: ['user', 'name'], value: 'Jane' }]
+ */
+export function create(state, mutate, options = { enablePatches: true }) {
+    // Extract enablePatches but ignore it (patches are always returned)
+    const { enablePatches, ...recordPatchesOptions } = options;
+    const patches = recordPatches(state, mutate, recordPatchesOptions);
+    return [state, patches];
+}
 //# sourceMappingURL=index.js.map