silentium 0.0.2

package/src/Private/PrivateClass.modules.test.ts

@@ -0,0 +1,36 @@
+import { PrivateClass } from "./PrivateClass";
+import { GuestType } from "../Guest/Guest";
+import { SourceWithPool, SourceWithPoolType } from "../Source/SourceWithPool";
+import { expect, test, vitest } from "vitest";
+import { PrivateType } from "./Private";
+
+class TestClass {
+  private source: SourceWithPoolType;
+
+  public constructor(
+    baseNum: number,
+    modules: { main: PrivateType<SourceWithPoolType> },
+  ) {
+    this.source = modules.main.get(baseNum + 55);
+  }
+
+  public value(guest: GuestType) {
+    this.source.value(guest);
+    return this;
+  }
+}
+
+test("PrivateClass.modules.test", () => {
+  const main = new PrivateClass(SourceWithPool);
+  const testSource = new PrivateClass(TestClass, {
+    main,
+  });
+
+  const source = testSource.get(42);
+
+  const guest = vitest.fn();
+  source.value(guest);
+
+  expect(guest).toBeCalled();
+  expect(guest).toBeCalledWith(97);
+});

package/src/Private/PrivateClass.test.ts

@@ -0,0 +1,13 @@
+import { expect, test, vitest } from "vitest";
+import { SourceWithPool } from "../Source/SourceWithPool";
+import { PrivateClass } from "./PrivateClass";
+
+test("PrivateClass.test", () => {
+  const sourcePrivate = new PrivateClass(SourceWithPool);
+  const source = sourcePrivate.get(42);
+
+  const guest = vitest.fn();
+  source.value(guest);
+
+  expect(guest).toBeCalledWith(42);
+});

package/src/Private/PrivateClass.ts

@@ -0,0 +1,29 @@
+import { PrivateType } from "./Private";
+
+interface Constructable<T> {
+  new (...args: unknown[]): T;
+}
+
+interface Prototyped<T> {
+  prototype: T;
+}
+
+export class PrivateClass<T> implements PrivateType<T> {
+  public constructor(
+    private constructorFn: Prototyped<T>,
+    private modules: Record<string, unknown> = {},
+  ) {
+    if (constructorFn === undefined) {
+      throw new Error("PrivateClass didnt receive constructorFn argument");
+    }
+  }
+
+  public get<R extends unknown[], CT = null>(
+    ...args: R
+  ): CT extends null ? T : CT {
+    return new (this.constructorFn as Constructable<T>)(
+      ...args,
+      this.modules,
+    ) as CT extends null ? T : CT;
+  }
+}

package/src/Source/Source.test.ts

@@ -0,0 +1,14 @@
+import { expect, test, vitest } from "vitest";
+import { Source } from "./Source";
+import { give } from "../Guest/Guest";
+
+test("Source.test", () => {
+  const aware = new Source((guest) => {
+    give(111, guest);
+  });
+
+  const guest = vitest.fn();
+  aware.value(guest);
+
+  expect(guest).toBeCalledWith(111);
+});

package/src/Source/Source.ts

@@ -0,0 +1,59 @@
+import { give, GuestType } from "../Guest/Guest";
+
+export type SourceExecutorType<T> = (guest: GuestType<T>) => unknown;
+
+export interface SourceObjectType<T> {
+  value: SourceExecutorType<T>;
+}
+
+export type SourceType<T = any> = SourceExecutorType<T> | SourceObjectType<T>;
+
+/**
+ * @url https://kosukhin.github.io/patron.site/#/utils/value
+ */
+export function value<T>(source: SourceType<T>, guest: GuestType<T>) {
+  if (source === undefined) {
+    throw new Error("value didnt receive source argument");
+  }
+  if (guest === undefined) {
+    throw new Error("value didnt receive guest argument");
+  }
+  if (typeof source === "function") {
+    return source(guest);
+  } else {
+    return source.value(guest);
+  }
+}
+
+/**
+ * @url https://kosukhin.github.io/patron.site/#/utils/is-source
+ */
+export function isSource(mbSource: any): mbSource is SourceType {
+  if (mbSource === undefined) {
+    throw new Error("isSource didnt receive mbSource argument");
+  }
+  return (
+    typeof mbSource === "function" || typeof mbSource?.value === "function"
+  );
+}
+
+/**
+ * @url https://kosukhin.github.io/patron.site/#/guest/source
+ */
+export class Source<T = any> implements SourceObjectType<T> {
+  public constructor(private source: SourceType<T>) {
+    if (source === undefined) {
+      throw new Error("Source constructor didnt receive executor function");
+    }
+  }
+
+  public value(guest: GuestType<T>): GuestType<T> {
+    value(this.source, guest);
+    return guest;
+  }
+}
+
+/**
+ * @url https://kosukhin.github.io/patron.site/#/utils/source-of
+ */
+export const sourceOf = <T>(value: T) => new Source<T>((g) => give(value, g));

