@cascateer/core 2.1.19 → 2.1.21

package/package.json

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

package/src/api.ts

@@ -5,11 +5,9 @@ import {
   isEqual,
   isFunction,
   memoize,
-  thru,
 } from "lodash";
 import objectHash from "object-hash";
 import {
-  BehaviorSubject,
   combineLatest,
   filter,
   finalize,
@@ -52,35 +50,27 @@ class Memoizable<Args, Result> {
     this.subscribe = (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 }),
-                ),
-                pending,
-              })),
+          new ProxyObservable((pending) =>
+            this.predicate(args).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 }),
+            ),
           ),
         (args) => objectHash(args ?? null),
       );

package/src/observable/ProxyObservable.ts

@@ -1,46 +1,31 @@
-import { tap, thru } from "lodash";
+import { constant, once, tap } from "lodash";
 import {
+  BehaviorSubject,
   isObservable,
   map,
+  NextObserver,
   Observable,
-  of,
   ReplaySubject,
   scan,
   Subscriber,
   UnaryFunction,
 } from "rxjs";
 
-export interface ProxyObservableDescriptor<T, U> {
-  (target: T):
-    | U
-    | {
-        value: U;
-        pending?: Observable<boolean>;
-      };
-}
-
-export class ProxyObservable<
-  X,
-  Y = X,
-  T extends Observable<X> = Observable<X>,
-> extends Observable<Y> {
+export class ProxyObservable<T> extends Observable<T> {
   pending: Observable<boolean>;
   refCount: Observable<number>;
 
   constructor(
-    target: T,
-    descriptor: ProxyObservableDescriptor<T, Observable<Y>>,
+    target: Observable<T> | ((pending: NextObserver<boolean>) => Observable<T>),
+    pendingFactory?: UnaryFunction<ProxyObservable<T>, Observable<boolean>>,
   ) {
-    const { value, pending = of(false) } = thru(
-      descriptor(target),
-      (descriptor) =>
-        isObservable(descriptor) ? { value: descriptor } : descriptor,
-    );
-
     const subscribers = new ReplaySubject<
-      UnaryFunction<Set<Subscriber<Y>>, void>
+      UnaryFunction<Set<Subscriber<T>>, void>
     >();
 
+    const project = once(isObservable(target) ? constant(target) : target);
+    const pending = new BehaviorSubject(false);
+
     super((subscriber) => {
       subscribers.next((subscribers) => subscribers.add(subscriber));
 
@@ -48,12 +33,14 @@ export class ProxyObservable<
         subscribers.next((subscribers) => subscribers.delete(subscriber)),
       );
 
-      return value.subscribe(subscriber);
+      return project(pending).subscribe(subscriber);
     });
 
+    pendingFactory?.call(null, this).subscribe(pending);
+
     this.pending = pending;
     this.refCount = subscribers.pipe(
-      scan(tap, new Set<Subscriber<Y>>()),
+      scan(tap, new Set<Subscriber<T>>()),
       map((subscribers) => subscribers.size),
     );
   }

package/src/observable/ProxySubject.ts

@@ -1,11 +1,17 @@
-import { Observable, Observer, Subject, Unsubscribable } from "rxjs";
-import { ProxyObservable, ProxyObservableDescriptor } from "./ProxyObservable";
+import { once } from "lodash";
+import {
+  Observable,
+  Observer,
+  Subject,
+  UnaryFunction,
+  Unsubscribable,
+} from "rxjs";
 
-export class ProxySubject<X, Y = X, T extends Subject<X> = Subject<X>>
-  extends ProxyObservable<X, Y, T>
-  implements Observer<X>, Unsubscribable
+export class ProxySubject<T, R = T>
+  extends Observable<R>
+  implements Observer<T>, Unsubscribable
 {
-  next(value: X): void {
+  next(value: T): void {
     this.target.next(value);
   }
 
@@ -22,9 +28,11 @@ export class ProxySubject<X, Y = X, T extends Subject<X> = Subject<X>>
   }
 
   constructor(
-    private target: T,
-    descriptor: ProxyObservableDescriptor<T, Observable<Y>>,
+    private target: Subject<T>,
+    project: UnaryFunction<Observable<T>, Observable<R>>,
   ) {
-    super(target, descriptor);
+    project = once(project);
+
+    super((subscriber) => project(target).subscribe(subscriber));
   }
 }

package/src/observable/Signal.ts

@@ -54,7 +54,7 @@ export class Signal<T> extends ProxyObservable<T> {
     enumerator?: SignalEnumerator<T>;
     reflector?: SignalReflector<T>;
   }) {
-    super(value, identity);
+    super(value);
 
     this.enumerator = enumerator;
     this.reflector = reflector;

package/src/operators/proxyReplaySubject.ts

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

package/src/types.ts

@@ -45,12 +45,11 @@ export class ProxyEffectInterceptor extends ReplaySubject<
       effects,
       (effect) => (args) =>
         tap(
-          new ProxyObservable(effect(args), (target) => ({
-            value: target,
-            pending: combineLatest([target.pending, target.refCount]).pipe(
+          new ProxyObservable(effect(args), (target) =>
+            combineLatest([target.pending, target.refCount]).pipe(
               map((values) => values.every(Boolean)),
             ),
-          })),
+          ),
           (source) => this.next(source),
         ),
     );
@@ -58,9 +57,8 @@ export class ProxyEffectInterceptor extends ReplaySubject<
 
   proxy<Args, Result>(effect: Effect<Args, Result>): ProxyEffect<Args, Result> {
     return (args) =>
-      new ProxyObservable(effect(args), (target) => ({
-        value: target,
-        pending: this.pipe(
+      new ProxyObservable(effect(args), () =>
+        this.pipe(
           distinct(),
           concat(),
           switchMap((sources) =>
@@ -68,7 +66,7 @@ export class ProxyEffectInterceptor extends ReplaySubject<
           ),
           map((values) => values.some(Boolean)),
         ),
-      }));
+      );
   }
 }