@cascateer/core 2.1.30 → 2.1.32

package/package.json

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

package/src/observable/ProxyObservable.ts

@@ -20,14 +20,14 @@ export class ProxyObservable<
 
   constructor(
     target: U | ((pending: NextObserver<boolean>) => U),
-    pendingFactory?: UnaryFunction<U, Observable<boolean>>,
+    handler?: (target: U, receiver: ProxyObservable<T>) => Observable<boolean>,
   ) {
     const subscribers = new ReplaySubject<
       UnaryFunction<Set<Subscriber<T>>, void>
     >();
 
     const pending = new BehaviorSubject(false);
-    const source = once(() =>
+    const memoizedTarget = once(() =>
       isObservable(target) ? target : target(pending),
     );
 
@@ -38,7 +38,7 @@ export class ProxyObservable<
         subscribers.next((subscribers) => subscribers.delete(subscriber)),
       );
 
-      return source().subscribe(subscriber);
+      return memoizedTarget().subscribe(subscriber);
     });
 
     this.pending = pending;
@@ -47,6 +47,6 @@ export class ProxyObservable<
       map((subscribers) => subscribers.size),
     );
 
-    pendingFactory?.call(null, source()).subscribe(pending);
+    handler?.call(null, memoizedTarget(), this).subscribe(pending);
   }
 }

package/src/operators/every.ts

@@ -0,0 +1,4 @@
+import { map, OperatorFunction } from "rxjs";
+
+export const every = (): OperatorFunction<any[], boolean> => (source) =>
+  source.pipe(map((values) => values.every(Boolean)));

package/src/operators/index.ts

@@ -1,4 +1,5 @@
 export { concat } from "./concat";
+export { every } from "./every";
 export { exchangeWith } from "./exchangeWith";
 export { flatMap } from "./flatMap";
 export {
@@ -12,4 +13,4 @@ export {
 } from "./multicast";
 export { proxyReplaySubject } from "./proxyReplaySubject";
 export { sequence } from "./sequence";
-export { tapSubscription } from "./tapSubscription";
+export { some } from "./some";

package/src/operators/some.ts

@@ -0,0 +1,4 @@
+import { map, OperatorFunction } from "rxjs";
+
+export const some = (): OperatorFunction<any[], boolean> => (source) =>
+  source.pipe(map((values) => values.some(Boolean)));

package/src/terminal.ts

@@ -79,24 +79,27 @@ export class ExtendableTerminalAdapter<
   ) {
     return new ExtendableTerminalAdapter(
       this.context,
-      this.extendableEffects.extend((currentEffects) => () => {
-        const interceptor = new ProxyEffectInterceptor();
-        const source = {
-          store: {
-            effects: asStoreEffects(this.context.store.signals),
-          },
-          api: {
-            effects: interceptor.intercept(this.context.api.effects),
-          },
-          terminal: {
-            effects: interceptor.intercept(currentEffects),
-          },
-        };
+      this.extendableEffects.extend(
+        (currentEffects) => () =>
+          effects({
+            effect: (constructor) => {
+              const interceptor = new ProxyEffectInterceptor();
+              const source = {
+                store: {
+                  effects: asStoreEffects(this.context.store.signals),
+                },
+                api: {
+                  effects: interceptor.intercept(this.context.api.effects),
+                },
+                terminal: {
+                  effects: interceptor.intercept(currentEffects),
+                },
+              };
 
-        return effects({
-          effect: (constructor) => interceptor.proxy(constructor(source)),
-        });
-      }),
+              return interceptor.proxy(constructor(source));
+            },
+          }),
+      ),
       this.extendableActions,
     );
   }

package/src/types.ts

@@ -2,7 +2,6 @@ import { Dictionary, mapValues, tap } from "lodash";
 import {
   combineLatest,
   distinct,
-  map,
   ReplaySubject,
   switchMap,
   UnaryFunction,
@@ -11,7 +10,7 @@ import { Observable } from "rxjs/internal/Observable";
 import { ObservableInput } from "rxjs/internal/types";
 import { memoizeHashed } from "./lib";
 import { ProxyObservable } from "./observable";
-import { concat } from "./operators";
+import { concat, every, some } from "./operators";
 
 export interface Effect<Args, Result> extends UnaryFunction<
   Args,
@@ -45,10 +44,8 @@ export class ProxyEffectInterceptor extends ReplaySubject<
     return mapValues(effects, (effect) =>
       memoizeHashed((args) =>
         tap(
-          new ProxyObservable(effect(args), (target) =>
-            combineLatest([target.pending, target.refCount]).pipe(
-              map((values) => values.every(Boolean)),
-            ),
+          new ProxyObservable(effect(args), (target, receiver) =>
+            combineLatest([target.pending, receiver.refCount]).pipe(every()),
           ),
           (source) => this.next(source),
         ),
@@ -65,7 +62,7 @@ export class ProxyEffectInterceptor extends ReplaySubject<
           switchMap((sources) =>
             combineLatest(sources.map((source) => source.pending)),
           ),
-          map((values) => values.some(Boolean)),
+          some(),
         ),
       );
   }

package/src/operators/tapSubscription.ts

@@ -1,14 +0,0 @@
-import { MonoTypeOperatorFunction, NextObserver, tap } from "rxjs";
-
-export const tapSubscription =
-  <T>(observer?: NextObserver<boolean>): MonoTypeOperatorFunction<T> =>
-  (source) => {
-    let subscriptions = 0;
-
-    return source.pipe(
-      tap({
-        subscribe: () => observer?.next(++subscriptions > 0),
-        unsubscribe: () => observer?.next(--subscriptions > 0),
-      }),
-    );
-  };