silentium-components 0.0.26 → 0.0.28

package/src/strings/Concatenated.test.ts

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

package/src/strings/Concatenated.ts

@@ -1,19 +1,23 @@
-import { all, i, InformationType } from "silentium";
+import { All, From, Of, TheInformation, TheOwner } from "silentium";
 
 /**
  * Join sources of strings to one source
  * https://silentium-lab.github.io/silentium-components/#/string/concatenated
  */
-export const concatenated = (
-  sources: InformationType<string>[],
-  joinPartSrc: InformationType<string> = i(""),
-): InformationType<string> => {
-  return (o) => {
-    all(
-      joinPartSrc,
-      ...sources,
-    )(([joinPart, ...strings]) => {
-      o(strings.join(joinPart));
-    });
-  };
-};
+export class Concatenated extends TheInformation<string> {
+  public constructor(
+    private sources: TheInformation<string>[],
+    private joinPartSrc: TheInformation<string> = new Of(""),
+  ) {
+    super(...sources, joinPartSrc);
+  }
+
+  public value(o: TheOwner<string>): this {
+    new All(this.joinPartSrc, ...this.sources).value(
+      new From(([joinPart, ...strings]) => {
+        o.give(strings.join(joinPart));
+      }),
+    );
+    return this;
+  }
+}

package/src/structures/HashTable.test.ts

@@ -1,14 +1,14 @@
-import { of } from "silentium";
+import { From, Late } from "silentium";
 import { expect, test, vi } from "vitest";
