silentium 0.0.2

package/src/Guest/GuestDisposable.test.ts

@@ -0,0 +1,26 @@
+import { GuestDisposable } from "./GuestDisposable";
+import { Patron } from "../Patron/Patron";
+import { SourceWithPool } from "../Source/SourceWithPool";
+import { expect, test, vitest } from "vitest";
+
+test("GuestDisposable.test", () => {
+  const source = new SourceWithPool(1);
+
+  const guest = vitest.fn();
+
+  // Работает проверка один раз, потом патром себя удаляет
+  source.value(
+    new Patron(
+      new GuestDisposable(guest, (value) => {
+        return value !== null && value > 1;
+      }),
+    ),
+  );
+
+  // Эти выражения не вызывает expect
+  source.give(2);
+  source.give(3);
+
+  expect(guest).toBeCalledTimes(1);
+  expect(guest).toBeCalledWith(1);
+});

package/src/Guest/GuestDisposable.ts

@@ -0,0 +1,33 @@
+import { give, GuestObjectType, GuestType } from "./Guest";
+
+export interface GuestDisposableType<T = any> extends GuestObjectType<T> {
+  disposed(value: T | null): boolean;
+}
+
+export type MaybeDisposableType<T = any> = Partial<GuestDisposableType<T>>;
+
+/**
+ * @url https://kosukhin.github.io/patron.site/#/guest/guest-disposable
+ */
+export class GuestDisposable<T> implements GuestDisposableType<T> {
+  public constructor(
+    private guest: GuestType,
+    private disposeCheck: (value: T | null) => boolean,
+  ) {
+    if (guest === undefined) {
+      throw new Error("GuestDisposable didnt receive guest argument");
+    }
+    if (disposeCheck === undefined) {
+      throw new Error("GuestDisposable didnt receive disposeCheck argument");
+    }
+  }
+
+  public disposed(value: T | null): boolean {
+    return this.disposeCheck(value);
+  }
+
+  public give(value: T): this {
+    give(value, this.guest);
+    return this;
+  }
+}

package/src/Guest/GuestExecutorApplied.test.ts

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

package/src/Guest/GuestExecutorApplied.ts

@@ -0,0 +1,23 @@
+import {
+  give,
+  GuestExecutorType,
+  GuestObjectType,
+  GuestType,
+} from "../Guest/Guest";
+
+/**
+ * @url https://kosukhin.github.io/patron.site/#/guest/guest-executor-applied
+ */
+export class GuestExecutorApplied<T> implements GuestObjectType<T> {
+  public give: GuestExecutorType<T, this>;
+
+  public constructor(
+    baseGuest: GuestType<T>,
+    applier: (executor: GuestExecutorType) => GuestExecutorType,
+  ) {
+    this.give = applier((v) => give(v, baseGuest)) as GuestExecutorType<
+      T,
+      this
+    >;
+  }
+}

package/src/Guest/GuestObject.test.ts

@@ -0,0 +1,11 @@
+import { expect, test, vitest } from "vitest";
+import { SourceWithPool } from "../Source/SourceWithPool";
+import { GuestObject } from "./GuestObject";
+
+test("GuestObject.test", () => {
+  const source = new SourceWithPool(1);
+  const fnGuest = vitest.fn();
+  source.value(new GuestObject(fnGuest));
+  expect(fnGuest).toBeCalled();
+  expect(fnGuest).toBeCalledWith(1);
+});

package/src/Guest/GuestObject.ts

@@ -0,0 +1,34 @@
+import { Guest, GuestType } from "./Guest";
+import { GuestDisposableType, MaybeDisposableType } from "./GuestDisposable";
+
+/**
+ * @url https://kosukhin.github.io/patron.site/#/guest/guest-object
+ */
+export class GuestObject<T> implements GuestDisposableType<T> {
+  public constructor(private baseGuest: GuestType<T>) {
+    if (baseGuest === undefined) {
+      throw new Error("GuestObject didnt receive baseGuest argument");
+    }
+  }
+
+  public give(value: T): this {
+    let guest = this.baseGuest;
+    if (typeof guest === "function") {
+      guest = new Guest(guest);
+    }
+    guest.give(value);
+    return this;
+  }
+
+  public introduction() {
+    if (typeof this.baseGuest === "function" || !this.baseGuest.introduction) {
+      return "guest";
+    }
+    return this.baseGuest.introduction();
+  }
+
+  public disposed(value: T | null): boolean {
+    const maybeDisposable = this.baseGuest as MaybeDisposableType;
+    return maybeDisposable.disposed ? maybeDisposable.disposed(value) : false;
+  }
+}

