@cascateer/core 2.0.16 → 2.0.18

package/package.json

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

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

@@ -2,10 +2,13 @@ import { MonoTypeOperatorFunction, NextObserver, tap } from "rxjs";
 
 export const tapSubscription =
   <T>(observer?: NextObserver<boolean>): MonoTypeOperatorFunction<T> =>
-  (source) =>
-    source.pipe(
+  (source) => {
+    let subscriptions = 0;
+
+    return source.pipe(
       tap({
-        subscribe: () => observer?.next(true),
-        unsubscribe: () => observer?.next(false),
+        subscribe: () => observer?.next(++subscriptions > 0),
+        unsubscribe: () => observer?.next(--subscriptions > 0),
       }),
     );
+  };

package/src/terminal.ts

@@ -10,7 +10,7 @@ import {
 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";
 
@@ -103,15 +103,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(