@cascateer/core 2.1.14 → 2.1.16

package/package.json

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

package/src/api.ts

@@ -5,12 +5,12 @@ import {
   isEqual,
   isFunction,
   memoize,
+  thru,
 } from "lodash";
 import objectHash from "object-hash";
 import {
   BehaviorSubject,
   combineLatest,
-  defer,
   filter,
   finalize,
   lastValueFrom,
@@ -20,11 +20,12 @@ import {
   repeat,
   shareReplay,
   Subject,
+  tap,
   UnaryFunction,
 } from "rxjs";
 import { asObservable, ExtendableDictionary, property } from "./lib";
-import { AsyncObservable } from "./observable";
-import { Action, AsyncEffect, MaybeArray, MaybeObservable } from "./types";
+import { ProxyObservable } from "./observable";
+import { Action, MaybeArray, MaybeObservable, ProxyEffect } from "./types";
 
 interface TagsConstructor<Args, Result> {
   (args: Args, result: Result): string[];
@@ -39,7 +40,7 @@ class Memoizable<Args, Result> {
   predicate: UnaryFunction<Args, Observable<Result>>;
   tags: TagsConstructor<Args, Result>;
 
-  subscribe: UnaryFunction<Observable<string[]>, AsyncEffect<Args, Result>>;
+  subscribe: UnaryFunction<Observable<string[]>, ProxyEffect<Args, Result>>;
 
   share: UnaryFunction<NextObserver<string[]>, Action<Args, Result>>;
 
@@ -49,52 +50,38 @@ class Memoizable<Args, Result> {
     this.tags = isFunction(tags) ? tags : constant([tags ?? []].flat());
 
     this.subscribe = (invalidatedTags) => {
-      const memoizedEffect: AsyncEffect<Args, Result> = memoize(
-        (args) => {
-          const pending = new BehaviorSubject(false);
-
-          return new (class
-            extends Observable<Result>
-            implements AsyncObservable<Result>
-          {
-            pending: Observable<boolean>;
-
-            constructor(
-              source: Observable<Result>,
-              tags: TagsConstructor<Args, Result>,
-            ) {
-              super((subscriber) =>
-                defer(
-                  () => (
-                    pending.next(true),
-                    source.pipe(
-                      finalize(() => pending.next(false)),
-                      repeat({
-                        delay: () =>
-                          combineLatest([
-                            memoizedEffect(args).pipe(
-                              map((result) => tags(args, result)),
-                            ),
-                            invalidatedTags,
-                          ]).pipe(
-                            filter(([tags, invalidatedTags]) =>
-                              isEqual(
-                                tags,
-                                intersectionWith(tags, invalidatedTags),
-                              ),
-                            ),
+      const memoizedEffect: ProxyEffect<Args, Result> = memoize(
+        (args) =>
+          thru(
+            new BehaviorSubject(false),
+            (pending) =>
+              new ProxyObservable(this.predicate(args), (target) => ({
+                value: target.pipe(
+                  tap({
+                    subscribe: () => pending.next(true),
+                  }),
+                  finalize(() => pending.next(false)),
+                  repeat({
+                    delay: () =>
+                      combineLatest([
+                        memoizedEffect(args).pipe(
+                          map((result) => this.tags(args, result)),
+                        ),
+                        invalidatedTags,
+                      ]).pipe(
+                        filter(([tags, invalidatedTags]) =>
+                          isEqual(
+                            tags,
+                            intersectionWith(tags, invalidatedTags),
                           ),
-                      }),
-                      shareReplay({ bufferSize: 1, refCount: false }),
-                    )
-                  ),
-                ).subscribe(subscriber),
-              );
-
-              this.pending = pending;
-            }
-          })(this.predicate(args), this.tags);
-        },
+                        ),
+                      ),
+                  }),
+                  shareReplay({ bufferSize: 1, refCount: false }),
+                ),
+                pending,
+              })),
+          ),
         (args) => objectHash(args ?? null),
       );
 
@@ -108,7 +95,7 @@ class Memoizable<Args, Result> {
   }
 }
 
-export interface ApiEffect<Args, Result> extends AsyncEffect<Args, Result> {}
+export interface ApiEffect<Args, Result> extends ProxyEffect<Args, Result> {}
 
 type ApiAdapterPropertyConstructor<Source, Type extends "effect" | "action"> = {
   [T in Type]: <Args, Result>(

package/src/observable/ProxyObservable.ts

@@ -1,14 +1,34 @@
-import { once } from "lodash";
-import { Observable } from "rxjs";
+import { thru } from "lodash";
+import { isObservable, Observable, of } from "rxjs";
 
-export interface ProxyObservableHandler<T, U> {
-  (target: Observable<T>): Observable<U>;
+export interface ProxyObservableDescriptor<T, U> {
+  (target: T):
+    | U
+    | {
+        value: U;
+        pending?: Observable<boolean>;
+      };
 }
 
-export class ProxyObservable<T, U = T> extends Observable<U> {
-  constructor(target: Observable<T>, handler: ProxyObservableHandler<T, U>) {
-    handler = once(handler);
+export class ProxyObservable<
+  X,
+  Y = X,
+  T extends Observable<X> = Observable<X>,
+> extends Observable<Y> {
+  pending: Observable<boolean>;
 
-    super((subscriber) => handler(target).subscribe(subscriber));
+  constructor(
+    target: T,
+    descriptor: ProxyObservableDescriptor<T, Observable<Y>>,
+  ) {
+    const { value, pending = of(false) } = thru(
+      descriptor(target),
+      (descriptor) =>
+        isObservable(descriptor) ? { value: descriptor } : descriptor,
+    );
+
+    super((subscriber) => value.subscribe(subscriber));
+
+    this.pending = pending;
   }
 }

package/src/observable/ProxySubject.ts

@@ -1,11 +1,11 @@
-import { Observer, Subject, Unsubscribable } from "rxjs";
-import { ProxyObservable, ProxyObservableHandler } from "./ProxyObservable";
+import { Observable, Observer, Subject, Unsubscribable } from "rxjs";
+import { ProxyObservable, ProxyObservableDescriptor } from "./ProxyObservable";
 
-export class ProxySubject<T, U = T>
-  extends ProxyObservable<T, U>
-  implements Observer<T>, Unsubscribable
+export class ProxySubject<X, Y = X, T extends Subject<X> = Subject<X>>
+  extends ProxyObservable<X, Y, T>
+  implements Observer<X>, Unsubscribable
 {
-  next(value: T): void {
+  next(value: X): void {
     this.target.next(value);
   }
 
@@ -22,9 +22,9 @@ export class ProxySubject<T, U = T>
   }
 
   constructor(
-    private target: Subject<T>,
-    handler: ProxyObservableHandler<T, U>,
+    private target: T,
+    descriptor: ProxyObservableDescriptor<T, Observable<Y>>,
   ) {
-    super(target, handler);
+    super(target, descriptor);
   }
 }

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 { AsyncObservable, ProxyObservable } from ".";
+import { distinctUntilChanged, map, Observable, UnaryFunction } from "rxjs";
+import { ProxyObservable } from ".";
 import {
   asEnumerable,
   EnumerableItem,
@@ -33,12 +33,7 @@ class SignalReflector<T> {
     new SignalReflector((transform) => this.predicate(lift(transform)));
 }
 
-export class Signal<T>
-  extends ProxyObservable<T>
-  implements AsyncObservable<T>
-{
-  pending = of(false);
-
+export class Signal<T> extends ProxyObservable<T> {
   clone(): Signal<T> {
     return this;
   }

package/src/observable/index.ts

@@ -1,4 +1,3 @@
-export { AsyncObservable } from "./AsyncObservable";
 export { Future } from "./Future";
 export { ProxyObservable } from "./ProxyObservable";
 export { ProxySubject } from "./ProxySubject";

package/src/operators/proxyReplaySubject.ts

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

package/src/terminal.ts

@@ -6,13 +6,13 @@ import { ComputedSignal } from "./observable";
 import { asStoreEffects, StoreAdapter, StoreEffects } from "./store";
 import {
   Action,
-  AsyncEffect,
-  AsyncEffectInterceptor,
-  AsyncEffects,
   Effect,
+  ProxyEffect,
+  ProxyEffectInterceptor,
+  ProxyEffects,
 } from "./types";
 
-export interface TerminalEffect<Args, Result> extends AsyncEffect<
+export interface TerminalEffect<Args, Result> extends ProxyEffect<
   Args,
   Result
 > {}
@@ -64,10 +64,10 @@ export class ExtendableTerminalAdapter<
                 effects: StoreEffects<StoreSignals>;
               };
               api: {
-                effects: AsyncEffects<ApiEffects>;
+                effects: ProxyEffects<ApiEffects>;
               };
               terminal: {
-                effects: AsyncEffects<Effects>;
+                effects: ProxyEffects<Effects>;
               };
             },
             Effect<Args, Result>
@@ -80,7 +80,7 @@ export class ExtendableTerminalAdapter<
     return new ExtendableTerminalAdapter(
       this.context,
       this.extendableEffects.extend((currentEffects) => () => {
-        const interceptor = new AsyncEffectInterceptor();
+        const interceptor = new ProxyEffectInterceptor();
         const source = {
           store: {
             effects: asStoreEffects(this.context.store.signals),
@@ -94,8 +94,7 @@ export class ExtendableTerminalAdapter<
         };
 
         return effects({
-          effect: (constructor) =>
-            interceptor.toAsyncEffect(constructor(source)),
+          effect: (constructor) => interceptor.proxy(constructor(source)),
         });
       }),
       this.extendableActions,

package/src/types.ts

@@ -1,8 +1,8 @@
-import { Dictionary, mapValues, tap } from "lodash";
+import { Dictionary, mapValues, thru } from "lodash";
 import {
+  BehaviorSubject,
   combineLatest,
   distinct,
-  identity,
   map,
   ReplaySubject,
   switchMap,
@@ -10,67 +10,67 @@ import {
 } from "rxjs";
 import { Observable } from "rxjs/internal/Observable";
 import { ObservableInput } from "rxjs/internal/types";
-import { AsyncObservable, ProxyObservable } from "./observable";
-import { concat } from "./operators";
+import { ProxyObservable } from "./observable";
+import { concat, tapSubscription } from "./operators";
 
 export interface Effect<Args, Result> extends UnaryFunction<
   Args,
   Observable<Result>
 > {}
 
-export interface AsyncEffect<Args, Result> extends UnaryFunction<
+export interface ProxyEffect<Args, Result> extends UnaryFunction<
   Args,
-  AsyncObservable<Result>
+  ProxyObservable<Result>
 > {}
 
-export type AsyncEffects<Effects extends Dictionary<AsyncEffect<any, any>>> = {
+export type ProxyEffects<Effects extends Dictionary<ProxyEffect<any, any>>> = {
   [K in keyof Effects]: ReturnType<
     <
-      Args extends Effects[K] extends AsyncEffect<infer Args, infer _>
+      Args extends Effects[K] extends ProxyEffect<infer Args, infer _>
         ? Args
         : never,
-      Result extends Effects[K] extends AsyncEffect<infer _, infer Result>
+      Result extends Effects[K] extends ProxyEffect<infer _, infer Result>
         ? Result
         : never,
-    >() => AsyncEffect<Args, Result>
+    >() => ProxyEffect<Args, Result>
   >;
 };
 
-export class AsyncEffectInterceptor extends ReplaySubject<
-  AsyncObservable<any>
+export class ProxyEffectInterceptor extends ReplaySubject<
+  ProxyObservable<any>
 > {
-  intercept<Effects extends Dictionary<AsyncEffect<any, any>>>(
+  intercept<Effects extends Dictionary<ProxyEffect<any, any>>>(
     effects: Effects,
-  ): AsyncEffects<Effects> {
+  ): ProxyEffects<Effects> {
     return mapValues(
       effects,
-      (effect) => (args) => tap(effect(args), (source) => this.next(source)),
+      (effect) => (args) =>
+        thru(
+          new BehaviorSubject(false),
+          (subscribed) =>
+            new ProxyObservable(effect(args), (target) => ({
+              value: target.pipe(tapSubscription(subscribed)),
+              pending: combineLatest([target.pending, subscribed]).pipe(
+                map((values) => values.every(Boolean)),
+              ),
+            })),
+        ),
     );
   }
 
-  toAsyncEffect<Args, Result>(
-    effect: Effect<Args, Result>,
-  ): AsyncEffect<Args, Result> {
+  proxy<Args, Result>(effect: Effect<Args, Result>): ProxyEffect<Args, Result> {
     return (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);
+      new ProxyObservable(effect(args), (target) => ({
+        value: target,
+        pending: this.pipe(
+          distinct(),
+          concat(),
+          switchMap((sources) =>
+            combineLatest(sources.map((source) => source.pending)),
+          ),
+          map((values) => values.some(Boolean)),
+        ),
+      }));
   }
 }
 

package/src/observable/AsyncObservable.ts

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