package/src/Guest/GuestPool.test.ts

@@ -0,0 +1,30 @@
+import { expect, test } from "vitest";
+import { Patron } from "../Patron/Patron";
+import { GuestPool } from "./GuestPool";
+
+test("GuestPool.test", async () => {
+  const pool = new GuestPool<number>(null);
+  let receivedCount = 0;
+
+  // 2 + 2
+  pool.add(
+    new Patron((value) => {
+      receivedCount += value;
+    }),
+  );
+  // 2 + 2
+  pool.add(
+    new Patron((value) => {
+      receivedCount += value;
+    }),
+  );
+  // 2
+  pool.add((value) => {
+    receivedCount += value;
+  });
+
+  pool.give(2);
+  pool.give(2);
+
+  expect(receivedCount).toBe(10);
+});

package/src/Guest/GuestPool.ts

@@ -0,0 +1,56 @@
+import { PatronPool, PoolType } from "../Patron/PatronPool";
+import { give, GuestObjectType, GuestType } from "./Guest";
+
+/**
+ * @url https://kosukhin.github.io/patron.site/#/guest/guest-pool
+ */
+export class GuestPool<T> implements GuestObjectType<T>, PoolType<T> {
+  private guests = new Set<GuestType<T>>();
+
+  private patronPool: PatronPool<T>;
+
+  public constructor(initiator: unknown) {
+    this.patronPool = new PatronPool(initiator);
+  }
+
+  public give(value: T): this {
+    this.deliverToGuests(value);
+    this.patronPool.give(value);
+    return this;
+  }
+
+  public add(guest: GuestType<T>): this {
+    if (
+      typeof guest === "function" ||
+      !guest.introduction ||
+      guest.introduction() === "guest"
+    ) {
+      this.guests.add(guest);
+    }
+    this.patronPool.add(guest);
+    return this;
+  }
+
+  public remove(patron: GuestObjectType<T>): this {
+    this.guests.delete(patron);
+    this.patronPool.remove(patron);
+    return this;
+  }
+
+  public distribute(receiving: T, possiblePatron: GuestObjectType<T>): this {
+    this.add(possiblePatron);
+    this.give(receiving);
+    return this;
+  }
+
+  public size() {
+    return this.patronPool.size() + this.guests.size;
+  }
+
+  private deliverToGuests(value: T) {
+    this.guests.forEach((target) => {
+      give(value, target);
+    });
+    this.guests.clear();
+  }
+}

package/src/Guest/GuestSync.test.ts

@@ -0,0 +1,12 @@
+import { expect, test } from "vitest";
+import { GuestSync } from "./GuestSync";
+import { SourceWithPool } from "../Source/SourceWithPool";
+
+test("GuestSync.test", () => {
+  const source = new SourceWithPool(123);
+  const syncGuest = new GuestSync(111);
+  syncGuest.give(222);
+  expect(syncGuest.value()).toBe(222);
+  source.value(syncGuest);
+  expect(syncGuest.value()).toBe(123);
+});

package/src/Guest/GuestSync.ts

@@ -0,0 +1,25 @@
+import { GuestObjectType } from "./Guest";
+
+export interface GuestValueType<T = any> extends GuestObjectType<T> {
+  value(): T;
+}
+
+/**
+ * @url https://kosukhin.github.io/patron.site/#/guest/guest-sync
+ */
+export class GuestSync<T> implements GuestValueType<T> {
+  public constructor(private theValue: T) {
+    if (theValue === undefined) {
+      throw new Error("GuestSync didnt receive theValue argument");
+    }
+  }
+
+  public give(value: T): this {
+    this.theValue = value;
+    return this;
+  }
+
+  public value() {
+    return this.theValue;
+  }
+}

