@cascateer/core 2.3.48 → 2.3.50

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@cascateer/core",
-  "version": "2.3.48",
+  "version": "2.3.50",
   "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

@@ -12,25 +12,24 @@ import {
 import { Transform } from "../types";
 
 class SignalEnumerator<T> {
-  constructor(private predicate: Enumerator<T> = nthArg(1)) {}
+  constructor(private enumerator: Enumerator<T> = nthArg(1)) {}
 
   findIndex = (key: PropertyKey) => (value: T) =>
-    asEnumerable(value).map(this.predicate).indexOf(key);
+    asEnumerable(value).map(this.enumerator).indexOf(key);
 
-  enumerate = (value: T) => asEnumerable(value).map(this.predicate);
+  enumerate = (value: T) => asEnumerable(value).map(this.enumerator);
 }
 
-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> {
+    return new SignalAdapter((transform) => this.lift(connector(transform)));
+  }
 }
 
 export class Signal<T> extends ProxyObservable<T> {
@@ -43,38 +42,38 @@ 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>>,
-    enumerate?: Enumerator<U>,
+    projector: UnaryFunction<T, U>,
+    connector: UnaryFunction<Transform<U>, Transform<T>>,
+    enumerator?: Enumerator<U>,
   ): Signal<U> {
     return new Signal({
-      value: this.pipe(map(project), distinctUntilChanged()),
-      enumerator: new SignalEnumerator(enumerate),
-      reflector: this.reflector.reflect(lift),
+      value: this.pipe(map(projector), distinctUntilChanged()),
+      enumerator: new SignalEnumerator(enumerator),
+      adapter: this.adapter.connect(connector),
     });
   }
 
   protected property<K extends keyof T>(
     key: K,
-    enumerate?: Enumerator<T[K]>,
+    enumerator?: Enumerator<T[K]>,
   ): Signal<T[K]> {
     const findProperty: UnaryFunction<T, T[K]> = property(key);
 
@@ -87,13 +86,13 @@ export class Signal<T> extends ProxyObservable<T> {
 
         return value;
       },
-      enumerate,
+      enumerator,
     );
   }
 
   protected item(
     key: PropertyKey,
-    enumerate?: Enumerator<EnumerableItem<T>>,
+    enumerator?: Enumerator<EnumerableItem<T>>,
   ): Signal<EnumerableItem<T>> {
     const findIndex = this.enumerator.findIndex(key);
     const findItem: UnaryFunction<T, EnumerableItem<T>> = (value) =>
@@ -108,7 +107,7 @@ export class Signal<T> extends ProxyObservable<T> {
 
         return value;
       },
-      enumerate,
+      enumerator,
     );
   }
 
@@ -151,16 +150,16 @@ export class Signal<T> extends ProxyObservable<T> {
 export class ComputedSignal<T> extends Signal<T> {
   property<K extends keyof T>(
     key: K,
-    enumerate?: Enumerator<T[K]>,
+    enumerator?: Enumerator<T[K]>,
   ): ComputedSignal<T[K]> {
-    return new ComputedSignal(super.property(key, enumerate));
+    return new ComputedSignal(super.property(key, enumerator));
   }
 
   item(
     key: PropertyKey,
-    enumerate?: Enumerator<EnumerableItem<T>>,
+    enumerator?: Enumerator<EnumerableItem<T>>,
   ): ComputedSignal<EnumerableItem<T>> {
-    return new ComputedSignal(super.item(key, enumerate));
+    return new ComputedSignal(super.item(key, enumerator));
   }
 
   collection<K extends keyof EnumerableItem<T>>(

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) =>