package/src/Source/SourceActive.test.ts

@@ -0,0 +1,13 @@
+import { SourceActive } from "./SourceActive";
+import { expect, test, vitest } from "vitest";
+
+test("SourceActive.test", () => {
+  const active = new SourceActive<number, number>((config, source) => {
+    source.give(config * 3);
+  });
+
+  const guest = vitest.fn();
+  active.do(4).value(guest);
+
+  expect(guest).toBeCalledWith(12);
+});

package/src/Source/SourceActive.ts

@@ -0,0 +1,41 @@
+import { GuestType } from "../Guest/Guest";
+import { SourceObjectType } from "./Source";
+import { SourceWithPool, SourceWithPoolType } from "./SourceWithPool";
+
+/**
+ * @url https://kosukhin.github.io/patron.site/#/utils/action-type
+ */
+export interface ActionType<P = any> {
+  do(config: P): this;
+}
+
+export interface SourceAcitveType<R = unknown, T = unknown>
+  extends SourceObjectType<T>,
+    ActionType<R> {}
+
+/**
+ * @url https://kosukhin.github.io/patron.site/#/guest/source-active
+ */
+export class SourceActive<R, T> implements SourceAcitveType<R, T> {
+  private source = new SourceWithPool<T>();
+
+  public constructor(
+    private configExecutor: (config: R, source: SourceWithPoolType<T>) => void,
+  ) {
+    if (configExecutor === undefined) {
+      throw new Error(
+        "SourceActive constructor didnt receive executor function",
+      );
+    }
+  }
+
+  public do(config: R): this {
+    this.configExecutor(config, this.source);
+    return this;
+  }
+
+  public value(guest: GuestType<T>): this {
+    this.source.value(guest);
+    return this;
+  }
+}

package/src/Source/SourceAll._asArray.test.ts

@@ -0,0 +1,22 @@
+import { expect, test, vitest } from "vitest";
+import { SourceAll } from "./SourceAll";
+import { SourceWithPool } from "./SourceWithPool";
+import { Patron } from "../Patron/Patron";
+
+test("SourceAll._asArray.test", () => {
+  const one = new SourceWithPool(1);
+  const two = new SourceWithPool(2);
+  const all = new SourceAll<[number, number]>();
+
+  one.value(new Patron(all.guestKey("0")));
+  two.value(new Patron(all.guestKey("1")));
+
+  const guest = vitest.fn();
+  all.valueArray(
+    new Patron((value) => {
+      guest(JSON.stringify(value));
+    }),
+  );
+
+  expect(guest).toBeCalledWith("[1,2]");
+});

package/src/Source/SourceAll._twoValuesAfter.test.ts

@@ -0,0 +1,19 @@
+import { expect, test, vitest } from "vitest";
+import { SourceWithPool } from "./SourceWithPool";
+import { SourceAll } from "./SourceAll";
+
+test("SourceAll._twoValuesAfter.test", () => {
+  const one = new SourceWithPool(1);
+  const two = new SourceWithPool(2);
+  const all = new SourceAll<{ one: number; two: number }>(["one", "two"]);
+
+  const g = vitest.fn();
+  all.value((value) => {
+    g(Object.values(value).join());
+  });
+
+  one.value(all.guestKey("one"));
+  two.value(all.guestKey("two"));
+
+  expect(g).toBeCalledWith("1,2");
+});

package/src/Source/SourceAll._twoValuesBefore.test.ts

@@ -0,0 +1,19 @@
+import { expect, test, vitest } from "vitest";
+import { SourceWithPool } from "./SourceWithPool";
+import { SourceAll } from "./SourceAll";
+
+test("SourceAll._twoValuesBefore.test", () => {
+  const one = new SourceWithPool(1);
+  const two = new SourceWithPool(2);
+  const all = new SourceAll<{ one: number; two: number }>();
+
+  one.value(all.guestKey("one"));
+  two.value(all.guestKey("two"));
+
+  const g = vitest.fn();
+  all.value((value) => {
+    g(Object.values(value).join());
+  });
+
+  expect(g).toBeCalledWith("1,2");
+});

package/src/Source/SourceAll._withPatron.test.ts

