@cascateer/core 2.0.18 → 2.0.20

package/package.json

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

package/src/api.ts

@@ -56,6 +56,7 @@ class Memoizable<Args, Result> {
 
     this.subscribe = (invalidatedTags) => {
       const loading = new BehaviorSubject(false);
+      console.log(loading);
       const effect: Effect<Args, Result> = memoize(
         (args) =>
           this.predicate(args).pipe(

package/src/component.ts

@@ -130,7 +130,9 @@ export class ExtendableComponentsAdapter<
                   actions: this.context.store.actions,
                 },
                 api: {
-                  effects: this.context.api.effects,
+                  effects:
+                    (console.log(this.context.api.effects),
+                    this.context.api.effects),
                   actions: this.context.api.actions,
                 },
                 terminal: {

package/src/terminal.ts

@@ -1,42 +1,14 @@
-import { Dictionary, mapValues, memoize, tap, thru } from "lodash";
-import {
-  combineLatest,
-  distinct,
-  map,
-  NextObserver,
-  switchMap,
-  UnaryFunction,
-} from "rxjs";
+import { Dictionary, thru } from "lodash";
+import { combineLatest, distinct, map, switchMap, UnaryFunction } from "rxjs";
 import { ApiAdapter, ApiEffect } from "./api";
 import { ExtendableDictionary } from "./lib";
 import { ComputedSignal, TapObservable } from "./observable";
 import { concat, proxyReplaySubject } from "./operators";
 import { asStoreEffects, StoreAdapter, StoreEffects } from "./store";
-import { Action, Effect, TapEffect } from "./types";
+import { Action, asTapEffects, Effect, TapEffect, TapEffects } from "./types";
 
 export interface TerminalEffect<Args, Result> extends TapEffect<Args, Result> {}
 
-type TerminalEffects<Effects extends Dictionary<TapEffect<any, any>>> = {
-  [K in keyof Effects]: ReturnType<
-    <
-      Args extends Effects[K] extends TapEffect<infer Args, infer _>
-        ? Args
-        : never,
-      Result extends Effects[K] extends TapEffect<infer _, infer Result>
-        ? Result
-        : never,
-    >() => TerminalEffect<Args, Result>
-  >;
-};
-
-const asTerminalEffects = <Effects extends Dictionary<TapEffect<any, any>>>(
-  effects: Effects,
-  observer?: NextObserver<TapObservable<any>>,
-): TerminalEffects<Effects> =>
-  mapValues(effects, (effect) =>
-    memoize((args) => tap(effect(args), (value) => observer?.next(value))),
-  );
-
 export class TerminalAdapter<
   Effects extends Dictionary<TerminalEffect<any, any>>,
   Actions extends Dictionary<Action<any, any>>,
@@ -84,10 +56,10 @@ export class ExtendableTerminalAdapter<
                 effects: StoreEffects<StoreSignals>;
               };
               api: {
-                effects: TerminalEffects<ApiEffects>;
+                effects: TapEffects<ApiEffects>;
               };
               terminal: {
-                effects: TerminalEffects<Effects>;
+                effects: TapEffects<Effects>;
               };
             },
             Effect<Args, Result>
@@ -121,10 +93,10 @@ export class ExtendableTerminalAdapter<
                     effects: asStoreEffects(this.context.store.signals, deps),
                   },
                   api: {
-                    effects: asTerminalEffects(this.context.api.effects, deps),
+                    effects: asTapEffects(this.context.api.effects, deps),
                   },
                   terminal: {
-                    effects: asTerminalEffects(currentEffects, deps),
+                    effects: asTapEffects(currentEffects, deps),
                   },
                 }),
                 (effect) => (args) => new TapObservable(effect(args), deps),

package/src/types.ts

@@ -1,6 +1,7 @@
+import { Dictionary, mapValues, memoize, tap } from "lodash";
 import { UnaryFunction } from "rxjs";
 import { Observable } from "rxjs/internal/Observable";
-import { ObservableInput } from "rxjs/internal/types";
+import { NextObserver, ObservableInput } from "rxjs/internal/types";
 import { TapObservable } from "./observable";
 
 export interface Effect<Args, Result> extends UnaryFunction<
@@ -13,6 +14,27 @@ export interface TapEffect<Args, Result> extends UnaryFunction<
   TapObservable<Result>
 > {}
 
+export type TapEffects<Effects extends Dictionary<TapEffect<any, any>>> = {
+  [K in keyof Effects]: ReturnType<
+    <
+      Args extends Effects[K] extends TapEffect<infer Args, infer _>
+        ? Args
+        : never,
+      Result extends Effects[K] extends TapEffect<infer _, infer Result>
+        ? Result
+        : never,
+    >() => TapEffect<Args, Result>
+  >;
+};
+
+export const asTapEffects = <Effects extends Dictionary<TapEffect<any, any>>>(
+  effects: Effects,
+  observer?: NextObserver<TapObservable<any>>,
+): TapEffects<Effects> =>
+  mapValues(effects, (effect) =>
+    memoize((args) => tap(effect(args), (source) => observer?.next(source))),
+  );
+
 export interface Action<Args, Result> extends UnaryFunction<
   Args,
   Promise<Result>