feat(state): add provideRxStateConfig function

eneajaho · edbzn · commit 3ee6fda9db63 · 2024-05-18T23:32:41.000+02:00
diff --git a/libs/state/selections/spec/accumulation-observable.spec.ts b/libs/state/selections/spec/accumulation-observable.spec.ts
@@ -1,17 +1,17 @@
 import { TestBed } from '@angular/core/testing';
 import {
-  RX_ACCUMULATOR_FN,
-  createAccumulationObservable,
-  select,
-} from '@rx-angular/state/selections';
-import {
-  PrimitiveState,
   initialPrimitiveState,
   jestMatcher,
+  PrimitiveState,
 } from '@test-helpers/rx-angular';
 import { of, throwError } from 'rxjs';
 import { map } from 'rxjs/operators';
 import { TestScheduler } from 'rxjs/testing';
+import {
+  createAccumulationObservable,
+  RX_ACCUMULATOR_FN,
+} from '../src/lib/accumulation-observable';
+import { select } from '../src/lib/operators';
 
 function setupAccumulationObservable<T extends object>(cfg: {
   initialState?: T;
diff --git a/libs/state/selections/src/lib/accumulation-observable.ts b/libs/state/selections/src/lib/accumulation-observable.ts
@@ -1,3 +1,4 @@
+import { inject, InjectionToken } from '@angular/core';
 import {
   BehaviorSubject,
   ConnectableObservable,
@@ -20,7 +21,6 @@ import {
   withLatestFrom,
 } from 'rxjs/operators';
 import { AccumulationFn, Accumulator } from './model';
-import { inject, InjectionToken } from '@angular/core';
 
 const defaultAccumulator: AccumulationFn = <T>(st: T, sl: Partial<T>): T => {
   return { ...st, ...sl };
@@ -40,36 +40,37 @@ const defaultAccumulator: AccumulationFn = <T>(st: T, sl: Partial<T>): T => {
 export const RX_ACCUMULATOR_FN = new InjectionToken<AccumulationFn>(
   'RX_ACCUMULATOR_FN',
   {
+    providedIn: 'root',
     factory: () => defaultAccumulator,
-  }
+  },
 );
 
 export function createAccumulationObservable<T extends object>(
   stateObservables = new Subject<Observable<Partial<T>>>(),
-  stateSlices = new Subject<Partial<T>>()
+  stateSlices = new Subject<Partial<T>>(),
 ): Accumulator<T> {
   const accumulatorFn = inject(RX_ACCUMULATOR_FN);
   const accumulatorObservable = new BehaviorSubject(accumulatorFn);
   const signal$ = merge(
     stateObservables.pipe(
       distinctUntilChanged(),
       mergeAll(),
-      observeOn(queueScheduler)
+      observeOn(queueScheduler),
     ),
-    stateSlices.pipe(observeOn(queueScheduler))
+    stateSlices.pipe(observeOn(queueScheduler)),
   ).pipe(
     withLatestFrom(accumulatorObservable.pipe(observeOn(queueScheduler))),
     scan(
       (state, [slice, stateAccumulator]) => stateAccumulator(state, slice),
-      {} as T
+      {} as T,
     ),
     tap(
       (newState) => (compositionObservable.state = newState),
-      (error) => console.error(error)
+      (error) => console.error(error),
     ),
     // @Notice We catch the error here as it get lost in between `publish` and `publishReplay`. We return empty to
     catchError((e) => EMPTY),
-    publish()
+    publish(),
   );
   const state$: Observable<T> = signal$.pipe(publishReplay(1));
   const compositionObservable: Accumulator<T> = {
@@ -105,7 +106,7 @@ export function createAccumulationObservable<T extends object>(
       compositionObservable.signal$ as ConnectableObservable<T>
     ).connect();
     sub.add(
-      (compositionObservable.state$ as ConnectableObservable<T>).connect()
+      (compositionObservable.state$ as ConnectableObservable<T>).connect(),
     );
     sub.add(() => {
       accumulatorObservable.complete();
diff --git a/libs/state/src/lib/provide-rx-state-config.ts b/libs/state/src/lib/provide-rx-state-config.ts
@@ -0,0 +1,64 @@
+import { InjectionToken, Provider } from '@angular/core';
+import { AccumulationFn, RX_ACCUMULATOR_FN } from '../../selections/src';
+
+export const enum RX_STATE_CONFIGS {
+  Scheduler,
+  Accumulator,
+}
+
+interface RxStateConfigFn {
+  kind: RX_STATE_CONFIGS;
+  providers: Provider[];
+}
+
+/**
+ * Injection token for the default accumulator function.
+ * @param fn
+ */
+export function withAccumulatorFn(fn: AccumulationFn): RxStateConfigFn {
+  return {
+    kind: RX_STATE_CONFIGS.Accumulator,
+    providers: [{ provide: RX_ACCUMULATOR_FN, useValue: fn }],
+  };
+}
+
+export const RX_STATE_SCHEDULER = new InjectionToken<any>(
+  'RX_STATE_SCHEDULER',
+  {
+    providedIn: 'root',
+    factory: () => undefined,
+  },
+);
+
+/**
+ * Injection token for the default scheduler for rxState.
+ * @param fn
+ */
+export function withScheduler(
+  scheduler: any /* TODO: add type here*/,
+): RxStateConfigFn {
+  return {
+    kind: RX_STATE_CONFIGS.Scheduler,
+    providers: [{ provide: RX_STATE_SCHEDULER, useValue: scheduler }],
+  };
+}
+
+/**
+ * This function is used to provide the configuration for the rxState function.
+ *
+ * You can provide multiple configurations at once.
+ *
+ * You can use these functions to provide the configuration:
+ * - withAccumulatorFn - to provide a custom accumulator function
+ * - withScheduler - to provide a custom scheduler
+ *
+ */
+export function provideRxStateConfig(
+  ...configs: RxStateConfigFn[]
+): Provider[] {
+  return flatten(configs.map((c) => c.providers));
+}
+
+function flatten<T>(arr: T[][]): T[] {
+  return arr.reduce((acc, val) => acc.concat(val), []);
+}