@@ -0,0 +1,25 @@
+import { expect, test, vitest } from "vitest";
+import { SourceAll } from "./SourceAll";
+import { SourceWithPool } from "./SourceWithPool";
+import { Patron } from "../Patron/Patron";
+
+test("SourceAll._withPatron.test", () => {
+  const one = new SourceWithPool(1);
+  const two = new SourceWithPool(2);
+  const all = new SourceAll<{ one: number; two: number }>();
+
+  one.value(new Patron(all.guestKey("one")));
+  two.value(new Patron(all.guestKey("two")));
+
+  one.give(3);
+  one.give(4);
+
+  const g = vitest.fn();
+  all.value(
+    new Patron((value: Record<string, unknown>) => {
+      g(Object.values(value).length);
+    }),
+  );
+
+  expect(g).toBeCalledWith(2);
+});

package/src/Source/SourceAll.ts

@@ -0,0 +1,86 @@
+import { SourceObjectType } from "./Source";
+import { SourceWithPool } from "./SourceWithPool";
+import { Guest, GuestObjectType, GuestType } from "../Guest/Guest";
+import { GuestCast } from "../Guest/GuestCast";
+import { GuestObject } from "../Guest/GuestObject";
+import { GuestPool } from "../Guest/GuestPool";
+
+export interface SourceAllType<T = any> extends SourceObjectType<T> {
+  valueArray(guest: GuestObjectType<T>): this;
+  guestKey<R>(key: string): GuestObjectType<R>;
+}
+
+/**
+ * @url https://kosukhin.github.io/patron.site/#/guest/source-all
+ */
+export class SourceAll<T> implements SourceAllType<T> {
+  private theAll: SourceWithPool<Record<string, unknown>>;
+
+  private keysKnown: Set<string>;
+
+  private keysFilled = new Set();
+
+  private filledAllPool = new GuestPool(this);
+
+  public constructor(initialKnownKeys: string[] = []) {
+    this.theAll = new SourceWithPool<Record<string, unknown>>({});
+    this.keysKnown = new Set(initialKnownKeys);
+  }
+
+  public valueArray(guest: GuestType<T>) {
+    const guestObject = new GuestObject(guest);
+    this.filledAllPool.add(
+      new GuestCast(guestObject, (value: Record<string, unknown>) => {
+        guestObject.give(Object.values(value) as T);
+      }),
+    );
+    if (this.isAllFilled()) {
+      this.theAll.value(
+        new Guest((all: Record<string, unknown>) => {
+          this.filledAllPool.give(Object.values(all));
+        }),
+      );
+    }
+    return this;
+  }
+
+  public value(guest: GuestType<T>) {
+    const guestObject = new GuestObject(guest);
+    if (this.isAllFilled()) {
+      this.filledAllPool.add(guestObject);
+      this.theAll.value(
+        new Guest((all) => {
+          this.filledAllPool.give(all);
+        }),
+      );
+    } else {
+      this.filledAllPool.add(guestObject);
+    }
+    return this;
+  }
+
+  public guestKey<R>(key: string): GuestObjectType<R> {
+    this.keysKnown.add(key);
+    return new Guest((value) => {
+      this.theAll.value(
+        new Guest((all: Record<string, unknown>) => {
+          this.keysFilled.add(key);
+          const lastAll = {
+            ...all,
+            [key]: value,
+          };
+          this.theAll.give(lastAll);
+          if (this.isAllFilled()) {
+            this.filledAllPool.give(lastAll);
+          }
+        }),
+      );
+    });
+  }
+
+  private isAllFilled() {
+    return (
+      this.keysFilled.size > 0 && this.keysFilled.size === this.keysKnown.size
+    );
+  }
+}

package/src/Source/SourceApplied.test.ts

@@ -0,0 +1,14 @@
+import { GuestSync } from "../Guest/GuestSync";
+import { SourceApplied } from "../Source/SourceApplied";
+import { SourceWithPool } from "../Source/SourceWithPool";
+import { expect, test } from "vitest";
+
+test("SourceApplied.test", () => {
+  const source = new SourceWithPool(1);
+  const sourceDouble = new SourceApplied(source, (x) => x * 2);
+  const guest = new GuestSync(0);
+
+  sourceDouble.value(guest);
+
+  expect(guest.value()).toBe(2);
+});

package/src/Source/SourceApplied.ts

