@cascateer/core 2.0.10 → 2.0.12

package/package.json

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

package/src/fragment.ts

@@ -15,7 +15,7 @@ import {
 import { asArray, asObservable } from "./lib";
 import { flatMap } from "./operators";
 
-export type Primitive =
+export type Leaf =
   | string
   | number
   | bigint
@@ -24,7 +24,7 @@ export type Primitive =
   | null
   | undefined;
 
-const isPrimitive = (value: unknown): value is Primitive =>
+const isLeaf = (value: unknown): value is Leaf =>
   ["string", "number", "bigint", "boolean", "symbol"].includes(typeof value) ||
   value == null;
 
@@ -102,9 +102,7 @@ export class ObservableFragment extends AnchorFragment {
                 element instanceof ObservableFragment
                   ? element.nodes
                   : of(
-                      isPrimitive(element)
-                        ? new Text(element?.toString())
-                        : element,
+                      isLeaf(element) ? new Text(element?.toString()) : element,
                     ),
               ),
               startWith(),

package/src/jsx-runtime.ts

@@ -8,7 +8,7 @@ import {
   Observer,
   UnaryFunction,
 } from "rxjs";
-import { ObservableFragment, Primitive } from "./fragment";
+import { Leaf, ObservableFragment } from "./fragment";
 import { asArray, asObservable, keys } from "./lib";
 import { sequence } from "./operators";
 import {
@@ -23,22 +23,7 @@ type DocumentEventListener<EventName extends keyof DocumentEventMap> =
 
 declare global {
   namespace JSX {
-    type Element = MaybeObservable<Node | Primitive>;
-
-    export type CSSCustomPropertyDefinition = Omit<PropertyDefinition, "name">;
-
-    export type CSSCustomIntegerPropertyDefinition =
-      CSSCustomPropertyDefinition & { syntax: "<integer>" };
-
-    export interface CSSCustomPropertyDefinitions extends Record<
-      keyof {},
-      CSSCustomPropertyDefinition
-    > {}
-
-    type CSSCustomProperties = Record<
-      keyof CSSCustomPropertyDefinitions & `--${string}`,
-      string | number
-    >;
+    type Element = MaybeObservable<Node | Leaf>;
 
     type Children = MaybeObservable<MaybeArray<Element>>;
 
@@ -72,6 +57,21 @@ declare global {
     interface Component<P extends Props = Props> {
       (props: IntrinsicAttributes & P): Element;
     }
+
+    export type CSSCustomPropertyDefinition = Omit<PropertyDefinition, "name">;
+
+    export type CSSCustomIntegerPropertyDefinition =
+      CSSCustomPropertyDefinition & { syntax: "<integer>" };
+
+    export interface CSSCustomPropertyDefinitions extends Record<
+      keyof {},
+      CSSCustomPropertyDefinition
+    > {}
+
+    type CSSCustomProperties = Record<
+      keyof CSSCustomPropertyDefinitions & `--${string}`,
+      string | number
+    >;
   }
 }
 

package/src/multicast.ts

@@ -9,8 +9,8 @@ import {
   MulticastActionMessage,
   MulticastClientMessage,
   MulticastConnectMessageData,
+  proxy,
   sequence,
-  transform,
 } from "./operators";
 
 declare var self: ServiceWorkerGlobalScope;
@@ -21,9 +21,9 @@ declare global {
   }
 }
 
-const sliceActionsSequence = memoize(
+const memoizedSliceActions = memoize(
   <Seed>({ seed }: MulticastConnectMessageData<Seed>) =>
-    transform<MulticastActionMessage<any>>((actions) =>
+    proxy<MulticastActionMessage<any>>((actions) =>
       actions.pipe(
         startWith({
           id: v4(),
@@ -42,37 +42,36 @@ self.addEventListener("connect", ({ ports }) => {
     thru(
       new Future<Observable<MulticastActionMessage<any>>>(),
       (sliceActions) =>
-        transform<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(sliceActionsSequence(event.data)),
-                  );
+        proxy<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 [];
+              }
 
-                return { ...event, origin: port };
-              }),
-              tap(actions),
-            ),
+              return { ...event, origin: port };
+            }),
+            tap(actions),
+          ),
         ),
     ).subscribe();
   }

package/src/observable/{TransformSubject.ts → ProxySubject.ts}

@@ -4,11 +4,14 @@ import {
   Observer,
   ReplaySubject,
   Subject,
-  UnaryFunction,
   Unsubscribable,
 } from "rxjs";
 
-export class TransformSubject<T, U = T>
+export interface ProxySubjectHandler<T, U> {
+  (target: Subject<T>, receiver: Observable<U>): Observable<U>;
+}
+
+export class ProxySubject<T, U = T>
   extends Observable<U>
   implements Observer<T>, Unsubscribable
 {
@@ -29,11 +32,11 @@ export class TransformSubject<T, U = T>
   }
 
   constructor(
-    project: UnaryFunction<Subject<T>, Observable<U>>,
+    handler: ProxySubjectHandler<T, U>,
     private target: Subject<T> = new ReplaySubject(),
   ) {
-    project = once(project);
+    handler = once(handler);
 
-    super((subscriber) => project(target).subscribe(subscriber));
+    super((subscriber) => handler(target, this).subscribe(subscriber));
   }
 }

