Update package version to 0.1.23, enhance enableMapSet function to update global equality check for Map and Set support, and add comprehensive tests for immer-utils and reaction handling with Maps and Sets.

Author: flexsurfer

package.json

@@ -1,6 +1,6 @@
 {
   "name": "@flexsurfer/reflex",
-  "version": "0.1.22",
+  "version": "0.1.23",
   "license": "MIT",
   "repository": {
     "type": "git",

src/immer-utils.ts

@@ -4,6 +4,9 @@
  */
 
 import { isDraft, original as immerOriginal, current as immerCurrent, enableMapSet as immerEnableMapSet } from 'immer';
+import { setGlobalEqualityCheck, getGlobalEqualityCheck } from './settings';
+import isEqual from 'fast-deep-equal';
+import isEqualEs6 from 'fast-deep-equal/es6';
 
 /**
  * Safe version of immer's original function
@@ -26,7 +29,14 @@ export function current<T>(value: T): T {
 /**
  * Enable Map and Set support in Immer
  * This allows Immer to handle Map and Set objects properly in drafts
+ * Also updates the global equality check to use fast-deep-equal/es6 for proper Map/Set comparison,
+ * but only if the current equality check is still the default isEqual
  */
 export function enableMapSet(): void {
   immerEnableMapSet();
+  // Only update the global equality check if it's still the default isEqual
+  // to avoid overriding user-set custom equality checks
+  if (getGlobalEqualityCheck() === isEqual) {
+    setGlobalEqualityCheck(isEqualEs6);
+  }
 }

src/tests/immer-utils.test.ts

@@ -0,0 +1,93 @@
+import { enableMapSet, original, current } from '../immer-utils';
+import { getGlobalEqualityCheck, setGlobalEqualityCheck } from '../settings';
+import isEqual from 'fast-deep-equal';
+import isEqualEs6 from 'fast-deep-equal/es6';
+
+describe('immer-utils', () => {
+    describe('enableMapSet', () => {
+        beforeEach(() => {
+            // Reset to default equality check before each test
+            setGlobalEqualityCheck(isEqual);
+        });
+
+        it('should update global equality check to isEqualEs6 when current check is default isEqual', () => {
+            // Initially should be the default isEqual
+            expect(getGlobalEqualityCheck()).toBe(isEqual);
+
+            enableMapSet();
+
+            // Should now be isEqualEs6
+            expect(getGlobalEqualityCheck()).toBe(isEqualEs6);
+        });
+
+        it('should NOT override custom equality check when user has set one', () => {
+            // Set a custom equality check
+            const customEquality = () => true;
+            setGlobalEqualityCheck(customEquality);
+
+            // Verify it's set
+            expect(getGlobalEqualityCheck()).toBe(customEquality);
+
+            enableMapSet();
+
+            // Should still be the custom equality check, not isEqualEs6
+            expect(getGlobalEqualityCheck()).toBe(customEquality);
+            expect(getGlobalEqualityCheck()).not.toBe(isEqualEs6);
+        });
+
+        it('should handle Map and Set equality correctly after enableMapSet is called', () => {
+            const map1 = new Map([['key1', 'value1'], ['key2', 'value2']]);
+            const map2 = new Map([['key1', 'value1'], ['key2', 'value2']]);
+            const set1 = new Set(['a', 'b', 'c']);
+            const set2 = new Set(['a', 'b', 'c']);
+            const map3 = new Map([['key1', 'value1'], ['key2', 'different']]);
+            const set3 = new Set(['a', 'b', 'd']);
+
+            // Before enableMapSet, default isEqual might not handle Map/Set properly
+            let equalityCheck = getGlobalEqualityCheck();
+
+            expect(equalityCheck(map1, map2)).toBe(true);
+            expect(equalityCheck(set1, set2)).toBe(true);
+            expect(equalityCheck(map1, map3)).toBe(true);
+            expect(equalityCheck(set1, set3)).toBe(true);
+
+            enableMapSet();
+
+            // After enableMapSet, isEqualEs6 should handle Map/Set properly
+            equalityCheck = getGlobalEqualityCheck();
+
+            expect(equalityCheck(map1, map2)).toBe(true);
+            expect(equalityCheck(set1, set2)).toBe(true);
+            expect(equalityCheck(map1, map3)).toBe(false);
+            expect(equalityCheck(set1, set3)).toBe(false);
+        });
+    });
+
+    describe('original', () => {
+        it('should return original value for non-draft values', () => {
+            const obj = { a: 1, b: 2 };
+            expect(original(obj)).toBe(obj);
+        });
+
+        it('should return original value for primitive values', () => {
+            expect(original(42)).toBe(42);
+            expect(original('hello')).toBe('hello');
+            expect(original(null)).toBe(null);
+            expect(original(undefined)).toBe(undefined);
+        });
+    });
+
+    describe('current', () => {
+        it('should return current value for non-draft values', () => {
+            const obj = { a: 1, b: 2 };
+            expect(current(obj)).toBe(obj);
+        });
+
+        it('should return current value for primitive values', () => {
+            expect(current(42)).toBe(42);
+            expect(current('hello')).toBe('hello');
+            expect(current(null)).toBe(null);
+            expect(current(undefined)).toBe(undefined);
+        });
+    });
+});

src/tests/reaction.test.ts

@@ -1057,6 +1057,162 @@ describe('Complex data structures and memoization', () => {
     });
   });
 
