patch-recorder 0.0.1 → 0.2.0

package/src/arrays.ts

@@ -1,64 +1,72 @@
-import type {RecorderState} from './types.js';
-import {Operation} from './types.js';
+import type {NonPrimitive, PatchPath, RecorderState} from './types.js';
 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: any[],
+	array: unknown[],
 	prop: string,
-	path: (string | number)[],
-	state: RecorderState<any>,
+	path: PatchPath,
+	state: RecorderState<NonPrimitive>,
 ): any {
 	// Mutating methods
-	const mutatingMethods = ['push', 'pop', 'shift', 'unshift', 'splice', 'sort', 'reverse'];
+	if (MUTATING_METHODS.has(prop)) {
+		return (...args: unknown[]) => {
+			// Optimized: only copy what's needed for each method
+			const oldLength = array.length;
+			let oldValue: unknown[] | null = null;
+
+			// Only create full copy for sort/reverse which need the entire old array
+			if (prop === 'sort' || prop === 'reverse') {
+				oldValue = [...array];
+			}
 
-	if (mutatingMethods.includes(prop)) {
-		return (...args: any[]) => {
-			const oldValue = [...obj]; // Snapshot before mutation
-			const result = (Array.prototype as any)[prop].apply(obj, args);
+			const result = (Array.prototype as any)[prop].apply(array, args);
 
 			// Generate patches based on the method
-			generateArrayPatches(state, obj, prop, args, result, path, oldValue);
+			generateArrayPatches(state, array, 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)) {
-		return (Array.prototype as any)[prop].bind(obj);
+	if (NON_MUTATING_METHODS.has(prop)) {
+		return (Array.prototype as any)[prop].bind(array);
 	}
 
 	// Property access
 	if (prop === 'length') {
-		return obj.length;
+		return array.length;
 	}
 
-	const value = obj[prop as any];
+	const value = array[prop as any];
 
 	// For numeric properties (array indices), check if the value is an object/array
 	// If so, return a proxy to enable nested mutation tracking
@@ -76,106 +84,77 @@ export function handleArrayGet(
  * Generate patches for array mutations
  */
 function generateArrayPatches(
-	state: RecorderState<any>,
-	obj: any[],
+	state: RecorderState<NonPrimitive>,
+	array: unknown[],
 	method: string,
-	args: any[],
+	args: unknown[],
 	result: any,
-	path: (string | number)[],
-	oldValue: any[],
+	path: PatchPath,
+	oldArray: unknown[] | null,
+	oldLength: number,
 ) {
 	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'], array.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 as number[];
+			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 as any[];
+
+			// 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;
@@ -184,7 +163,8 @@ function generateArrayPatches(
 		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, array, oldArray);
 			break;
 		}
 	}

package/src/index.ts

@@ -1,13 +1,6 @@
 import {createProxy} from './proxy.js';
 import {compressPatches} from './optimizer.js';
-import type {
-	NonPrimitive,
-	Draft,
-	RecordPatchesOptions,
-	Patches,
-	Patch,
-	Operation,
-} from './types.js';
+import type {NonPrimitive, Draft, RecordPatchesOptions, Patches} from './types.js';
 
 /**
  * Record JSON patches from mutations applied to an object, array, Map, or Set.
@@ -26,24 +19,18 @@ import type {
  * console.log(state.user.name); // 'Jane' (mutated in place!)
  * console.log(patches); // [{ op: 'replace', path: ['user', 'name'], value: 'Jane' }]
  */
-export function recordPatches<T extends NonPrimitive>(
-	state: T,
-	mutate: (state: Draft<T>) => void,
-	options: RecordPatchesOptions = {},
-): Patches<true> {
-	const internalPatchesOptions = {
-		pathAsArray: options.pathAsArray ?? true,
-		arrayLengthAssignment: options.arrayLengthAssignment ?? true,
-	};
-
+export function recordPatches<
+	T extends NonPrimitive,
+	PatchesOption extends RecordPatchesOptions = {},
+>(state: T, mutate: (state: Draft<T>) => void, options?: PatchesOption): Patches {
 	const recorderState = {
-		original: state,
+		state,
 		patches: [],
 		basePath: [],
 		options: {
 			...options,
-			internalPatchesOptions,
 		},
+		proxyCache: new WeakMap(),
 	};
 
 	// Create proxy
@@ -53,42 +40,11 @@ export function recordPatches<T extends NonPrimitive>(
 	mutate(proxy);
 
 	// Return patches (optionally compressed)
-	if (options.compressPatches !== false) {
+	if (options?.compressPatches !== false) {
 		return compressPatches(recorderState.patches);
 	}
 
-	return recorderState.patches as 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 function create<T extends NonPrimitive>(
-	state: T,
-	mutate: (state: Draft<T>) => void,
-	options: RecordPatchesOptions & {enablePatches: true} = {enablePatches: true},
-): [T, Patches<true>] {
-	// Extract enablePatches but ignore it (patches are always returned)
-	const {enablePatches, ...recordPatchesOptions} = options;
-	const patches = recordPatches(state, mutate, recordPatchesOptions);
-	return [state, patches];
+	return recorderState.patches as Patches;
 }
 
 // Re-export types

package/src/maps.ts

@@ -1,29 +1,29 @@
-import type {RecorderState} from './types.js';
+import type {PatchPath, RecorderState} from './types.js';
 import {createProxy} from './proxy.js';
-import {Operation} from './types.js';
 import {generateAddPatch, generateDeletePatch, generateReplacePatch} from './patches.js';
-import {cloneIfNeeded, isMap, isArray} from './utils.js';
+import {cloneIfNeeded} from './utils.js';
 
 /**
  * Handle property access on Map objects
  * Wraps mutating methods (set, delete, clear) to generate patches
  */
-export function handleMapGet<K = any, V = any>(
-	obj: Map<K, V>,
+export function handleMapGet(
+	obj: Map<any, any>,
 	prop: string | symbol,
-	path: (string | number)[],
+	path: PatchPath,
 	state: RecorderState<any>,
 ): any {
-	// Skip symbol properties
+	// Handle symbol properties - return the property value directly
+	// Symbol methods like Symbol.iterator should work normally
 	if (typeof prop === 'symbol') {
 		return (obj as any)[prop];
 	}
 
 	// Mutating methods
 	if (prop === 'set') {
-		return (key: K, value: V) => {
-			// Check if key existed BEFORE mutation
-			const existed = keyExistsInOriginal(state.original, path, key);
+		return (key: any, value: any) => {
+			// Check if key exists BEFORE mutation (current state, not original)
+			const existed = obj.has(key);
 			const oldValue = obj.get(key);
 			const result = obj.set(key, value);
 
@@ -31,8 +31,8 @@ export function handleMapGet<K = any, V = any>(
 			const itemPath = [...path, key as any];
 
 			if (existed) {
-				// Key exists - replace
-				generateReplacePatch(state, itemPath, cloneIfNeeded(value));
+				// Key exists - replace (pass oldValue for getItemId)
+				generateReplacePatch(state, itemPath, cloneIfNeeded(value), oldValue);
 			} else {
 				// Key doesn't exist - add
 				generateAddPatch(state, itemPath, cloneIfNeeded(value));
@@ -43,7 +43,7 @@ export function handleMapGet<K = any, V = any>(
 	}
 
 	if (prop === 'delete') {
-		return (key: K) => {
+		return (key: any) => {
 			const oldValue = obj.get(key);
 			const result = obj.delete(key);
 
@@ -71,14 +71,12 @@ export function handleMapGet<K = any, V = any>(
 
 	// Non-mutating methods
 	if (prop === 'get') {
-		return (key: K) => {
+		return (key: any) => {
 			const value = obj.get(key);
 
-			// If the value is a Map, Array, or object, return a proxy
+			// If the value is an object, return a proxy for nested mutation tracking
 			if (value != null && typeof value === 'object') {
-				if (isMap(value) || isArray(value)) {
-					return createProxy(value, [...path, key as any], state);
-				}
+				return createProxy(value, [...path, key as any], state);
 			}
 
 			return value;
@@ -100,21 +98,3 @@ export function handleMapGet<K = any, V = any>(
 	return (obj as any)[prop];
 }
 
-/**
- * Navigate to the original Map at the given path and check if a key exists
- * This is needed to check if a key existed before mutations
- */
-function keyExistsInOriginal(original: any, path: (string | number)[], key: any): boolean {
-	let current = original;
-	for (const part of path) {
-		if (current == null) return false;
-		current = current[part];
-	}
-
-	// If we reached a Map, check if the key exists
-	if (current instanceof Map) {
-		return current.has(key);
-	}
-
-	return false;
-}