@cascateer/core 2.1.15 → 2.1.16

package/package.json

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

package/src/api.ts

@@ -55,34 +55,32 @@ class Memoizable<Args, Result> {
           thru(
             new BehaviorSubject(false),
             (pending) =>
-              new ProxyObservable(
-                this.predicate(args),
-                (source) =>
-                  source.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),
-                            ),
+              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 }),
-                  ),
+                      ),
+                  }),
+                  shareReplay({ bufferSize: 1, refCount: false }),
+                ),
                 pending,
-              ),
+              })),
           ),
         (args) => objectHash(args ?? null),
       );

package/src/observable/ProxyObservable.ts

@@ -1,21 +1,33 @@
-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> {
+export class ProxyObservable<
+  X,
+  Y = X,
+  T extends Observable<X> = Observable<X>,
+> extends Observable<Y> {
   pending: Observable<boolean>;
 
   constructor(
-    target: Observable<T>,
-    handler: ProxyObservableHandler<T, U>,
-    pending: Observable<boolean>,
+    target: T,
+    descriptor: ProxyObservableDescriptor<T, Observable<Y>>,
   ) {
-    handler = once(handler);
+    const { value, pending = of(false) } = thru(
+      descriptor(target),
+      (descriptor) =>
+        isObservable(descriptor) ? { value: descriptor } : descriptor,
+    );
 
-    super((subscriber) => handler(target).subscribe(subscriber));
+    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,5 +1,5 @@
 import { clone, identity, isEqual, memoize } from "lodash";
-import { distinctUntilChanged, map, Observable, of, UnaryFunction } from "rxjs";
+import { distinctUntilChanged, map, Observable, UnaryFunction } from "rxjs";
 import { ProxyObservable } from ".";
 import {
   asEnumerable,
@@ -54,7 +54,7 @@ export class Signal<T> extends ProxyObservable<T> {
     enumerator?: SignalEnumerator<T>;
     reflector?: SignalReflector<T>;
   }) {
-    super(value, identity, of(false));
+    super(value, identity);
 
     this.enumerator = enumerator;
     this.reflector = reflector;

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/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,
@@ -11,7 +11,7 @@ import {
 import { Observable } from "rxjs/internal/Observable";
 import { ObservableInput } from "rxjs/internal/types";
 import { ProxyObservable } from "./observable";
-import { concat } from "./operators";
+import { concat, tapSubscription } from "./operators";
 
 export interface Effect<Args, Result> extends UnaryFunction<
   Args,
@@ -44,16 +44,25 @@ export class ProxyEffectInterceptor extends ReplaySubject<
   ): 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)),
+              ),
+            })),
+        ),
     );
   }
 
   proxy<Args, Result>(effect: Effect<Args, Result>): ProxyEffect<Args, Result> {
     return (args) =>
-      new ProxyObservable(
-        effect(args),
-        identity,
-        this.pipe(
+      new ProxyObservable(effect(args), (target) => ({
+        value: target,
+        pending: this.pipe(
           distinct(),
           concat(),
           switchMap((sources) =>
@@ -61,7 +70,7 @@ export class ProxyEffectInterceptor extends ReplaySubject<
           ),
           map((values) => values.some(Boolean)),
         ),
-      );
+      }));
   }
 }