silentium-components 0.0.70 → 0.0.71

package/src/lists/First.test.ts

@@ -1,10 +1,10 @@
-import { Of } from "silentium";
+import { Of, Transport } 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(g);
+  f.event(Transport(g));
   expect(g).toHaveBeenCalledWith(1);
 });

package/src/lists/First.ts

@@ -1,12 +1,12 @@
-import { Applied, EventType } from "silentium";
+import { Applied, Event, EventType } from "silentium";
 
 /**
  * Represents the first element Of an array.
  */
 export function First<T extends Array<unknown>>(
-  baseSrc: EventType<T>,
+  $base: EventType<T>,
 ): EventType<T[0]> {
-  return (user) => {
-    Applied(baseSrc, (a) => a[0])(user);
-  };
+  return Event((transport) => {
+    Applied($base, (a) => a[0]).event(transport);
+  });
 }

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

@@ -1,4 +1,11 @@
-import { Applied, Late, Of, Shared } from "silentium";
+import {
+  Applied,
+  Late,
+  Of,
+  Shared,
+  Transport,
+  TransportEvent,
+} from "silentium";
 import { Router } from "../navigation/Router";
 import { expect, test, vi } from "vitest";
 
@@ -7,40 +14,40 @@ const drop = (dropPart: string) => (value: string) => {
 };
 
 test("Router._main.test", () => {
-  const urlSrc = Late<string>("http://domain.com/");
-  const urlPathSrc = Shared(Applied(urlSrc.event, drop("http://domain.com")));
+  const $url = Late<string>("http://domain.com/");
+  const $urlPath = Shared(Applied($url, drop("http://domain.com")));
   const g = vi.fn();
-  urlPathSrc.event(g);
+  $urlPath.event(Transport(g));
 
-  const routerSrc = Router(
-    urlPathSrc.event,
+  const $router = Router(
+    $urlPath,
     Of([
       {
         pattern: "^/$",
-        template: () => Of("page/home.html"),
+        event: TransportEvent(() => Of("page/home.html")),
       },
       {
         pattern: "/some/contacts",
-        template: () => Of("page/contacts.html"),
+        event: TransportEvent(() => Of("page/contacts.html")),
       },
     ]),
-    () => Of<string>("page/404.html"),
+    TransportEvent(() => Of<string>("page/404.html")),
   );
   const g2 = vi.fn();
-  routerSrc(g2);
+  $router.event(Transport(g2));
 
   expect(g2).toHaveBeenLastCalledWith("page/home.html");
 
-  urlSrc.use("http://domain.com/some/contacts");
+  $url.use("http://domain.com/some/contacts");
 
   expect(g).toHaveBeenLastCalledWith("/some/contacts");
   expect(g2).toHaveBeenLastCalledWith("page/contacts.html");
 
-  urlSrc.use("http://domain.com/some/unknown/");
+  $url.use("http://domain.com/some/unknown/");
 
   expect(g2).toHaveBeenLastCalledWith("page/404.html");
 
-  urlSrc.use("http://domain.com/");
+  $url.use("http://domain.com/");
 
   expect(g2).toHaveBeenLastCalledWith("page/home.html");
 });

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

@@ -1,88 +1,96 @@
-import { LateShared, Of } from "silentium";
+import { Event, LateShared, Of, Transport, TransportEvent } from "silentium";
 import { describe, expect, test } from "vitest";
 import { Detached } from "../behaviors/Detached";
 import { Router } from "../navigation/Router";
 
 describe("Router._nested.test", () => {
   test("Вложенные роуты", () => {
-    const urlSrc = LateShared("/");
-    const routerSrc = Router(
-      urlSrc.event,
+    const $url = LateShared("/");
+    const $router = Router(
+      $url,
       Of([
         {
           pattern: "^/$",
-          template: () => Of<string>("home"),
+          event: TransportEvent(() => Of<string>("home")),
         },
         {
           pattern: "/admin.*",
-          template: () => {
-            return (user) => {
+          event: TransportEvent(() => {
+            return Event((transport) => {
               // need to replace with detached component
-              const localUrlSrc = Detached(urlSrc.event);
+              const localUrlSrc = Detached($url);
 
               const r = Router(
                 localUrlSrc,
                 Of([
                   {
                     pattern: "^/admin/articles$",
-                    template: () => Of("articles list"),
+                    event: TransportEvent(() => Of("articles list")),
                   },
                   {
                     pattern: "^/admin/articles/create$",
-                    template: () => Of("articles create"),
+                    event: TransportEvent(() => Of("articles create")),
                   },
                   {
                     pattern: "^/admin/articles/update$",
-                    template: () => Of("articles update"),
+                    event: TransportEvent(() => Of("articles update")),
                   },
                   {
                     pattern: "^/admin/nested/.*$",
-                    template: () => {
-                      return (user) => {
-                        const localUrlSrc = Detached(urlSrc.event);
+                    event: TransportEvent(() => {
+                      return Event((transport) => {
+                        const localUrlSrc = Detached($url);
 
                         const r = Router(
                           localUrlSrc,
                           Of([
                             {
                               pattern: "^/admin/nested/list$",
-                              template: () => Of("admin nested list"),
+                              event: TransportEvent(() =>
+                                Of("admin nested list"),
+                              ),
                             },
                           ]),
-                          () => Of<string>("admin nested not found"),
+                          TransportEvent(() =>
+                            Of<string>("admin nested not found"),
+                          ),
                         );
-                        const rDestructor = r(user);
+
+                        r.event(transport);
 
                         return function AdminDestroy() {
-                          rDestructor?.();
+                          r.destroy();
                         };
-                      };
-                    },
+                      });
+                    }),
                   },
                 ]),
-                () => Of<string>("admin not found"),
+                TransportEvent(() => Of<string>("admin not found")),
               );
-              const rDestructor = r(user);
+
+              r.event(transport);
 
               return function AdminDestroy() {
-                rDestructor?.();
+                r.destroy();
               };
-            };
-          },
+            });
+          }),
         },
       ]),
-      () => Of("not found"),
+      TransportEvent(() => Of("not found")),
     );
     const d: string[] = [];
-    routerSrc((v) => {
-      d.push(v);
-    });
+    $router.event(
+      Transport((v) => {
+        d.push(v);
+      }),
+    );
     const pd = () => d.join("\n");
 
-    urlSrc.use("/admin/articles");
-    urlSrc.use("/admin/nested/list");
-    urlSrc.use("/admin/articles/create");
-    urlSrc.use("/admin/articles/update");
+    $url.use("/admin/articles");
+    $url.use("/admin/nested/list");
+    $url.use("/admin/articles/create");
+    $url.use("/admin/articles/update");
 
     expect(pd()).toBe(`home
 articles list

package/src/navigation/Router.ts

@@ -1,76 +1,74 @@
 import {
   All,
   Applied,
+  DestroyableType,
+  Event,
   EventType,
-  Destructor,
-  DestructorType,
   Of,
-  ConstructorType,
+  Transport,
+  TransportDestroyable,
+  TransportEvent,
+  TransportType,
 } from "silentium";
-import { RegexpMatched } from "../system";
 import { BranchLazy } from "../behaviors";
+import { RegexpMatched } from "../system";
 
 export interface Route<T> {
   pattern: string;
   patternFlags?: string;
-  template: ConstructorType<[], EventType<T>>;
+  event: TransportType<[], EventType<T>>;
 }
 
-const emptySrc = () => Of(false);
+const $empty = TransportEvent(() => Of(false));
 
 /**
  * Router component what will return template if url matches pattern
  * https://silentium-lab.github.io/silentium-components/#/navigation/router
  */
 export function Router<T = "string">(
-  urlSrc: EventType<string>,
-  routesSrc: EventType<Route<T>[]>,
-  defaultSrc: ConstructorType<[], EventType<T>>,
-): EventType<T> {
-  return (user) => {
-    const destructors: DestructorType[] = [];
-    const destroyAllData = () => {
-      destructors.forEach((d) => d());
+  $url: EventType<string>,
+  $routes: EventType<Route<T>[]>,
+  $default: TransportType<void, EventType<T>>,
+): EventType<T> & DestroyableType {
+  return Event<T>((transport) => {
+    const destructors: DestroyableType[] = [];
+    const destructor = () => {
+      destructors.forEach((d) => d.destroy());
       destructors.length = 0;
     };
-    All(
-      routesSrc,
-      urlSrc,
-    )(([routes, url]) => {
-      destroyAllData();
-      const instance = All(
-        defaultSrc(),
-        All(
-          ...routes.map(
-            (r) =>
-              Destructor(
-                BranchLazy(
-                  RegexpMatched(
-                    Of(r.pattern),
-                    Of(url),
-                    r.patternFlags ? Of(r.patternFlags) : undefined,
-                  ),
-                  r.template,
-                  emptySrc,
+    All($routes, $url).event(
+      Transport(([routes, url]) => {
+        destructor();
+        const instance = All(
+          $default.use(),
+          All(
+            ...routes.map((r) => {
+              const $template = TransportDestroyable(r.event);
+              destructors.push($template);
+              return BranchLazy(
+                RegexpMatched(
+                  Of(r.pattern),
+                  Of(url),
+                  r.patternFlags ? Of(r.patternFlags) : undefined,
                 ),
-                (d: DestructorType) => destructors.push(d),
-              ).event,
+                $template,
+                $empty,
+              );
+            }),
           ),
-        ),
-      );
-
-      // Return first not false or default
-      Applied(instance, (r) => {
-        const firstReal = r[1].find((r) => r !== false);
-
-        if (firstReal) {
-          return firstReal as T;
-        }
+        );
 
-        return r[0];
-      })(user);
-    });
+        // Return first not false or default
+        Applied(instance, (r) => {
+          const first = r[1].find((r: unknown) => r !== false);
+          if (first) {
+            return first as T;
+          }
+          return r[0];
+        }).event(transport);
+      }),
+    );
 
-    return destroyAllData;
-  };
+    return destructor;
+  });
 }

package/src/strings/Concatenated.test.ts

@@ -1,14 +1,14 @@
-import { Of } from "silentium";
+import { Of, Transport } from "silentium";
 import { Concatenated } from "../strings/Concatenated";
 import { expect, test, vi } from "vitest";
 
 test("Concatenated.test", () => {
-  const concatenatedSrc = Concatenated(
+  const $concatenated = Concatenated(
     [Of("one"), Of("two"), Of("three")],
     Of("-"),
   );
   const g = vi.fn();
-  concatenatedSrc(g);
+  $concatenated.event(Transport(g));
 
   expect(g).toHaveBeenLastCalledWith("one-two-three");
 });

package/src/strings/Concatenated.ts

@@ -1,4 +1,4 @@
-import { All, EventType, Of } from "silentium";
+import { All, Event, EventType, Of, Transport } from "silentium";
 
 /**
  * Join sources Of strings to one source
@@ -8,12 +8,11 @@ export function Concatenated(
   sources: EventType<string>[],
   joinPartSrc: EventType<string> = Of(""),
 ): EventType<string> {
-  return (user) => {
-    All(
-      joinPartSrc,
-      ...sources,
-    )(([joinPart, ...strings]) => {
-      user(strings.join(joinPart));
-    });
-  };
+  return Event((transport) => {
+    All(joinPartSrc, ...sources).event(
+      Transport(([joinPart, ...strings]) => {
+        transport.use(strings.join(joinPart));
+      }),
+    );
+  });
 }

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

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

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

@@ -1,4 +1,4 @@
-import { Of } from "silentium";
+import { Of, Transport } 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.value(g);
+  t.event(Transport(g));
 
   expect(g).toHaveBeenLastCalledWith('<div class="greeting">Hello User</div>');
 });

package/src/strings/Template.ts

@@ -1,53 +1,67 @@
 import {
   All,
   Applied,
+  DestroyableType,
+  DestroyContainer,
   EventType,
-  Destructor,
-  DestructorType,
+  isDestroyable,
   Of,
+  TransportType,
 } from "silentium";
 import { RecordOf } from "../structures";
 
 export function Template(
-  theSrc: EventType<string> = Of(""),
-  placesSrc: EventType<Record<string, unknown>> = Of({}),
+  $src: EventType<string> = Of(""),
+  $places: EventType<Record<string, unknown>> = Of({}),
 ) {
-  let placesCounter = 0;
-  const vars: Record<string, EventType> = {
+  return new TemplateEvent($src, $places);
+}
+
+class TemplateEvent implements EventType<string>, DestroyableType {
+  private dc = DestroyContainer();
+  private vars: Record<string, EventType> = {
     $TPL: Of("$TPL"),
   };
-  const destructors: DestructorType[] = [];
-  return {
-    value: <EventType<string>>((user) => {
-      const varsSrc = RecordOf(vars);
-      Applied(All(theSrc, placesSrc, varsSrc), ([base, rules, vars]) => {
-        Object.entries(rules).forEach(([ph, val]) => {
-          base = base.replaceAll(ph, String(val));
-        });
-        Object.entries(vars).forEach(([ph, val]) => {
-          base = base.replaceAll(ph, String(val));
-        });
-
-        return base;
-      })(user);
-    }),
-    template: (value: string) => {
-      theSrc = Of(value);
-    },
-    /**
-     * Ability to register variable
-     * in concrete place Of template
-     */
-    var: (src: EventType<string>) => {
-      const varName = `$var${placesCounter}`;
-      placesCounter += 1;
-      vars[varName] = Destructor(src, (d: DestructorType) => {
-        destructors.push(d);
-      }).event;
-      return varName;
-    },
-    destroy() {
-      destructors.forEach((d) => d());
-    },
-  };
+
+  public constructor(
+    private $src: EventType<string> = Of(""),
+    private $places: EventType<Record<string, unknown>> = Of({}),
+  ) {}
+
+  public event(transport: TransportType<string, null>): this {
+    const $vars = RecordOf(this.vars);
+    Applied(All(this.$src, this.$places, $vars), ([base, rules, vars]) => {
+      Object.entries(rules).forEach(([ph, val]) => {
+        base = base.replaceAll(ph, String(val));
+      });
+      Object.entries(vars).forEach(([ph, val]) => {
+        base = base.replaceAll(ph, String(val));
+      });
+
+      return base;
+    }).event(transport);
+    return this;
+  }
+
+  public template(value: string) {
+    this.$src = Of(value);
+  }
+
+  /**
+   * Ability to register variable
+   * in concrete place Of template
+   */
+  public var(src: EventType<string>) {
+    const places = Object.keys(this.vars).length;
+    const varName = `$var${places}`;
+    if (isDestroyable(src)) {
+      this.dc.add(src);
+    }
+    this.vars[varName] = src;
+    return varName;
+  }
+
+  public destroy(): this {
+    return this;
+  }
 }

package/src/structures/HashTable.test.ts

@@ -1,14 +1,14 @@
-import { Late } from "silentium";
+import { Late, Transport } from "silentium";
 import { HashTable } from "../structures/HashTable";
 import { expect, test, vi } from "vitest";
 
 test("HashTable.test", () => {
-  const entrySource = Late<[string, string]>();
-  const hashTableSrc = HashTable(entrySource.event);
+  const $entry = Late<[string, string]>();
+  const $hash = HashTable($entry);
   const g = vi.fn();
-  hashTableSrc(g);
-  entrySource.use(["key-one", "value-one"]);
-  entrySource.use(["key-two", "value-two"]);
+  $hash.event(Transport(g));
+  $entry.use(["key-one", "value-one"]);
+  $entry.use(["key-two", "value-two"]);
 
   expect(g).toHaveBeenLastCalledWith({
     "key-one": "value-one",

package/src/structures/HashTable.ts

@@ -1,17 +1,19 @@
-import { EventType } from "silentium";
+import { Event, EventType, Transport } from "silentium";
 
 /**
  * https://silentium-lab.github.io/silentium-components/#/structures/hash-table
  */
 export function HashTable<T>(
-  baseSrc: EventType<[string, unknown]>,
+  $base: EventType<[string, unknown]>,
 ): EventType<T> {
-  return (user) => {
+  return Event((transport) => {
     const record: Record<string, unknown> = {};
 
-    baseSrc(([key, value]) => {
-      record[key] = value;
-      user(record as T);
-    });
-  };
+    $base.event(
+      Transport(([key, value]) => {
+        record[key] = value;
+        transport.use(record as T);
+      }),
+    );
+  });
 }

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

@@ -1,16 +1,16 @@
-import { Late, Of } from "silentium";
+import { Late, Of, Transport } from "silentium";
 import { expect, test, vi } from "vitest";
 import { RecordOf } from "./RecordOf";
 
 test("Record._main.test", () => {
-  const three = Late<string>("three");
-  const recordSrc = RecordOf({
+  const $three = Late<string>("three");
+  const $record = RecordOf({
     one: Of("one"),
     two: Of(2),
-    three: three.event,
+    three: $three,
   });
   const g = vi.fn();
-  recordSrc(g);
+  $record.event(Transport(g));
 
   expect(g).toHaveBeenLastCalledWith({
     one: "one",
@@ -18,7 +18,7 @@ test("Record._main.test", () => {
     three: "three",
   });
 
-  three.use("three-changed");
+  $three.use("three-changed");
 
   expect(g).toHaveBeenLastCalledWith({
     one: "one",