@@ -0,0 +1,23 @@
+import { give, GuestType } from "../Guest/Guest";
+import { GuestCast } from "../Guest/GuestCast";
+import { SourceObjectType, SourceType, value } from "../Source/Source";
+
+/**
+ * @url https://kosukhin.github.io/patron.site/#/source/source-applied
+ */
+export class SourceApplied<T, R> implements SourceObjectType<R> {
+  public constructor(
+    private baseSource: SourceType<T>,
+    private applier: (v: T) => R,
+  ) {}
+
+  public value(g: GuestType<R>) {
+    value(
+      this.baseSource,
+      new GuestCast(g, (v) => {
+        give(this.applier(v), g);
+      }),
+    );
+    return this;
+  }
+}

package/src/Source/SourceDynamic.ofSource.test.ts

@@ -0,0 +1,21 @@
+import { SourceDynamic } from "./SourceDynamic";
+import { SourceWithPool } from "./SourceWithPool";
+import { expect, test, vitest } from "vitest";
+
+test("SourceDynamic.ofSource.test", () => {
+  const source = new SourceWithPool(1);
+  const sourceDynamic = new SourceDynamic(source, source);
+
+  const g1 = vitest.fn();
+  sourceDynamic.value(g1);
+  expect(g1).toBeCalledWith(1);
+
+  sourceDynamic.give(2);
+
+  const g2 = vitest.fn();
+  sourceDynamic.value(g2);
+  expect(g2).toBeCalledWith(2);
+  const g3 = vitest.fn();
+  source.value(g3);
+  expect(g3).toBeCalledWith(2);
+});

package/src/Source/SourceDynamic.test.ts

@@ -0,0 +1,26 @@
+import { SourceDynamic } from "./SourceDynamic";
+import { expect, test, vitest } from "vitest";
+import { give, Guest } from "../Guest/Guest";
+import { Source } from "./Source";
+
+test("SourceDynamic", () => {
+  let theValue = 1;
+  const sourceDynamic = new SourceDynamic(
+    new Guest((value: number) => {
+      theValue = value;
+    }),
+    new Source((guest) => {
+      give(theValue, guest);
+    }),
+  );
+
+  const g1 = vitest.fn();
+  sourceDynamic.value(g1);
+  expect(g1).toBeCalledWith(1);
+
+  sourceDynamic.give(2);
+
+  const g2 = vitest.fn();
+  sourceDynamic.value(g2);
+  expect(g2).toBeCalledWith(2);
+});

package/src/Source/SourceDynamic.ts

@@ -0,0 +1,35 @@
+import { give, GuestType } from "../Guest/Guest";
+import { SourceType, value } from "./Source";
+import { PatronPool } from "../Patron/PatronPool";
+import { SourceWithPoolType } from "./SourceWithPool";
+
+/**
+ * @url https://kosukhin.github.io/patron.site/#/source-dynamic
+ */
+export class SourceDynamic<T = unknown> implements SourceWithPoolType<T> {
+  public constructor(
+    private baseGuest: GuestType<T>,
+    private baseSource: SourceType<T>,
+  ) {
+    if (baseGuest === undefined) {
+      throw new Error("SourceDynamic didnt receive baseGuest argument");
+    }
+    if (baseSource === undefined) {
+      throw new Error("SourceDynamic didnt receive baseSource argument");
+    }
+  }
+
+  public value(guest: GuestType<T>) {
+    value(this.baseSource, guest);
+    return this;
+  }
+
+  public give(value: T) {
+    give(value, this.baseGuest);
+    return this;
+  }
+
+  public pool(): PatronPool<T> {
+    throw Error("No pool in SourceDynamic");
+  }
+}

package/src/Source/SourceExecutorApplied.test.ts

@@ -0,0 +1,30 @@
+import { SourceExecutorApplied } from "../Source/SourceExecutorApplied";
+import { SourceWithPool } from "../Source/SourceWithPool";
+import { debounce } from "../../test-utils/debounce";
+import { expect, test, vi } from "vitest";
+import { Patron } from "../Patron/Patron";
+
+test("SourceExecutorApplied.test", () => {
+  vi.useFakeTimers({ shouldAdvanceTime: true });
+
+  const source = new SourceWithPool<number>();
+  const sourceDebounced = new SourceExecutorApplied(
+    source,
+    debounce.bind(null, 100),
+  );
+
+  let counter = 0;
+  sourceDebounced.value(
+    new Patron((v) => {
+      counter += v;
+    }),
+  );
+
+  source.give(1);
+  source.give(1);
+  source.give(1);
+
+  vi.runOnlyPendingTimers();
+
+  expect(counter).toBe(1);
+});

package/src/Source/SourceExecutorApplied.ts

