@cascateer/core 2.4.32 → 2.4.34

package/package.json

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

package/src/jsx-runtime.ts

@@ -6,8 +6,8 @@ import {
   MaybeObservable,
   MaybeObservableInputTuple,
 } from "@cascateer/lib";
-import { chain } from "@cascateer/lib/observables";
-import { bind, camelCase, isFunction, isObject } from "lodash";
+import { reduce } from "@cascateer/lib/observables";
+import { bind, camelCase, Dictionary, isFunction, isObject } from "lodash";
 import React, { CSSProperties } from "react";
 import {
   combineLatest,
@@ -139,6 +139,17 @@ export const createElement = (
                 );
               } else if (name === "style") {
                 if (isObject(propertyValue)) {
+                  const assignStyles = (
+                    target: CSSStyleDeclaration,
+                    source: Dictionary<unknown>,
+                  ) => {
+                    for (const [name, value] of Object.entries(source)) {
+                      target.setProperty(name, String(value));
+                    }
+
+                    return source;
+                  };
+
                   combineLatest(
                     Object.entries(propertyValue).reduce<
                       ObservableInputTuple<Record<string, unknown>>
@@ -151,19 +162,16 @@ export const createElement = (
                     ),
                   )
                     .pipe(
-                      chain(([style], [previousStyle]) => {
-                        if (previousStyle != null) {
+                      reduce(
+                        (previousStyle, style) => {
                           for (const name in previousStyle) {
                             element.style.removeProperty(name);
                           }
-                        }
 
-                        for (const [name, value] of Object.entries(style)) {
-                          element.style.setProperty(name, String(value));
-                        }
-
-                        return style;
-                      }),
+                          return assignStyles(element.style, style);
+                        },
+                        (style) => assignStyles(element.style, style),
+                      ),
                     )
                     .subscribe();
                 }

package/src/multicast.ts

@@ -1,6 +1,6 @@
 import { property } from "@cascateer/lib";
 import { flatMap, reduce } from "@cascateer/lib/observables";
-import { partition, thru, uniq, uniqBy } from "lodash";
+import { partition, tap, thru, uniq, uniqBy } from "lodash";
 import {
   distinct,
   filter,
@@ -20,7 +20,11 @@ import {
   MulticastClientMessage,
   proxyReplaySubject,
 } from "./operators";
-import { MulticastConnectMessage } from "./operators/multicast";
+import {
+  assertIsMulticastSeedActionMessage,
+  isMulticastSeedActionMessage,
+  MulticastConnectMessage,
+} from "./operators/multicast";
 
 declare var self: ServiceWorkerGlobalScope;
 
@@ -86,14 +90,10 @@ self.addEventListener("connect", ({ ports }) => {
         filter((message) => !message.sameOrigin || message.origin === port),
         reduce(
           ({ id: previousId }, action) =>
-            action.type === "seedAction" ? action : { ...action, previousId },
-          (action) => {
-            if (action.type === "seedAction") {
-              return action;
-            }
-
-            throw new Error();
-          },
+            isMulticastSeedActionMessage(action)
+              ? action
+              : { ...action, previousId },
+          (action) => tap(action, assertIsMulticastSeedActionMessage),
         ),
         map(({ origin, ...message }) => message),
         exchangeWith<MulticastClientMessage, MulticastActionMessage<any>>(port),

package/src/operators/multicast.ts

@@ -6,7 +6,7 @@ import { ComputedSignal } from "../signal";
 import { exchangeWith } from "./exchangeWith";
 import { proxyReplaySubject } from "./proxyReplaySubject";
 
-interface MulticastBaseMessage<Type, Data> {
+interface MulticastBaseMessage<Data, Type> {
   id: string;
   previousId?: string;
   type: Type;
@@ -34,12 +34,25 @@ interface MulticastActions<Data> {
 export type MulticastBaseActionMessage<
   Data,
   Type extends keyof MulticastActions<Data>,
-> = MulticastBaseMessage<Type, MulticastActions<Data>[Type]["data"]>;
+> = MulticastBaseMessage<MulticastActions<Data>[Type]["data"], Type>;
 
 export type MulticastActionMessage<Data> =
   | MulticastBaseActionMessage<Data, "seedAction">
   | MulticastBaseActionMessage<Data, "transformAction">;
 
+export const isMulticastSeedActionMessage = <Data>(
+  action: MulticastActionMessage<Data>,
+): action is MulticastBaseActionMessage<Data, "seedAction"> =>
+  action.type === "seedAction";
+
+export const assertIsMulticastSeedActionMessage = <Data>(
+  action: MulticastActionMessage<Data>,
+): asserts action is MulticastBaseActionMessage<Data, "seedAction"> => {
+  if (!isMulticastSeedActionMessage(action)) {
+    throw new Error();
+  }
+};
+
 export type MulticastAction<
   Data,
   Type extends keyof MulticastActions<Data> = keyof MulticastActions<Data>,
@@ -59,8 +72,8 @@ export interface MulticastConnectMessageData {
 }
 
 export type MulticastConnectMessage = MulticastBaseMessage<
-  "connect",
-  MulticastConnectMessageData
+  MulticastConnectMessageData,
+  "connect"
 >;
 
 export type MulticastHostMessage = MulticastActionMessage<any>;

package/src/store.ts

@@ -7,10 +7,13 @@ import {
   Observable,
   ReplaySubject,
   shareReplay,
+  tap as tapOperator,
   UnaryFunction,
 } from "rxjs";
 import { MulticastAction, MulticastSubject } from "./operators";
 import {
+  assertIsMulticastSeedActionMessage,
+  isMulticastSeedActionMessage,
   MulticastBaseActionMessage,
   MulticastClientMessage,
   MulticastMessageConstructor,
@@ -221,30 +224,26 @@ export class StoreProvider<Data> extends ExtendableStoreAdapter<
       new ExtendableDictionary({
         data: new ComputedSignal({
           value: merge(seedActions, transformActions).pipe(
+            tapOperator((action) => console.log(action)),
             reduce<MulticastAction<Data>, Data>(
               (previousState, action, previousAction) => {
-                console.log(action);
-
-                if (action.type === "seedAction") {
+                if (isMulticastSeedActionMessage(action)) {
                   return action.predicate();
                 }
 
-                if (action.previousId === previousAction?.id) {
-                  return tap(
-                    action.predicate(previousState),
-                    action.callback ?? noop,
-                  );
-                }
-
-                throw new Error();
-              },
-              (action) => {
-                if (action.type === "seedAction") {
-                  return tap(action, console.log).predicate();
+                if (action.previousId !== previousAction?.id) {
+                  throw new Error();
                 }
 
-                throw new Error();
+                return tap(
+                  action.predicate(previousState),
+                  action.callback ?? noop,
+                );
               },
+              (action) => (
+                assertIsMulticastSeedActionMessage(action),
+                action.predicate()
+              ),
             ),
             shareReplay(1),
           ),