@cascateer/core 2.1.16 → 2.1.18

package/package.json

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

package/src/observable/ProxyObservable.ts

@@ -1,5 +1,14 @@
-import { thru } from "lodash";
-import { isObservable, Observable, of } from "rxjs";
+import { tap, thru } from "lodash";
+import {
+  isObservable,
+  map,
+  Observable,
+  of,
+  scan,
+  Subject,
+  Subscriber,
+  UnaryFunction,
+} from "rxjs";
 
 export interface ProxyObservableDescriptor<T, U> {
   (target: T):
@@ -16,6 +25,7 @@ export class ProxyObservable<
   T extends Observable<X> = Observable<X>,
 > extends Observable<Y> {
   pending: Observable<boolean>;
+  refCount: Observable<number>;
 
   constructor(
     target: T,
@@ -27,8 +37,22 @@ export class ProxyObservable<
         isObservable(descriptor) ? { value: descriptor } : descriptor,
     );
 
-    super((subscriber) => value.subscribe(subscriber));
+    const subscribers = new Subject<UnaryFunction<Set<Subscriber<Y>>, void>>();
+
+    super((subscriber) => {
+      subscribers.next((subscribers) => subscribers.add(subscriber));
+
+      subscriber.add(() =>
+        subscribers.next((subscribers) => subscribers.delete(subscriber)),
+      );
+
+      return value.subscribe(subscriber);
+    });
 
     this.pending = pending;
+    this.refCount = subscribers.pipe(
+      scan(tap, new Set<Subscriber<Y>>()),
+      map((subscribers) => subscribers.size),
+    );
   }
 }

package/src/types.ts

@@ -1,6 +1,5 @@
-import { Dictionary, mapValues, thru } from "lodash";
+import { Dictionary, mapValues, tap } from "lodash";
 import {
-  BehaviorSubject,
   combineLatest,
   distinct,
   map,
@@ -11,7 +10,7 @@ import {
 import { Observable } from "rxjs/internal/Observable";
 import { ObservableInput } from "rxjs/internal/types";
 import { ProxyObservable } from "./observable";
-import { concat, tapSubscription } from "./operators";
+import { concat } from "./operators";
 
 export interface Effect<Args, Result> extends UnaryFunction<
   Args,
@@ -45,15 +44,14 @@ export class ProxyEffectInterceptor extends ReplaySubject<
     return mapValues(
       effects,
       (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)),
-              ),
-            })),
+        tap(
+          new ProxyObservable(effect(args), (target) => ({
+            value: target,
+            pending: combineLatest([target.pending, target.refCount]).pipe(
+              map((values) => values.every(Boolean)),
+            ),
+          })),
+          (source) => this.next(source),
         ),
     );
   }