package/src/Patron/Patron.test.ts

@@ -0,0 +1,16 @@
+import { expect, test } from "vitest";
+import { Patron } from "./Patron";
+import { SourceWithPool } from "../Source/SourceWithPool";
+
+test("Patron.test", () => {
+  const one = new SourceWithPool(1);
+  let patronCalledTimes = 0;
+  const patron = new Patron(() => {
+    patronCalledTimes += 1;
+  });
+
+  one.value(patron);
+  one.give(2);
+
+  expect(patronCalledTimes).toBe(2);
+});

package/src/Patron/Patron.ts

@@ -0,0 +1,35 @@
+import { give, GuestType } from "../Guest/Guest";
+import { GuestDisposableType } from "../Guest/GuestDisposable";
+
+/**
+ * @url https://kosukhin.github.io/patron.site/#/patron
+ */
+export class Patron<T> implements GuestDisposableType<T> {
+  public constructor(private willBePatron: GuestType<T>) {
+    if (willBePatron === undefined) {
+      throw new Error("Patron didnt receive willBePatron argument");
+    }
+  }
+
+  public introduction() {
+    return "patron" as const;
+  }
+
+  public give(value: T): this {
+    give(value, this.willBePatron);
+    return this;
+  }
+
+  public disposed(value: T | null): boolean {
+    const maybeDisposable = this.willBePatron as GuestDisposableType;
+    return maybeDisposable?.disposed?.(value) || false;
+  }
+}
+
+/**
+ * @url https://kosukhin.github.io/patron.site/#/utils/is-patron
+ */
+export const isPatron = (guest: GuestType): guest is Patron<unknown> =>
+  typeof guest === "object" &&
+  guest !== null &&
+  guest?.introduction?.() === "patron";

package/src/Patron/PatronApplied.ts

@@ -0,0 +1,22 @@
+import { GuestObjectType, GuestType } from "../Guest/Guest";
+import { GuestApplied } from "../Guest/GuestApplied";
+
+/**
+ * @url https://kosukhin.github.io/patron.site/#/patron/patron-applied
+ */
+export class PatronApplied<T, R> implements GuestObjectType<T> {
+  private guestApplied: GuestApplied<T, R>;
+
+  public constructor(baseGuest: GuestType<R>, applier: (value: T) => R) {
+    this.guestApplied = new GuestApplied(baseGuest, applier);
+  }
+
+  public give(value: T): this {
+    this.guestApplied.give(value);
+    return this;
+  }
+
+  public introduction(): "guest" | "patron" {
+    return "patron";
+  }
+}

package/src/Patron/PatronExecutorApplied.ts

@@ -0,0 +1,25 @@
+import { GuestExecutorType, GuestObjectType, GuestType } from "../Guest/Guest";
+import { GuestExecutorApplied } from "../Guest/GuestExecutorApplied";
+
+/**
+ * @url https://kosukhin.github.io/patron.site/#/patron/patron-executor-applied
+ */
+export class PatronExecutorApplied<T> implements GuestObjectType<T> {
+  private guestApplied: GuestExecutorApplied<T>;
+
+  public constructor(
+    baseGuest: GuestType<T>,
+    applier: (executor: GuestExecutorType) => GuestExecutorType,
+  ) {
+    this.guestApplied = new GuestExecutorApplied(baseGuest, applier);
+  }
+
+  public give(value: T): this {
+    this.guestApplied.give(value);
+    return this;
+  }
+
+  public introduction(): "guest" | "patron" {
+    return "patron";
+  }
+}

package/src/Patron/PatronOnce.sourceEmpty.test.ts

