@cascateer/core 2.1.11 → 2.1.13

package/package.json

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

package/src/api.ts

@@ -8,6 +8,7 @@ import {
 } from "lodash";
 import objectHash from "object-hash";
 import {
+  BehaviorSubject,
   combineLatest,
   filter,
   finalize,
@@ -48,26 +49,51 @@ class Memoizable<Args, Result> {
 
     this.subscribe = (invalidatedTags) => {
       const memoizedEffect: AsyncEffect<Args, Result> = memoize(
-        (args) =>
-          new AsyncObservable((complete) =>
-            this.predicate(args).pipe(
-              finalize(() => (console.log("completed"), complete())),
-              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) => {
+          const pending = new BehaviorSubject(false);
+
+          return new (class
+            extends Observable<Result>
+            implements AsyncObservable<Result>
+          {
+            pending: Observable<boolean>;
+
+            constructor(
+              source: Observable<Result>,
+              tags: TagsConstructor<Args, Result>,
+            ) {
+              super(
+                (subscriber) => (
+                  pending.next(true),
+                  source
+                    .pipe(
+                      finalize(() => pending.next(false)),
+                      repeat({
+                        delay: () =>
+                          combineLatest([
+                            memoizedEffect(args).pipe(
+                              map((result) => tags(args, result)),
+                            ),
+                            invalidatedTags,
+                          ]).pipe(
+                            filter(([tags, invalidatedTags]) =>
+                              isEqual(
+                                tags,
+                                intersectionWith(tags, invalidatedTags),
+                              ),
+                            ),
+                          ),
+                      }),
+                      shareReplay({ bufferSize: 1, refCount: false }),
+                    )
+                    .subscribe(subscriber)
+                ),
+              );
+
+              this.pending = pending;
+            }
+          })(this.predicate(args), this.tags);
+        },
         (args) => objectHash(args ?? null),
       );
 

package/src/observable/AsyncObservable.ts

@@ -7,12 +7,13 @@ import {
   Observable,
   UnaryFunction,
 } from "rxjs";
+import { ProxyObservable } from "./ProxyObservable";
 
 export interface AsyncObservable<T> {
   pending: Observable<boolean>;
 }
 
-export class AsyncObservable<T> extends Observable<T> {
+export class AsyncObservable<T> extends ProxyObservable<T> {
   constructor(
     source: Observable<T> | UnaryFunction<() => void, Observable<T>>,
   ) {
@@ -23,10 +24,8 @@ export class AsyncObservable<T> extends Observable<T> {
       source = constant(source);
     }
 
-    super((subscriber) =>
-      defer(() => (pending.next(true), source(complete)))
-        .pipe(finalize(complete))
-        .subscribe(subscriber),
+    super(source(complete), (source) =>
+      defer(() => (pending.next(true), source)).pipe(finalize(complete)),
     );
 
     this.pending = pending;

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,
@@ -43,11 +42,9 @@ export class AsyncEffectInterceptor extends ReplaySubject<
   intercept<Effects extends Dictionary<AsyncEffect<any, any>>>(
     effects: Effects,
   ): AsyncEffects<Effects> {
-    return mapValues(effects, (effect) =>
-      memoize(
-        (args) => tap(effect(args), (source) => this.next(source)),
-        (args) => objectHash(args ?? null),
-      ),
+    return mapValues(
+      effects,
+      (effect) => (args) => tap(effect(args), (source) => this.next(source)),
     );
   }