@cascateer/core 2.1.4 → 2.1.6

package/package.json

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

package/src/api.ts

@@ -10,6 +10,7 @@ import objectHash from "object-hash";
 import {
   combineLatest,
   filter,
+  finalize,
   lastValueFrom,
   map,
   NextObserver,
@@ -17,7 +18,6 @@ import {
   repeat,
   shareReplay,
   Subject,
-  tap,
   UnaryFunction,
 } from "rxjs";
 import { asObservable, ExtendableDictionary, property } from "./lib";
@@ -49,9 +49,9 @@ class Memoizable<Args, Result> {
     this.subscribe = (invalidatedTags) => {
       const memoizedEffect: AsyncEffect<Args, Result> = memoize(
         (args) =>
-          new AsyncObservable(
+          new AsyncObservable((complete) =>
             this.predicate(args).pipe(
-              tap({ complete: () => console.log("complete") }),
+              finalize(complete),
               repeat({
                 delay: () =>
                   combineLatest([

package/src/observable/AsyncObservable.ts

@@ -1,4 +1,12 @@
-import { BehaviorSubject, defer, finalize, Observable } from "rxjs";
+import { constant } from "lodash";
+import {
+  BehaviorSubject,
+  defer,
+  finalize,
+  isObservable,
+  Observable,
+  UnaryFunction,
+} from "rxjs";
 import { ProxyObservable } from "./ProxyObservable";
 
 export interface AsyncObservable<T> {
@@ -6,13 +14,18 @@ export interface AsyncObservable<T> {
 }
 
 export class AsyncObservable<T> extends ProxyObservable<T> {
-  constructor(source: Observable<T>) {
+  constructor(
+    source: Observable<T> | UnaryFunction<() => void, Observable<T>>,
+  ) {
     const pending = new BehaviorSubject(false);
+    const complete = () => pending.next(false);
 
-    super(source, (source) =>
-      defer(() => (pending.next(true), source)).pipe(
-        finalize(() => pending.next(false)),
-      ),
+    if (isObservable(source)) {
+      source = constant(source);
+    }
+
+    super(source(complete), (source) =>
+      defer(() => (pending.next(true), source)).pipe(finalize(complete)),
     );
 
     this.pending = pending;

package/src/terminal.ts

@@ -1,4 +1,4 @@
-import { Dictionary, thru } from "lodash";
+import { Dictionary } from "lodash";
 import { UnaryFunction } from "rxjs";
 import { ApiAdapter, ApiEffect } from "./api";
 import { ExtendableDictionary } from "./lib";
@@ -79,29 +79,25 @@ export class ExtendableTerminalAdapter<
   ) {
     return new ExtendableTerminalAdapter(
       this.context,
-      this.extendableEffects.extend(
-        (currentEffects) => () =>
-          effects({
-            effect: (constructor) => {
-              const interceptor = new AsyncEffectInterceptor();
+      this.extendableEffects.extend((currentEffects) => () => {
+        const interceptor = new AsyncEffectInterceptor();
+        const source = {
+          store: {
+            effects: asStoreEffects(this.context.store.signals),
+          },
+          api: {
+            effects: interceptor.intercept(this.context.api.effects),
+          },
+          terminal: {
+            effects: interceptor.intercept(currentEffects),
+          },
+        };
 
-              return thru(
-                constructor({
-                  store: {
-                    effects: asStoreEffects(this.context.store.signals),
-                  },
-                  api: {
-                    effects: interceptor.intercept(this.context.api.effects),
-                  },
-                  terminal: {
-                    effects: interceptor.intercept(currentEffects),
-                  },
-                }),
-                interceptor.toAsyncEffect,
-              );
-            },
-          }),
-      ),
+        return effects({
+          effect: (constructor) =>
+            interceptor.toAsyncEffect(constructor(source)),
+        });
+      }),
       this.extendableActions,
     );
   }

package/src/types.ts

@@ -39,17 +39,19 @@ export type AsyncEffects<Effects extends Dictionary<AsyncEffect<any, any>>> = {
 export class AsyncEffectInterceptor extends ReplaySubject<
   AsyncObservable<any>
 > {
-  intercept = <Effects extends Dictionary<AsyncEffect<any, any>>>(
+  intercept<Effects extends Dictionary<AsyncEffect<any, any>>>(
     effects: Effects,
-  ): AsyncEffects<Effects> =>
-    mapValues(
+  ): AsyncEffects<Effects> {
+    return mapValues(
       effects,
       (effect) => (args) => tap(effect(args), (source) => this.next(source)),
     );
+  }
 
-  toAsyncEffect =
-    <Args, Result>(effect: Effect<Args, Result>): AsyncEffect<Args, Result> =>
-    (args) =>
+  toAsyncEffect<Args, Result>(
+    effect: Effect<Args, Result>,
+  ): AsyncEffect<Args, Result> {
+    return (args) =>
       new (class
         extends ProxyObservable<Result>
         implements AsyncObservable<Result>
@@ -69,6 +71,7 @@ export class AsyncEffectInterceptor extends ReplaySubject<
           );
         }
       })(this);
+  }
 }
 
 export interface Action<Args, Result> extends UnaryFunction<