@cascateer/core 2.4.15 → 2.4.17

package/.vscode/settings.json

@@ -0,0 +1,4 @@
+{
+  "workbench.editor.customLabels.enabled": true,
+  "eslint.rules.customizations": [{ "rule": "*", "severity": "warn" }]
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@cascateer/core",
-  "version": "2.4.15",
+  "version": "2.4.17",
   "repository": {
     "type": "git",
     "url": "git+https://github.com/cascateer/core.git"
@@ -28,7 +28,7 @@
     "vitest": "^4.1.9"
   },
   "dependencies": {
-    "@cascateer/lib": "^1.0.9",
+    "@cascateer/lib": "^1.0.21",
     "lodash": "^4.18.1",
     "object-hash": "^3.0.0",
     "rxjs": "^7.8.2",

package/src/fragment.ts

@@ -1,5 +1,5 @@
 import { asArray, asObservable } from "@cascateer/lib";
-import { flatMap } from "@cascateer/lib/operators";
+import { flatMap } from "@cascateer/lib/observables";
 import { tap } from "lodash";
 import {
   combineLatest,

package/src/jsx-runtime.ts

@@ -6,6 +6,7 @@ import {
   MaybeObservable,
   MaybeObservableInputTuple,
 } from "@cascateer/lib";
+import { chain } from "@cascateer/lib/observables";
 import { bind, camelCase, isFunction, isObject } from "lodash";
 import React, { CSSProperties } from "react";
 import {
@@ -17,7 +18,6 @@ import {
   UnaryFunction,
 } from "rxjs";
 import { Leaf, ObservableFragment } from "./fragment";
-import { sequence } from "./operators";
 
 type DocumentEventListener<EventName extends keyof DocumentEventMap> =
   | Partial<Observer<DocumentEventMap[EventName]>>
@@ -151,7 +151,7 @@ export const createElement = (
                     ),
                   )
                     .pipe(
-                      sequence(([style], [previousStyle]) => {
+                      chain(([style], [previousStyle]) => {
                         if (previousStyle != null) {
                           for (const name in previousStyle) {
                             element.style.removeProperty(name);

package/src/multicast.ts

@@ -1,5 +1,5 @@
 import { property } from "@cascateer/lib";
-import { flatMap } from "@cascateer/lib/operators";
+import { chain, flatMap } from "@cascateer/lib/observables";
 import { partition, thru, uniq, uniqBy } from "lodash";
 import {
   distinct,
@@ -19,7 +19,6 @@ import {
   MulticastActionMessage,
   MulticastClientMessage,
   proxyReplaySubject,
-  sequence,
 } from "./operators";
 import { MulticastConnectMessage } from "./operators/multicast";
 
@@ -85,7 +84,7 @@ self.addEventListener("connect", ({ ports }) => {
         flatMap(({ ports, actions }) => (ports.includes(port) ? actions : [])),
         distinct(property("id")),
         filter((message) => !message.sameOrigin || message.origin === port),
-        sequence(([action, previousAction]) =>
+        chain(([action, previousAction]) =>
           action.type === "seedAction"
             ? action
             : { ...action, previousId: previousAction!.id },

package/src/operators/index.ts

@@ -11,5 +11,4 @@ export {
   type MulticastSubject,
 } from "./multicast";
 export { proxyReplaySubject } from "./proxyReplaySubject";
-export { sequence } from "./sequence";
 export { some } from "./some";

package/src/operators/multicast.ts

@@ -70,7 +70,7 @@ export type MulticastClientMessage =
 
 type MulticastMessage = MulticastHostMessage | MulticastClientMessage;
 
-type MulticastMessageConstructor<Message extends MulticastMessage> =
+export type MulticastMessageConstructor<Message extends MulticastMessage> =
   UnaryFunction<Record<"key" | "id", string>, Promise<Message>>;
 
 export interface MulticastSubject extends ProxySubject<

package/src/store.ts

@@ -1,8 +1,7 @@
 import { EndoFunction, ExtendableDictionary } from "@cascateer/lib";
-import { flatMap } from "@cascateer/lib/operators";
-import { constant, Dictionary, mapValues, tap, thru } from "lodash";
+import { chain, flatMap } from "@cascateer/lib/observables";
+import { constant, Dictionary, mapValues, tap } from "lodash";
 import {
-  identity,
   merge,
   mergeMap,
   Observable,
@@ -10,7 +9,12 @@ import {
   shareReplay,
   UnaryFunction,
 } from "rxjs";
-import { MulticastAction, MulticastSubject, sequence } from "./operators";
+import { MulticastAction, MulticastSubject } from "./operators";
+import {
+  MulticastClientMessage,
+  MulticastHostMessage,
+  MulticastMessageConstructor,
+} from "./operators/multicast";
 import { Serializable } from "./serializable";
 import { ComputedSignal, Signal } from "./signal";
 import { Action } from "./types";
@@ -55,19 +59,16 @@ export class ExtendableStoreAdapter<
 
   constructor(
     public context: {
-      transform: UnaryFunction<
-        Promise<string>,
-        {
-          share: UnaryFunction<
-            {
-              args: unknown;
-              callback: UnaryFunction<unknown, void>;
-              sameOrigin?: boolean;
-            },
-            void
-          >;
-          register: UnaryFunction<(args: any) => EndoFunction<any>, void>;
-        }
+      share: UnaryFunction<
+        MulticastMessageConstructor<MulticastClientMessage>,
+        void
+      >;
+      register: UnaryFunction<
+        UnaryFunction<
+          MulticastHostMessage,
+          Promise<MulticastAction<any, "transformAction"> | undefined>
+        >,
+        void
       >;
     },
     private extendableSignals: ExtendableDictionary<
@@ -136,17 +137,47 @@ export class ExtendableStoreAdapter<
                     mapValues(
                       this.extendableSignals.currentValue,
                       (signal) => ({
-                        update: (predicate, config = {}) =>
-                          thru(this.context.transform(key), (transform) => {
-                            transform.register((args) =>
-                              signal.pull(predicate(args)),
+                        update: (predicate, config = {}) => {
+                          const callbacks = new Map<
+                            string,
+                            UnaryFunction<unknown, void>
+                          >();
+
+                          this.context.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) =>
+                              this.context.share(
+                                async ({ id }) => (
+                                  callbacks.set(id, callback),
+                                  {
+                                    id,
+                                    type: "transformAction",
+                                    data: {
+                                      key: await key,
+                                      args: JSON.stringify(args),
+                                    },
+                                    sameOrigin: config.sameOrigin,
+                                  }
+                                ),
+                              ),
                             );
-
-                            return (args) =>
-                              new Promise<unknown>((callback) =>
-                                transform.share({ args, callback, ...config }),
-                              );
-                          }),
+                        },
                       }),
                     ),
                   ),
@@ -177,55 +208,22 @@ export class StoreProvider<Data> extends ExtendableStoreAdapter<
         ),
       );
 
-    const callbacks = new Map<string, UnaryFunction<unknown, void>>();
-
     super(
       {
-        transform: (key) => ({
-          share: ({ args, callback, sameOrigin }) =>
-            actions.next(
-              async ({ id }) => (
-                callbacks.set(id, callback),
-                {
-                  id,
-                  type: "transformAction",
-                  data: {
-                    key: await key,
-                    args: JSON.stringify(args),
-                  },
-                  sameOrigin,
-                }
-              ),
-            ),
-          register: (transform) =>
-            actions
-              .pipe(
-                mergeMap(async (event) => {
-                  if (
-                    event.type === "transformAction" &&
-                    event.data.key === (await key)
-                  ) {
-                    return {
-                      ...event,
-                      predicate: transform(
-                        Serializable.parse(event.data.args ?? null),
-                      ),
-                      callback: callbacks.get(event.id),
-                    };
-                  }
-
-                  return [];
-                }),
-                flatMap(identity),
-              )
-              .subscribe(transformActions),
-        }),
+        share: (action) => actions.next(action),
+        register: (project) =>
+          actions
+            .pipe(
+              mergeMap(project),
+              flatMap((action) => action ?? []),
+            )
+            .subscribe(transformActions),
       },
       new ExtendableDictionary({
         data: new ComputedSignal({
           value: merge(seedActions, transformActions).pipe(
-            sequence<MulticastAction<Data>, Data>(
-              ([action, previousAction], [previousState]) => {
+            chain<MulticastAction<Data>, Data>(
+              ([action, previousAction], previousStates) => {
                 console.log(action);
 
                 if (action.type === "seedAction") {
@@ -234,12 +232,12 @@ export class StoreProvider<Data> extends ExtendableStoreAdapter<
 
                 if (
                   action.previousId !== previousAction?.id ||
-                  previousState == null
+                  !(0 in previousStates)
                 ) {
                   throw new Error();
                 }
 
-                return tap(action.predicate(previousState), (state) =>
+                return tap(action.predicate(previousStates[0]), (state) =>
                   action.callback?.call(null, state),
                 );
               },

package/src/operators/sequence.ts

@@ -1,23 +0,0 @@
-import { map, OperatorFunction, scan } from "rxjs";
-
-export const sequence =
-  <Input, Output>(
-    predicate: (inputs: [Input, ...Input[]], outputs: Output[]) => Output,
-  ): OperatorFunction<Input, Output> =>
-  (source) =>
-    source.pipe(
-      scan(
-        ({ inputs, outputs }, input) => ({
-          inputs: [input],
-          outputs: [predicate([input, ...inputs], outputs)],
-        }),
-        { inputs: new Array<Input>(), outputs: new Array<Output>() },
-      ),
-      map(({ outputs }) => {
-        if (!(0 in outputs)) {
-          throw new Error();
-        }
-
-        return outputs[0];
-      }),
-    );