silentium-components 0.0.82 → 0.0.83

package/src/behaviors/Dirty.ts

@@ -4,8 +4,8 @@ import {
   Late,
   MessageType,
   SourceType,
-  Transport,
-  TransportType,
+  Tap,
+  TapType,
 } from "silentium";
 
 /**
@@ -39,10 +39,10 @@ class DirtySource<T> implements SourceType<T> {
     }
   }
 
-  public to(transport: TransportType<T>) {
+  public pipe(transport: TapType<T>) {
     const $comparing = Applied(this.$comparing, this.cloner);
-    All($comparing, this.$base).to(
-      Transport(([comparing, base]) => {
+    All($comparing, this.$base).pipe(
+      Tap(([comparing, base]) => {
         if (!comparing) {
           return;
         }

package/src/behaviors/Loading.test.ts

@@ -1,4 +1,4 @@
-import { Late, Transport } from "silentium";
+import { Late, Tap } from "silentium";
 import { Loading } from "../behaviors/Loading";
 import { expect, test, vi } from "vitest";
 
@@ -7,7 +7,7 @@ test("Loading.test", () => {
   const $loadingFinish = Late();
   const $loading = Loading($loadingStart, $loadingFinish);
   const g = vi.fn();
-  $loading.to(Transport(g));
+  $loading.pipe(Tap(g));
   $loadingStart.use({});
   expect(g).toHaveBeenLastCalledWith(true);
   $loadingFinish.use({});

package/src/behaviors/Loading.ts

@@ -1,4 +1,4 @@
-import { Message, MessageType, Transport } from "silentium";
+import { Message, MessageType, Tap } from "silentium";
 
 /**
  * Representation Of loading process
@@ -7,11 +7,11 @@ import { Message, MessageType, Transport } from "silentium";
  * https://silentium-lab.github.io/silentium-components/#/behaviors/loading
  */
 export function Loading(
-  $loadingStart: MessageType<unknown>,
-  $loadingFinish: MessageType<unknown>,
+  $start: MessageType<unknown>,
+  $finish: MessageType<unknown>,
 ) {
-  return Message<boolean>((transport) => {
-    $loadingStart.to(Transport(() => transport.use(true)));
-    $loadingFinish.to(Transport(() => transport.use(false)));
+  return Message<boolean>(function () {
+    $start.pipe(Tap(() => this.use(true)));
+    $finish.pipe(Tap(() => this.use(false)));
   });
 }

package/src/behaviors/Lock.test.ts

@@ -1,4 +1,4 @@
-import { Late, Shared, Transport } from "silentium";
+import { Late, Shared, Tap } from "silentium";
 import { Lock } from "../behaviors/Lock";
 import { expect, test, vi } from "vitest";
 
@@ -9,7 +9,7 @@ test("Lock.test", () => {
   const ls = Lock(source, lockSrc);
   const lockedSrc = Shared(ls);
   const g = vi.fn();
-  lockedSrc.to(Transport(g));
+  lockedSrc.pipe(Tap(g));
 
   expect(g).toHaveBeenLastCalledWith(1);
 

package/src/behaviors/Lock.ts

@@ -1,4 +1,4 @@
-import { Filtered, Message, MessageType, Transport } from "silentium";
+import { Filtered, Message, MessageType, Tap } from "silentium";
 
 /**
  * Allows locking messages
@@ -6,14 +6,14 @@ import { Filtered, Message, MessageType, Transport } from "silentium";
  * https://silentium-lab.github.io/silentium-components/#/behaviors/lock
  */
 export function Lock<T>($base: MessageType<T>, $lock: MessageType<boolean>) {
-  return Message<T>((transport) => {
+  return Message<T>(function () {
     let locked = false;
-    $lock.to(
-      Transport((newLock) => {
+    $lock.pipe(
+      Tap((newLock) => {
         locked = newLock;
       }),
     );
     const i = Filtered($base, () => !locked);
-    i.to(transport);
+    i.pipe(this);
   });
 }

package/src/behaviors/Memo.test.ts

@@ -1,4 +1,4 @@
-import { Late, Shared, Transport } from "silentium";
+import { Late, Shared, Tap } from "silentium";
 import { Memo } from "../behaviors/Memo";
 import { expect, test, vi } from "vitest";
 
@@ -6,11 +6,11 @@ test("Memo.test", () => {
   const l = Late<number>(1);
   const mem = Shared(Memo(l));
   const g = vi.fn();
-  mem.to(Transport(g));
+  mem.pipe(Tap(g));
   let counter = 0;
 
-  mem.to(
-    Transport(() => {
+  mem.pipe(
+    Tap(() => {
       counter += 1;
     }),
   );

package/src/behaviors/Memo.ts

@@ -1,16 +1,16 @@
-import { isFilled, Message, MessageType, Transport } from "silentium";
+import { isFilled, Message, MessageType, Tap } from "silentium";
 
 /**
  * Didn't respond if new value Of baseSrc equals to old value
  * https://silentium-lab.github.io/silentium-components/#/behaviors/memo
  */
 export function Memo<T>($base: MessageType<T>) {
-  return Message<T>((transport) => {
+  return Message<T>(function () {
     let last: T | null = null;
-    $base.to(
-      Transport((v) => {
+    $base.pipe(
+      Tap((v) => {
         if (v !== last && isFilled(v)) {
-          transport.use(v);
+          this.use(v);
           last = v;
         }
       }),

package/src/behaviors/OnlyChanged.test.ts

@@ -1,4 +1,4 @@
-import { Late, Shared, Transport } from "silentium";
+import { Late, Shared, Tap } from "silentium";
 import { OnlyChanged } from "../behaviors/OnlyChanged";
 import { expect, test, vi } from "vitest";
 
@@ -7,12 +7,12 @@ test("OnlyChanged.test", () => {
   const changedSrc = Shared(OnlyChanged(src));
 
   const g = vi.fn();
-  changedSrc.to(Transport(g));
+  changedSrc.pipe(Tap(g));
   expect(g).not.toBeCalled();
 
   src.use(2);
 
   const g2 = vi.fn();
-  changedSrc.to(Transport(g2));
+  changedSrc.pipe(Tap(g2));
   expect(g2).toBeCalledWith(2);
 });

package/src/behaviors/OnlyChanged.ts

@@ -1,18 +1,18 @@
-import { Message, MessageType, Transport } from "silentium";
+import { Message, MessageType, Tap } from "silentium";
 
 /**
  * Represents source what was changed at least once
  * https://silentium-lab.github.io/silentium-components/#/behaviors/only-changed
  */
 export function OnlyChanged<T>($base: MessageType<T>) {
-  return Message<T>((transport) => {
+  return Message<T>(function () {
     let first = false;
-    $base.to(
-      Transport((v) => {
+    $base.pipe(
+      Tap((v) => {
         if (first === false) {
           first = true;
         } else {
-          transport.use(v);
+          this.use(v);
         }
       }),
     );

package/src/behaviors/Part.test.ts

@@ -1,4 +1,4 @@
-import { Late, Of, SharedSource, Transport } from "silentium";
+import { Late, Of, SharedSource, Tap } from "silentium";
 import { describe, expect, test, vi } from "vitest";
 import { Part } from "../behaviors/Part";
 
@@ -12,7 +12,7 @@ describe("Part.test", () => {
     );
     const $name = Part<string>($record, Of("name"));
     const g = vi.fn();
-    $record.to(Transport(g));
+    $record.pipe(Tap(g));
     expect(g).toHaveBeenLastCalledWith({ name: "Peter", surname: "Parker" });
 
     $name.use("Shmiter");
@@ -28,7 +28,7 @@ describe("Part.test", () => {
     );
     const $name = Part<string>($record, "name");
     const g = vi.fn();
-    $record.to(Transport(g));
+    $record.pipe(Tap(g));
     expect(g).toHaveBeenLastCalledWith({ name: "Peter", surname: "Parker" });
 
     $name.use("Shmiter");

package/src/behaviors/Part.ts

@@ -8,8 +8,8 @@ import {
   Shared,
   SharedSource,
   SourceType,
-  Transport,
-  TransportType,
+  Tap,
+  TapType,
 } from "silentium";
 
 /**
@@ -35,9 +35,9 @@ class PartImpl<R, T extends object | Array<any>, K extends string = any>
     this.$keyed = Shared($key);
   }
 
-  public to(transport: TransportType<R, null>): this {
-    All(this.$base, this.$keyed).to(
-      Transport(([base, keyed]) => {
+  public pipe(transport: TapType<R, null>): this {
+    All(this.$base, this.$keyed).pipe(
+      Tap(([base, keyed]) => {
         const keys = keyed.split(".");
         let value: unknown = base;
         keys.forEach((key) => {

package/src/behaviors/Path._keyRaw.test.ts

@@ -1,4 +1,4 @@
-import { Of, Transport } from "silentium";
+import { Of, Tap } from "silentium";
 import { expect, test, vi } from "vitest";
 import { Path } from "./Path";
 
@@ -9,6 +9,6 @@ test("Path._keyRaw.test", () => {
   };
   const name = Path<string>(Of(record), "name");
   const g = vi.fn();
-  name.to(Transport(g));
+  name.pipe(Tap(g));
   expect(g).toHaveBeenLastCalledWith("Peter");
 });

package/src/behaviors/Path._main.test.ts

@@ -1,4 +1,4 @@
-import { Of, Transport } from "silentium";
+import { Of, Tap } from "silentium";
 import { expect, test, vi } from "vitest";
 import { Path } from "./Path";
 
@@ -9,6 +9,6 @@ test("Path._main.test", () => {
   };
   const name = Path<string>(Of(record), Of("name"));
   const g = vi.fn();
-  name.to(Transport(g));
+  name.pipe(Tap(g));
   expect(g).toHaveBeenLastCalledWith("Peter");
 });

package/src/behaviors/Path.index.test.ts

@@ -1,4 +1,4 @@
-import { Of, Transport } from "silentium";
+import { Of, Tap } from "silentium";
 import { expect, test, vi } from "vitest";
 import { Path } from "./Path";
 
@@ -13,6 +13,6 @@ test("Path.index.test", () => {
   };
   const bestColor = Path(Of(record), Of("colors.0"));
   const g = vi.fn();
-  bestColor.to(Transport(g));
+  bestColor.pipe(Tap(g));
   expect(g).toHaveBeenLastCalledWith("blue");
 });

package/src/behaviors/Path.nested.test.ts

@@ -1,4 +1,4 @@
-import { Of, Transport } from "silentium";
+import { Of, Tap } from "silentium";
 import { Path } from "../behaviors/Path";
 import { expect, test, vi } from "vitest";
 
@@ -12,6 +12,6 @@ test("Path.nested.test", () => {
   };
   const typeName = Path(Of(record), Of("type.name"));
   const g = vi.fn();
-  typeName.to(Transport(g));
+  typeName.pipe(Tap(g));
   expect(g).toHaveBeenLastCalledWith("spider-man");
 });

package/src/behaviors/Path.ts

@@ -4,7 +4,7 @@ import {
   MaybeMessage,
   Message,
   MessageType,
-  Transport,
+  Tap,
 } from "silentium";
 
 /**
@@ -17,16 +17,16 @@ export function Path<
   K extends string = any,
 >($base: MessageType<T>, _keyed: MaybeMessage<K>) {
   const $keyed = ActualMessage(_keyed);
-  return Message<R>((transport) => {
-    All($base, $keyed).to(
-      Transport(([base, keyed]) => {
+  return Message<R>(function () {
+    All($base, $keyed).pipe(
+      Tap(([base, keyed]) => {
         const keys = keyed.split(".");
         let value: unknown = base;
         keys.forEach((key) => {
           value = (value as Record<string, unknown>)[key];
         });
         if (value !== undefined && value !== base) {
-          transport.use(value as R);
+          this.use(value as R);
         }
       }),
     );

package/src/behaviors/Polling.ts

@@ -1,14 +1,14 @@
-import { Message, MessageType, Transport } from "silentium";
+import { Message, MessageType, Tap } from "silentium";
 
 /**
  * Active polling of $base message
  * synchronized with $trigger message
  */
 export function Polling<T>($base: MessageType<T>, $trigger: MessageType<T>) {
-  return Message<T>((transport) => {
-    $trigger.to(
-      Transport(() => {
-        $base.to(transport);
+  return Message<T>(function () {
+    $trigger.pipe(
+      Tap(() => {
+        $base.pipe(this);
       }),
     );
   });

package/src/behaviors/Shot._main.test.ts

@@ -1,4 +1,4 @@
-import { Late, Shared, Transport } from "silentium";
+import { Late, Shared, Tap } from "silentium";
 import { Shot } from "../behaviors/Shot";
 import { expect, test, vi } from "vitest";
 
@@ -8,7 +8,7 @@ test("Shot._main.test", () => {
 
   const $shotted = Shared(Shot($base, $trigger));
   const g = vi.fn();
-  $shotted.to(Transport(g));
+  $shotted.pipe(Tap(g));
 
   $base.use(1);
   $trigger.use(1);
@@ -24,6 +24,6 @@ test("Shot._main.test", () => {
   expect(g).toHaveBeenLastCalledWith(2);
 
   const g2 = vi.fn();
-  $shotted.to(Transport(g2));
+  $shotted.pipe(Tap(g2));
   expect(g2).toHaveBeenLastCalledWith(2);
 });

package/src/behaviors/Shot._onlyChanged.test.ts

@@ -1,4 +1,4 @@
-import { Late, Shared, Transport } from "silentium";
+import { Late, Shared, Tap } from "silentium";
 import { OnlyChanged } from "../behaviors/OnlyChanged";
 import { Shot } from "../behaviors/Shot";
 import { expect, test } from "vitest";
@@ -10,8 +10,8 @@ test("Shot._onlyChanged.test", () => {
 
   const vals: number[] = [];
 
-  $result.to(
-    Transport((v) => {
+  $result.pipe(
+    Tap((v) => {
       vals.push(v);
     }),
   );

package/src/behaviors/Shot.ts

@@ -1,24 +1,18 @@
-import {
-  isFilled,
-  Message,
-  MessageType,
-  Primitive,
-  Transport,
-} from "silentium";
+import { isFilled, Message, MessageType, Primitive, Tap } from "silentium";
 
 /**
  * Helps to represent only last fresh value Of some source, refreshing controls by shotSrc
  * https://silentium-lab.github.io/silentium-components/#/behaviors/shot
  */
 export function Shot<T>($target: MessageType<T>, $trigger: MessageType) {
-  return Message<T>((transport) => {
+  return Message<T>(function () {
     const targetSync = Primitive($target);
     targetSync.primitive();
-    $trigger.to(
-      Transport(() => {
+    $trigger.pipe(
+      Tap(() => {
         const value = targetSync.primitive();
         if (isFilled(value)) {
-          transport.use(value);
+          this.use(value);
         }
       }),
     );

package/src/behaviors/Task.test.ts

@@ -1,4 +1,4 @@
-import { Late, Transport } from "silentium";
+import { Late, Tap } from "silentium";
 import { Task } from "../behaviors/Task";
 import { afterEach, beforeEach, expect, test, vi } from "vitest";
 
@@ -15,8 +15,8 @@ test("Task delays emission", () => {
   const $trigger = Late<string>();
   const delayed = Task($trigger, 100);
   const data: string[] = [];
-  delayed.to(
-    Transport((v) => {
+  delayed.pipe(
+    Tap((v) => {
       data.push(v);
     }),
   );
@@ -36,8 +36,8 @@ test("Task emits only last value when multiple before delay", () => {
   const $trigger = Late<string>();
   const delayed = Task($trigger, 100);
   const data: string[] = [];
-  delayed.to(
-    Transport((v) => {
+  delayed.pipe(
+    Tap((v) => {
       data.push(v);
     }),
   );

package/src/behaviors/Task.ts

@@ -6,7 +6,7 @@ import { ExecutorApplied, Message, MessageType } from "silentium";
  * a certain timer firing interval
  */
 export function Task<T>(baseSrc: MessageType<T>, delay: number = 0) {
-  return Message<T>((transport) => {
+  return Message<T>(function () {
     let prevTimer: unknown | null = null;
     ExecutorApplied(baseSrc, (fn) => {
       return (v) => {
@@ -17,6 +17,6 @@ export function Task<T>(baseSrc: MessageType<T>, delay: number = 0) {
           fn(v);
         }, delay);
       };
-    }).to(transport);
+    }).pipe(this);
   });
 }

package/src/behaviors/Tick.test.ts

@@ -1,4 +1,4 @@
-import { Any, Late, Shared, Transport } from "silentium";
+import { Any, Late, Shared, Tap } from "silentium";
 import { Tick } from "../behaviors/Tick";
 import { afterEach, beforeEach, expect, test, vi } from "vitest";
 
@@ -17,7 +17,7 @@ test("Tick.test", async () => {
   const $tick = Shared(Tick(Any($s1, $s2)), true);
 
   const g = vi.fn();
-  $tick.to(Transport(g));
+  $tick.pipe(Tap(g));
 
   $s1.use(3);
   $s2.use(4);

package/src/behaviors/Tick.ts

@@ -1,11 +1,11 @@
-import { Message, MessageType, Transport } from "silentium";
+import { Message, MessageType, Tap } from "silentium";
 
 /**
  * Accumulates the last value Of the source and returns one result once per tick
  * https://silentium-lab.github.io/silentium-components/#/behaviors/tick
  */
 export function Tick<T>($base: MessageType<T>) {
-  return Message((transport) => {
+  return Message(function () {
     let microtaskScheduled = false;
     let lastValue: T | null = null;
 
@@ -14,14 +14,14 @@ export function Tick<T>($base: MessageType<T>) {
       queueMicrotask(() => {
         microtaskScheduled = false;
         if (lastValue !== null) {
-          transport.use(lastValue);
+          this.use(lastValue);
           lastValue = null;
         }
       });
     };
 
-    $base.to(
-      Transport((v) => {
+    $base.pipe(
+      Tap((v) => {
         lastValue = v;
         if (!microtaskScheduled) {
           scheduleMicrotask();

package/src/behaviors/Transaction.ts

@@ -5,7 +5,7 @@ import {
   Message,
   MessageType,
   Of,
-  Transport,
+  Tap,
 } from "silentium";
 import { Detached } from "../behaviors/Detached";
 
@@ -21,18 +21,18 @@ export function Transaction<T, R = unknown>(
   >,
   ...args: MessageType[]
 ) {
-  return Message<R>((transport) => {
+  return Message<R>(function () {
     const $res = LateShared<R>();
     const destructors: DestroyableType[] = [];
 
-    $base.to(
-      Transport((v) => {
+    $base.pipe(
+      Tap((v) => {
         const $msg = builder(Of(v), ...args.map((a) => Detached(a)));
         destructors.push($msg as unknown as DestroyableType);
-        $msg.to($res);
+        $msg.pipe($res);
       }),
     );
-    $res.to(transport);
+    $res.pipe(this);
 
     return () => {
       destructors.forEach((d) => d?.destroy());

package/src/boolean/And.test.ts

@@ -1,4 +1,4 @@
-import { Late, Transport } from "silentium";
+import { Late, Tap } from "silentium";
 import { expect, test, vi } from "vitest";
 import { And } from "../boolean/And";
 
@@ -7,7 +7,7 @@ test("And.test", () => {
   const $two = Late<boolean>(false);
   const result = And($one, $two);
   const g = vi.fn();
-  result.to(Transport(g));
+  result.pipe(Tap(g));
   expect(g).toHaveBeenLastCalledWith(false);
 
   $one.use(true);

package/src/boolean/And.ts

@@ -1,14 +1,14 @@
-import { All, Message, MessageType, Transport } from "silentium";
+import { All, Message, MessageType, Tap } from "silentium";
 
 /**
  * Logical AND over two messages
  * https://silentium-lab.github.io/silentium-components/#/boolean/and
  */
 export function And($one: MessageType<boolean>, $two: MessageType<boolean>) {
-  return Message<boolean>((transport) => {
-    All($one, $two).to(
-      Transport(([one, two]) => {
-        transport.use(one && two);
+  return Message<boolean>(function () {
+    All($one, $two).pipe(
+      Tap(([one, two]) => {
+        this.use(!!(one && two));
       }),
     );
   });

package/src/boolean/Bool.test.ts

@@ -1,9 +1,9 @@
-import { Of, Transport } from "silentium";
+import { Of, Tap } from "silentium";
 import { Bool } from "../boolean/Bool";
 import { expect, test, vi } from "vitest";
 
 test("Bool.test", () => {
   const o = vi.fn();
-  Bool(Of(1)).to(Transport(o));
+  Bool(Of(1)).pipe(Tap(o));
   expect(o).toHaveBeenCalledWith(true);
 });

package/src/boolean/Bool.ts

@@ -5,7 +5,7 @@ import { Applied, Message, MessageType } from "silentium";
  * https://silentium-lab.github.io/silentium-components/#/boolean/bool
  */
 export function Bool($base: MessageType) {
-  return Message<boolean>((transport) => {
-    Applied($base, Boolean).to(transport);
+  return Message<boolean>(function () {
+    Applied($base, Boolean).pipe(this);
   });
 }

package/src/boolean/Not.test.ts

@@ -1,4 +1,4 @@
-import { Late, Transport } from "silentium";
+import { Late, Tap } from "silentium";
 import { Not } from "../boolean/Not";
 import { expect, test, vi } from "vitest";
 
@@ -6,7 +6,7 @@ test("Not.test", () => {
   const one = Late<boolean>(false);
   const result = Not(one);
   const g = vi.fn();
-  result.to(Transport(g));
+  result.pipe(Tap(g));
   expect(g).toHaveBeenLastCalledWith(true);
 
   one.use(true);

package/src/boolean/Not.ts

@@ -1,14 +1,14 @@
-import { Message, MessageType, Transport } from "silentium";
+import { Message, MessageType, Tap } from "silentium";
 
 /**
  * Logical negation of message
  * https://silentium-lab.github.io/silentium-components/#/boolean/not
  */
 export function Not($base: MessageType<boolean>) {
-  return Message<boolean>((transport) => {
-    $base.to(
-      Transport((v) => {
-        transport.use(!v);
+  return Message<boolean>(function () {
+    $base.pipe(
+      Tap((v) => {
+        this.use(!v);
       }),
     );
   });