@cascateer/core 2.0.23 → 2.0.25

package/package.json

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

package/src/api.ts

@@ -8,7 +8,6 @@ import {
 } from "lodash";
 import objectHash from "object-hash";
 import {
-  BehaviorSubject,
   combineLatest,
   filter,
   lastValueFrom,
@@ -18,19 +17,11 @@ import {
   repeat,
   shareReplay,
   Subject,
-  tap,
   UnaryFunction,
 } from "rxjs";
 import { asObservable, ExtendableDictionary, property } from "./lib";
 import { TapObservable } from "./observable";
-import { tapSubscription } from "./operators";
-import {
-  Action,
-  Effect,
-  MaybeArray,
-  MaybeObservable,
-  TapEffect,
-} from "./types";
+import { Action, MaybeArray, MaybeObservable, TapEffect } from "./types";
 
 interface TagsConstructor<Args, Result> {
   (args: Args, result: Result): string[];
@@ -55,35 +46,30 @@ class Memoizable<Args, Result> {
     this.tags = isFunction(tags) ? tags : constant([tags ?? []].flat());
 
     this.subscribe = (invalidatedTags) => {
-      const loading = new BehaviorSubject(false);
-
-      const effect: Effect<Args, Result> = memoize(
+      const memoizedEffect: TapEffect<Args, Result> = memoize(
         (args) =>
-          this.predicate(args).pipe(
-            tapSubscription(loading),
-            tap({
-              complete: () => loading.next(false),
-            }),
-            repeat({
-              delay: () =>
-                combineLatest([
-                  effect(args).pipe(map((result) => this.tags(args, result))),
-                  invalidatedTags,
-                ]).pipe(
-                  filter(([tags, invalidatedTags]) =>
-                    isEqual(tags, intersectionWith(tags, invalidatedTags)),
+          new TapObservable(
+            this.predicate(args).pipe(
+              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 }),
+              }),
+              shareReplay({ bufferSize: 1, refCount: false }),
+            ),
           ),
         (args) => objectHash(args ?? null),
       );
 
-      return memoize(
-        (args) => new TapObservable(effect(args), loading),
-        (args) => objectHash(args ?? null),
-      );
+      return memoizedEffect;
     };
 
     this.share = (invalidatedTags) => (args) =>

package/src/observable/TapObservable.ts

@@ -1,11 +1,4 @@
-import {
-  BehaviorSubject,
-  combineLatest,
-  distinctUntilChanged,
-  map,
-  Observable,
-} from "rxjs";
-import { tapSubscription } from "../operators";
+import { BehaviorSubject, defer, finalize, Observable } from "rxjs";
 import { ProxyObservable } from "./ProxyObservable";
 
 export interface TapObservable<T> {
@@ -13,14 +6,15 @@ export interface TapObservable<T> {
 }
 
 export class TapObservable<T> extends ProxyObservable<T> {
-  constructor(source: Observable<T>, loading: Observable<boolean>) {
-    const subscribed = new BehaviorSubject(false);
+  constructor(source: Observable<T>) {
+    const loading = new BehaviorSubject(false);
 
-    super(source, (source) => source.pipe(tapSubscription(subscribed)));
-
-    this.loading = combineLatest([loading, subscribed]).pipe(
-      map((values) => values.every(Boolean)),
-      distinctUntilChanged(),
+    super(source, (source) =>
+      defer(() => (loading.next(true), source)).pipe(
+        finalize(() => loading.next(false)),
+      ),
     );
+
+    this.loading = loading;
   }
 }

package/src/store.ts

@@ -1,9 +1,8 @@
-import { constant, Dictionary, mapValues, memoize, tap, thru } from "lodash";
+import { constant, Dictionary, mapValues, tap, thru } from "lodash";
 import {
   identity,
   merge,
   mergeMap,
-  NextObserver,
   Observable,
   ReplaySubject,
   shareReplay,
@@ -33,11 +32,8 @@ export type StoreEffects<Signals extends Dictionary<ComputedSignal<any>>> = {
 
 export const asStoreEffects = <Signals extends Dictionary<ComputedSignal<any>>>(
   signals: Signals,
-  observer?: NextObserver<Signal<any>>,
 ): StoreEffects<Signals> =>
-  mapValues(signals, (signal) =>
-    memoize(() => tap(signal.clone(), (value) => observer?.next(value))),
-  );
+  mapValues(signals, (signal) => () => signal.clone());
 
 export class StoreAdapter<
   Signals extends Dictionary<ComputedSignal<any>>,

package/src/terminal.ts

@@ -1,11 +1,10 @@
 import { Dictionary, thru } from "lodash";
-import { combineLatest, distinct, map, switchMap, UnaryFunction } from "rxjs";
+import { 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, asTapEffects, Effect, TapEffect, TapEffects } from "./types";
+import { Action, Effect, TapEffect, TapEffects } from "./types";
 
 export interface TerminalEffect<Args, Result> extends TapEffect<Args, Result> {}
 
@@ -75,31 +74,19 @@ export class ExtendableTerminalAdapter<
         (currentEffects) => () =>
           effects({
             effect: (constructor) => {
-              const deps = proxyReplaySubject<TapObservable<any>, boolean>(
-                (deps) =>
-                  deps.pipe(
-                    distinct(),
-                    concat(),
-                    switchMap((dep) =>
-                      combineLatest(dep.map((dep) => dep.loading)),
-                    ),
-                    map((values) => values.some(Boolean)),
-                  ),
-              );
-
               return thru(
                 constructor({
                   store: {
-                    effects: asStoreEffects(this.context.store.signals, deps),
+                    effects: asStoreEffects(this.context.store.signals),
                   },
                   api: {
-                    effects: asTapEffects(this.context.api.effects, deps),
+                    effects: this.context.api.effects,
                   },
                   terminal: {
-                    effects: asTapEffects(currentEffects, deps),
+                    effects: currentEffects,
                   },
                 }),
-                (effect) => (args) => new TapObservable(effect(args), deps),
+                (effect) => (args) => new TapObservable(effect(args)),
               );
             },
           }),

package/src/types.ts

@@ -1,7 +1,7 @@
-import { Dictionary, mapValues, memoize, tap } from "lodash";
+import { Dictionary } from "lodash";
 import { UnaryFunction } from "rxjs";
 import { Observable } from "rxjs/internal/Observable";
-import { NextObserver, ObservableInput } from "rxjs/internal/types";
+import { ObservableInput } from "rxjs/internal/types";
 import { TapObservable } from "./observable";
 
 export interface Effect<Args, Result> extends UnaryFunction<
@@ -27,14 +27,6 @@ export type TapEffects<Effects extends Dictionary<TapEffect<any, any>>> = {
   >;
 };
 
-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>