silentium-components 0.0.26 → 0.0.28

package/src/behaviors/Dirty.ts

@@ -1,45 +1,53 @@
-import { all, applied, InformationType, of } from "silentium";
+import { All, Applied, From, Late, TheInformation, TheOwner } from "silentium";
 
 /**
  * Takes source and remember it first value
  * returns new record, what will contain only fields what was changed
  * https://silentium-lab.github.io/silentium-components/#/behaviors/dirty
  */
-export const dirty = <T extends object>(
-  baseEntitySource: InformationType<T>,
-  alwaysKeep: string[] = [],
-  excludeKeys: string[] = [],
-) => {
-  const [comparing, co] = of<T>();
+export class Dirty<T> extends TheInformation<T> {
+  private comparingSrc = new Late<T>();
 
-  const comparingDetached = applied(comparing, (value) =>
-    JSON.parse(JSON.stringify(value)),
-  );
+  public constructor(
+    private baseEntitySource: TheInformation<T>,
+    private alwaysKeep: string[] = [],
+    private excludeKeys: string[] = [],
+  ) {
+    super([baseEntitySource]);
+  }
 
-  const i: InformationType<Partial<T>> = (o) => {
-    all(
-      comparingDetached,
-      baseEntitySource,
-    )(([comparing, base]) => {
-      if (!comparing) {
-        return;
-      }
+  public value(o: TheOwner<T>): this {
+    const comparingDetached = new Applied(this.comparingSrc, (value) =>
+      JSON.parse(JSON.stringify(value)),
+    );
 
-      o(
-        Object.fromEntries(
-          Object.entries(comparing).filter(([key, value]) => {
-            if (alwaysKeep.includes(key)) {
-              return true;
-            }
-            if (excludeKeys.includes(key)) {
-              return false;
-            }
-            return value !== (base as any)[key];
-          }),
-        ) as T,
-      );
-    });
-  };
+    const allSrc = new All(comparingDetached, this.baseEntitySource).value(
+      new From(([comparing, base]) => {
+        if (!comparing) {
+          return;
+        }
 
-  return [i, co] as const;
-};
+        o.give(
+          Object.fromEntries(
+            Object.entries(comparing).filter(([key, value]) => {
+              if (this.alwaysKeep.includes(key)) {
+                return true;
+              }
+              if (this.excludeKeys.includes(key)) {
+                return false;
+              }
+              return value !== (base as any)[key];
+            }),
+          ) as T,
+        );
+      }),
+    );
+    this.addDep(allSrc);
+
+    return this;
+  }
+
+  public owner() {
+    return this.comparingSrc.owner();
+  }
+}

package/src/behaviors/Loading.test.ts

@@ -1,15 +1,15 @@
-import { of } from "silentium";
+import { From, Late } from "silentium";
 import { expect, test, vi } from "vitest";
-import { loading } from "../behaviors/Loading";
+import { Loading } from "../behaviors/Loading";
 
 test("Loading.test", () => {
-  const [loadingStartSource, lso] = of();
-  const [loadingFinishSource, lfo] = of();
-  const loadingSrc = loading(loadingStartSource, loadingFinishSource);
+  const loadingStartSource = new Late();
+  const loadingFinishSource = new Late();
+  const loadingSrc = new Loading(loadingStartSource, loadingFinishSource);
   const g = vi.fn();
-  loadingSrc(g);
-  lso({});
+  loadingSrc.value(new From(g));
+  loadingStartSource.owner().give({});
   expect(g).toHaveBeenLastCalledWith(true);
-  lfo({});
+  loadingFinishSource.owner().give({});
   expect(g).toHaveBeenLastCalledWith(false);
 });

package/src/behaviors/Loading.ts

@@ -1,4 +1,4 @@
-import { InformationType } from "silentium";
+import { From, TheInformation, TheOwner } from "silentium";
 
 /**
  * Representation of loading process
@@ -6,17 +6,27 @@ import { InformationType } from "silentium";
  * second information source stops loading
  * https://silentium-lab.github.io/silentium-components/#/behaviors/loading
  */
