silentium-components 0.0.26 → 0.0.28

package/src/behaviors/Sync.ts

@@ -1,19 +1,42 @@
-import { InformationType } from "silentium";
+import { From, isFilled, TheInformation, TheOwner } from "silentium";
 
-export const sync = <T>(base: InformationType<T>) => {
-  let value: T | undefined;
+export class Sync<T> extends TheInformation<T> {
+  private theValue: T | undefined;
+  private isInit = false;
 
-  base((v) => {
-    value = v;
-  });
+  public constructor(private baseSrc: TheInformation<T>) {
+    super(baseSrc);
+  }
 
-  return {
-    value() {
-      if (value === undefined) {
-        throw new Error("no value in sync");
-      }
+  public value(o: TheOwner<T>): this {
+    this.baseSrc.value(o);
+    return this;
+  }
 
-      return value;
-    },
-  };
-};
+  public valueExisted() {
+    this.initOwner();
+    return isFilled(this.theValue);
+  }
+
+  public valueSync(): T {
+    this.initOwner();
+
+    if (!isFilled(this.theValue)) {
+      throw new Error("no value in sync");
+    }
+
+    return this.theValue;
+  }
+
+  public initOwner() {
+    if (!this.isInit) {
+      this.isInit = true;
+      this.value(
+        new From((v) => {
+          this.theValue = v;
+        }),
+      );
+    }
+    return this;
+  }
+}

package/src/behaviors/Tick.test.ts

@@ -1,6 +1,6 @@
-import { any, of, sharedStateless } from "silentium";
+import { Any, From, Late, Shared } from "silentium";
 import { afterEach, beforeEach, expect, test, vi } from "vitest";
