@cascateer/core 2.0.17 → 2.0.19

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@cascateer/core",
-  "version": "2.0.17",
+  "version": "2.0.19",
   "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/multicast.ts

@@ -9,7 +9,7 @@ import {
   MulticastActionMessage,
   MulticastClientMessage,
   MulticastConnectMessageData,
-  proxy,
+  proxyReplaySubject,
   sequence,
 } from "./operators";
 
@@ -23,7 +23,7 @@ declare global {
 
 const memoizedSliceActions = memoize(
   <Seed>({ seed }: MulticastConnectMessageData<Seed>) =>
-    proxy<MulticastActionMessage<any>>((actions) =>
+    proxyReplaySubject<MulticastActionMessage<any>>((actions) =>
       actions.pipe(
         startWith({
           id: v4(),
@@ -42,36 +42,37 @@ self.addEventListener("connect", ({ ports }) => {
     thru(
       new Future<Observable<MulticastActionMessage<any>>>(),
       (sliceActions) =>
-        proxy<MulticastActionMessage<any>, MulticastClientMessage>((actions) =>
-          sliceActions.pipe(
-            mergeAll(),
-            flatMap(({ origin, ...message }) =>
-              !message.sameOrigin || origin === port ? message : [],
-            ),
-            sequence(([action, previousAction]) =>
-              action.type === "seedAction"
-                ? action
-                : {
-                    ...action,
-                    previousId: nonNullable(previousAction).id,
-                  },
-            ),
-            exchangeWith<MulticastClientMessage, MulticastActionMessage<any>>(
-              port,
-            ),
-            flatMap((event) => {
-              if (event.type === "connect") {
-                actions.subscribe(
-                  sliceActions.completeWith(memoizedSliceActions(event.data)),
-                );
+        proxyReplaySubject<MulticastActionMessage<any>, MulticastClientMessage>(
+          (actions) =>
+            sliceActions.pipe(
+              mergeAll(),
+              flatMap(({ origin, ...message }) =>
+                !message.sameOrigin || origin === port ? message : [],
+              ),
+              sequence(([action, previousAction]) =>
+                action.type === "seedAction"
+                  ? action
+                  : {
+                      ...action,
+                      previousId: nonNullable(previousAction).id,
+                    },
+              ),
+              exchangeWith<MulticastClientMessage, MulticastActionMessage<any>>(
+                port,
+              ),
+              flatMap((event) => {
+                if (event.type === "connect") {
+                  actions.subscribe(
+                    sliceActions.completeWith(memoizedSliceActions(event.data)),
+                  );
 
-                return [];
-              }
+                  return [];
+                }
 
-              return { ...event, origin: port };
-            }),
-            tap(actions),
-          ),
+                return { ...event, origin: port };
+              }),
+              tap(actions),
+            ),
         ),
     ).subscribe();
   }

package/src/observable/ProxyObservable.ts

@@ -0,0 +1,14 @@
+import { once } from "lodash";
+import { Observable } from "rxjs";
+
+export interface ProxyObservableHandler<T> {
+  (target: Observable<T>, receiver: Observable<T>): Observable<T>;
+}
+
+export class ProxyObservable<T> extends Observable<T> {
+  constructor(target: Observable<T>, handler: ProxyObservableHandler<T>) {
+    handler = once(handler);
+
+    super((subscriber) => handler(target, this).subscribe(subscriber));
+  }
+}

package/src/observable/ProxySubject.ts

@@ -1,11 +1,5 @@
 import { once } from "lodash";
-import {
-  Observable,
-  Observer,
-  ReplaySubject,
-  Subject,
-  Unsubscribable,
-} from "rxjs";
+import { Observable, Observer, Subject, Unsubscribable } from "rxjs";
 
 export interface ProxySubjectHandler<T, U> {
   (target: Subject<T>, receiver: Observable<U>): Observable<U>;
@@ -32,8 +26,8 @@ export class ProxySubject<T, U = T>
   }
 
   constructor(
+    private target: Subject<T>,
     handler: ProxySubjectHandler<T, U>,
-    private target: Subject<T> = new ReplaySubject(),
   ) {
     handler = once(handler);
 

package/src/observable/TapObservable.ts

@@ -1,26 +1,16 @@
-import { once } from "lodash";
-import {
-  BehaviorSubject,
-  combineLatest,
-  map,
-  MonoTypeOperatorFunction,
-  Observable,
-} from "rxjs";
+import { BehaviorSubject, combineLatest, map, Observable } from "rxjs";
 import { tapSubscription } from "../operators";
+import { ProxyObservable } from "./ProxyObservable";
 
-export interface TapObservable<T> extends Observable<T> {
+export interface TapObservable<T> {
   loading: Observable<boolean>;
 }
 
-export class TapObservable<T> extends Observable<T> {
+export class TapObservable<T> extends ProxyObservable<T> {
   constructor(source: Observable<T>, loading: Observable<boolean>) {
     const subscribed = new BehaviorSubject(false);
 
-    const intercept: MonoTypeOperatorFunction<T> = once((source) =>
-      source.pipe(tapSubscription(subscribed)),
-    );
-
-    super((subscriber) => source.pipe(intercept).subscribe(subscriber));
+    super(source, (source) => source.pipe(tapSubscription(subscribed)));
 
     this.loading = combineLatest([loading, subscribed]).pipe(
       map((values) => values.every(Boolean)),

package/src/observable/index.ts

@@ -1,4 +1,5 @@
 export { Future } from "./Future";
+export { ProxyObservable } from "./ProxyObservable";
 export { ProxySubject } from "./ProxySubject";
 export { ComputedSignal, Signal } from "./Signal";
 export { TapObservable } from "./TapObservable";

package/src/operators/index.ts

@@ -10,6 +10,6 @@ export {
   type MulticastHostMessage,
   type MulticastSubject,
 } from "./multicast";
-export { proxy } from "./proxy";
+export { proxyReplaySubject } from "./proxyReplaySubject";
 export { sequence } from "./sequence";
 export { tapSubscription } from "./tapSubscription";

package/src/operators/multicast.ts

@@ -1,7 +1,7 @@
 import { concatMap, shareReplay, startWith, UnaryFunction } from "rxjs";
 import { v4 } from "uuid";
 import { ComputedSignal, ProxySubject } from "../observable";
-import { exchangeWith, proxy } from "../operators";
+import { exchangeWith, proxyReplaySubject } from "../operators";
 import { Transform } from "../types";
 
 interface MulticastBaseMessage<Type, Data> {
@@ -80,7 +80,7 @@ export const multicast = <Seed>(
   key: Promise<string>,
   seed: Seed,
 ): MulticastSubject =>
-  proxy((messages) =>
+  proxyReplaySubject((messages) =>
     messages.pipe(
       startWith(
         ({ key, id }): MulticastConnectMessage => ({

package/src/operators/{proxy.ts → proxyReplaySubject.ts}

@@ -1,8 +1,7 @@
-import { Subject } from "rxjs";
+import { ReplaySubject } from "rxjs";
 import { ProxySubject } from "../observable";
 import { ProxySubjectHandler } from "../observable/ProxySubject";
 
-export const proxy = <T, U = T>(
+export const proxyReplaySubject = <T, U = T>(
   handler: ProxySubjectHandler<T, U>,
-  target?: Subject<T>,
-) => new ProxySubject(handler, target);
+) => new ProxySubject<T, U>(new ReplaySubject(), handler);

package/src/operators/tapSubscription.ts

@@ -8,7 +8,7 @@ export const tapSubscription =
     return source.pipe(
       tap({
         subscribe: () => observer?.next(++subscriptions > 0),
-        unsubscribe: () => observer?.next(--subscriptions === 0),
+        unsubscribe: () => observer?.next(--subscriptions > 0),
       }),
     );
   };

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, proxy } from "./operators";
+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>
@@ -103,15 +75,16 @@ export class ExtendableTerminalAdapter<
         (currentEffects) => () =>
           effects({
             effect: (constructor) => {
-              const deps = proxy<TapObservable<any>, boolean>((deps) =>
-                deps.pipe(
-                  distinct(),
-                  concat(),
-                  switchMap((dep) =>
-                    combineLatest(dep.map((dep) => dep.loading)),
+              const deps = proxyReplaySubject<TapObservable<any>, boolean>(
+                (deps) =>
+                  deps.pipe(
+                    distinct(),
+                    concat(),
+                    switchMap((dep) =>
+                      combineLatest(dep.map((dep) => dep.loading)),
+                    ),
+                    map((values) => values.some(Boolean)),
                   ),
-                  map((values) => values.some(Boolean)),
-                ),
               );
 
               return thru(
@@ -120,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>