silentium-components 0.0.82 → 0.0.83

package/src/boolean/Or.test.ts

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

package/src/boolean/Or.ts

@@ -1,14 +1,14 @@
-import { All, Message, MessageType, Transport } from "silentium";
+import { All, Message, MessageType, Tap } from "silentium";
 
 /**
  * Logical OR over two messages
  * https://silentium-lab.github.io/silentium-components/#/boolean/or
  */
 export function Or($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/formats/FromJson.ts

@@ -1,17 +1,17 @@
-import { Message, MessageType, Transport, TransportType } from "silentium";
+import { Message, MessageType, Tap, TapType } from "silentium";
 
 /**
  * Represents object from json
  */
 export function FromJson<T = Record<string, unknown>>(
   $json: MessageType<string>,
-  error?: TransportType,
+  error?: TapType,
 ) {
-  return Message<T>((transport) => {
-    $json.to(
-      Transport((json) => {
+  return Message<T>(function () {
+    $json.pipe(
+      Tap((json) => {
         try {
-          transport.use(JSON.parse(json));
+          this.use(JSON.parse(json));
         } catch (e) {
           error?.use(new Error(`Failed to parse JSON: ${e}`));
         }

package/src/formats/ToJson.ts

@@ -1,14 +1,14 @@
-import { Message, MessageType, Transport, TransportType } from "silentium";
+import { Message, MessageType, Tap, TapType } from "silentium";
 
 /**
  * Represents json from object
  */
-export function ToJson($data: MessageType, error?: TransportType) {
-  return Message<string>((transport) => {
-    $data.to(
-      Transport((data: unknown) => {
+export function ToJson($data: MessageType, error?: TapType) {
+  return Message<string>(function () {
+    $data.pipe(
+      Tap((data: unknown) => {
         try {
-          transport.use(JSON.stringify(data));
+          this.use(JSON.stringify(data));
         } catch {
           error?.use(new Error("Failed to convert to JSON"));
         }

package/src/lists/First.test.ts

@@ -1,10 +1,10 @@
-import { Of, Transport } from "silentium";
+import { Of, Tap } from "silentium";
 import { expect, test, vi } from "vitest";
 import { First } from "./First";
 
 test("first", () => {
   const f = First(Of([1, 2, 3]));
   const g = vi.fn();
-  f.to(Transport(g));
+  f.pipe(Tap(g));
   expect(g).toHaveBeenCalledWith(1);
 });

package/src/lists/First.ts

@@ -4,7 +4,7 @@ import { Applied, Message, MessageType } from "silentium";
  * Represents the first element Of an array.
  */
 export function First<T extends Array<unknown>>($base: MessageType<T>) {
-  return Message<T[0]>((transport) => {
-    Applied($base, (a) => a[0]).to(transport);
+  return Message<T[0]>(function () {
+    Applied($base, (a) => a[0]).pipe(this);
   });
 }

package/src/navigation/Router._destroy.test.ts

@@ -4,8 +4,8 @@ import {
   Message,
   Of,
   Shared,
-  Transport,
-  TransportMessage,
+  Tap,
+  TapMessage,
 } from "silentium";
 import { Router } from "../navigation/Router";
 import { expect, test, vi } from "vitest";
@@ -18,28 +18,28 @@ test("Router destroys previous route messages when switching routes", () => {
   const $url = Late<string>("http://domain.com/");
   const $urlPath = Shared(Applied($url, drop("http://domain.com")));
   const g = vi.fn();
-  $urlPath.to(Transport(g));
+  $urlPath.pipe(Tap(g));
 
   // Create mock destroyable messages for routes
   const firstRouteDestroy = vi.fn();
   const secondRouteDestroy = vi.fn();
   const defaultDestroy = vi.fn();
 
-  const $firstRoute = TransportMessage(() =>
+  const $firstRoute = TapMessage(() =>
     Message<string>((transport) => {
       transport.use("first-route-response");
       return firstRouteDestroy;
     }),
   );
 
-  const $secondRoute = TransportMessage(() =>
+  const $secondRoute = TapMessage(() =>
     Message<string>((transport) => {
       transport.use("second-route-response");
       return secondRouteDestroy;
     }),
   );
 
-  const $default = TransportMessage(() =>
+  const $default = TapMessage(() =>
     Message<string>((transport) => {
       transport.use("default-response");
       return defaultDestroy;
@@ -62,7 +62,7 @@ test("Router destroys previous route messages when switching routes", () => {
   );
 
   const g2 = vi.fn();
-  $router.to(Transport(g2));
+  $router.pipe(Tap(g2));
 
   // Initially no route matches, should use default
   expect(g2).toHaveBeenLastCalledWith("default-response");

package/src/navigation/Router._firstMatch.test.ts

@@ -3,8 +3,8 @@ import {
   Late,
   Of,
   Shared,
-  Transport,
-  TransportMessage,
+  Tap,
+  TapMessage,
 } from "silentium";
 import { expect, test, vi } from "vitest";
 import { Router } from "../navigation/Router";
@@ -17,7 +17,7 @@ test("Router first matching route responds, not subsequent matches", () => {
   const $url = Late<string>("http://domain.com/page/general");
   const $urlPath = Shared(Applied($url, drop("http://domain.com")));
   const g = vi.fn();
-  $urlPath.to(Transport(g));
+  $urlPath.pipe(Tap(g));
 
   const firstRouteMock = vi.fn(() => Of("first-route-response"));
   const secondRouteMock = vi.fn(() => Of("second-route-response"));
@@ -27,17 +27,17 @@ test("Router first matching route responds, not subsequent matches", () => {
     Of([
       {
         pattern: "^/page/.*", // This matches /page/anything
-        message: TransportMessage(firstRouteMock),
+        message: TapMessage(firstRouteMock),
       },
       {
         pattern: "^/page/specific$", // This also matches /page/specific
-        message: TransportMessage(secondRouteMock),
+        message: TapMessage(secondRouteMock),
       },
     ]),
-    TransportMessage(() => Of<string>("page/404.html")),
+    TapMessage(() => Of<string>("page/404.html")),
   );
   const g2 = vi.fn();
-  $router.to(Transport(g2));
+  $router.pipe(Tap(g2));
 
   // Initial URL should match first route
   expect(g2).toHaveBeenLastCalledWith("first-route-response");

package/src/navigation/Router._main.test.ts

@@ -3,8 +3,8 @@ import {
   Late,
   Of,
   Shared,
-  Transport,
-  TransportMessage,
+  Tap,
+  TapMessage,
 } from "silentium";
 import { expect, test, vi } from "vitest";
 import { Router } from "../navigation/Router";
@@ -17,24 +17,24 @@ test("Router._main.test", () => {
   const $url = Late<string>("http://domain.com/");
   const $urlPath = Shared(Applied($url, drop("http://domain.com")));
   const g = vi.fn();
-  $urlPath.to(Transport(g));
+  $urlPath.pipe(Tap(g));
 
   const $router = Router(
     $urlPath,
     Of([
       {
         pattern: "^/$",
-        message: TransportMessage(() => Of("page/home.html")),
+        message: TapMessage(() => Of("page/home.html")),
       },
       {
         pattern: "/some/contacts",
-        message: TransportMessage(() => Of("page/contacts.html")),
+        message: TapMessage(() => Of("page/contacts.html")),
       },
     ]),
-    TransportMessage(() => Of<string>("page/404.html")),
+    TapMessage(() => Of<string>("page/404.html")),
   );
   const g2 = vi.fn();
-  $router.to(Transport(g2));
+  $router.pipe(Tap(g2));
 
   expect(g2).toHaveBeenLastCalledWith("page/home.html");
 

package/src/navigation/Router._nested.test.ts

@@ -2,8 +2,8 @@ import {
   LateShared,
   Message,
   Of,
-  Transport,
-  TransportMessage,
+  Tap,
+  TapMessage,
 } from "silentium";
 import { describe, expect, test } from "vitest";
 import { Detached } from "../behaviors/Detached";
@@ -17,11 +17,11 @@ describe("Router._nested.test", () => {
       Of([
         {
           pattern: "^/$",
-          message: TransportMessage(() => Of<string>("home")),
+          message: TapMessage(() => Of<string>("home")),
         },
         {
           pattern: "/admin.*",
-          message: TransportMessage(() => {
+          message: TapMessage(() => {
             return Message((transport) => {
               // need to replace with detached component
               const localUrlSrc = Detached($url);
@@ -31,19 +31,19 @@ describe("Router._nested.test", () => {
                 Of([
                   {
                     pattern: "^/admin/articles$",
-                    message: TransportMessage(() => Of("articles list")),
+                    message: TapMessage(() => Of("articles list")),
                   },
                   {
                     pattern: "^/admin/articles/create$",
-                    message: TransportMessage(() => Of("articles create")),
+                    message: TapMessage(() => Of("articles create")),
                   },
                   {
                     pattern: "^/admin/articles/update$",
-                    message: TransportMessage(() => Of("articles update")),
+                    message: TapMessage(() => Of("articles update")),
                   },
                   {
                     pattern: "^/admin/nested/.*$",
-                    message: TransportMessage(() => {
+                    message: TapMessage(() => {
                       return Message((transport) => {
                         const localUrlSrc = Detached($url);
 
@@ -52,17 +52,17 @@ describe("Router._nested.test", () => {
                           Of([
                             {
                               pattern: "^/admin/nested/list$",
-                              message: TransportMessage(() =>
+                              message: TapMessage(() =>
                                 Of("admin nested list"),
                               ),
                             },
                           ]),
-                          TransportMessage(() =>
+                          TapMessage(() =>
                             Of<string>("admin nested not found"),
                           ),
                         );
 
-                        r.to(transport);
+                        r.pipe(transport);
 
                         return function AdminDestroy() {
                           r.destroy();
@@ -71,10 +71,10 @@ describe("Router._nested.test", () => {
                     }),
                   },
                 ]),
-                TransportMessage(() => Of<string>("admin not found")),
+                TapMessage(() => Of<string>("admin not found")),
               );
 
-              r.to(transport);
+              r.pipe(transport);
 
               return function AdminDestroy() {
                 r.destroy();
@@ -83,11 +83,11 @@ describe("Router._nested.test", () => {
           }),
         },
       ]),
-      TransportMessage(() => Of("not found")),
+      TapMessage(() => Of("not found")),
     );
     const d: string[] = [];
-    $router.to(
-      Transport((v) => {
+    $router.pipe(
+      Tap((v) => {
         d.push(v);
       }),
     );

package/src/navigation/Router.ts

@@ -5,15 +5,15 @@ import {
   Message,
   MessageType,
   Of,
-  Transport,
-  TransportType,
+  Tap,
+  TapType,
 } from "silentium";
 import { RegexpMatched } from "../system";
 
 export interface Route<T> {
   pattern: string;
   patternFlags?: string;
-  message: TransportType<void, MessageType<T>>;
+  message: TapType<void, MessageType<T>>;
 }
 
 /**
@@ -23,15 +23,15 @@ export interface Route<T> {
 export function Router<T = "string">(
   $url: MessageType<string>,
   $routes: MessageType<Route<T>[]>,
-  $default: TransportType<void, MessageType<T>>,
+  $default: TapType<void, MessageType<T>>,
 ): MessageType<T> & DestroyableType {
-  return Message<T>((transport) => {
+  return Message<T>(function () {
     const dc = DestroyContainer();
     const destructor = () => {
       dc.destroy();
     };
-    All($routes, $url).to(
-      Transport(([routes, url]) => {
+    All($routes, $url).pipe(
+      Tap(([routes, url]) => {
         destructor();
         const $matches = All(
           ...routes.map((r) =>
@@ -42,20 +42,20 @@ export function Router<T = "string">(
             ),
           ),
         );
-        $matches.to(
-          Transport((matches) => {
+        $matches.pipe(
+          Tap((matches) => {
             const index = matches.findIndex((v) => v === true);
 
             if (index === -1) {
               const instance = $default.use();
               dc.add(instance);
-              instance.to(transport);
+              instance.pipe(this);
             }
 
             if (index > -1) {
               const instance = routes[index].message.use();
               dc.add(instance);
-              instance.to(transport);
+              instance.pipe(this);
             }
           }),
         );

package/src/strings/Concatenated.test.ts

@@ -1,4 +1,4 @@
-import { Of, Transport } from "silentium";
+import { Of, Tap } from "silentium";
 import { Concatenated } from "../strings/Concatenated";
 import { expect, test, vi } from "vitest";
 
@@ -8,7 +8,7 @@ test("Concatenated.test", () => {
     Of("-"),
   );
   const g = vi.fn();
-  $concatenated.to(Transport(g));
+  $concatenated.pipe(Tap(g));
 
   expect(g).toHaveBeenLastCalledWith("one-two-three");
 });

package/src/strings/Concatenated.ts

@@ -1,4 +1,4 @@
-import { All, Message, MessageType, Of, Transport } from "silentium";
+import { All, Message, MessageType, Of, Tap } from "silentium";
 
 /**
  * Join sources Of strings to one source
@@ -8,10 +8,10 @@ export function Concatenated(
   sources: MessageType<string>[],
   joinPartSrc: MessageType<string> = Of(""),
 ) {
-  return Message<string>((transport) => {
-    All(joinPartSrc, ...sources).to(
-      Transport(([joinPart, ...strings]) => {
-        transport.use(strings.join(joinPart));
+  return Message<string>(function () {
+    All(joinPartSrc, ...sources).pipe(
+      Tap(([joinPart, ...strings]) => {
+        this.use(strings.join(joinPart));
       }),
     );
   });

package/src/strings/Template._main.test.ts

@@ -1,4 +1,4 @@
-import { Of, Transport } from "silentium";
+import { Of, Tap } from "silentium";
 import { Template } from "../strings/Template";
 import { Record } from "../structures";
 import { expect, test, vi } from "vitest";
@@ -11,7 +11,7 @@ test("Template._main.test", () => {
     }),
   );
   const g = vi.fn();
-  tpl.to(Transport(g));
+  tpl.pipe(Tap(g));
 
   expect(g).toHaveBeenLastCalledWith("<h1>one value</h1>");
 
@@ -22,7 +22,7 @@ test("Template._main.test", () => {
     }),
   );
   const g2 = vi.fn();
-  tpl2.to(Transport(g2));
+  tpl2.pipe(Tap(g2));
 
   expect(g2).toHaveBeenLastCalledWith("<h2>second value</h2>");
 });

package/src/strings/Template._place.test.ts

@@ -1,4 +1,4 @@
-import { Of, Transport } from "silentium";
+import { Of, Tap } from "silentium";
 import { Template } from "../strings/Template";
 import { expect, test, vi } from "vitest";
 
@@ -6,7 +6,7 @@ test("Template._place.test", () => {
   const t = Template();
   t.template(`<div class="greeting">Hello ${t.var(Of("User"))}</div>`);
   const g = vi.fn();
-  t.to(Transport(g));
+  t.pipe(Tap(g));
 
   expect(g).toHaveBeenLastCalledWith('<div class="greeting">Hello User</div>');
 });

package/src/strings/Template.ts

@@ -6,7 +6,7 @@ import {
   isDestroyable,
   MessageType,
   Of,
-  TransportType,
+  TapType,
 } from "silentium";
 import { Record } from "../structures";
 
@@ -33,7 +33,7 @@ class TemplateImpl implements MessageType<string>, DestroyableType {
     private $places: MessageType<Record<string, unknown>> = Of({}),
   ) {}
 
-  public to(transport: TransportType<string>): this {
+  public pipe(transport: TapType<string>): this {
     const $vars = Record(this.vars);
     Applied(All(this.$src, this.$places, $vars), ([base, rules, vars]) => {
       Object.entries(rules).forEach(([ph, val]) => {
@@ -44,7 +44,7 @@ class TemplateImpl implements MessageType<string>, DestroyableType {
       });
 
       return base;
-    }).to(transport);
+    }).pipe(transport);
     return this;
   }
 

package/src/structures/HashTable.test.ts

@@ -1,4 +1,4 @@
-import { Late, Transport } from "silentium";
+import { Late, Tap } from "silentium";
 import { HashTable } from "../structures/HashTable";
 import { expect, test, vi } from "vitest";
 
@@ -6,7 +6,7 @@ test("HashTable.test", () => {
   const $entry = Late<[string, string]>();
   const $hash = HashTable($entry);
   const g = vi.fn();
-  $hash.to(Transport(g));
+  $hash.pipe(Tap(g));
   $entry.use(["key-one", "value-one"]);
   $entry.use(["key-two", "value-two"]);
 

package/src/structures/HashTable.ts

@@ -1,4 +1,4 @@
-import { Message, MessageType, Transport } from "silentium";
+import { Message, MessageType, Tap } from "silentium";
 
 /**
  * By receiving a message with a key and value, collects a table
@@ -6,13 +6,13 @@ import { Message, MessageType, Transport } from "silentium";
  * https://silentium-lab.github.io/silentium-components/#/structures/hash-table
  */
 export function HashTable<T>($base: MessageType<[string, unknown]>) {
-  return Message<T>((transport) => {
+  return Message<T>(function () {
     const record: Record<string, unknown> = {};
 
-    $base.to(
-      Transport(([key, value]) => {
+    $base.pipe(
+      Tap(([key, value]) => {
         record[key] = value;
-        transport.use(record as T);
+        this.use(record as T);
       }),
     );
   });

package/src/structures/Record._main.test.ts

@@ -1,4 +1,4 @@
-import { Late, Of, Transport } from "silentium";
+import { Late, Of, Tap } from "silentium";
 import { expect, test, vi } from "vitest";
 import { Record } from "./Record";
 
@@ -10,7 +10,7 @@ test("Record._main.test", () => {
     three: $three,
   });
   const g = vi.fn();
-  $record.to(Transport(g));
+  $record.pipe(Tap(g));
 
   expect(g).toHaveBeenLastCalledWith({
     one: "one",

package/src/structures/Record._mixed.test.ts

@@ -1,4 +1,4 @@
-import { Late, Transport } from "silentium";
+import { Late, Tap } from "silentium";
 import { expect, test, vi } from "vitest";
 import { Record } from "./Record";
 
@@ -10,7 +10,7 @@ test("Record._mixed.test", () => {
     three: $three,
   });
   const g = vi.fn();
-  $record.to(Transport(g));
+  $record.pipe(Tap(g));
 
   expect(g).toHaveBeenLastCalledWith({
     one: "one",

package/src/structures/Record.concatenated.test.ts

@@ -1,4 +1,4 @@
-import { Late, Of, Shared, Transport } from "silentium";
+import { Late, Of, Shared, Tap } from "silentium";
 import { Concatenated } from "../strings";
 import { Record } from "./Record";
 import { expect, test, vi } from "vitest";
@@ -15,10 +15,10 @@ test("Record.concatenated.test", () => {
     }),
   );
   const g = vi.fn();
-  r.to(Transport(g));
+  r.pipe(Tap(g));
   let counter = 0;
-  r.to(
-    Transport(() => {
+  r.pipe(
+    Tap(() => {
       counter += 1;
     }),
   );

package/src/structures/Record.nested.test.ts

@@ -1,4 +1,4 @@
-import { Of, Transport } from "silentium";
+import { Of, Tap } from "silentium";
 import { expect, test, vi } from "vitest";
 import { Record } from "./Record";
 
@@ -14,7 +14,7 @@ test("Record.nested.test", () => {
     }),
   });
   const g = vi.fn();
-  $record.to(Transport(g));
+  $record.pipe(Tap(g));
 
   expect(g).toHaveBeenLastCalledWith({
     one: "one",

package/src/structures/Record.ts

@@ -1,4 +1,4 @@
-import { All, isMessage, Message, MessageType, Of, Transport } from "silentium";
+import { All, isMessage, Message, MessageType, Of, Tap } from "silentium";
 
 type UnWrap<T> = T extends MessageType<infer U> ? U : T;
 
@@ -7,20 +7,20 @@ type UnWrap<T> = T extends MessageType<infer U> ? U : T;
  * https://silentium-lab.github.io/silentium-components/#/structures/record
  */
 export function Record<T>(record: Record<string, T>) {
-  return Message<Record<string, UnWrap<T>>>((transport) => {
+  return Message<Record<string, UnWrap<T>>>(function () {
     const keys = Object.keys(record);
     keys.forEach((key) => {
       if (!isMessage(record[key])) {
         record[key] = Of(record[key]) as any;
       }
     });
-    All(...(Object.values(record) as any)).to(
-      Transport((entries) => {
+    All(...(Object.values(record) as any)).pipe(
+      Tap((entries) => {
         const record: Record<string, any> = {};
         entries.forEach((entry, index) => {
           record[keys[index]] = entry;
         });
-        transport.use(record);
+        this.use(record);
       }),
     );
   });

package/src/system/RegexpMatch._group.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 "../behaviors";
 import { RegexpMatch } from "./RegexpMatch";
@@ -7,7 +7,7 @@ test("RegexpMatch._group.test", () => {
   const $url = Of<string>("http://domain.com/some/url/");
   const $matched = Path(RegexpMatch(Of("/(s\\w+)/"), $url), Of("1"));
   const g = vi.fn();
-  $matched.to(Transport(g));
+  $matched.pipe(Tap(g));
 
   expect(g).toHaveBeenLastCalledWith("some");
 });