@cascateer/core 2.3.48 → 2.3.49

package/package.json

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

package/src/observable/Signal.test.ts

@@ -1,12 +1,40 @@
-import { lastValueFrom, of, toArray } from "rxjs";
+import { identity } from "lodash";
+import {
+  lastValueFrom,
+  of,
+  ReplaySubject,
+  scan,
+  startWith,
+  toArray,
+} from "rxjs";
 import { expect, test } from "vitest";
+import { Transform } from "../types";
 import { ComputedSignal } from "./Signal";
 
-test("projects", () =>
-  lastValueFrom(
-    new ComputedSignal({
-      value: of({ number: 1 }, { number: 2 }, { number: 3 }),
-    })
-      .property("number")
-      .pipe(toArray()),
-  ).then((numbers) => expect(numbers).toEqual([1, 2, 3])));
+test("projection", () => {
+  const signal = new ComputedSignal({
+    value: of({ number: 1 }, { number: 2 }, { number: 3 }),
+  }).property("number");
+
+  lastValueFrom(signal.pipe(toArray())).then((numbers) =>
+    expect(numbers).toEqual([1, 2, 3]),
+  );
+});
+
+test("transformation", () => {
+  const transforms = new ReplaySubject<Transform<any>>();
+  const signal = new ComputedSignal({
+    value: transforms.pipe(
+      startWith(identity),
+      scan((state, transform) => transform(state), { number: 1 }),
+    ),
+  }).property("number");
+
+  transforms.next(signal.adapter.lift((number) => number + 1));
+  transforms.next(signal.adapter.lift((number) => number + 2));
+  transforms.complete();
+
+  return lastValueFrom(signal.pipe(toArray())).then((numbers) =>
+    expect(numbers).toEqual([1, 2, 4]),
+  );
+});

package/src/observable/Signal.ts

@@ -20,17 +20,15 @@ class SignalEnumerator<T> {
   enumerate = (value: T) => asEnumerable(value).map(this.predicate);
 }
 
-class SignalReflector<T> {
+class SignalAdapter<T> {
   constructor(
-    public predicate: (
-      transform: Transform<T>,
-    ) => Transform<unknown> = identity,
+    public lift: (transform: Transform<T>) => Transform<unknown> = identity,
   ) {}
 
-  reflect = <U>(
-    lift: UnaryFunction<Transform<U>, Transform<T>>,
-  ): SignalReflector<U> =>
-    new SignalReflector((transform) => this.predicate(lift(transform)));
+  connect = <U>(
+    connector: UnaryFunction<Transform<U>, Transform<T>>,
+  ): SignalAdapter<U> =>
+    new SignalAdapter((transform) => this.lift(connector(transform)));
 }
 
 export class Signal<T> extends ProxyObservable<T> {
@@ -43,32 +41,32 @@ export class Signal<T> extends ProxyObservable<T> {
   }
 
   enumerator: SignalEnumerator<T>;
-  reflector: SignalReflector<T>;
+  adapter: SignalAdapter<T>;
 
   constructor({
     value,
     enumerator = new SignalEnumerator(),
-    reflector = new SignalReflector(),
+    adapter = new SignalAdapter(),
   }: {
     value: Observable<T>;
     enumerator?: SignalEnumerator<T>;
-    reflector?: SignalReflector<T>;
+    adapter?: SignalAdapter<T>;
   }) {
     super(value);
 
     this.enumerator = enumerator;
-    this.reflector = reflector;
+    this.adapter = adapter;
   }
 
   private project<U>(
-    project: UnaryFunction<T, U>,
-    lift: UnaryFunction<Transform<U>, Transform<T>>,
+    projector: UnaryFunction<T, U>,
+    connector: UnaryFunction<Transform<U>, Transform<T>>,
     enumerate?: Enumerator<U>,
   ): Signal<U> {
     return new Signal({
-      value: this.pipe(map(project), distinctUntilChanged()),
+      value: this.pipe(map(projector), distinctUntilChanged()),
       enumerator: new SignalEnumerator(enumerate),
-      reflector: this.reflector.reflect(lift),
+      adapter: this.adapter.connect(connector),
     });
   }
 

package/src/store.ts

@@ -143,7 +143,7 @@ export class ExtendableStoreAdapter<
                         update: (predicate, config = {}) =>
                           thru(this.context.transform(key), (transform) => {
                             transform.register((args) =>
-                              signal.reflector.predicate(predicate(args)),
+                              signal.adapter.lift(predicate(args)),
                             );
 
                             return (args) =>