+  describe('Map and Set support with enableMapSet', () => {
+    it('should work correctly with Map objects after enableMapSet is called', async () => {
+      const { enableMapSet } = await import('../../src/immer-utils');
+      const { setGlobalEqualityCheck } = await import('../../src/settings');
+      const isEqual = (await import('fast-deep-equal')).default;
+
+      let mapValue = new Map([['key1', 'value1'], ['key2', 'value2']]);
+      const root = Reaction.create(() => mapValue);
+      const computed = Reaction.create((map) => ({
+        size: map.size,
+        keys: Array.from(map.keys()).sort(),
+        values: Array.from(map.values()).sort()
+      }), [root]);
+
+      const callback = jest.fn();
+      computed.watch(callback);
+
+      // Initial computation
+      const result1 = computed.computeValue();
+      expect(result1.size).toBe(2);
+      expect(result1.keys).toEqual(['key1', 'key2']);
+      expect(result1.values).toEqual(['value1', 'value2']);
+      callback.mockClear();
+
+      // Enable MapSet support
+      enableMapSet();
+
+      // Update map with same content - should not trigger change due to equality
+      mapValue = new Map([['key1', 'value1'], ['key2', 'value2']]);
+      root.markDirty();
+
+      await waitForMicrotasks();
+      expect(callback).not.toHaveBeenCalled(); // Should not trigger due to deep equality
+
+      // Update map with different content - should trigger change
+      mapValue = new Map([['key1', 'value1'], ['key2', 'updated']]);
+      root.markDirty();
+
+      await waitForMicrotasks();
+      expect(callback).toHaveBeenCalledWith({
+        size: 2,
+        keys: ['key1', 'key2'],
+        values: ['updated', 'value1']
+      });
+
+      computed.unwatch(callback);
+
+      // Reset to default equality check
+      setGlobalEqualityCheck(isEqual);
+    });
+
+    it('should work correctly with Set objects after enableMapSet is called', async () => {
+      const { enableMapSet } = await import('../../src/immer-utils');
+      const { setGlobalEqualityCheck, getGlobalEqualityCheck } = await import('../../src/settings');
+      const isEqual = (await import('fast-deep-equal')).default;
+
+      let setValue = new Set(['a', 'b', 'c']);
+      const root = Reaction.create(() => setValue);
+      const computed = Reaction.create((set) => ({
+        size: set.size,
+        values: Array.from(set).sort()
+      }), [root]);
+
+      const callback = jest.fn();
+      computed.watch(callback);
+
+      // Initial computation
+      const result1 = computed.computeValue();
+      expect(result1.size).toBe(3);
+      expect(result1.values).toEqual(['a', 'b', 'c']);
+      callback.mockClear();
+
+      // Enable MapSet support
+      enableMapSet();
+
+      // Update set with same content - should not trigger change
+      setValue = new Set(['a', 'b', 'c']);
+      root.markDirty();
+
+      await waitForMicrotasks();
+      expect(callback).not.toHaveBeenCalled(); // Should not trigger due to deep equality
+
+      // Update set with different content - should trigger change
+      setValue = new Set(['a', 'b', 'd']);
+      root.markDirty();
+
+      await waitForMicrotasks();
+      expect(callback).toHaveBeenCalledWith({
+        size: 3,
+        values: ['a', 'b', 'd']
+      });
+
+      computed.unwatch(callback);
+
+      // Reset to default equality check
+      setGlobalEqualityCheck(isEqual);
+    });
+
+    it('should handle complex nested structures with Maps and Sets', async () => {
+      const { enableMapSet } = await import('../../src/immer-utils');
+      const { setGlobalEqualityCheck, getGlobalEqualityCheck } = await import('../../src/settings');
+      const isEqual = (await import('fast-deep-equal')).default;
+
+      let complexValue = {
+        map: new Map([['users', new Set(['alice', 'bob'])]]),
+        config: { enabled: true }
+      };
+
+      const root = Reaction.create(() => complexValue);
+      const computed = Reaction.create((obj) => ({
+        userCount: obj.map.get('users')?.size || 0,
+        enabled: obj.config.enabled
+      }), [root]);
+
+      const callback = jest.fn();
+      computed.watch(callback);
+
+      // Initial computation
+      const result1 = computed.computeValue();
+      expect(result1.userCount).toBe(2);
+      expect(result1.enabled).toBe(true);
+      callback.mockClear();
+
+      // Enable MapSet support
+      enableMapSet();
+
+      // Update with structurally identical object - should not trigger change
+      complexValue = {
+        map: new Map([['users', new Set(['alice', 'bob'])]]),
+        config: { enabled: true }
+      };
+      root.markDirty();
+
+      await waitForMicrotasks();
+      expect(callback).not.toHaveBeenCalled();
+
+      // Update with different Map content - should trigger change
+      complexValue = {
+        map: new Map([['users', new Set(['alice', 'bob', 'charlie'])]]),
+        config: { enabled: true }
+      };
+      root.markDirty();
+
+      await waitForMicrotasks();
+      expect(callback).toHaveBeenCalledWith({
+        userCount: 3,
+        enabled: true
+      });
+
+      computed.unwatch(callback);
+
+      // Reset to default equality check
+      setGlobalEqualityCheck(isEqual);
+    });
+  });
+
   describe('Custom equality check configuration', () => {
     // Note: Equality checks are only used for COMPUTED reactions (those with dependencies).
     // Root reactions always mark changed=true and don't use equality checks.