-export const loading = (
-  loadingStartSource: InformationType<unknown>,
-  loadingFinishSource: InformationType<unknown>,
-): InformationType<boolean> => {
-  return (o) => {
-    loadingStartSource(() => {
-      o(true);
-    });
+export class Loading extends TheInformation<boolean> {
+  public constructor(
+    private loadingStartSrc: TheInformation<unknown>,
+    private loadingFinishSrc: TheInformation<unknown>,
+  ) {
+    super(loadingFinishSrc, loadingStartSrc);
+  }
 
-    loadingFinishSource(() => {
-      o(false);
-    });
-  };
-};
+  public value(o: TheOwner<boolean>): this {
+    this.loadingStartSrc.value(
+      new From(() => {
+        o.give(true);
+      }),
+    );
+
+    this.loadingFinishSrc.value(
+      new From(() => {
+        o.give(false);
+      }),
+    );
+
+    return this;
+  }
+}

package/src/behaviors/Lock.test.ts

@@ -1,30 +1,30 @@
-import { of, sharedStateless } from "silentium";
+import { From, Late, Shared } from "silentium";
+import { Lock } from "../behaviors/Lock";
 import { expect, test, vi } from "vitest";
-import { lock } from "../behaviors/Lock";
 
 test("Lock.test", () => {
-  const [source, so] = of<number>(1);
-  const [lockSrc, lo] = of<boolean>(false);
+  const source = new Late<number>(1);
+  const lockSrc = new Late<boolean>(false);
 
-  const ls = lock(source, lockSrc);
-  const [lockedSrc] = sharedStateless(ls);
+  const ls = new Lock(source, lockSrc);
+  const lockedSrc = new Shared(ls);
   const g = vi.fn();
-  lockedSrc(g);
+  lockedSrc.value(new From(g));
 
   expect(g).toHaveBeenLastCalledWith(1);
 
-  so(2);
+  source.owner().give(2);
 
   expect(g).toHaveBeenLastCalledWith(2);
 
-  lo(true);
-  so(3);
-  so(4);
-  so(5);
+  lockSrc.owner().give(true);
+  source.owner().give(3);
+  source.owner().give(4);
+  source.owner().give(5);
 
   expect(g).toHaveBeenLastCalledWith(2);
 
-  lo(false);
-  so(6);
+  lockSrc.owner().give(false);
+  source.owner().give(6);
   expect(g).toHaveBeenLastCalledWith(6);
 });

package/src/behaviors/Lock.ts

@@ -1,19 +1,26 @@
-import { filtered, InformationType } from "silentium";
+import { Filtered, From, TheInformation, TheOwner } from "silentium";
 
 /**
  * https://silentium-lab.github.io/silentium-components/#/behaviors/lock
  */
-export const lock = <T>(
-  baseSrc: InformationType<T>,
-  lockSrc: InformationType<boolean>,
-): InformationType<T> => {
-  let locked = false;
-  const i = filtered(baseSrc, () => !locked);
+export class Lock<T> extends TheInformation<T> {
+  public constructor(
+    private baseSrc: TheInformation<T>,
+    private lockSrc: TheInformation<boolean>,
+  ) {
+    super(baseSrc, lockSrc);
+  }
 
-  return (o) => {
-    lockSrc((newLock) => {
-      locked = newLock;
-    });
-    i(o);
-  };
-};
+  public value(o: TheOwner<T>): this {
+    let locked = false;
+    this.lockSrc.value(
+      new From((newLock) => {
+        locked = newLock;
+      }),
+    );
+    const i = new Filtered(this.baseSrc, () => !locked);
+    this.addDep(i);
+    i.value(o);
+    return this;
+  }
+}

package/src/behaviors/Memo.test.ts

@@ -1,28 +1,30 @@
-import { of, shared } from "silentium";
+import { From, Late, Shared } from "silentium";
 import { expect, test, vi } from "vitest";
