@cascateer/core 2.2.0 → 2.2.2

package/package.json

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

package/src/api.ts

@@ -4,9 +4,7 @@ import {
   intersectionWith,
   isEqual,
   isFunction,
-  memoize,
 } from "lodash";
-import objectHash from "object-hash";
 import {
   combineLatest,
   filter,
@@ -22,6 +20,7 @@ import {
   UnaryFunction,
 } from "rxjs";
 import { asObservable, ExtendableDictionary, property } from "./lib";
+import { memoizeHashed } from "./lib/memoizeHashed";
 import { ProxyObservable } from "./observable";
 import { Action, MaybeArray, MaybeObservable, ProxyEffect } from "./types";
 
@@ -48,7 +47,7 @@ class Memoizable<Args, Result> {
     this.tags = isFunction(tags) ? tags : constant([tags ?? []].flat());
 
     this.subscribe = (invalidatedTags) => {
-      const memoizedEffect: ProxyEffect<Args, Result> = memoize(
+      const memoizedEffect: ProxyEffect<Args, Result> = memoizeHashed(
         (args) =>
           new ProxyObservable((pending) =>
             this.predicate(args).pipe(
@@ -72,7 +71,6 @@ class Memoizable<Args, Result> {
               shareReplay({ bufferSize: 1, refCount: false }),
             ),
           ),
-        (args) => objectHash(args ?? null),
       );
 
       return memoizedEffect;

package/src/lib/memoizeHashed.ts

@@ -0,0 +1,5 @@
+import { memoize } from "lodash";
+import objectHash from "object-hash";
+
+export const memoizeHashed = <T extends (...args: any) => any>(func: T) =>
+  memoize(func, (...args: Parameters<T>) => objectHash(args ?? null));

package/src/multicast.ts

@@ -1,17 +1,25 @@
-import { memoize, thru } from "lodash";
-import { mergeAll, Observable, startWith, tap } from "rxjs";
+import { tap } from "lodash";
+import {
+  combineLatest,
+  groupBy,
+  map,
+  mergeAll,
+  mergeMap,
+  Observable,
+  partition,
+} from "rxjs";
 import { v4 } from "uuid";
-import { nonNullable, property } from "./lib";
-import { Future } from "./observable";
+import { nonNullable } from "./lib";
 import {
+  concatLeft,
   exchangeWith,
   flatMap,
   MulticastActionMessage,
   MulticastClientMessage,
-  MulticastConnectMessageData,
   proxyReplaySubject,
   sequence,
 } from "./operators";
+import { MulticastConnectMessage } from "./operators/multicast";
 
 declare var self: ServiceWorkerGlobalScope;
 
@@ -21,59 +29,73 @@ declare global {
   }
 }
 
-const memoizedSliceActions = memoize(
-  <Seed>({ seed }: MulticastConnectMessageData<Seed>) =>
-    proxyReplaySubject<MulticastActionMessage<any>>((actions) =>
-      actions.pipe(
-        startWith({
-          id: v4(),
-          type: "seedAction" as const,
-          data: {
-            seed,
-          },
-        }),
+const actions = proxyReplaySubject<
+  Observable<[MulticastConnectMessage<any>, MulticastActionMessage<any>]>,
+  {
+    ports: MessagePort[];
+    action: MulticastActionMessage<any>;
+  }
+>((messages) =>
+  messages.pipe(
+    mergeAll(),
+    groupBy(([connect]) => connect.data.key),
+    mergeMap((group) =>
+      group.pipe(
+        flatMap(([connect, action], index) =>
+          index
+            ? action
+            : [
+                {
+                  id: v4(),
+                  type: "seedAction" as const,
+                  data: {
+                    seed: connect.data.seed,
+                  },
+                },
+                action,
+              ],
+        ),
+        concatLeft(),
+        flatMap((actions) =>
+          0 in actions
+            ? {
+                ports: actions.flatMap((action) => action.origin ?? []),
+                action: actions[0],
+              }
+            : [],
+        ),
       ),
     ),
-  property("key"),
+  ),
 );
 
 self.addEventListener("connect", ({ ports }) => {
   for (const port of ports) {
-    thru(
-      new Future<Observable<MulticastActionMessage<any>>>(),
-      (sliceActions) =>
-        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 { ...event, origin: port };
-              }),
-              tap(actions),
-            ),
+    actions
+      .pipe(
+        flatMap(({ ports, action: { origin, ...message } }) =>
+          ports.includes(port) && (!message.sameOrigin || origin === port)
+            ? message
+            : [],
         ),
-    ).subscribe();
+        sequence(([action, previousAction]) =>
+          action.type === "seedAction"
+            ? action
+            : {
+                ...action,
+                previousId: nonNullable(previousAction).id,
+              },
+        ),
+        exchangeWith<MulticastClientMessage, MulticastActionMessage<any>>(port),
+        map((event) => ({ ...event, origin: port })),
+        (messages) =>
+          tap(
+            combineLatest(
+              partition(messages, (message) => message.type === "connect"),
+            ),
+            (sliceActions) => actions.next(sliceActions),
+          ),
+      )
+      .subscribe();
   }
 });

package/src/operators/concatLeft.ts

@@ -0,0 +1,10 @@
+import { map, OperatorFunction } from "rxjs";
+import { concat } from "./concat";
+
+export const concatLeft =
+  <T>(): OperatorFunction<T | T[], T[]> =>
+  (source) =>
+    source.pipe(
+      concat(),
+      map((value) => value.toReversed()),
+    );

package/src/operators/index.ts

@@ -1,4 +1,5 @@
 export { concat } from "./concat";
+export { concatLeft } from "./concatLeft";
 export { every } from "./every";
 export { exchangeWith } from "./exchangeWith";
 export { flatMap } from "./flatMap";

package/src/operators/multicast.ts

@@ -1,8 +1,9 @@
 import { concatMap, shareReplay, startWith, UnaryFunction } from "rxjs";
 import { v4 } from "uuid";
 import { ComputedSignal, ProxySubject } from "../observable";
-import { exchangeWith, proxyReplaySubject } from "../operators";
 import { Transform } from "../types";
+import { exchangeWith } from "./exchangeWith";
+import { proxyReplaySubject } from "./proxyReplaySubject";
 
 interface MulticastBaseMessage<Type, Data> {
   id: string;
@@ -56,7 +57,7 @@ export interface MulticastConnectMessageData<Seed> {
   seed: Seed;
 }
 
-type MulticastConnectMessage<Seed = any> = MulticastBaseMessage<
+export type MulticastConnectMessage<Seed = any> = MulticastBaseMessage<
   "connect",
   MulticastConnectMessageData<Seed>
 >;

package/src/types.ts

@@ -2,6 +2,7 @@ import { Dictionary, mapValues, tap } from "lodash";
 import { combineLatest, ReplaySubject, switchMap, UnaryFunction } from "rxjs";
 import { Observable } from "rxjs/internal/Observable";
 import { ObservableInput } from "rxjs/internal/types";
+import { memoizeHashed } from "./lib/memoizeHashed";
 import { ProxyObservable } from "./observable";
 import { concat, every, some } from "./operators";
 
@@ -34,15 +35,15 @@ export class ProxyEffectInterceptor extends ReplaySubject<
   intercept<Effects extends Dictionary<ProxyEffect<any, any>>>(
     effects: Effects,
   ): ProxyEffects<Effects> {
-    return mapValues(
-      effects,
-      (effect) => (args) =>
+    return mapValues(effects, (effect) =>
+      memoizeHashed((args) =>
         tap(
           new ProxyObservable(effect(args), (target, receiver) =>
             combineLatest([target.pending, receiver.refCount]).pipe(every()),
           ),
           (source) => this.next(source),
         ),
+      ),
     );
   }