@@ -0,0 +1,38 @@
+import { afterEach, beforeEach, expect, test, vi } from "vitest";
+import { PatronOnce } from "./PatronOnce";
+import { SourceWithPool } from "../Source/SourceWithPool";
+
+beforeEach(() => {
+  vi.useFakeTimers({ shouldAdvanceTime: true });
+});
+
+afterEach(() => {
+  vi.runOnlyPendingTimers();
+  vi.useRealTimers();
+});
+
+const wait = (ms: number) =>
+  new Promise((resolve) => {
+    setTimeout(() => {
+      resolve(1);
+    }, ms);
+  });
+
+test("PatronOnce.sourceEmpty.test", async () => {
+  const source = new SourceWithPool();
+  let calls = 0;
+  const patron = new PatronOnce(() => {
+    calls += 1;
+  });
+  source.value(patron);
+
+  await wait(10);
+  source.give(22);
+  await wait(10);
+  source.give(32);
+  await wait(10);
+  source.give(42);
+  await wait(10);
+
+  expect(calls).toBe(1);
+});

package/src/Patron/PatronOnce.test.ts

@@ -0,0 +1,32 @@
+import { wait } from "./../../test-utils/wait";
+import { afterEach, beforeEach, expect, test, vi } from "vitest";
+import { SourceWithPool } from "../Source/SourceWithPool";
+import { PatronOnce } from "./PatronOnce";
+
+beforeEach(() => {
+  vi.useFakeTimers({ shouldAdvanceTime: true });
+});
+
+afterEach(() => {
+  vi.runOnlyPendingTimers();
+  vi.useRealTimers();
+});
+
+test("PatronOnce.test", async () => {
+  const source = new SourceWithPool(12);
+  let calls = 0;
+  const patron = new PatronOnce(() => {
+    calls += 1;
+  });
+  source.value(patron);
+
+  await wait(10);
+  source.give(22);
+  await wait(10);
+  source.give(32);
+  await wait(10);
+  source.give(42);
+  await wait(10);
+
+  expect(calls).toBe(1);
+});

package/src/Patron/PatronOnce.ts

@@ -0,0 +1,38 @@
+import { give, GuestType } from "../Guest/Guest";
+import {
+  GuestDisposableType,
+  MaybeDisposableType,
+} from "../Guest/GuestDisposable";
+
+/**
+ * @url https://kosukhin.github.io/patron.site/#/patron/patron-once
+ */
+export class PatronOnce<T> implements GuestDisposableType<T> {
+  private received = false;
+
+  public constructor(private baseGuest: GuestType<T>) {
+    if (baseGuest === undefined) {
+      throw new Error("PatronOnce didnt receive baseGuest argument");
+    }
+  }
+
+  public introduction() {
+    return "patron" as const;
+  }
+
+  public give(value: T): this {
+    if (!this.received) {
+      this.received = true;
+      give(value, this.baseGuest);
+    }
+    return this;
+  }
+
+  public disposed(value: T | null): boolean {
+    if (this.received) {
+      return true;
+    }
+    const maybeDisposable = this.baseGuest as MaybeDisposableType;
+    return maybeDisposable.disposed ? maybeDisposable.disposed(value) : false;
+  }
+}

package/src/Patron/PatronPool.test.ts

@@ -0,0 +1,22 @@
+import { expect, test } from "vitest";
+import { PatronPool } from "./PatronPool";
+import { Patron } from "./Patron";
+
+test("PatronPool.test", () => {
+  const pool = new PatronPool<number>(null);
+  let receivedCount = 0;
+
+  pool.add(
+    new Patron((value) => {
+      receivedCount += value;
+    }),
+  );
+  pool.add(
+    new Patron((value) => {
+      receivedCount += value;
+    }),
+  );
+  pool.give(2);
+
+  expect(receivedCount).toBe(4);
+});

package/src/Patron/PatronPool.ts