-import { memo } from "../behaviors/Memo";
+import { Memo } from "../behaviors/Memo";
 
 test("Memo.test", () => {
-  const [src, so] = of<number>(1);
-  const [mem] = shared(memo(src));
+  const l = new Late<number>(1);
+  const mem = new Shared(new Memo(l));
   const g = vi.fn();
-  mem(g);
+  mem.value(new From(g));
   let counter = 0;
 
-  mem(() => {
-    counter += 1;
-  });
+  mem.value(
+    new From(() => {
+      counter += 1;
+    }),
+  );
 
-  so(2);
-  so(2);
-  so(2);
-  so(2);
-  so(2);
+  l.owner().give(2);
+  l.owner().give(2);
+  l.owner().give(2);
+  l.owner().give(2);
+  l.owner().give(2);
 
   expect(g).toHaveBeenLastCalledWith(2);
   expect(counter).toBe(2);
 
-  so(3);
+  l.owner().give(3);
 
   expect(g).toHaveBeenLastCalledWith(3);
   expect(counter).toBe(3);

package/src/behaviors/Memo.ts

@@ -1,18 +1,26 @@
-import { InformationType } from "silentium";
+import { From, TheInformation, TheOwner } from "silentium";
 
 /**
  * Didn't respond if new value of baseSrc equals to old value
  * https://silentium-lab.github.io/silentium-components/#/behaviors/memo
  */
-export const memo = <T>(baseSrc: InformationType<T>): InformationType<T> => {
-  let lastValue: T | null = null;
+export class Memo<T> extends TheInformation<T> {
+  public constructor(private baseSrc: TheInformation<T>) {
+    super(baseSrc);
+  }
 
-  return (o) => {
-    baseSrc((v) => {
-      if (v !== lastValue) {
-        o(v);
-        lastValue = v;
-      }
-    });
-  };
-};
+  public value(o: TheOwner<T>): this {
+    let lastValue: T | null = null;
+
+    this.baseSrc.value(
+      new From((v) => {
+        if (v !== lastValue) {
+          o.give(v);
+          lastValue = v;
+        }
+      }),
+    );
+
+    return this;
+  }
+}

package/src/behaviors/OnlyChanged.test.ts

@@ -1,18 +1,18 @@
-import { of, shared } from "silentium";
+import { From, Late, Shared } from "silentium";
 import { expect, test, vi } from "vitest";
-import { onlyChanged } from "../behaviors/OnlyChanged";
+import { OnlyChanged } from "../behaviors/OnlyChanged";
 
 test("OnlyChanged.test", () => {
-  const [src, so] = of<number>(1);
-  const [changedSrc] = shared(onlyChanged(src));
+  const src = new Late<number>(1);
+  const changedSrc = new Shared(new OnlyChanged(src));
 
   const g = vi.fn();
-  changedSrc(g);
+  changedSrc.value(new From(g));
   expect(g).not.toBeCalled();
 
-  so(2);
+  src.owner().give(2);
 
   const g2 = vi.fn();
-  changedSrc(g2);
+  changedSrc.value(new From(g2));
   expect(g2).toBeCalledWith(2);
 });

package/src/behaviors/OnlyChanged.ts

@@ -1,20 +1,27 @@
-import { InformationType } from "silentium";
+import { From, TheInformation, TheOwner } from "silentium";
 
 /**
  * Represents source what was changed at least once
  * https://silentium-lab.github.io/silentium-components/#/behaviors/only-changed
  */
-export const onlyChanged = <T>(
-  baseSrc: InformationType<T>,
-): InformationType<T> => {
-  let firstValue = false;
-  return (o) => {
-    baseSrc((v) => {
-      if (firstValue === false) {
-        firstValue = true;
-      } else {
-        o(v);
-      }
-    });
-  };
-};
+export class OnlyChanged<T> extends TheInformation<T> {
+  public constructor(private baseSrc: TheInformation<T>) {
+    super(baseSrc);
+  }
+
+  public value(o: TheOwner<T>): this {
+    let firstValue = false;
+
+    this.baseSrc.value(
+      new From((v) => {
+        if (firstValue === false) {
+          firstValue = true;
+        } else {
+          o.give(v);
+        }
+      }),
+    );
+
+    return this;
+  }
+}

package/src/behaviors/Path._main.test.ts

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

package/src/behaviors/Path.index.test.ts

@@ -1,6 +1,6 @@
-import { i } from "silentium";
+import { From, Of } from "silentium";
 import { expect, test, vi } from "vitest";
-import { path } from "./Path";
+import { Path } from "./Path";
 
 test("Path.index.test", () => {
   const record = {
@@ -11,8 +11,8 @@ test("Path.index.test", () => {
       name: "spider-man",
     },
   };
-  const bestColor = path(i(record), i("colors.0"));
+  const bestColor = new Path(new Of(record), new Of("colors.0"));
   const g = vi.fn();
-  bestColor(g);
+  bestColor.value(new From(g));
   expect(g).toHaveBeenLastCalledWith("blue");
 });

package/src/behaviors/Path.nested.test.ts

@@ -1,6 +1,6 @@
-import { i } from "silentium";
+import { From, Of } from "silentium";
 import { expect, test, vi } from "vitest";
-import { path } from "./Path";
+import { Path } from "./Path";
 
 test("Path.nested.test", () => {
   const record = {
@@ -10,8 +10,8 @@ test("Path.nested.test", () => {
       name: "spider-man",
     },
   };
-  const typeName = path(i(record), i("type.name"));
+  const typeName = new Path(new Of(record), new Of("type.name"));
   const g = vi.fn();
-  typeName(g);
+  typeName.value(new From(g));
   expect(g).toHaveBeenLastCalledWith("spider-man");
 });

package/src/behaviors/Path.ts

@@ -1,31 +1,36 @@
-import { all, InformationType } from "silentium";
+import { All, From, TheInformation, TheOwner } from "silentium";
 
 /**
  * Return source of record path
  * https://silentium-lab.github.io/silentium-components/#/behaviors/path
  */
-export const path = <
+export class Path<
   R,
   T extends Record<string, unknown> | Array<unknown> = any,
   K extends string = any,
->(
-  baseSrc: InformationType<T>,
-  keySrc: InformationType<K>,
-): InformationType<R> => {
-  return (o) => {
-    all(
-      baseSrc,
-      keySrc,
-    )(([base, key]) => {
-      const keyChunks = key.split(".");
-      let value: unknown = base;
-      keyChunks.forEach((keyChunk) => {
-        value = (value as Record<string, unknown>)[keyChunk];
-      });
+> extends TheInformation<R> {
+  public constructor(
+    private baseSrc: TheInformation<T>,
+    private keySrc: TheInformation<K>,
+  ) {
+    super(baseSrc, keySrc);
+  }
 
-      if (value !== undefined && value !== base) {
-        o(value as R);
-      }
-    });
-  };
-};
+  public value(o: TheOwner<R>): this {
+    const allSrc = new All(this.baseSrc, this.keySrc).value(
+      new From(([base, key]) => {
+        const keyChunks = key.split(".");
+        let value: unknown = base;
+        keyChunks.forEach((keyChunk) => {
+          value = (value as Record<string, unknown>)[keyChunk];
+        });
+
+        if (value !== undefined && value !== base) {
+          o.give(value as R);
+        }
+      }),
+    );
+    this.addDep(allSrc);
+    return this;
+  }
+}

package/src/behaviors/Shot._main.test.ts

@@ -0,0 +1,29 @@
+import { From, Late, Shared } from "silentium";
+import { expect, test, vi } from "vitest";
+import { Shot } from "../behaviors/Shot";
+
+test("Shot._main.test", () => {
+  const baseSrc = new Late();
+  const shotSrc = new Late();
+
+  const shotResult = new Shared(new Shot(baseSrc, shotSrc));
+  const g = vi.fn();
+  shotResult.value(new From(g));
+
+  baseSrc.owner().give(1);
+  shotSrc.owner().give(1);
+
+  expect(g).toHaveBeenLastCalledWith(1);
+
+  baseSrc.owner().give(2);
+
+  expect(g).toHaveBeenLastCalledWith(1);
+
+  shotSrc.owner().give(1);
+
+  expect(g).toHaveBeenLastCalledWith(2);
+
+  const g2 = vi.fn();
+  shotResult.value(new From(g2));
+  expect(g2).toHaveBeenLastCalledWith(2);
+});

package/src/behaviors/Shot._onlyChanged.test.ts

@@ -1,34 +1,36 @@
-import { of, sharedStateless } from "silentium";
+import { From, Late, Shared } from "silentium";
 import { expect, test } from "vitest";
-import { onlyChanged } from "../behaviors/OnlyChanged";
-import { shot } from "../behaviors/Shot";
+import { OnlyChanged } from "../behaviors/OnlyChanged";
+import { Shot } from "../behaviors/Shot";
 
 test("Shot._onlyChanged.test", () => {
-  const [baseSrc, bo] = of<number>(123);
-  const [sharedBase] = sharedStateless(baseSrc);
-  const resultSrc = shot(sharedBase, onlyChanged(sharedBase));
+  const baseSrc = new Late<number>(123);
+  const sharedBase = new Shared(baseSrc, true);
+  const resultSrc = new Shot(sharedBase, new OnlyChanged(sharedBase));
 
   const vals: number[] = [];
 
-  resultSrc((v) => {
-    vals.push(v);
-  });
+  resultSrc.value(
+    new From((v) => {
+      vals.push(v);
+    }),
+  );
 
   expect(vals).toStrictEqual([]);
 
-  bo(222);
+  baseSrc.owner().give(222);
 
   expect(vals).toStrictEqual([]);
 
-  bo(222);
+  baseSrc.owner().give(222);
 
   expect(vals).toStrictEqual([222]);
 
-  bo(333);
+  baseSrc.owner().give(333);
 
   expect(vals).toStrictEqual([222, 333]);
 
-  bo(123);
+  baseSrc.owner().give(123);
 
   expect(vals).toStrictEqual([222, 333, 123]);
 });

package/src/behaviors/Shot.ts

@@ -1,21 +1,30 @@
-import { InformationType, isFilled } from "silentium";
-import { sync } from "./Sync";
+import { From, TheInformation, TheOwner } from "silentium";
+import { Sync } from "./Sync";
 
 /**
  * Helps to represent only last fresh value of some source, refreshing controls by shotSrc
  * https://silentium-lab.github.io/silentium-components/#/behaviors/shot
  */
-export const shot = <T>(
-  targetSrc: InformationType<T>,
-  triggerSrc: InformationType,
-): InformationType<T> => {
-  return (o) => {
-    const targetSync = sync(targetSrc);
+export class Shot<T> extends TheInformation<T> {
+  public constructor(
+    private targetSrc: TheInformation<T>,
+    private triggerSrc: TheInformation,
+  ) {
+    super(targetSrc, triggerSrc);
+  }
 
-    triggerSrc(() => {
-      if (isFilled(targetSync.value())) {
-        o(targetSync.value());
-      }
-    });
-  };
-};
+  public value(o: TheOwner<T>): this {
+    const targetSync = new Sync(this.targetSrc);
+    targetSync.initOwner();
+
+    this.triggerSrc.value(
+      new From(() => {
+        if (targetSync.valueExisted()) {
+          o.give(targetSync.valueSync());
+        }
+      }),
+    );
+
+    return this;
+  }
+}

package/src/behaviors/Sync.test.ts

@@ -0,0 +1,10 @@
+import { Of } from "silentium";
+import { expect, test } from "vitest";
+import { Sync } from "./Sync";
+
+test("Sync.test", () => {
+  const o = new Of(1);
+  const s = new Sync(o);
+
+  expect(s.valueSync()).toBe(1);
+});