@cascateer/core 2.4.16 → 2.4.18

package/package.json

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

package/src/operators/multicast.ts

@@ -31,7 +31,7 @@ interface MulticastActions<Data> {
   };
 }
 
-type MulticastBaseActionMessage<
+export type MulticastBaseActionMessage<
   Data,
   Type extends keyof MulticastActions<Data>,
 > = MulticastBaseMessage<Type, MulticastActions<Data>[Type]["data"]>;

package/src/store.ts

@@ -1,8 +1,7 @@
 import { EndoFunction, ExtendableDictionary } from "@cascateer/lib";
 import { chain, flatMap } from "@cascateer/lib/observables";
-import { constant, Dictionary, mapValues, tap, thru } from "lodash";
+import { constant, Dictionary, mapValues, tap } from "lodash";
 import {
-  identity,
   merge,
   mergeMap,
   Observable,
@@ -12,8 +11,8 @@ import {
 } from "rxjs";
 import { MulticastAction, MulticastSubject } from "./operators";
 import {
+  MulticastBaseActionMessage,
   MulticastClientMessage,
-  MulticastHostMessage,
   MulticastMessageConstructor,
 } from "./operators/multicast";
 import { Serializable } from "./serializable";
@@ -59,23 +58,17 @@ export class ExtendableStoreAdapter<
   }
 
   constructor(
-    public context: {
-      transform: UnaryFunction<
-        Promise<string>,
-        {
-          share: UnaryFunction<
-            MulticastMessageConstructor<MulticastClientMessage>,
-            void
-          >;
-          register: UnaryFunction<
-            UnaryFunction<
-              MulticastHostMessage,
-              Promise<MulticastAction<any, "transformAction"> | undefined>
-            >,
-            void
-          >;
-        }
+    public transform: {
+      share: UnaryFunction<
+        MulticastMessageConstructor<MulticastClientMessage>,
+        void
       >;
+      parse: (
+        key: Promise<string>,
+        handler: (
+          action: MulticastBaseActionMessage<any, "transformAction">,
+        ) => Promise<MulticastAction<any, "transformAction"> | undefined>,
+      ) => void;
     },
     private extendableSignals: ExtendableDictionary<
       ComputedSignal<any>,
@@ -95,7 +88,7 @@ export class ExtendableStoreAdapter<
     >,
   ) {
     return new ExtendableStoreAdapter(
-      this.context,
+      this.transform,
       this.extendableSignals.extend(
         (currentSignals) => () =>
           signals({
@@ -131,7 +124,7 @@ export class ExtendableStoreAdapter<
     >,
   ) {
     return new ExtendableStoreAdapter(
-      this.context,
+      this.transform,
       this.extendableSignals,
       this.extendableActions.extend(
         () =>
@@ -143,50 +136,40 @@ export class ExtendableStoreAdapter<
                     mapValues(
                       this.extendableSignals.currentValue,
                       (signal) => ({
-                        update: (predicate, config = {}) =>
-                          thru(this.context.transform(key), (transform) => {
-                            const callbacks = new Map<
-                              string,
-                              UnaryFunction<unknown, void>
-                            >();
-
-                            transform.register(async (event) => {
-                              if (
-                                event.type === "transformAction" &&
-                                event.data.key === (await key)
-                              ) {
-                                return {
-                                  ...event,
-                                  predicate: signal.pull(
-                                    predicate(
-                                      Serializable.parse(
-                                        event.data.args ?? null,
-                                      ),
-                                    ),
-                                  ),
-                                  callback: callbacks.get(event.id),
-                                };
-                              }
-                            });
-
-                            return (args) =>
-                              new Promise<unknown>((callback) =>
-                                transform.share(
-                                  async ({ id }) => (
-                                    callbacks.set(id, callback),
-                                    {
-                                      id,
-                                      type: "transformAction",
-                                      data: {
-                                        key: await key,
-                                        args: JSON.stringify(args),
-                                      },
-                                      sameOrigin: config.sameOrigin,
-                                    }
-                                  ),
+                        update: (predicate, config = {}) => {
+                          const callbacks = new Map<
+                            string,
+                            UnaryFunction<unknown, void>
+                          >();
+
+                          this.transform.parse(key, async (event) => ({
+                            ...event,
+                            predicate: signal.pull(
+                              predicate(
+                                Serializable.parse(event.data.args ?? null),
+                              ),
+                            ),
+                            callback: callbacks.get(event.id),
+                          }));
+
+                          return (args) =>
+                            new Promise<unknown>((callback) =>
+                              this.transform.share(
+                                async ({ id }) => (
+                                  callbacks.set(id, callback),
+                                  {
+                                    id,
+                                    type: "transformAction",
+                                    data: {
+                                      key: await key,
+                                      args: JSON.stringify(args),
+                                    },
+                                    sameOrigin: config.sameOrigin,
+                                  }
                                 ),
-                              );
-                          }),
+                              ),
+                            );
+                        },
                       }),
                     ),
                   ),
@@ -217,22 +200,23 @@ export class StoreProvider<Data> extends ExtendableStoreAdapter<
         ),
       );
 
-    const callbacks = new Map<string, UnaryFunction<unknown, void>>();
-
     super(
       {
-        transform: (key) => ({
-          share: (messageConstructor) => actions.next(messageConstructor),
-          register: (project) =>
-            actions
-              .pipe(
-                mergeMap((event) =>
-                  project(event).then((action) => action ?? []),
-                ),
-                flatMap(identity),
-              )
-              .subscribe(transformActions),
-        }),
+        share: (action) => actions.next(action),
+        parse: (key, handler) =>
+          actions
+            .pipe(
+              mergeMap(async (event) => {
+                if (
+                  event.type === "transformAction" &&
+                  event.data.key === (await key)
+                ) {
+                  return handler(event);
+                }
+              }),
+              flatMap((action) => action ?? []),
+            )
+            .subscribe(transformActions),
       },
       new ExtendableDictionary({
         data: new ComputedSignal({