@@ -0,0 +1,121 @@
+import { give, GuestObjectType, GuestType } from "../Guest/Guest";
+import { GuestDisposableType } from "../Guest/GuestDisposable";
+
+const poolSets = new Map<PoolType, Set<GuestObjectType>>();
+
+/**
+ * @url https://kosukhin.github.io/patron.site/#/utils/patron-pools
+ */
+export const patronPools = (patron: GuestObjectType) => {
+  const pools: PoolType[] = [];
+  poolSets.forEach((pool, poolInstance) => {
+    if (pool.has(patron)) {
+      pools.push(poolInstance);
+    }
+  });
+  return pools;
+};
+
+/**
+ * @url https://kosukhin.github.io/patron.site/#/utils/remove-patron-from-pools
+ */
+export const removePatronFromPools = (patron: GuestObjectType) => {
+  if (patron === undefined) {
+    throw new Error("removePatronFromPools didnt receive patron argument");
+  }
+  poolSets.forEach((pool) => {
+    pool.delete(patron);
+  });
+};
+
+/**
+ * @url https://kosukhin.github.io/patron.site/#/utils/is-patron-in-pools
+ */
+export const isPatronInPools = (patron: GuestObjectType) => {
+  if (patron === undefined) {
+    throw new Error("isPatronInPools didnt receive patron argument");
+  }
+  let inPool = false;
+  poolSets.forEach((pool) => {
+    if (!inPool) {
+      inPool = pool.has(patron);
+    }
+  });
+  return inPool;
+};
+
+export interface PoolType<T = any> extends GuestObjectType<T> {
+  add(guest: GuestObjectType<T>): this;
+  distribute(receiving: T, possiblePatron: GuestObjectType<T>): this;
+  remove(patron: GuestObjectType<T>): this;
+  size(): number;
+}
+
+/**
+ * @url https://kosukhin.github.io/patron.site/#/patron/patron-pool
+ */
+export class PatronPool<T> implements PoolType<T> {
+  private patrons: Set<GuestObjectType<T>>;
+
+  public give: (value: T) => this;
+
+  public constructor(private initiator: unknown) {
+    this.patrons = new Set<GuestObjectType<T>>();
+    poolSets.set(this, this.patrons);
+    const doReceive = (value: T) => {
+      this.patrons.forEach((target) => {
+        this.sendValueToGuest(value, target);
+      });
+    };
+    this.give = (value: T) => {
+      doReceive(value);
+      return this;
+    };
+  }
+
+  public size(): number {
+    return this.patrons.size;
+  }
+
+  public add(shouldBePatron: GuestType<T>) {
+    if (!shouldBePatron) {
+      throw new Error("PatronPool add method received nothing!");
+    }
+    if (
+      typeof shouldBePatron !== "function" &&
+      shouldBePatron.introduction &&
+      shouldBePatron.introduction() === "patron"
+    ) {
+      this.patrons.add(shouldBePatron);
+    }
+    return this;
+  }
+
+  public remove(patron: GuestObjectType<T>) {
+    this.patrons.delete(patron);
+    return this;
+  }
+
+  public distribute(receiving: T, possiblePatron: GuestType<T>): this {
+    this.add(possiblePatron);
+    this.sendValueToGuest(receiving, possiblePatron);
+    return this;
+  }
+
+  private sendValueToGuest(value: T, guest: GuestType<T>) {
+    const isDisposed = this.guestDisposed(value, guest);
+
+    if (!isDisposed) {
+      give(value, guest);
+    }
+  }
+
+  private guestDisposed(value: T, guest: GuestType<T>) {
+    if ((guest as GuestDisposableType).disposed?.(value)) {
+      this.remove(guest as GuestObjectType);
+      return true;
+    }
+
+    return false;
+  }
+}

package/src/Private/Private.test.ts

@@ -0,0 +1,12 @@
+import { Private } from "./Private";
+import { expect, test } from "vitest";
+
+test("Private.test", () => {
+  const privateNum = new Private((val) => {
+    return {
+      num: val,
+    };
+  });
+
+  expect(JSON.stringify(privateNum.get(11))).toBe('{"num":11}');
+});

package/src/Private/Private.ts

@@ -0,0 +1,20 @@
+/**
+ * @url https://kosukhin.github.io/patron.site/#/utils/private
+ */
+export interface PrivateType<T> {
+  get<R extends unknown[], CT = null>(...args: R): CT extends null ? T : CT;
+}
+
+export class Private<T> implements PrivateType<T> {
+  public constructor(private buildingFn: (...args: any[]) => T) {
+    if (buildingFn === undefined) {
+      throw new Error("Private didnt receive buildingFn argument");
+    }
+  }
+
+  public get<R extends unknown[], CT = null>(
+    ...args: R
+  ): CT extends null ? T : CT {
+    return this.buildingFn(...args) as CT extends null ? T : CT;
+  }
+}