@cascateer/core 2.1.12 → 2.1.14

package/package.json

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

package/src/api.ts

@@ -8,7 +8,9 @@ import {
 } from "lodash";
 import objectHash from "object-hash";
 import {
+  BehaviorSubject,
   combineLatest,
+  defer,
   filter,
   finalize,
   lastValueFrom,
@@ -48,26 +50,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)),
-                    ),
+        (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) =>
+                defer(
+                  () => (
+                    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 }),
+                    )
                   ),
-              }),
-              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,40 +42,35 @@ 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)),
     );
   }
 
   toAsyncEffect<Args, Result>(
     effect: Effect<Args, Result>,
   ): AsyncEffect<Args, Result> {
-    return memoize(
-      (args) =>
-        new (class
-          extends ProxyObservable<Result>
-          implements AsyncObservable<Result>
-        {
-          pending: Observable<boolean>;
+    return (args) =>
+      new (class
+        extends ProxyObservable<Result>
+        implements AsyncObservable<Result>
+      {
+        pending: Observable<boolean>;
 
-          constructor(interceptor: AsyncEffectInterceptor) {
-            super(effect(args), identity);
+        constructor(interceptor: AsyncEffectInterceptor) {
+          super(effect(args), identity);
 
-            this.pending = interceptor.pipe(
-              distinct(),
-              concat(),
-              switchMap((sources) =>
-                combineLatest(sources.map((source) => source.pending)),
-              ),
-              map((values) => values.some(Boolean)),
-            );
-          }
-        })(this),
-      (args) => objectHash(args ?? null),
-    );
+          this.pending = interceptor.pipe(
+            distinct(),
+            concat(),
+            switchMap((sources) =>
+              combineLatest(sources.map((source) => source.pending)),
+            ),
+            map((values) => values.some(Boolean)),
+          );
+        }
+      })(this);
   }
 }