-import { tick } from "../behaviors/Tick";
+import { Tick } from "../behaviors/Tick";
 
 beforeEach(() => {
   vi.useFakeTimers({ shouldAdvanceTime: true });
@@ -12,15 +12,15 @@ afterEach(() => {
 });
 
 test("Tick.test", async () => {
-  const [s1, s1o] = of<number>(1);
-  const [s2, s2o] = of<number>(2);
-  const [tickSrc] = sharedStateless(tick(any(s1, s2)));
+  const s1 = new Late<number>(1);
+  const s2 = new Late<number>(2);
+  const tickSrc = new Shared(new Tick(new Any(s1, s2)), true);
 
   const g = vi.fn();
-  tickSrc(g);
+  tickSrc.value(new From(g));
 
-  s1o(3);
-  s2o(4);
+  s1.owner().give(3);
+  s2.owner().give(4);
 
   await vi.advanceTimersByTimeAsync(10);
   vi.runAllTicks();

package/src/behaviors/Tick.ts

@@ -1,11 +1,15 @@
-import { InformationType } from "silentium";
+import { From, TheInformation, TheOwner } 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 const tick = <T>(baseSrc: InformationType<T>): InformationType<T> => {
-  return (o) => {
+export class Tick<T> extends TheInformation<T> {
+  public constructor(private baseSrc: TheInformation<T>) {
+    super(baseSrc);
+  }
+
+  public value(o: TheOwner<T>): this {
     let microtaskScheduled = false;
     let lastValue: T | null = null;
 
@@ -14,17 +18,21 @@ export const tick = <T>(baseSrc: InformationType<T>): InformationType<T> => {
       queueMicrotask(() => {
         microtaskScheduled = false;
         if (lastValue !== null) {
-          o(lastValue);
+          o.give(lastValue);
           lastValue = null;
         }
       });
     };
 
-    baseSrc((v) => {
-      lastValue = v;
-      if (!microtaskScheduled) {
-        scheduleMicrotask();
-      }
-    });
-  };
-};
+    this.baseSrc.value(
+      new From((v) => {
+        lastValue = v;
+        if (!microtaskScheduled) {
+          scheduleMicrotask();
+        }
+      }),
+    );
+
+    return this;
+  }
+}

package/src/boolean/And.test.ts

@@ -1,24 +1,24 @@
-import { of } from "silentium";
+import { From, Late } from "silentium";
 import { expect, test, vi } from "vitest";
-import { and } from "../boolean/And";
+import { And } from "../boolean/And";
 
 test("And.test", () => {
-  const [one, oo] = of<boolean>(false);
-  const [two, to] = of<boolean>(false);
-  const result = and(one, two);
+  const one = new Late<boolean>(false);
+  const two = new Late<boolean>(false);
+  const result = new And(one, two);
   const g = vi.fn();
-  result(g);
+  result.value(new From(g));
   expect(g).toHaveBeenLastCalledWith(false);
 
-  oo(true);
-  to(false);
+  one.owner().give(true);
+  two.owner().give(false);
   expect(g).toHaveBeenLastCalledWith(false);
 
-  oo(false);
-  to(true);
+  one.owner().give(false);
+  two.owner().give(true);
   expect(g).toHaveBeenLastCalledWith(false);
 
-  oo(true);
-  to(true);
+  one.owner().give(true);
+  two.owner().give(true);
   expect(g).toHaveBeenLastCalledWith(true);
 });

package/src/boolean/And.ts

@@ -1,18 +1,22 @@
-import { all, InformationType } from "silentium";
+import { All, From, TheInformation, TheOwner } from "silentium";
 
 /**
  * https://silentium-lab.github.io/silentium-components/#/boolean/and
  */
-export const and = (
-  oneSrc: InformationType<boolean>,
-  twoSrc: InformationType<boolean>,
-): InformationType<boolean> => {
-  return (o) => {
-    all(
-      oneSrc,
-      twoSrc,
-    )(([one, two]) => {
-      o(one && two);
-    });
-  };
-};
+export class And extends TheInformation<boolean> {
+  public constructor(
+    private oneSrc: TheInformation<boolean>,
+    private twoSrc: TheInformation<boolean>,
+  ) {
+    super(oneSrc, twoSrc);
+  }
+
+  public value(o: TheOwner<boolean>): this {
+    new All(this.oneSrc, this.twoSrc).value(
+      new From(([one, two]) => {
+        o.give(one && two);
+      }),
+    );
+    return this;
+  }
+}

package/src/boolean/Bool.ts

@@ -1,7 +1,16 @@
-import { applied, InformationType } from "silentium";
+import { Applied, TheInformation, TheOwner } from "silentium";
 
 /**
  * Convert any source to boolean source
  * https://silentium-lab.github.io/silentium-components/#/boolean/bool
  */
-export const bool = (baseSrc: InformationType) => applied(baseSrc, Boolean);
+export class Bool extends TheInformation<boolean> {
+  public constructor(private baseSrc: TheInformation) {
+    super(baseSrc);
+  }
+
+  public value(o: TheOwner<boolean>): this {
+    new Applied(this.baseSrc, Boolean).value(o);
+    return this;
+  }
+}

package/src/boolean/Not.test.ts

@@ -1,14 +1,14 @@
-import { of } from "silentium";
+import { From, Late } from "silentium";
 import { expect, test, vi } from "vitest";
-import { not } from "../boolean/Not";
+import { Not } from "../boolean/Not";
 
 test("Not.test", () => {
-  const [one, oo] = of<boolean>(false);
-  const result = not(one);
+  const one = new Late<boolean>(false);
+  const result = new Not(one);
   const g = vi.fn();
-  result(g);
+  result.value(new From(g));
   expect(g).toHaveBeenLastCalledWith(true);
 
-  oo(true);
+  one.owner().give(true);
   expect(g).toHaveBeenLastCalledWith(false);
 });

package/src/boolean/Not.ts

@@ -1,14 +1,19 @@
-import { InformationType } from "silentium";
+import { From, TheInformation, TheOwner } from "silentium";
 
 /**
  * https://silentium-lab.github.io/silentium-components/#/boolean/not
  */
-export const not = (
-  baseSrc: InformationType<boolean>,
-): InformationType<boolean> => {
-  return (o) => {
-    baseSrc((v) => {
-      o(!v);
-    });
-  };
-};
+export class Not extends TheInformation<boolean> {
+  public constructor(private baseSrc: TheInformation<boolean>) {
+    super(baseSrc);
+  }
+
+  public value(o: TheOwner<boolean>): this {
+    this.baseSrc.value(
+      new From((v) => {
+        o.give(!v);
+      }),
+    );
+    return this;
+  }
+}

package/src/boolean/Or.test.ts

@@ -1,24 +1,24 @@
-import { of } from "silentium";
+import { From, Late } from "silentium";
 import { expect, test, vi } from "vitest";
-import { or } from "../boolean/Or";
+import { Or } from "../boolean/Or";
 
 test("Or.test", () => {
-  const [one, oo] = of<boolean>(false);
-  const [two, to] = of<boolean>(false);
-  const result = or(one, two);
+  const one = new Late<boolean>(false);
+  const two = new Late<boolean>(false);
+  const result = new Or(one, two);
   const g = vi.fn();
-  result(g);
+  result.value(new From(g));
   expect(g).toHaveBeenLastCalledWith(false);
 
-  oo(true);
-  to(false);
+  one.owner().give(true);
+  two.owner().give(false);
   expect(g).toHaveBeenLastCalledWith(true);
 
-  oo(false);
-  to(true);
+  one.owner().give(false);
+  two.owner().give(true);
   expect(g).toHaveBeenLastCalledWith(true);
 
-  oo(true);
-  to(true);
+  one.owner().give(true);
+  two.owner().give(true);
   expect(g).toHaveBeenLastCalledWith(true);
 });

package/src/boolean/Or.ts

@@ -1,18 +1,22 @@
-import { all, InformationType } from "silentium";
+import { All, From, TheInformation, TheOwner } from "silentium";
 
 /**
  * https://silentium-lab.github.io/silentium-components/#/boolean/or
  */
-export const or = (
-  oneSrc: InformationType<boolean>,
-  twoSrc: InformationType<boolean>,
-): InformationType<boolean> => {
-  return (o) => {
-    all(
-      oneSrc,
-      twoSrc,
-    )(([one, two]) => {
-      o(one || two);
-    });
-  };
-};
+export class Or extends TheInformation<boolean> {
+  public constructor(
+    private oneSrc: TheInformation<boolean>,
+    private twoSrc: TheInformation<boolean>,
+  ) {
+    super(oneSrc, twoSrc);
+  }
+
+  public value(o: TheOwner<boolean>): this {
+    new All(this.oneSrc, this.twoSrc).value(
+      new From(([one, two]) => {
+        o.give(one || two);
+      }),
+    );
+    return this;
+  }
+}

package/src/boolean/index.ts

@@ -1,3 +1,4 @@
 export * from "./And";
 export * from "./Or";
 export * from "./Not";
+export * from "./Bool";

package/src/formats/FromJson.test.ts

@@ -0,0 +1,11 @@
+import { Late } from "silentium";
+import { expect, test } from "vitest";
+import { Sync } from "../behaviors/Sync";
+import { FromJson } from "../formats/FromJson";
+
+test("FromJson.test", () => {
+  const one = new Late('{"hello": "world"}');
+  const objectSync = new Sync(new FromJson<{ hello: string }>(one));
+
+  expect(objectSync.valueSync().hello).toBe("world");
+});

package/src/formats/FromJson.ts

@@ -1,19 +1,26 @@
-import { InformationType, OwnerType } from "silentium";
+import { From, TheInformation, TheOwner } from "silentium";
 
 /**
  * Represents object from json
  */
-export const fromJson = <T>(
-  jsonSrc: InformationType<string>,
-  errorOwner?: OwnerType,
-): InformationType<T> => {
-  return (o) => {
-    jsonSrc((json) => {
-      try {
-        o(JSON.parse(json));
-      } catch (error) {
-        errorOwner?.(new Error(`Failed to parse JSON: ${error}`));
-      }
-    });
-  };
-};
+export class FromJson<T> extends TheInformation<T> {
+  public constructor(
+    private jsonSrc: TheInformation<string>,
+    private errorOwner?: TheOwner,
+  ) {
+    super(jsonSrc);
+  }
+
+  public value(o: TheOwner<T>): this {
+    this.jsonSrc.value(
+      new From((json) => {
+        try {
+          o.give(JSON.parse(json));
+        } catch (error) {
+          this.errorOwner?.give(new Error(`Failed to parse JSON: ${error}`));
+        }
+      }),
+    );
+    return this;
+  }
+}

package/src/formats/ToJson.test.ts

@@ -0,0 +1,11 @@
+import { Late } from "silentium";
+import { expect, test } from "vitest";
+import { Sync } from "../behaviors/Sync";
+import { ToJson } from "../formats/ToJson";
+
+test("FromJson.test", () => {
+  const one = new Late({ hello: "world" });
+  const objectSync = new Sync(new ToJson(one));
+
+  expect(objectSync.valueSync()).toBe('{"hello":"world"}');
+});

package/src/formats/ToJson.ts

@@ -1,19 +1,26 @@
-import { InformationType, OwnerType } from "silentium";
+import { From, TheInformation, TheOwner } from "silentium";
 
 /**
- * Repreresents json from object
+ * Represents json from object
  */
-export const toJson = (
-  dataSrc: InformationType,
-  errorOwner?: OwnerType,
-): InformationType<string> => {
-  return (o) => {
-    dataSrc((data) => {
-      try {
-        o(JSON.stringify(data));
-      } catch {
-        errorOwner?.(new Error("Failed to convert to JSON"));
-      }
-    });
-  };
-};
+export class ToJson extends TheInformation<string> {
+  public constructor(
+    private dataSrc: TheInformation,
+    private errorOwner?: TheOwner,
+  ) {
+    super(dataSrc);
+  }
+
+  public value(o: TheOwner<string>): this {
+    this.dataSrc.value(
+      new From((data: unknown) => {
+        try {
+          o.give(JSON.stringify(data));
+        } catch {
+          this.errorOwner?.give(new Error("Failed to convert to JSON"));
+        }
+      }),
+    );
+    return this;
+  }
+}

package/src/lists/First.test.ts

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

package/src/lists/First.ts

@@ -1,10 +1,15 @@
-import { applied, InformationType } from "silentium";
+import { Applied, TheInformation, TheOwner } from "silentium";
 
 /**
  * Represents the first element of an array.
  */
-export const first = <T extends Array<unknown>>(
-  baseSrc: InformationType<T>,
-): InformationType<T[0]> => {
-  return applied(baseSrc, (a) => a[0]);
-};
+export class First<T extends Array<unknown>> extends TheInformation<T[0]> {
+  public constructor(private baseSrc: TheInformation<T>) {
+    super(baseSrc);
+  }
+
+  public value(o: TheOwner<T[0]>): this {
+    new Applied(this.baseSrc, (a) => a[0]).value(o);
+    return this;
+  }
+}

package/src/navigation/Router.test.ts

@@ -1,46 +1,46 @@
-import { applied, i, of, shared } from "silentium";
+import { Applied, From, Late, Of, Shared } from "silentium";
 import { expect, test, vi } from "vitest";
-import { router } from "../navigation/Router";
+import { Router } from "../navigation/Router";
 
 const drop = (dropPart: string) => (value: string) => {
   return value.replace(dropPart, "");
 };
 
 test("Router.test", () => {
-  const [urlSrc, uo] = of<string>("http://domain.com/");
-  const [urlPathSrc] = shared(applied(urlSrc, drop("http://domain.com")));
+  const urlSrc = new Late<string>("http://domain.com/");
+  const urlPathSrc = new Shared(new Applied(urlSrc, drop("http://domain.com")));
   const g = vi.fn();
-  urlPathSrc(g);
+  urlPathSrc.value(new From(g));
 
-  const routerSrc = router(
+  const routerSrc = new Router(
     urlPathSrc,
-    i([
+    new Of([
       {
         pattern: "^/$",
-        template: i("page/home.html"),
+        template: new Of("page/home.html"),
       },
       {
         pattern: "/some/contacts",
         template: "page/contacts.html",
       },
     ]),
-    i("page/404.html"),
+    new Of<string>("page/404.html"),
   );
   const g2 = vi.fn();
-  routerSrc(g2);
+  routerSrc.value(new From(g2));
 
   expect(g2).toHaveBeenLastCalledWith("page/home.html");
 
-  uo("http://domain.com/some/contacts");
+  urlSrc.owner().give("http://domain.com/some/contacts");
 
   expect(g).toHaveBeenLastCalledWith("/some/contacts");
   expect(g2).toHaveBeenLastCalledWith("page/contacts.html");
 
-  uo("http://domain.com/some/unknown/");
+  urlSrc.owner().give("http://domain.com/some/unknown/");
 
   expect(g2).toHaveBeenLastCalledWith("page/404.html");
 
-  uo("http://domain.com/");
+  urlSrc.owner().give("http://domain.com/");
 
   expect(g2).toHaveBeenLastCalledWith("page/home.html");
 });

package/src/navigation/Router.ts

@@ -1,39 +1,46 @@
-import { any, chain, i, InformationType, OwnerType } from "silentium";
-import { branch } from "../behaviors";
-import { regexpMatched } from "../system/RegexpMatched";
+import { Any, Chain, From, Of, TheInformation, TheOwner } from "silentium";
+import { Branch } from "../behaviors";
+import { RegexpMatched } from "../system";
 
 export interface Route<T> {
   pattern: string;
   patternFlags?: string;
-  template: T | InformationType<T>;
+  template: T | TheInformation<T>;
 }
 
 /**
  * Router component what will return template if url matches pattern
  * https://silentium-lab.github.io/silentium-components/#/navigation/router
  */
-export const router = <T = "string">(
-  urlSrc: InformationType<string>,
-  routesSrc: InformationType<Route<T>[]>,
-  defaultSrc: InformationType<T>,
-): InformationType<T> => {
-  return (o) => {
-    routesSrc((routes) => {
-      any(
-        chain(urlSrc, defaultSrc),
-        ...routes.map((r) => {
-          return branch(
-            regexpMatched(
-              i(r.pattern),
-              urlSrc,
-              r.patternFlags ? i(r.patternFlags) : undefined,
-            ),
-            (typeof r.template === "function"
-              ? r.template
-              : i(r.template)) as InformationType,
-          );
-        }),
-      )(o as OwnerType<unknown>);
-    });
-  };
-};
+export class Router<T = "string"> extends TheInformation<T> {
+  public constructor(
+    private urlSrc: TheInformation<string>,
+    private routesSrc: TheInformation<Route<T>[]>,
+    private defaultSrc: TheInformation<T>,
+  ) {
+    super(urlSrc, routesSrc, defaultSrc);
+  }
+
+  public value(o: TheOwner<T>): this {
+    this.routesSrc.value(
+      new From((routes) => {
+        new Any(
+          new Chain(this.urlSrc, this.defaultSrc),
+          ...routes.map((r) => {
+            return new Branch(
+              new RegexpMatched(
+                new Of(r.pattern),
+                this.urlSrc,
+                r.patternFlags ? new Of(r.patternFlags) : undefined,
+              ),
+              (r.template instanceof TheInformation
+                ? r.template
+                : new Of(r.template)) as TheInformation,
+            );
+          }),
+        ).value(o as TheOwner);
+      }),
+    );
+    return this;
+  }
+}