@cascateer/core 2.0.26 → 2.1.1

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@cascateer/core",
-  "version": "2.0.26",
+  "version": "2.1.1",
   "repository": {
     "type": "git",
     "url": "https://github.com/cascateer/core.git"

package/src/api.ts

@@ -20,8 +20,8 @@ import {
   UnaryFunction,
 } from "rxjs";
 import { asObservable, ExtendableDictionary, property } from "./lib";
-import { TapObservable } from "./observable";
-import { Action, MaybeArray, MaybeObservable, TapEffect } from "./types";
+import { AsyncObservable } from "./observable";
+import { Action, AsyncEffect, MaybeArray, MaybeObservable } from "./types";
 
 interface TagsConstructor<Args, Result> {
   (args: Args, result: Result): string[];
@@ -36,7 +36,7 @@ class Memoizable<Args, Result> {
   predicate: UnaryFunction<Args, Observable<Result>>;
   tags: TagsConstructor<Args, Result>;
 
-  subscribe: UnaryFunction<Observable<string[]>, TapEffect<Args, Result>>;
+  subscribe: UnaryFunction<Observable<string[]>, AsyncEffect<Args, Result>>;
 
   share: UnaryFunction<NextObserver<string[]>, Action<Args, Result>>;
 
@@ -46,9 +46,9 @@ class Memoizable<Args, Result> {
     this.tags = isFunction(tags) ? tags : constant([tags ?? []].flat());
 
     this.subscribe = (invalidatedTags) => {
-      const memoizedEffect: TapEffect<Args, Result> = memoize(
+      const memoizedEffect: AsyncEffect<Args, Result> = memoize(
         (args) =>
-          new TapObservable(
+          new AsyncObservable(
             this.predicate(args).pipe(
               repeat({
                 delay: () =>
@@ -79,7 +79,7 @@ class Memoizable<Args, Result> {
   }
 }
 
-export interface ApiEffect<Args, Result> extends TapEffect<Args, Result> {}
+export interface ApiEffect<Args, Result> extends AsyncEffect<Args, Result> {}
 
 type ApiAdapterPropertyConstructor<Source, Type extends "effect" | "action"> = {
   [T in Type]: <Args, Result>(

package/src/observable/AsyncObservable.ts

@@ -0,0 +1,20 @@
+import { BehaviorSubject, defer, finalize, Observable } from "rxjs";
+import { ProxyObservable } from "./ProxyObservable";
+
+export interface AsyncObservable<T> {
+  pending: Observable<boolean>;
+}
+
+export class AsyncObservable<T> extends ProxyObservable<T> {
+  constructor(source: Observable<T>) {
+    const pending = new BehaviorSubject(false);
+
+    super(source, (source) =>
+      defer(() => (pending.next(true), source)).pipe(
+        finalize(() => pending.next(false)),
+      ),
+    );
+
+    this.pending = pending;
+  }
+}

package/src/observable/ProxyObservable.ts

@@ -1,14 +1,14 @@
 import { once } from "lodash";
 import { Observable } from "rxjs";
 
-export interface ProxyObservableHandler<T> {
-  (target: Observable<T>, receiver: Observable<T>): Observable<T>;
+export interface ProxyObservableHandler<T, U> {
+  (target: Observable<T>): Observable<U>;
 }
 
-export class ProxyObservable<T> extends Observable<T> {
-  constructor(target: Observable<T>, handler: ProxyObservableHandler<T>) {
+export class ProxyObservable<T, U = T> extends Observable<U> {
+  constructor(target: Observable<T>, handler: ProxyObservableHandler<T, U>) {
     handler = once(handler);
 
-    super((subscriber) => handler(target, this).subscribe(subscriber));
+    super((subscriber) => handler(target).subscribe(subscriber));
   }
 }

package/src/observable/ProxySubject.ts

@@ -1,12 +1,8 @@
-import { once } from "lodash";
-import { Observable, Observer, Subject, Unsubscribable } from "rxjs";
-
-export interface ProxySubjectHandler<T, U> {
-  (target: Subject<T>, receiver: Observable<U>): Observable<U>;
-}
+import { Observer, Subject, Unsubscribable } from "rxjs";
+import { ProxyObservable, ProxyObservableHandler } from "./ProxyObservable";
 
 export class ProxySubject<T, U = T>
-  extends Observable<U>
+  extends ProxyObservable<T, U>
   implements Observer<T>, Unsubscribable
 {
   next(value: T): void {
@@ -27,10 +23,8 @@ export class ProxySubject<T, U = T>
 
   constructor(
     private target: Subject<T>,
-    handler: ProxySubjectHandler<T, U>,
+    handler: ProxyObservableHandler<T, U>,
   ) {
-    handler = once(handler);
-
-    super((subscriber) => handler(target, this).subscribe(subscriber));
+    super(target, handler);
   }
 }

package/src/observable/Signal.ts

@@ -1,6 +1,6 @@
 import { clone, identity, isEqual, memoize } from "lodash";
 import { distinctUntilChanged, map, Observable, of, UnaryFunction } from "rxjs";
-import { TapObservable } from ".";
+import { AsyncObservable, ProxyObservable } from ".";
 import {
   asEnumerable,
   EnumerableItem,
@@ -33,8 +33,11 @@ class SignalReflector<T> {
     new SignalReflector((transform) => this.predicate(lift(transform)));
 }
 
-export class Signal<T> extends Observable<T> implements TapObservable<T> {
-  loading = of(false);
+export class Signal<T>
+  extends ProxyObservable<T>
+  implements AsyncObservable<T>
+{
+  pending = of(false);
 
   clone(): Signal<T> {
     return this;
@@ -56,7 +59,7 @@ export class Signal<T> extends Observable<T> implements TapObservable<T> {
     enumerator?: SignalEnumerator<T>;
     reflector?: SignalReflector<T>;
   }) {
-    super((subscriber) => value.subscribe(subscriber));
+    super(value, identity);
 
     this.enumerator = enumerator;
     this.reflector = reflector;

package/src/observable/index.ts

@@ -1,5 +1,5 @@
+export { AsyncObservable } from "./AsyncObservable";
 export { Future } from "./Future";
 export { ProxyObservable } from "./ProxyObservable";
 export { ProxySubject } from "./ProxySubject";
 export { ComputedSignal, Signal } from "./Signal";
-export { TapObservable } from "./TapObservable";

package/src/operators/proxyReplaySubject.ts

@@ -1,7 +1,7 @@
 import { ReplaySubject } from "rxjs";
 import { ProxySubject } from "../observable";
-import { ProxySubjectHandler } from "../observable/ProxySubject";
+import { ProxyObservableHandler } from "../observable/ProxyObservable";
 
 export const proxyReplaySubject = <T, U = T>(
-  handler: ProxySubjectHandler<T, U>,
+  handler: ProxyObservableHandler<T, U>,
 ) => new ProxySubject<T, U>(new ReplaySubject(), handler);

package/src/terminal.ts

@@ -1,13 +1,21 @@
-import { Dictionary, memoize, thru } from "lodash";
-import objectHash from "object-hash";
+import { Dictionary, thru } from "lodash";
 import { UnaryFunction } from "rxjs";
 import { ApiAdapter, ApiEffect } from "./api";
 import { ExtendableDictionary } from "./lib";
-import { ComputedSignal, TapObservable } from "./observable";
+import { ComputedSignal } from "./observable";
 import { asStoreEffects, StoreAdapter, StoreEffects } from "./store";
-import { Action, Effect, TapEffect, TapEffects } from "./types";
+import {
+  Action,
+  AsyncEffect,
+  AsyncEffectInterceptor,
+  AsyncEffects,
+  Effect,
+} from "./types";
 
-export interface TerminalEffect<Args, Result> extends TapEffect<Args, Result> {}
+export interface TerminalEffect<Args, Result> extends AsyncEffect<
+  Args,
+  Result
+> {}
 
 export class TerminalAdapter<
   Effects extends Dictionary<TerminalEffect<any, any>>,
@@ -56,10 +64,10 @@ export class ExtendableTerminalAdapter<
                 effects: StoreEffects<StoreSignals>;
               };
               api: {
-                effects: TapEffects<ApiEffects>;
+                effects: AsyncEffects<ApiEffects>;
               };
               terminal: {
-                effects: TapEffects<Effects>;
+                effects: AsyncEffects<Effects>;
               };
             },
             Effect<Args, Result>
@@ -75,23 +83,21 @@ export class ExtendableTerminalAdapter<
         (currentEffects) => () =>
           effects({
             effect: (constructor) => {
+              const interceptor = new AsyncEffectInterceptor();
+
               return thru(
                 constructor({
                   store: {
                     effects: asStoreEffects(this.context.store.signals),
                   },
                   api: {
-                    effects: this.context.api.effects,
+                    effects: interceptor.intercept(this.context.api.effects),
                   },
                   terminal: {
-                    effects: currentEffects,
+                    effects: interceptor.intercept(currentEffects),
                   },
                 }),
-                (effect) =>
-                  memoize(
-                    (args) => new TapObservable(effect(args)),
-                    (args) => objectHash(args ?? null),
-                  ),
+                interceptor.toAsyncEffect,
               );
             },
           }),

package/src/types.ts

@@ -1,32 +1,76 @@
-import { Dictionary } from "lodash";
-import { UnaryFunction } from "rxjs";
+import { Dictionary, mapValues, tap } from "lodash";
+import {
+  combineLatest,
+  distinct,
+  identity,
+  map,
+  ReplaySubject,
+  switchMap,
+  UnaryFunction,
+} from "rxjs";
 import { Observable } from "rxjs/internal/Observable";
 import { ObservableInput } from "rxjs/internal/types";
-import { TapObservable } from "./observable";
+import { AsyncObservable, ProxyObservable } from "./observable";
+import { concat } from "./operators";
 
 export interface Effect<Args, Result> extends UnaryFunction<
   Args,
   Observable<Result>
 > {}
 
-export interface TapEffect<Args, Result> extends UnaryFunction<
+export interface AsyncEffect<Args, Result> extends UnaryFunction<
   Args,
-  TapObservable<Result>
+  AsyncObservable<Result>
 > {}
 
-export type TapEffects<Effects extends Dictionary<TapEffect<any, any>>> = {
+export type AsyncEffects<Effects extends Dictionary<AsyncEffect<any, any>>> = {
   [K in keyof Effects]: ReturnType<
     <
-      Args extends Effects[K] extends TapEffect<infer Args, infer _>
+      Args extends Effects[K] extends AsyncEffect<infer Args, infer _>
         ? Args
         : never,
-      Result extends Effects[K] extends TapEffect<infer _, infer Result>
+      Result extends Effects[K] extends AsyncEffect<infer _, infer Result>
         ? Result
         : never,
-    >() => TapEffect<Args, Result>
+    >() => AsyncEffect<Args, Result>
   >;
 };
 
+export class AsyncEffectInterceptor extends ReplaySubject<
+  AsyncObservable<any>
+> {
+  intercept = <Effects extends Dictionary<AsyncEffect<any, any>>>(
+    effects: Effects,
+  ): AsyncEffects<Effects> =>
+    mapValues(
+      effects,
+      (effect) => (args) => tap(effect(args), (source) => this.next(source)),
+    );
+
+  toAsyncEffect =
+    <Args, Result>(effect: Effect<Args, Result>): AsyncEffect<Args, Result> =>
+    (args) =>
+      new (class
+        extends ProxyObservable<Result>
+        implements AsyncObservable<Result>
+      {
+        pending: Observable<boolean>;
+
+        constructor(interceptor: AsyncEffectInterceptor) {
+          super(effect(args), identity);
+
+          this.pending = interceptor.pipe(
+            distinct(),
+            concat(),
+            switchMap((sources) =>
+              combineLatest(sources.map((source) => source.pending)),
+            ),
+            map((values) => values.some(Boolean)),
+          );
+        }
+      })(this);
+}
+
 export interface Action<Args, Result> extends UnaryFunction<
   Args,
   Promise<Result>

package/src/observable/TapObservable.ts

@@ -1,20 +0,0 @@
-import { BehaviorSubject, defer, finalize, Observable } from "rxjs";
-import { ProxyObservable } from "./ProxyObservable";
-
-export interface TapObservable<T> {
-  loading: Observable<boolean>;
-}
-
-export class TapObservable<T> extends ProxyObservable<T> {
-  constructor(source: Observable<T>) {
-    const loading = new BehaviorSubject(false);
-
-    super(source, (source) =>
-      defer(() => (loading.next(true), source)).pipe(
-        finalize(() => loading.next(false)),
-      ),
-    );
-
-    this.loading = loading;
-  }
-}