@@ -0,0 +1,22 @@
+import {
+  SourceExecutorType,
+  SourceObjectType,
+  SourceType,
+  value,
+} from "../Source/Source";
+
+/**
+ * @url https://kosukhin.github.io/patron.site/#/source/source-executor-applied
+ */
+export class SourceExecutorApplied<T> implements SourceObjectType<T> {
+  public value: SourceExecutorType<T>;
+
+  public constructor(
+    source: SourceType<T>,
+    applier: (executor: SourceExecutorType<T>) => SourceExecutorType<T>,
+  ) {
+    this.value = applier((g) => {
+      value(source, g);
+    });
+  }
+}

package/src/Source/SourceMap.defered.test.ts

@@ -0,0 +1,46 @@
+import { wait } from "../../test-utils/wait";
+import { Private } from "../Private/Private";
+import { afterEach, beforeEach, expect, test, vi } from "vitest";
+import { SourceWithPool } from "./SourceWithPool";
+import { give, GuestType } from "../Guest/Guest";
+import { Source, SourceType, value } from "./Source";
+import { SourceMap } from "./SourceMap";
+import { GuestCast } from "../Guest/GuestCast";
+
+beforeEach(() => {
+  vi.useFakeTimers({ shouldAdvanceTime: true });
+});
+
+afterEach(() => {
+  vi.runOnlyPendingTimers();
+  vi.useRealTimers();
+});
+
+function x2(baseNumber: SourceType<number>) {
+  return (guest: GuestType<number>) => {
+    value(
+      baseNumber,
+      new GuestCast(guest, (v) => {
+        give(v * 2, guest);
+      }),
+    );
+    return guest;
+  };
+}
+
+test("SourceMap.defered.test", async () => {
+  const sourceOf = (val: number) =>
+    new Source(async (guest) => {
+      await wait(5);
+      give(val, guest);
+    });
+  const source = new SourceWithPool([1, 2, 3, 9].map(sourceOf));
+  const guestMapped = new SourceMap(source, new Private(x2));
+  const callFn = vi.fn();
+  guestMapped.value((v) => {
+    callFn(v.join());
+  });
+  await wait(50);
+  expect(callFn).toBeCalled();
+  expect(callFn).toBeCalledWith("2,4,6,18");
+});

package/src/Source/SourceMap.fn.test.ts

@@ -0,0 +1,27 @@
+import { Private } from "../Private/Private";
+import { expect, test, vitest } from "vitest";
+import { SourceWithPool } from "./SourceWithPool";
+import { give, GuestType } from "../Guest/Guest";
+import { SourceType, value } from "./Source";
+import { SourceMap } from "./SourceMap";
+import { GuestCast } from "../Guest/GuestCast";
+
+function x2(baseNumber: SourceType<number>) {
+  return (guest: GuestType<number>) => {
+    value(
+      baseNumber,
+      new GuestCast(<GuestType>guest, (v) => {
+        give(v * 2, guest);
+      }),
+    );
+    return guest;
+  };
+}
+
+test("SourceMap.test", () => {
+  const source = new SourceWithPool([1, 2, 3, 9]);
+  const guestMapped = new SourceMap(source, new Private(x2));
+  const g = vitest.fn();
+  guestMapped.value(g);
+  expect(g).toBeCalledWith([2, 4, 6, 18]);
+});

package/src/Source/SourceMap.test.ts

@@ -0,0 +1,32 @@
+import { expect, test } from "vitest";
+import { give, GuestType } from "../Guest/Guest";
+import { SourceObjectType, SourceType, value } from "./Source";
+import { SourceMap } from "./SourceMap";
+import { GuestCast } from "../Guest/GuestCast";
+import { SourceWithPool } from "./SourceWithPool";
+import { PrivateClass } from "../Private/PrivateClass";
+import { GuestSync } from "../Guest/GuestSync";
+
+class X2 implements SourceObjectType<number> {
+  public constructor(private baseNumber: SourceType<number>) {}
+
+  public value(guest: GuestType<number>) {
+    value(
+      this.baseNumber,
+      new GuestCast(<GuestType>guest, (v) => {
+        give(v * 2, guest);
+      }),
+    );
+    return this;
+  }
+}
+
+test("SourceMap.test", () => {
+  const source = new SourceWithPool([1, 2, 3, 9]);
+  const guestMapped = new SourceMap(source, new PrivateClass(X2));
+  const guest = new GuestSync([]);
+
+  guestMapped.value(guest);
+
+  expect(guest.value().join()).toBe("2,4,6,18");
+});