Merge pull request #80 from andrewcourtice/feat/skip-history-tracking

Skip history tracking

extensions/history/src/index.ts

@@ -25,6 +25,7 @@ import traceExtension, {
 } from '@harlem/extension-trace';
 
 import {
+    Disposable,
     matchGetFilter,
     numberClamp,
     objectFromPath,
@@ -43,18 +44,35 @@ import type {
 
 export * from './types';
 
-function getOptions(options?: Partial<Options>): Options {
-    return {
+function getMutationGroups(mutations: Options['mutations']) {
+    const hasGroups = typeIsObject(mutations) && 'groups' in mutations;
+    const groups = hasGroups ? mutations.groups : {};
+
+    if (!hasGroups || typeIsMatchable(mutations)) {
+        groups[DEFAULT_GROUP_KEY] = mutations;
+    }
+
+    return Object.entries(groups)
+        .map(([key, matcher]) => {
+            const matchable = typeIsMatchable(matcher) ? matcher : {
+                include: matcher,
+            };
+
+            return {
+                key,
+                filter: matchGetFilter(matchable),
+            };
+        });
+}
+
+export default function historyExtension<TState extends BaseState>(options?: Partial<Options>) {
+    const _options = {
         max: 50,
         mutations: '*',
         ...options,
     };
-}
 
-export default function historyExtension<TState extends BaseState>(options?: Partial<Options>) {
-    const _options = getOptions(options);
     const groups = getMutationGroups(_options.mutations);
-
     const createTraceExtension = traceExtension<TState>({
         autoStart: false,
     });
@@ -90,26 +108,43 @@ export default function historyExtension<TState extends BaseState>(options?: Par
         };
 
         let historyState = createHistoryState();
+        let trackingListener: Disposable | undefined;
 
-        store.on(CORE_EVENTS.mutation.before, (event?: EventPayload<TriggerEventData>) => {
-            if (!event || MUTATION_FILTER.test(event.data.name) || !mutationFilter(event.data.name)) {
-                return;
-            }
+        function startHistoryTracking() {
+            trackingListener ??= store.on(CORE_EVENTS.mutation.before, (event?: EventPayload<TriggerEventData>) => {
+                if (!event || MUTATION_FILTER.test(event.data.name) || !mutationFilter(event.data.name)) {
+                    return;
+                }
 
-            startTrace([
-                'set',
-                'deleteProperty',
-            ]);
+                startTrace([
+                    'set',
+                    'deleteProperty',
+                ]);
 
-            const listener = onTraceResult(result => historyState.results.push(result));
+                const listener = onTraceResult(result => historyState.results.push(result));
 
-            store.once(CORE_EVENTS.mutation.after, () => {
-                stopTrace();
-                processResults(event.data.name);
+                store.once(CORE_EVENTS.mutation.after, () => {
+                    stopTrace();
+                    processResults(event.data.name);
 
-                listener.dispose();
+                    listener.dispose();
+                });
             });
-        });
+        }
+
+        function stopHistoryTracking() {
+            trackingListener = (trackingListener?.dispose(), undefined);
+        }
+
+        function skipHistoryTracking<TResult = void>(callback: () => TResult) {
+            stopHistoryTracking();
+
+            try {
+                return callback();
+            } finally {
+                startHistoryTracking();
+            }
+        }
 
         function applyChange(type: ChangeType, change: MutationTrace) {
             store.write(`extension:history:${type}`, SENDER, state => {
@@ -244,38 +279,21 @@ export default function historyExtension<TState extends BaseState>(options?: Par
         const onHistoryChangeSuccess = getTrigger(EVENTS.change.success);
         const onHistoryChangeError = getTrigger(EVENTS.change.error);
 
+        startHistoryTracking();
+
         return {
             undo,
             redo,
             canUndo,
             canRedo,
             clearHistory,
+            startHistoryTracking,
+            stopHistoryTracking,
+            skipHistoryTracking,
             onBeforeHistoryChange,
             onAfterHistoryChange,
             onHistoryChangeSuccess,
             onHistoryChangeError,
         };
     };
-}
-
-function getMutationGroups(mutations: Options['mutations']) {
-    const hasGroups = typeIsObject(mutations) && 'groups' in mutations;
-    const groups = hasGroups ? mutations.groups : {};
-
-    if (!hasGroups || typeIsMatchable(mutations)) {
-        groups[DEFAULT_GROUP_KEY] = mutations;
-    }
-
-    return Object.entries(groups)
-        .map(([key, matcher]) => {
-            const matchable = typeIsMatchable(matcher) ? matcher : {
-                include: matcher,
-            };
-
-            return {
-                key,
-                filter: matchGetFilter(matchable),
-            };
-        });
-}
-
+}

extensions/history/test/history.test.ts

@@ -187,4 +187,41 @@ describe('History Extension', () => {
         expect(spyFn).toHaveBeenCalledTimes(6);
     });
 
+    test('Can skip history operations', () => {
+        const {
+            store,
+            setUserID,
+            setUserDetails,
+        } = instance;
+
+        const {
+            state,
+            canUndo,
+            skipHistoryTracking,
+            startHistoryTracking,
+            stopHistoryTracking,
+        } = store;
+
+        skipHistoryTracking(() => setUserID(5));
+        expect(state.id).toBe(5);
+        expect(canUndo()).toBe(false);
+
+        setUserID(10);
+        expect(state.id).toBe(10);
+        expect(canUndo()).toBe(true);
+
+        stopHistoryTracking();
+
+        setUserDetails({
+            firstName: 'Michael',
+            lastName: 'Scott',
+        });
+
+        startHistoryTracking();
+
+        expect(state.details.firstName).toBe('Michael');
+        expect(state.details.lastName).toBe('Scott');
+        expect(canUndo('userDetails')).toBe(false);
+    });
+
 });