-import { hashTable } from "../structures/HashTable";
+import { HashTable } from "../structures/HashTable";
 
 test("HashTable.test", () => {
-  const [entrySource, eo] = of<[string, string]>();
-  const hashTableSrc = hashTable(entrySource);
+  const entrySource = new Late<[string, string]>();
+  const hashTableSrc = new HashTable(entrySource);
   const g = vi.fn();
-  hashTableSrc(g);
-  eo(["key-one", "value-one"]);
-  eo(["key-two", "value-two"]);
+  hashTableSrc.value(new From(g));
+  entrySource.owner().give(["key-one", "value-one"]);
+  entrySource.owner().give(["key-two", "value-two"]);
 
   expect(g).toHaveBeenLastCalledWith({
     "key-one": "value-one",

package/src/structures/HashTable.ts

@@ -1,17 +1,23 @@
-import { InformationType } from "silentium";
+import { From, TheInformation, TheOwner } from "silentium";
 
 /**
  * https://silentium-lab.github.io/silentium-components/#/structures/hash-table
  */
-export const hashTable = <T>(
-  base: InformationType<[string, unknown]>,
-): InformationType<T> => {
-  return (o) => {
+export class HashTable<T> extends TheInformation<T> {
+  public constructor(private baseSrc: TheInformation<[string, unknown]>) {
+    super(baseSrc);
+  }
+
+  public value(o: TheOwner<T>): this {
     const record: Record<string, unknown> = {};
 
-    base(([key, value]) => {
-      record[key] = value;
-      o(record as T);
-    });
-  };
-};
+    this.baseSrc.value(
+      new From(([key, value]) => {
+        record[key] = value;
+        o.give(record as T);
+      }),
+    );
+
+    return this;
+  }
+}

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

@@ -0,0 +1,28 @@
+import { From, Late, Of } from "silentium";
+import { expect, test, vi } from "vitest";
+import { RecordOf } from "./RecordOf";
+
+test("Record._main.test", () => {
+  const three = new Late<string>("three");
+  const recordSrc = new RecordOf({
+    one: new Of("one"),
+    two: new Of(2),
+    three,
+  });
+  const g = vi.fn();
+  recordSrc.value(new From(g));
+
+  expect(g).toHaveBeenLastCalledWith({
+    one: "one",
+    two: 2,
+    three: "three",
+  });
+
+  three.owner().give("three-changed");
+
+  expect(g).toHaveBeenLastCalledWith({
+    one: "one",
+    two: 2,
+    three: "three-changed",
+  });
+});

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

@@ -1,25 +1,27 @@
-import { i, of, shared } from "silentium";
+import { From, Late, Of, Shared } from "silentium";
 import { expect, test, vi } from "vitest";
-import { concatenated } from "../strings";
-import { record } from "./Record";
+import { Concatenated } from "../strings";
+import { RecordOf } from "./RecordOf";
 
 test("Record.concatenated.test", () => {
-  const three = i<string>("three");
-  const [concatPart, cpo] = of<string>("part");
-  const [r] = shared(
-    record({
-      one: i("one"),
-      two: i("two"),
+  const three = new Of<string>("three");
+  const concatPart = new Late<string>("part");
+  const r = new Shared(
+    new RecordOf({
+      one: new Of("one"),
+      two: new Of("two"),
       three,
-      nested: concatenated([i("one"), concatPart]),
+      nested: new Concatenated([new Of("one"), concatPart]),
     }),
   );
   const g = vi.fn();
-  r(g);
+  r.value(new From(g));
   let counter = 0;
-  r(() => {
-    counter += 1;
-  });
+  r.value(
+    new From(() => {
+      counter += 1;
+    }),
+  );
 
   expect(g).toHaveBeenLastCalledWith({
     one: "one",
@@ -28,7 +30,7 @@ test("Record.concatenated.test", () => {
     nested: "onepart",
   });
 
-  cpo("changed");
+  concatPart.owner().give("changed");
 
   expect(g).toHaveBeenLastCalledWith({
     one: "one",

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

@@ -1,20 +1,20 @@
-import { i } from "silentium";
+import { From, Of } from "silentium";
 import { expect, test, vi } from "vitest";
-import { record } from "./Record";
+import { RecordOf } from "./RecordOf";
 
 test("Record.nested.test", () => {
-  const three = i<string>("three");
-  const recordSrc = record({
-    one: i("one"),
-    two: i("two"),
+  const three = new Of<string>("three");
+  const recordSrc = new RecordOf({
+    one: new Of("one"),
+    two: new Of("two"),
     three,
-    nested: record({
-      four: i("four"),
-      five: i("five"),
+    nested: new RecordOf({
+      four: new Of("four"),
+      five: new Of("five"),
     }),
   });
   const g = vi.fn();
-  recordSrc(g);
+  recordSrc.value(new From(g));
 
   expect(g).toHaveBeenLastCalledWith({
     one: "one",

package/src/structures/RecordOf.ts

@@ -0,0 +1,29 @@
+import { All, From, TheInformation, TheOwner } from "silentium";
+
+type UnInformation<T> = T extends TheInformation<infer U> ? U : never;
+
+/**
+ * Returns record of data from record of sources
+ * https://silentium-lab.github.io/silentium-components/#/structures/record
+ */
+export class RecordOf<T extends TheInformation> extends TheInformation<
+  Record<string, UnInformation<T>>
+> {
+  public constructor(private recordSrc: Record<string, T>) {
+    super(...Object.values(recordSrc));
+  }
+
+  public value(o: TheOwner<Record<string, UnInformation<T>>>): this {
+    const keys = Object.keys(this.recordSrc);
+    new All(...Object.values(this.recordSrc)).value(
+      new From((entries) => {
+        const record: Record<string, any> = {};
+        entries.forEach((entry, index) => {
+          record[keys[index]] = entry;
+        });
+        o.give(record);
+      }),
+    );
+    return this;
+  }
+}

package/src/structures/index.ts

@@ -1,2 +1,2 @@
 export * from "./HashTable";
-export * from "./Record";
+export * from "./RecordOf";

package/src/system/RegexpMatch._group.test.ts

@@ -1,13 +1,16 @@
-import { i } from "silentium";
+import { From, Of } from "silentium";
 import { expect, test, vi } from "vitest";
-import { path } from "../behaviors";
-import { regexpMatch } from "./RegexpMatch";
+import { Path } from "../behaviors";
+import { RegexpMatch } from "./RegexpMatch";
 
 test("RegexpMatch._group.test", () => {
-  const urlSrc = i<string>("http://domain.com/some/url/");
-  const matchedSrc = path(regexpMatch(i("/(s\\w+)/"), urlSrc), i("1"));
+  const urlSrc = new Of<string>("http://domain.com/some/url/");
+  const matchedSrc = new Path(
+    new RegexpMatch(new Of("/(s\\w+)/"), urlSrc),
+    new Of("1"),
+  );
   const g = vi.fn();
-  matchedSrc(g);
+  matchedSrc.value(new From(g));
 
   expect(g).toHaveBeenLastCalledWith("some");
 });

package/src/system/RegexpMatch._main.test.ts

@@ -0,0 +1,16 @@
+import { From, Of } from "silentium";
+import { expect, test, vi } from "vitest";
+import { Path } from "../behaviors";
+import { RegexpMatch } from "./RegexpMatch";
+
+test("RegexpMatch._main.test", () => {
+  const urlSrc = new Of<string>("http://domain.com/some/url/");
+  const matchedSrc = new Path(
+    new RegexpMatch(new Of("/(s\\w+)/"), urlSrc),
+    new Of("0"),
+  );
+  const g = vi.fn();
+  matchedSrc.value(new From(g));
+
+  expect(g).toHaveBeenLastCalledWith("/some/");
+});

package/src/system/RegexpMatch.ts

@@ -1,22 +1,25 @@
-import { all, i, InformationType } from "silentium";
+import { All, From, Of, TheInformation, TheOwner } from "silentium";
 
 /**
  * First match of regexp
  * https://silentium-lab.github.io/silentium-components/#/system/regexp-matched
  */
-export const regexpMatch =
-  (
-    patternSrc: InformationType<string>,
-    valueSrc: InformationType<string>,
-    flagsSrc: InformationType<string> = i(""),
-  ): InformationType<string[]> =>
-  (o) => {
-    all(
-      patternSrc,
-      valueSrc,
-      flagsSrc,
-    )(([pattern, value, flags]) => {
-      const result = new RegExp(pattern, flags).exec(value);
-      o(result ?? []);
-    });
-  };
+export class RegexpMatch extends TheInformation<string[]> {
+  public constructor(
+    private patternSrc: TheInformation<string>,
+    private valueSrc: TheInformation<string>,
+    private flagsSrc: TheInformation<string> = new Of(""),
+  ) {
+    super(patternSrc, valueSrc, flagsSrc);
+  }
+
+  public value(o: TheOwner<string[]>): this {
+    new All(this.patternSrc, this.valueSrc, this.flagsSrc).value(
+      new From(([pattern, value, flags]) => {
+        const result = new RegExp(pattern, flags).exec(value);
+        o.give(result ?? []);
+      }),
+    );
+    return this;
+  }
+}

package/src/system/RegexpMatched.test.ts

@@ -1,16 +1,16 @@
-import { i, of } from "silentium";
+import { From, Late, Of } from "silentium";
 import { expect, test, vi } from "vitest";
-import { regexpMatched } from "../system/RegexpMatched";
+import { RegexpMatched } from "../system/RegexpMatched";
 
 test("RegexpMatched.test", () => {
-  const [urlI, urlO] = of<string>("http://domain.com/some/url/");
-  const matchedSrc = regexpMatched(i("/some/url"), urlI);
+  const urlI = new Late<string>("http://domain.com/some/url/");
+  const matchedSrc = new RegexpMatched(new Of("/some/url"), urlI);
   const g = vi.fn();
-  matchedSrc(g);
+  matchedSrc.value(new From(g));
 
   expect(g).toHaveBeenLastCalledWith(true);
 
-  urlO("http://domain.com/changed");
+  urlI.owner().give("http://domain.com/changed");
 
   expect(g).toHaveBeenLastCalledWith(false);
 });

package/src/system/RegexpMatched.ts

@@ -1,21 +1,24 @@
-import { all, i, InformationType } from "silentium";
+import { All, From, Of, TheInformation, TheOwner } from "silentium";
 
 /**
  * Boolean source what checks what string matches pattern
  * https://silentium-lab.github.io/silentium-components/#/system/regexp-matched
  */
-export const regexpMatched =
-  (
-    patternSrc: InformationType<string>,
-    valueSrc: InformationType<string>,
-    flagsSrc: InformationType<string> = i(""),
-  ): InformationType<boolean> =>
-  (o) => {
-    all(
-      patternSrc,
-      valueSrc,
-      flagsSrc,
-    )(([pattern, value, flags]) => {
-      o(new RegExp(pattern, flags).test(value));
-    });
-  };
+export class RegexpMatched extends TheInformation<boolean> {
+  public constructor(
+    private patternSrc: TheInformation<string>,
+    private valueSrc: TheInformation<string>,
+    private flagsSrc: TheInformation<string> = new Of(""),
+  ) {
+    super(patternSrc, valueSrc, flagsSrc);
+  }
+
+  public value(o: TheOwner<boolean>): this {
+    new All(this.patternSrc, this.valueSrc, this.flagsSrc).value(
+      new From(([pattern, value, flags]) => {
+        o.give(new RegExp(pattern, flags).test(value));
+      }),
+    );
+    return this;
+  }
+}

package/src/system/RegexpReplaced.test.ts

@@ -1,16 +1,20 @@
-import { i, of } from "silentium";
+import { From, Late, Of } from "silentium";
 import { expect, test, vi } from "vitest";
-import { regexpReplaced } from "../system/RegexpReplaced";
+import { RegexpReplaced } from "../system/RegexpReplaced";
 
 test("RegexpReplaced.test", () => {
-  const [urlSrc, urlO] = of<string>("http://domain.com/some/url/");
-  const matchedSrc = regexpReplaced(urlSrc, i("some/url/"), i(""));
+  const urlSrc = new Late<string>("http://domain.com/some/url/");
+  const matchedSrc = new RegexpReplaced(
+    urlSrc,
+    new Of("some/url/"),
+    new Of(""),
+  );
   const g = vi.fn();
-  matchedSrc(g);
+  matchedSrc.value(new From(g));
 
   expect(g).toHaveBeenLastCalledWith("http://domain.com/");
 
-  urlO("http://domain.com/some/url/changed/");
+  urlSrc.owner().give("http://domain.com/some/url/changed/");
 
   expect(g).toHaveBeenLastCalledWith("http://domain.com/changed/");
 });

package/src/system/RegexpReplaced.ts

@@ -1,23 +1,30 @@
-import { all, i, InformationType } from "silentium";
+import { All, From, Of, TheInformation, TheOwner } from "silentium";
 
 /**
  * Returns string replaced by regular expression pattern
  * https://silentium-lab.github.io/silentium-components/#/system/regexp-replaced
  */
-export const regexpReplaced =
-  (
-    valueSrc: InformationType<string>,
-    patternSrc: InformationType<string>,
-    replaceValueSrc: InformationType<string>,
-    flagsSrc: InformationType<string> = i(""),
-  ): InformationType<string> =>
-  (o) => {
-    all(
-      patternSrc,
-      valueSrc,
-      replaceValueSrc,
-      flagsSrc,
-    )(([pattern, value, replaceValue, flags]) => {
-      o(String(value).replace(new RegExp(pattern, flags), replaceValue));
-    });
-  };
+export class RegexpReplaced extends TheInformation<string> {
+  public constructor(
+    private valueSrc: TheInformation<string>,
+    private patternSrc: TheInformation<string>,
+    private replaceValueSrc: TheInformation<string>,
+    private flagsSrc: TheInformation<string> = new Of(""),
+  ) {
+    super(valueSrc, patternSrc, replaceValueSrc, flagsSrc);
+  }
+
+  public value(o: TheOwner<string>): this {
+    new All(
+      this.patternSrc,
+      this.valueSrc,
+      this.replaceValueSrc,
+      this.flagsSrc,
+    ).value(
+      new From(([pattern, value, replaceValue, flags]) => {
+        o.give(String(value).replace(new RegExp(pattern, flags), replaceValue));
+      }),
+    );
+    return this;
+  }
+}

package/src/system/Set.test.ts

@@ -1,19 +1,19 @@
-import { i, of } from "silentium";
+import { From, Late, Of } from "silentium";
+import { Set } from "../system/Set";
 import { expect, test, vi } from "vitest";
-import { set } from "../system/Set";
 
 test("Set.test", () => {
-  const [value, o] = of<string>();
+  const value = new Late<string>();
   const object = {
     value: "hello",
   };
-  const obj = set(i(object), i("value"), value);
+  const obj = new Set(new Of(object), new Of("value"), value);
   const g = vi.fn();
-  obj(g);
+  obj.value(new From(g));
 
   expect(object.value).toBe("hello");
 
-  o("bue!");
+  value.owner().give("bue!");
 
   expect(object.value).toBe("bue!");
 });

package/src/system/Set.ts

@@ -1,22 +1,25 @@
-import { all, InformationType } from "silentium";
+import { All, From, TheInformation, TheOwner } from "silentium";
 
 /**
  * Ability to mutate some object, helpful when integrate to procedure systems
  * https://silentium-lab.github.io/silentium-components/#/system/set
  */
-export const set = <T extends Record<string, unknown>>(
-  baseSrc: InformationType<T>,
-  keySrc: InformationType<string>,
-  valueSrc: InformationType<unknown>,
-): InformationType<T> => {
-  return (o) => {
-    all(
-      baseSrc,
-      keySrc,
-      valueSrc,
-    )(([base, key, value]) => {
-      (base as Record<string, unknown>)[key] = value;
-      o(base);
-    });
-  };
-};
+export class Set<T extends Record<string, unknown>> extends TheInformation<T> {
+  public constructor(
+    private baseSrc: TheInformation<T>,
+    private keySrc: TheInformation<string>,
+    private valueSrc: TheInformation<unknown>,
+  ) {
+    super(baseSrc, keySrc, valueSrc);
+  }
+
+  public value(o: TheOwner<T>): this {
+    new All(this.baseSrc, this.keySrc, this.valueSrc).value(
+      new From(([base, key, value]) => {
+        (base as Record<string, unknown>)[key] = value;
+        o.give(base);
+      }),
+    );
+    return this;
+  }
+}

package/src/behaviors/Branch.test.ts

@@ -1,22 +0,0 @@
-import { applied, i, of } from "silentium";
-import { expect, test, vi } from "vitest";
-import { branch } from "../behaviors/Branch";
-
-test("Branch.test", () => {
-  const [dts, dto] = of<number>(2);
-  const res = branch(
-    applied(dts, (t) => {
-      return t === 2;
-    }),
-    i("Then ветка"),
-    i("Else ветка"),
-  );
-
-  const g = vi.fn();
-  res(g);
-  expect(g).toBeCalledWith("Then ветка");
-
-  dto(1);
-
-  expect(g).toBeCalledWith("Else ветка");
-});

package/src/behaviors/Path.test.ts

@@ -1,14 +0,0 @@
-import { i } from "silentium";
-import { expect, test, vi } from "vitest";
-import { path } from "../behaviors/Path";
-
-test("Path.test", () => {
-  const record = {
-    name: "Peter",
-    surname: "Parker",
-  };
-  const name = path<string>(i(record), i("name"));
-  const g = vi.fn();
-  name(g);
-  expect(g).toHaveBeenLastCalledWith("Peter");
-});

package/src/behaviors/Shot.test.ts

@@ -1,29 +0,0 @@
-import { of } from "silentium";
-import { expect, test, vi } from "vitest";
-import { shot } from "../behaviors/Shot";
-
-test("Shot.test", () => {
-  const [baseSrc, bo] = of();
-  const [shotSrc, so] = of();
-
-  const shotResult = shot(baseSrc, shotSrc);
-  const g = vi.fn();
-  shotResult(g);
-
-  bo(1);
-  so(1);
-
-  expect(g).toHaveBeenLastCalledWith(1);
-
-  bo(2);
-
-  expect(g).toHaveBeenLastCalledWith(1);
-
-  so(1);
-
-  expect(g).toHaveBeenLastCalledWith(2);
-
-  const g2 = vi.fn();
-  shotResult(g2);
-  expect(g2).toHaveBeenLastCalledWith(2);
-});