@cascateer/core 2.4.15 → 2.4.16

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.16",
   "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,5 +1,5 @@
 import { EndoFunction, ExtendableDictionary } from "@cascateer/lib";
-import { flatMap } from "@cascateer/lib/operators";
+import { chain, flatMap } from "@cascateer/lib/observables";
 import { constant, Dictionary, mapValues, tap, thru } from "lodash";
 import {
   identity,
@@ -10,7 +10,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";
@@ -59,14 +64,16 @@ export class ExtendableStoreAdapter<
         Promise<string>,
         {
           share: UnaryFunction<
-            {
-              args: unknown;
-              callback: UnaryFunction<unknown, void>;
-              sameOrigin?: boolean;
-            },
+            MulticastMessageConstructor<MulticastClientMessage>,
+            void
+          >;
+          register: UnaryFunction<
+            UnaryFunction<
+              MulticastHostMessage,
+              Promise<MulticastAction<any, "transformAction"> | undefined>
+            >,
             void
           >;
-          register: UnaryFunction<(args: any) => EndoFunction<any>, void>;
         }
       >;
     },
@@ -138,13 +145,46 @@ export class ExtendableStoreAdapter<
                       (signal) => ({
                         update: (predicate, config = {}) =>
                           thru(this.context.transform(key), (transform) => {
-                            transform.register((args) =>
-                              signal.pull(predicate(args)),
-                            );
+                            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({ args, callback, ...config }),
+                                transform.share(
+                                  async ({ id }) => (
+                                    callbacks.set(id, callback),
+                                    {
+                                      id,
+                                      type: "transformAction",
+                                      data: {
+                                        key: await key,
+                                        args: JSON.stringify(args),
+                                      },
+                                      sameOrigin: config.sameOrigin,
+                                    }
+                                  ),
+                                ),
                               );
                           }),
                       }),
@@ -182,40 +222,13 @@ export class StoreProvider<Data> extends ExtendableStoreAdapter<
     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) =>
+          share: (messageConstructor) => actions.next(messageConstructor),
+          register: (project) =>
             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 [];
-                }),
+                mergeMap((event) =>
+                  project(event).then((action) => action ?? []),
+                ),
                 flatMap(identity),
               )
               .subscribe(transformActions),
@@ -224,8 +237,8 @@ export class StoreProvider<Data> extends ExtendableStoreAdapter<
       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 +247,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];
-      }),
-    );