silentium-components 0.0.65 → 0.0.67

package/src/boolean/Not.test.ts

@@ -1,10 +1,10 @@
-import { late } from "silentium";
-import { not } from "../boolean/Not";
+import { Late } from "silentium";
+import { Not } from "../boolean/Not";
 import { expect, test, vi } from "vitest";
 
 test("Not.test", () => {
-  const one = late<boolean>(false);
-  const result = not(one.event);
+  const one = Late<boolean>(false);
+  const result = Not(one.event);
   const g = vi.fn();
   result(g);
   expect(g).toHaveBeenLastCalledWith(true);

package/src/boolean/Not.ts

@@ -3,10 +3,10 @@ import { EventType } from "silentium";
 /**
  * https://silentium-lab.github.io/silentium-components/#/boolean/not
  */
-export const not = (baseSrc: EventType<boolean>): EventType<boolean> => {
-  return (u) => {
+export function Not(baseSrc: EventType<boolean>): EventType<boolean> {
+  return (user) => {
     baseSrc((v) => {
-      u(!v);
+      user(!v);
     });
   };
-};
+}

package/src/boolean/Or.test.ts

@@ -1,11 +1,11 @@
-import { late } from "silentium";
-import { or } from "../boolean/Or";
+import { Late } from "silentium";
+import { Or } from "../boolean/Or";
 import { expect, test, vi } from "vitest";
 
 test("Or.test", () => {
-  const one = late<boolean>(false);
-  const two = late<boolean>(false);
-  const result = or(one.event, two.event);
+  const one = Late<boolean>(false);
+  const two = Late<boolean>(false);
+  const result = Or(one.event, two.event);
   const g = vi.fn();
   result(g);
   expect(g).toHaveBeenLastCalledWith(false);

package/src/boolean/Or.ts

@@ -1,18 +1,18 @@
-import { all, EventType } from "silentium";
+import { All, EventType } from "silentium";
 
 /**
  * https://silentium-lab.github.io/silentium-components/#/boolean/or
  */
-export const or = (
+export function Or(
   oneSrc: EventType<boolean>,
   twoSrc: EventType<boolean>,
-): EventType<boolean> => {
-  return (u) => {
-    all(
+): EventType<boolean> {
+  return (user) => {
+    All(
       oneSrc,
       twoSrc,
     )(([one, two]) => {
-      u(one || two);
+      user(one || two);
     });
   };
-};
+}

package/src/formats/FromJson.test.ts

@@ -1,10 +1,10 @@
-import { of, primitive } from "silentium";
-import { fromJson } from "../formats/FromJson";
+import { Of, Primitive } from "silentium";
+import { FromJson } from "../formats/FromJson";
 import { expect, test } from "vitest";
 
 test("FromJson.test", () => {
-  const one = of('{"hello": "world"}');
-  const objectSync = primitive(fromJson<{ hello: string }>(one));
+  const one = Of('{"hello": "world"}');
+  const objectSync = Primitive(FromJson<{ hello: string }>(one));
 
   expect(objectSync.primitive()?.hello).toBe("world");
 });

package/src/formats/FromJson.ts

@@ -3,17 +3,17 @@ import { EventType, EventUserType } from "silentium";
 /**
  * Represents object from json
  */
-export const fromJson = <T = Record<string, unknown>>(
+export function FromJson<T = Record<string, unknown>>(
   jsonSrc: EventType<string>,
   errorOwner?: EventUserType,
-): EventType<T> => {
-  return (u) => {
+): EventType<T> {
+  return (user) => {
     jsonSrc((json) => {
       try {
-        u(JSON.parse(json));
+        user(JSON.parse(json));
       } catch (error) {
         errorOwner?.(new Error(`Failed to parse JSON: ${error}`));
       }
     });
   };
-};
+}

package/src/formats/ToJson.test.ts

@@ -1,10 +1,10 @@
-import { of, primitive } from "silentium";
+import { Of, Primitive } from "silentium";
 import { expect, test } from "vitest";
-import { toJson } from "../formats/ToJson";
+import { ToJson } from "../formats/ToJson";
 
 test("ToJson.test", () => {
-  const one = of({ hello: "world" });
-  const objectSync = primitive(toJson(one));
+  const one = Of({ hello: "world" });
+  const objectSync = Primitive(ToJson(one));
 
   expect(objectSync.primitive()).toBe('{"hello":"world"}');
 });

package/src/formats/ToJson.ts

@@ -3,17 +3,17 @@ import { EventType, EventUserType } from "silentium";
 /**
  * Represents json from object
  */
-export const toJson = (
+export function ToJson(
   dataSrc: EventType,
   errorOwner?: EventUserType,
-): EventType<string> => {
-  return (u) => {
+): EventType<string> {
+  return (user) => {
     dataSrc((data: unknown) => {
       try {
-        u(JSON.stringify(data));
+        user(JSON.stringify(data));
       } catch {
         errorOwner?.(new Error("Failed to convert to JSON"));
       }
     });
   };
-};
+}

package/src/lists/First.test.ts

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

package/src/lists/First.ts

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

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

@@ -1,5 +1,5 @@
-import { applied, late, of, shared } from "silentium";
-import { router } from "../navigation/Router";
+import { Applied, Late, Of, Shared } from "silentium";
+import { Router } from "../navigation/Router";
 import { expect, test, vi } from "vitest";
 
 const drop = (dropPart: string) => (value: string) => {
@@ -7,24 +7,24 @@ 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 urlSrc = Late<string>("http://domain.com/");
+  const urlPathSrc = Shared(Applied(urlSrc.event, drop("http://domain.com")));
   const g = vi.fn();
   urlPathSrc.event(g);
 
-  const routerSrc = router(
+  const routerSrc = Router(
     urlPathSrc.event,
-    of([
+    Of([
       {
         pattern: "^/$",
-        template: () => of("page/home.html"),
+        template: () => Of("page/home.html"),
       },
       {
         pattern: "/some/contacts",
-        template: () => of("page/contacts.html"),
+        template: () => Of("page/contacts.html"),
       },
     ]),
-    () => of<string>("page/404.html"),
+    () => Of<string>("page/404.html"),
   );
   const g2 = vi.fn();
   routerSrc(g2);

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

@@ -1,55 +1,55 @@
-import { lateShared, of } from "silentium";
+import { LateShared, Of } from "silentium";
 import { describe, expect, test } from "vitest";
-import { detached } from "../behaviors/Detached";
-import { router } from "../navigation/Router";
+import { Detached } from "../behaviors/Detached";
+import { Router } from "../navigation/Router";
 
 describe("Router._nested.test", () => {
   test("Вложенные роуты", () => {
-    const urlSrc = lateShared("/");
-    const routerSrc = router(
+    const urlSrc = LateShared("/");
+    const routerSrc = Router(
       urlSrc.event,
-      of([
+      Of([
         {
           pattern: "^/$",
-          template: () => of<string>("home"),
+          template: () => Of<string>("home"),
         },
         {
           pattern: "/admin.*",
           template: () => {
             return (user) => {
               // need to replace with detached component
-              const localUrlSrc = detached(urlSrc.event);
+              const localUrlSrc = Detached(urlSrc.event);
 
-              const r = router(
+              const r = Router(
                 localUrlSrc,
-                of([
+                Of([
                   {
                     pattern: "^/admin/articles$",
-                    template: () => of("articles list"),
+                    template: () => Of("articles list"),
                   },
                   {
                     pattern: "^/admin/articles/create$",
-                    template: () => of("articles create"),
+                    template: () => Of("articles create"),
                   },
                   {
                     pattern: "^/admin/articles/update$",
-                    template: () => of("articles update"),
+                    template: () => Of("articles update"),
                   },
                   {
                     pattern: "^/admin/nested/.*$",
                     template: () => {
                       return (user) => {
-                        const localUrlSrc = detached(urlSrc.event);
+                        const localUrlSrc = Detached(urlSrc.event);
 
-                        const r = router(
+                        const r = Router(
                           localUrlSrc,
-                          of([
+                          Of([
                             {
                               pattern: "^/admin/nested/list$",
-                              template: () => of("admin nested list"),
+                              template: () => Of("admin nested list"),
                             },
                           ]),
-                          () => of<string>("admin nested not found"),
+                          () => Of<string>("admin nested not found"),
                         );
                         const rDestructor = r(user);
 
@@ -60,7 +60,7 @@ describe("Router._nested.test", () => {
                     },
                   },
                 ]),
-                () => of<string>("admin not found"),
+                () => Of<string>("admin not found"),
               );
               const rDestructor = r(user);
 
@@ -71,7 +71,7 @@ describe("Router._nested.test", () => {
           },
         },
       ]),
-      () => of("not found"),
+      () => Of("not found"),
     );
     const d: string[] = [];
     routerSrc((v) => {

package/src/navigation/Router.ts

@@ -1,14 +1,14 @@
 import {
-  all,
-  applied,
+  All,
+  Applied,
   EventType,
-  destructor,
+  Destructor,
   DestructorType,
-  of,
+  Of,
   ConstructorType,
 } from "silentium";
-import { regexpMatched } from "../system";
-import { branchLazy } from "../behaviors";
+import { RegexpMatched } from "../system";
+import { BranchLazy } from "../behaviors";
 
 export interface Route<T> {
   pattern: string;
@@ -16,51 +16,51 @@ export interface Route<T> {
   template: ConstructorType<[], EventType<T>>;
 }
 
-const emptySrc = () => of(false);
+const emptySrc = () => Of(false);
 
 /**
  * Router component what will return template if url matches pattern
  * https://silentium-lab.github.io/silentium-components/#/navigation/router
  */
-export const router = <T = "string">(
+export function Router<T = "string">(
   urlSrc: EventType<string>,
   routesSrc: EventType<Route<T>[]>,
   defaultSrc: ConstructorType<[], EventType<T>>,
-): EventType<T> => {
-  return (u) => {
+): EventType<T> {
+  return (user) => {
     const destructors: DestructorType[] = [];
     const destroyAllData = () => {
       destructors.forEach((d) => d());
       destructors.length = 0;
     };
-    all(
+    All(
       routesSrc,
       urlSrc,
     )(([routes, url]) => {
       destroyAllData();
-      const instance = all(
+      const instance = All(
         defaultSrc(),
-        all(
+        All(
           ...routes.map(
             (r) =>
-              destructor(
-                branchLazy(
-                  regexpMatched(
-                    of(r.pattern),
-                    of(url),
-                    r.patternFlags ? of(r.patternFlags) : undefined,
+              Destructor(
+                BranchLazy(
+                  RegexpMatched(
+                    Of(r.pattern),
+                    Of(url),
+                    r.patternFlags ? Of(r.patternFlags) : undefined,
                   ),
                   r.template,
                   emptySrc,
                 ),
                 (d: DestructorType) => destructors.push(d),
-              ).value,
+              ).event,
           ),
         ),
       );
 
       // Return first not false or default
-      applied(instance, (r) => {
+      Applied(instance, (r) => {
         const firstReal = r[1].find((r) => r !== false);
 
         if (firstReal) {
@@ -68,9 +68,9 @@ export const router = <T = "string">(
         }
 
         return r[0];
-      })(u);
+      })(user);
     });
 
     return destroyAllData;
   };
-};
+}

package/src/strings/Concatenated.test.ts

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

package/src/strings/Concatenated.ts

@@ -1,19 +1,19 @@
-import { all, EventType, of } from "silentium";
+import { All, EventType, Of } from "silentium";
 
 /**
- * Join sources of strings to one source
+ * Join sources Of strings to one source
  * https://silentium-lab.github.io/silentium-components/#/string/concatenated
  */
-export const concatenated = (
+export function Concatenated(
   sources: EventType<string>[],
-  joinPartSrc: EventType<string> = of(""),
-): EventType<string> => {
-  return (u) => {
-    all(
+  joinPartSrc: EventType<string> = Of(""),
+): EventType<string> {
+  return (user) => {
+    All(
       joinPartSrc,
       ...sources,
     )(([joinPart, ...strings]) => {
-      u(strings.join(joinPart));
+      user(strings.join(joinPart));
     });
   };
-};
+}

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

@@ -1,13 +1,13 @@
-import { of } from "silentium";
-import { template } from "../strings/Template";
-import { recordOf } from "../structures";
+import { Of } from "silentium";
+import { Template } from "../strings/Template";
+import { RecordOf } from "../structures";
 import { expect, test, vi } from "vitest";
 
 test("Template._main.test", () => {
-  const tpl = template(
-    of("<h1>$1</h1>"),
-    recordOf({
-      $1: of("one value"),
+  const tpl = Template(
+    Of("<h1>$1</h1>"),
+    RecordOf({
+      $1: Of("one value"),
     }),
   );
   const g = vi.fn();
@@ -15,10 +15,10 @@ test("Template._main.test", () => {
 
   expect(g).toHaveBeenLastCalledWith("<h1>one value</h1>");
 
-  const tpl2 = template(
-    of("<h2>$1</h2>"),
-    recordOf({
-      $1: of("second value"),
+  const tpl2 = Template(
+    Of("<h2>$1</h2>"),
+    RecordOf({
+      $1: Of("second value"),
     }),
   );
   const g2 = vi.fn();

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

@@ -1,10 +1,10 @@
-import { of } from "silentium";
-import { template } from "../strings/Template";
+import { Of } from "silentium";
+import { Template } from "../strings/Template";
 import { expect, test, vi } from "vitest";
 
 test("Template._place.test", () => {
-  const t = template();
-  t.template(`<div class="greeting">Hello ${t.var(of("User"))}</div>`);
+  const t = Template();
+  t.template(`<div class="greeting">Hello ${t.var(Of("User"))}</div>`);
   const g = vi.fn();
   t.value(g);
 

package/src/strings/Template.ts

@@ -1,26 +1,26 @@
 import {
-  all,
-  applied,
+  All,
+  Applied,
   EventType,
-  destructor,
+  Destructor,
   DestructorType,
-  of,
+  Of,
 } from "silentium";
-import { recordOf } from "../structures";
+import { RecordOf } from "../structures";
 
-export const template = (
-  theSrc: EventType<string> = of(""),
-  placesSrc: EventType<Record<string, unknown>> = of({}),
-) => {
+export function Template(
+  theSrc: EventType<string> = Of(""),
+  placesSrc: EventType<Record<string, unknown>> = Of({}),
+) {
   let placesCounter = 0;
   const vars: Record<string, EventType> = {
-    $TPL: of("$TPL"),
+    $TPL: Of("$TPL"),
   };
   const destructors: DestructorType[] = [];
   return {
-    value: <EventType<string>>((u) => {
-      const varsSrc = recordOf(vars);
-      applied(all(theSrc, placesSrc, varsSrc), ([base, rules, vars]) => {
+    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));
         });
@@ -29,25 +29,25 @@ export const template = (
         });
 
         return base;
-      })(u);
+      })(user);
     }),
     template: (value: string) => {
-      theSrc = of(value);
+      theSrc = Of(value);
     },
     /**
      * Ability to register variable
-     * in concrete place of template
+     * in concrete place Of template
      */
     var: (src: EventType<string>) => {
       const varName = `$var${placesCounter}`;
       placesCounter += 1;
-      vars[varName] = destructor(src, (d: DestructorType) => {
+      vars[varName] = Destructor(src, (d: DestructorType) => {
         destructors.push(d);
-      }).value;
+      }).event;
       return varName;
     },
     destroy() {
       destructors.forEach((d) => d());
     },
   };
-};
+}

package/src/structures/HashTable.test.ts

@@ -1,10 +1,10 @@
-import { late } from "silentium";
-import { hashTable } from "../structures/HashTable";
+import { Late } 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 entrySource = Late<[string, string]>();
+  const hashTableSrc = HashTable(entrySource.event);
   const g = vi.fn();
   hashTableSrc(g);
   entrySource.use(["key-one", "value-one"]);

package/src/structures/HashTable.ts

@@ -3,15 +3,15 @@ import { EventType } from "silentium";
 /**
  * https://silentium-lab.github.io/silentium-components/#/structures/hash-table
  */
-export const hashTable = <T>(
+export function HashTable<T>(
   baseSrc: EventType<[string, unknown]>,
-): EventType<T> => {
-  return (u) => {
+): EventType<T> {
+  return (user) => {
     const record: Record<string, unknown> = {};
 
     baseSrc(([key, value]) => {
       record[key] = value;
-      u(record as T);
+      user(record as T);
     });
   };
-};
+}

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

@@ -1,12 +1,12 @@
-import { late, of } from "silentium";
+import { Late, Of } from "silentium";
 import { expect, test, vi } from "vitest";
-import { recordOf } from "./RecordOf";
+import { RecordOf } from "./RecordOf";
 
 test("Record._main.test", () => {
-  const three = late<string>("three");
-  const recordSrc = recordOf({
-    one: of("one"),
-    two: of(2),
+  const three = Late<string>("three");
+  const recordSrc = RecordOf({
+    one: Of("one"),
+    two: Of(2),
     three: three.event,
   });
   const g = vi.fn();