@cascateer/core 2.1.29 → 2.1.31

package/package.json

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

package/src/api.ts

@@ -4,9 +4,7 @@ import {
   intersectionWith,
   isEqual,
   isFunction,
-  memoize,
 } from "lodash";
-import objectHash from "object-hash";
 import {
   combineLatest,
   filter,
@@ -21,7 +19,12 @@ import {
   tap,
   UnaryFunction,
 } from "rxjs";
-import { asObservable, ExtendableDictionary, property } from "./lib";
+import {
+  asObservable,
+  ExtendableDictionary,
+  memoizeHashed,
+  property,
+} from "./lib";
 import { ProxyObservable } from "./observable";
 import { Action, MaybeArray, MaybeObservable, ProxyEffect } from "./types";
 
@@ -48,7 +51,7 @@ class Memoizable<Args, Result> {
     this.tags = isFunction(tags) ? tags : constant([tags ?? []].flat());
 
     this.subscribe = (invalidatedTags) => {
-      const memoizedEffect: ProxyEffect<Args, Result> = memoize(
+      const memoizedEffect: ProxyEffect<Args, Result> = memoizeHashed(
         (args) =>
           new ProxyObservable((pending) =>
             this.predicate(args).pipe(
@@ -72,7 +75,6 @@ class Memoizable<Args, Result> {
               shareReplay({ bufferSize: 1, refCount: false }),
             ),
           ),
-        (args) => objectHash(args ?? null),
       );
 
       return memoizedEffect;

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/index.ts

@@ -12,4 +12,3 @@ export {
 } from "./multicast";
 export { proxyReplaySubject } from "./proxyReplaySubject";
 export { sequence } from "./sequence";
-export { tapSubscription } from "./tapSubscription";

package/src/types.ts

@@ -1,5 +1,4 @@
-import { Dictionary, mapValues, memoize, tap } from "lodash";
-import objectHash from "object-hash";
+import { Dictionary, mapValues, tap } from "lodash";
 import {
   combineLatest,
   distinct,
@@ -10,6 +9,7 @@ import {
 } from "rxjs";
 import { Observable } from "rxjs/internal/Observable";
 import { ObservableInput } from "rxjs/internal/types";
+import { memoizeHashed } from "./lib";
 import { ProxyObservable } from "./observable";
 import { concat } from "./operators";
 
@@ -43,17 +43,15 @@ export class ProxyEffectInterceptor extends ReplaySubject<
     effects: Effects,
   ): ProxyEffects<Effects> {
     return mapValues(effects, (effect) =>
-      memoize(
-        (args) =>
-          tap(
-            new ProxyObservable(effect(args), (target) =>
-              combineLatest([target.pending, target.refCount]).pipe(
-                map((values) => values.every(Boolean)),
-              ),
+      memoizeHashed((args) =>
+        tap(
+          new ProxyObservable(effect(args), (target, receiver) =>
+            combineLatest([target.pending, receiver.refCount]).pipe(
+              map((values) => values.every(Boolean)),
             ),
-            (source) => this.next(source),
           ),
-        (args) => objectHash(args ?? null),
+          (source) => this.next(source),
+        ),
       ),
     );
   }

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),
-      }),
-    );
-  };