perf: reduce smosh, organize typings

rx-angular · BioPhoton · Feb 3, 2022 · Feb 3, 2022 · Feb 3, 2022 · Feb 3, 2022
commit 0352d14d68bb18fd32cfe35dbd3f5048b9ac777a
diff --git a/libs/state/selections/spec/smosh.spec.ts b/libs/state/selections/spec/smosh.spec.ts
@@ -104,6 +104,42 @@ describe('createSmoshObservable', () => {
     });
   });
 
+  it('should return observable that emits if only static values are used', () => {
+    testScheduler.run(({ cold, expectObservable }) => {
+      const vm$: Observable<ViewModelTest> = smosh({
+        prop1: i,
+        prop2: b,
+        prop3: t,
+      },        cold('s'))
+      const expected = '(x|)';
+      expectObservable(vm$).toBe(expected, { x });
+    });
+  });
+
+  it('should return observable that emits when all static and observable sources emitted at least once', () => {
+    testScheduler.run(({ cold, expectObservable }) => {
+      const vm$: Observable<ViewModelTest> = smosh({
+        prop1: cold('h-h-i-', { h, i }),
+        prop2: cold('--a-b-', { a, b }),
+        prop3: t,
+      }, cold(      's'))
+      const expected = '----x-';
+      expectObservable(vm$).toBe(expected, { x });
+    });
+  });
+
+  it('should return observable that not emit when all static and observable sources emitted not at least once', () => {
+    testScheduler.run(({ cold, expectObservable }) => {
+      const vm$: Observable<ViewModelTest> = smosh({
+        prop1: cold('h-h-i-', { h, i }),
+        prop2: cold('--a-b-', { a, b }),
+        prop3: undefined,
+      }, cold(      's'))
+      const expected = '----x-';
+      expectObservable(vm$).toBe(expected, { x });
+    });
+  });
+
   it('should return observable that emits when all sources emitted at least once', () => {
     testScheduler.run(({ cold, expectObservable }) => {
       const vm$: Observable<ViewModelTest> = smosh({
@@ -116,6 +152,19 @@ describe('createSmoshObservable', () => {
     });
   });
 
+  it('should return observable that not emit when all sources emitted not at least once', () => {
+    testScheduler.run(({ cold, expectObservable }) => {
+      const vm$: Observable<ViewModelTest> = smosh({
+        prop1: cold('h-h-i-', { h, i }),
+        prop2: cold('--a-b-', { a, b }),
+        prop3: cold('------', { t }),
+      }, cold(      's'))
+      const expected = '------';
+      expectObservable(vm$).toBe(expected);
+    });
+  });
+
+
   it('should emit last for sync values when durationSelector is a Promise', () => {
     testScheduler.run(({ cold, expectObservable }) => {
       const durationSelector = from(Promise.resolve(1));

diff --git a/libs/state/selections/src/lib/smosh.ts b/libs/state/selections/src/lib/smosh.ts
@@ -1,35 +1,15 @@
 import { combineLatest, from, Observable } from 'rxjs';
 import { distinctUntilChanged, filter, map, shareReplay } from 'rxjs/operators';
 
-
 import { Promise } from '@rx-angular/cdk/zone-less/browser';
 import { coalesceWith } from '@rx-angular/cdk/coalescing';
 import { ExtractObservableValue } from '../../../../cdk/internals/core/src/lib/model';
-import { ArrayReducerFn, NotEmpty, ObservableMap, PropName, PropType } from './interfaces';
+import { NotEmpty, ObservableMap } from './interfaces';
+import { coerceObservable } from '@rx-angular/cdk/coercing';
 
 const resolvedPromise = Promise.resolve();
 const resolvedPromise$ = from(resolvedPromise);
 
-/**
- * @internal
- *
- * Used for typing
- */
-function getEntriesToObjectReducerFn<T extends Record<string, any>>(
-  keys: PropName<T>[]
-): ArrayReducerFn<T> {
-  return (
-    accumulator: T,
-    currentValue?: PropType<T>,
-    currentIndex?: number
-  ): T => {
-    return {
-      ...accumulator,
-      [keys[currentIndex]]: currentValue,
-    };
-  };
-}
-
 /**
  * This Observable creation function helps to accumulate an object of key & Observable of values to
  * an Observable of objects of key & value.
@@ -66,15 +46,14 @@ function getEntriesToObjectReducerFn<T extends Record<string, any>>(
  * @param obj - An object of key & Observable values pairs
  * @param durationSelector - An Observable determining the duration for the internal coalescing method
  */
-export function smosh<T extends ObservableMap & NotEmpty<T>>(
-  // @TODO type static or Observable to enable mixing of imperative and reatctive values
+export function smosh<T extends ObservableMap | (Partial<T> & NotEmpty<T>)>(
   obj: T,
   durationSelector: Observable<any> = resolvedPromise$
-): Observable<{ [K in keyof T]: ExtractObservableValue<T[K]> | T[K] }> {
+): Observable<{ [K in keyof T]: ExtractObservableValue<T[K]> }> {
   const keys = Object.keys(obj) as (keyof T)[];
-  // @TODO better typing to enable static values => coerceObservable(obj[key])
   const observables = keys.map((key) =>
-    obj[key].pipe(
+    // turn values, if they are static, into Observables
+    coerceObservable(obj[key]).pipe(
       // we avoid using the nullish operator later ;)
       filter((v) => v !== undefined),
       // state "changes" differ from each other, this operator ensures distinct values
@@ -85,9 +64,13 @@ export function smosh<T extends ObservableMap & NotEmpty<T>>(
     // As combineLatest will emit multiple times for a change in multiple properties we coalesce those emissions together
     coalesceWith(durationSelector),
     // mapping array of values to object
-    map((values) =>
-      values.reduce(getEntriesToObjectReducerFn(keys), {} as any)
-    ),
+    map((values) => {
+      let obj = {} as any;
+      for (let i = 0; i < values.length; i++) {
+        obj[keys[i]] = values[i];
+      }
+      return obj;
+    }),
     // by using shareReplay we share the last composition work done to create the accumulated object
     shareReplay(1)
   );