package/src/observable/Signal.ts

@@ -1,4 +1,4 @@
-import { clone, isEqual, memoize } from "lodash";
+import { clone, identity, isEqual, memoize } from "lodash";
 import { distinctUntilChanged, map, Observable, of, UnaryFunction } from "rxjs";
 import { TapObservable } from ".";
 import {
@@ -22,29 +22,21 @@ class SignalEnumerator<T> {
 
 class SignalReflector<T> {
   constructor(
-    private predicate: (
+    public predicate: (
       transform: Transform<T>,
-      callback: UnaryFunction<Transform<any>, void>,
-    ) => void = (transform, callback) => callback(transform),
+    ) => Transform<unknown> = identity,
   ) {}
 
-  reflect = (transform: Transform<T>) =>
-    new Promise<Transform<unknown>>((callback) =>
-      this.predicate(transform, callback),
-    );
-
-  lift = <U>(
+  reflect = <U>(
     lift: UnaryFunction<Transform<U>, Transform<T>>,
   ): SignalReflector<U> =>
-    new SignalReflector((transform, callback) =>
-      this.predicate(lift(transform), callback),
-    );
+    new SignalReflector((transform) => this.predicate(lift(transform)));
 }
 
 export class Signal<T> extends Observable<T> implements TapObservable<T> {
   loading = of(false);
 
-  capture(): Signal<T> {
+  clone(): Signal<T> {
     return this;
   }
 
@@ -78,7 +70,7 @@ export class Signal<T> extends Observable<T> implements TapObservable<T> {
     return new Signal({
       value: this.pipe(map(project), distinctUntilChanged()),
       enumerator: new SignalEnumerator(enumerate),
-      reflector: this.reflector.lift(lift),
+      reflector: this.reflector.reflect(lift),
     });
   }
 

package/src/observable/index.ts

@@ -1,4 +1,4 @@
 export { Future } from "./Future";
+export { ProxySubject } from "./ProxySubject";
 export { ComputedSignal, Signal } from "./Signal";
 export { TapObservable } from "./TapObservable";
-export { TransformSubject } from "./TransformSubject";

package/src/operators/index.ts

@@ -10,6 +10,6 @@ export {
   type MulticastHostMessage,
   type MulticastSubject,
 } from "./multicast";
+export { proxy } from "./proxy";
 export { sequence } from "./sequence";
 export { tapSubscription } from "./tapSubscription";
-export { transform } from "./transform";

package/src/operators/multicast.ts

@@ -1,7 +1,7 @@
 import { concatMap, shareReplay, startWith, UnaryFunction } from "rxjs";
 import { v4 } from "uuid";
-import { ComputedSignal, TransformSubject } from "../observable";
-import { exchangeWith, transform } from "../operators";
+import { ComputedSignal, ProxySubject } from "../observable";
+import { exchangeWith, proxy } from "../operators";
 import { Transform } from "../types";
 
 interface MulticastBaseMessage<Type, Data> {
@@ -71,7 +71,7 @@ type MulticastMessage = MulticastHostMessage | MulticastClientMessage;
 type MulticastMessageConstructor<Message extends MulticastMessage> =
   UnaryFunction<Record<"key" | "id", string>, Promise<Message>>;
 
-export interface MulticastSubject extends TransformSubject<
+export interface MulticastSubject extends ProxySubject<
   MulticastMessageConstructor<MulticastClientMessage>,
   MulticastHostMessage
 > {}
@@ -80,7 +80,7 @@ export const multicast = <Seed>(
   key: Promise<string>,
   seed: Seed,
 ): MulticastSubject =>
-  transform((messages) =>
+  proxy((messages) =>
     messages.pipe(
       startWith(
         ({ key, id }): MulticastConnectMessage => ({

package/src/operators/proxy.ts

@@ -0,0 +1,8 @@
+import { Subject } from "rxjs";
+import { ProxySubject } from "../observable";
+import { ProxySubjectHandler } from "../observable/ProxySubject";
+
+export const proxy = <T, U = T>(
+  handler: ProxySubjectHandler<T, U>,
+  target?: Subject<T>,
+) => new ProxySubject(handler, target);

package/src/store.ts

@@ -36,7 +36,7 @@ export const asStoreEffects = <Signals extends Dictionary<ComputedSignal<any>>>(
   observer?: NextObserver<Signal<any>>,
 ): StoreEffects<Signals> =>
   mapValues(signals, (signal) =>
-    memoize(() => tap(signal.capture(), (value) => observer?.next(value))),
+    memoize(() => tap(signal.clone(), (value) => observer?.next(value))),
   );
 
 export class StoreAdapter<
@@ -73,7 +73,7 @@ export class ExtendableStoreAdapter<
             },
             void
           >;
-          reflect: UnaryFunction<(args: any) => Promise<Transform<any>>, void>;
+          register: UnaryFunction<(args: any) => Transform<any>, void>;
         }
       >;
     },
@@ -145,8 +145,8 @@ export class ExtendableStoreAdapter<
                       (signal) => ({
                         update: (predicate, config = {}) =>
                           thru(this.context.transform(key), (transform) => {
-                            transform.reflect((args) =>
-                              signal.reflector.reflect(predicate(args)),
+                            transform.register((args) =>
+                              signal.reflector.predicate(predicate(args)),
                             );
 
                             return (args) =>
@@ -204,7 +204,7 @@ export class StoreProvider<Data> extends ExtendableStoreAdapter<
                 }
               ),
             ),
-          reflect: (transform) =>
+          register: (transform) =>
             actions
               .pipe(
                 mergeMap(async (event) => {
@@ -212,11 +212,11 @@ export class StoreProvider<Data> extends ExtendableStoreAdapter<
                     event.type === "transformAction" &&
                     event.data.key === (await key)
                   ) {
-                    return transform(event.data.args).then((predicate) => ({
+                    return {
                       ...event,
-                      predicate,
+                      predicate: transform(event.data.args),
                       callback: callbacks.get(event.id),
-                    }));
+                    };
                   }
 
                   return [];

package/src/terminal.ts

@@ -10,7 +10,7 @@ import {
 import { ApiAdapter, ApiEffect } from "./api";
 import { ExtendableDictionary } from "./lib";
 import { ComputedSignal, TapObservable } from "./observable";
-import { concat, transform } from "./operators";
+import { concat, proxy } from "./operators";
 import { asStoreEffects, StoreAdapter, StoreEffects } from "./store";
 import { Action, Effect, TapEffect } from "./types";
 
@@ -103,7 +103,7 @@ export class ExtendableTerminalAdapter<
         (currentEffects) => () =>
           effects({
             effect: (constructor) => {
-              const deps = transform<TapObservable<any>, boolean>((deps) =>
+              const deps = proxy<TapObservable<any>, boolean>((deps) =>
                 deps.pipe(
                   distinct(),
                   concat(),

package/src/operators/transform.ts

@@ -1,7 +0,0 @@
-import { Observable, Subject, UnaryFunction } from "rxjs";
-import { TransformSubject } from "../observable";
-
-export const transform = <T, U = T>(
-  project: UnaryFunction<Subject<T>, Observable<U>>,
-  target?: Subject<T>,
-) => new TransformSubject(project, target);