@veams/status-quo 1.1.0 → 1.3.0

package/src/store/__tests__/signal-state-handler.spec.ts

@@ -1,27 +1,40 @@
+import { resetStatusQuoForTests, setupStatusQuo } from '../../config/status-quo-config.js';
 import { SignalStateHandler } from '../signal-state-handler.js';
-
-class TestSignalStateHandler extends SignalStateHandler<
-  { test: string; test2: string },
-  { testAction: () => void }
-> {
-  constructor(withDevTools?: boolean) {
+import type { DistinctOptions } from '../../config/status-quo-config.js';
+
+type TestState = { test: string; test2: string };
+type TestActions = { testAction: () => void };
+type TestSignalHandlerOptions = {
+  withDevTools?: boolean;
+  distinct?: DistinctOptions<TestState>;
+  useDistinctUntilChanged?: boolean;
+};
+
+class TestSignalStateHandler extends SignalStateHandler<TestState, TestActions> {
+  constructor({ withDevTools, distinct, useDistinctUntilChanged }: TestSignalHandlerOptions = {}) {
     super({
       initialState: {
         test: 'testValue',
         test2: 'testValue2',
       },
-      ...(withDevTools && {
-        options: {
+      options: {
+        ...(withDevTools && {
           devTools: {
             enabled: true,
             namespace: 'TestSignalStateHandler',
           },
-        },
-      }),
+        }),
+        ...(distinct && {
+          distinct,
+        }),
+        ...(typeof useDistinctUntilChanged === 'boolean' && {
+          useDistinctUntilChanged,
+        }),
+      },
     });
   }
 
-  getActions(): { testAction: () => void } {
+  getActions(): TestActions {
     return {
       testAction: () => {
         this.setState({ test: 'newValue' });
@@ -34,9 +47,14 @@ describe('Signal State Handler', () => {
   let stateHandler: TestSignalStateHandler;
 
   beforeEach(() => {
+    resetStatusQuoForTests();
     stateHandler = new TestSignalStateHandler();
   });
 
+  afterEach(() => {
+    resetStatusQuoForTests();
+  });
+
   it('should provide initial state', () => {
     expect(stateHandler.getInitialState()).toStrictEqual({
       test: 'testValue',
@@ -94,4 +112,67 @@ describe('Signal State Handler', () => {
 
     expect(spy).toHaveBeenCalledTimes(2);
   });
+
+  it('should respect global distinct setup when disabled', () => {
+    setupStatusQuo({
+      distinct: {
+        enabled: false,
+      },
+    });
+
+    const handler = new TestSignalStateHandler();
+    const spy = jest.fn();
+    const unsubscribe = handler.subscribe(spy);
+
+    handler.setState({ test: 'same' });
+    handler.setState({ test: 'same' });
+
+    unsubscribe();
+
+    expect(spy).toHaveBeenCalledTimes(2);
+  });
+
+  it('should respect global custom distinct comparator from setupStatusQuo', () => {
+    setupStatusQuo({
+      distinct: {
+        comparator: (previous: TestState, next: TestState) => {
+          return previous.test === next.test;
+        },
+      },
+    });
+
+    const handler = new TestSignalStateHandler();
+    const spy = jest.fn();
+    const unsubscribe = handler.subscribe(spy);
+
+    handler.setState({ test2: 'newValue2' });
+    handler.setState({ test: 'newValue' });
+
+    unsubscribe();
+
+    expect(spy).toHaveBeenCalledTimes(1);
+  });
+
+  it('should prefer per-handler distinct options over global setup', () => {
+    setupStatusQuo({
+      distinct: {
+        enabled: false,
+      },
+    });
+
+    const handler = new TestSignalStateHandler({
+      distinct: {
+        enabled: true,
+      },
+    });
+    const spy = jest.fn();
+    const unsubscribe = handler.subscribe(spy);
+
+    handler.setState({ test: 'same' });
+    handler.setState({ test: 'same' });
+
+    unsubscribe();
+
+    expect(spy).toHaveBeenCalledTimes(1);
+  });
 });

package/src/store/index.ts

@@ -1,5 +1,5 @@
 export { BaseStateHandler } from './base-state-handler.js';
 export { ObservableStateHandler } from './observable-state-handler.js';
 export { SignalStateHandler } from './signal-state-handler.js';
-export type { StateSingleton } from './state-singleton.js';
+export type { StateSingleton, StateSingletonOptions } from './state-singleton.js';
 export { makeStateSingleton } from './state-singleton.js';

package/src/store/observable-state-handler.ts

@@ -1,8 +1,10 @@
-import { BehaviorSubject, distinctUntilKeyChanged, map, pipe, distinctUntilChanged } from 'rxjs';
+import { BehaviorSubject, distinctUntilChanged, distinctUntilKeyChanged, map } from 'rxjs';
 
 import { BaseStateHandler } from './base-state-handler.js';
+import { resolveDistinctOptions } from '../config/status-quo-config.js';
 
 import type { Observable } from 'rxjs';
+import type { DistinctOptions } from '../config/status-quo-config.js';
 
 type ObservableStateHandlerProps<S> = {
   initialState: S;
@@ -11,29 +13,21 @@ type ObservableStateHandlerProps<S> = {
       enabled?: boolean;
       namespace: string;
     };
+    distinct?: DistinctOptions<S>;
+    useDistinctUntilChanged?: boolean;
   };
 };
 
 type StateObservableOptions = { useDistinctUntilChanged?: boolean };
 
-function distinctUntilChangedAsJson<T>() {
-  return pipe<Observable<T>, Observable<T>>(
-    distinctUntilChanged((a, b) => {
-      return JSON.stringify(a) === JSON.stringify(b);
-    })
-  );
-}
-
-const pipeMap = {
-  useDistinctUntilChanged: distinctUntilChangedAsJson(),
-};
-
 export abstract class ObservableStateHandler<S, A> extends BaseStateHandler<S, A> {
   private readonly state$: BehaviorSubject<S>;
+  private readonly distinctOptions: ReturnType<typeof resolveDistinctOptions<S>>;
 
   protected constructor({ initialState, options }: ObservableStateHandlerProps<S>) {
     super(initialState);
     this.state$ = new BehaviorSubject<S>(initialState);
+    this.distinctOptions = resolveDistinctOptions(options?.distinct, options?.useDistinctUntilChanged);
     this.initDevTools(options?.devTools);
   }
 
@@ -52,26 +46,30 @@ export abstract class ObservableStateHandler<S, A> extends BaseStateHandler<S, A
     );
   }
 
-  getStateAsObservable(
-    options: StateObservableOptions = {
-      useDistinctUntilChanged: true,
+  getStateAsObservable(options: StateObservableOptions = {}) {
+    const useDistinctUntilChanged =
+      options.useDistinctUntilChanged ?? this.distinctOptions.enabled;
+
+    if (!useDistinctUntilChanged) {
+      return this.state$;
     }
-  ) {
-    // Unfortunately we cannot add pipe operators conditionally in an easy manner.
-    // That's why we use a simple object to attach operators to a new state observable via reduce().
-    // This way we can easily extend our default operators map.
-    return Object.keys(options)
-      .filter((optionKey) => options[optionKey as keyof StateObservableOptions] === true)
-      .map((enabledOptions) => pipeMap[enabledOptions as keyof StateObservableOptions])
-      .reduce((stateObservable$, operator) => {
-        return stateObservable$.pipe(operator) as BehaviorSubject<S>;
-      }, this.state$);
+
+    return this.state$.pipe(
+      distinctUntilChanged((previous, next) => {
+        return this.distinctOptions.comparator(previous, next);
+      })
+    ) as Observable<S>;
   }
 
-  getObservableItem(key: keyof S) {
+  getObservable(key: keyof S) {
     return this.getStateItemAsObservable(key);
   }
 
+  /** @deprecated Use getObservable instead. */
+  getObservableItem(key: keyof S) {
+    return this.getObservable(key);
+  }
+
   subscribe(listener: () => void) {
     let initialized = false;
     const subscription = this.getStateAsObservable().subscribe(() => {

package/src/store/signal-state-handler.ts

@@ -1,8 +1,10 @@
 import { signal } from '@preact/signals-core';
 
 import { BaseStateHandler } from './base-state-handler.js';
+import { resolveDistinctOptions } from '../config/status-quo-config.js';
 
 import type { Signal } from '@preact/signals-core';
+import type { DistinctOptions } from '../config/status-quo-config.js';
 
 type SignalStateHandlerProps<S> = {
   initialState: S;
@@ -11,34 +13,23 @@ type SignalStateHandlerProps<S> = {
       enabled?: boolean;
       namespace: string;
     };
+    distinct?: DistinctOptions<S>;
     useDistinctUntilChanged?: boolean;
   };
 };
 
 type Listener = () => void;
 
-const defaultOptions = {
-  useDistinctUntilChanged: true,
-};
-
-function isEqualAsJson(a: unknown, b: unknown) {
-  return JSON.stringify(a) === JSON.stringify(b);
-}
-
 export abstract class SignalStateHandler<S, A> extends BaseStateHandler<S, A> {
   private readonly state: Signal<S>;
   private readonly listeners = new Map<Listener, S>();
-  private readonly useDistinctUntilChanged: boolean;
+  private readonly distinctOptions: ReturnType<typeof resolveDistinctOptions<S>>;
 
-  protected constructor({ initialState, options = defaultOptions }: SignalStateHandlerProps<S>) {
+  protected constructor({ initialState, options }: SignalStateHandlerProps<S>) {
     super(initialState);
-    const mergedOptions = {
-      ...defaultOptions,
-      ...options,
-    };
 
     this.state = signal<S>(initialState);
-    this.useDistinctUntilChanged = mergedOptions.useDistinctUntilChanged ?? true;
+    this.distinctOptions = resolveDistinctOptions(options?.distinct, options?.useDistinctUntilChanged);
     this.initDevTools(options?.devTools);
   }
 
@@ -65,7 +56,7 @@ export abstract class SignalStateHandler<S, A> extends BaseStateHandler<S, A> {
 
   private notify(nextState: S) {
     for (const [listener, lastSnapshot] of this.listeners.entries()) {
-      if (this.useDistinctUntilChanged && isEqualAsJson(nextState, lastSnapshot)) {
+      if (this.distinctOptions.enabled && this.distinctOptions.comparator(lastSnapshot, nextState)) {
         continue;
       }
 

package/src/store/state-singleton.ts

@@ -4,12 +4,20 @@ export interface StateSingleton<V, A> {
   getInstance: () => StateSubscriptionHandler<V, A>;
 }
 
+export interface StateSingletonOptions {
+  destroyOnNoConsumers?: boolean;
+}
+
 export function makeStateSingleton<S, A>(
-  stateHandlerFactory: () => StateSubscriptionHandler<S, A>
+  stateHandlerFactory: () => StateSubscriptionHandler<S, A>,
+  { destroyOnNoConsumers = true }: StateSingletonOptions = {}
 ): StateSingleton<S, A> {
   let instance: StateSubscriptionHandler<S, A> | null = null;
-
-  return {
+  const singleton: StateSingleton<S, A> & {
+    destroyInstance: () => void;
+    destroyOnNoConsumers: boolean;
+  } = {
+    destroyOnNoConsumers,
     getInstance() {
       if (!instance) {
         instance = stateHandlerFactory();
@@ -17,5 +25,15 @@ export function makeStateSingleton<S, A>(
 
       return instance;
     },
+    destroyInstance() {
+      if (!instance) {
+        return;
+      }
+
+      instance.destroy();
+      instance = null;
+    },
   };
+
+  return singleton;
 }