patron-oop 1.1.0

package/src/Chain.ts

@@ -0,0 +1,79 @@
+import { Cache } from "./Cache";
+import { Guest } from "./Guest";
+import { GuestPool } from "./GuestPool";
+import { ChainType } from "./ChainType";
+import { GuestInTheMiddle } from "./GuestInTheMiddle";
+import { GuestType } from "./GuestType";
+
+export class Chain<T> implements ChainType<T> {
+  private theChain: Cache<Record<string, unknown>>;
+
+  private keysKnown = new Set();
+
+  private keysFilled = new Set();
+
+  private filledChainPool = new GuestPool(this);
+
+  public constructor() {
+    this.theChain = new Cache<Record<string, unknown>>(this, {});
+  }
+
+  public resultArray(guest: GuestType<T>) {
+    this.filledChainPool.add(
+      new GuestInTheMiddle(guest, (value: Record<string, unknown>) =>
+        Object.values(value),
+      ),
+    );
+    if (this.isChainFilled()) {
+      this.theChain.receiving(
+        new Guest((chain) => {
+          this.filledChainPool.receive(Object.values(chain));
+        }),
+      );
+    }
+
+    return this;
+  }
+
+  public result(guest: GuestType<T>) {
+    if (this.isChainFilled()) {
+      this.filledChainPool.add(guest);
+      this.theChain.receiving(
+        new Guest((chain) => {
+          this.filledChainPool.receive(chain);
+        }),
+      );
+    } else {
+      this.filledChainPool.add(guest);
+    }
+    return this;
+  }
+
+  public receiveKey<R>(key: string): GuestType<R> {
+    this.keysKnown.add(key);
+    return new Guest((value) => {
+      // Обернул в очередь чтобы можно было синхронно наполнить очередь известных ключей
+      queueMicrotask(() => {
+        this.theChain.receiving(
+          new Guest((chain) => {
+            this.keysFilled.add(key);
+            const lastChain = {
+              ...chain,
+              [key]: value,
+            };
+            this.theChain.receive(lastChain);
+            if (this.isChainFilled()) {
+              this.filledChainPool.receive(lastChain);
+            }
+          }),
+        );
+      });
+    });
+  }
+
+  private isChainFilled() {
+    return (
+      this.keysFilled.size > 0 && this.keysFilled.size === this.keysKnown.size
+    );
+  }
+}

package/src/ChainType.ts

@@ -0,0 +1,7 @@
+import { GuestType } from "./GuestType";
+
+export interface ChainType<T = unknown> {
+  result(guest: GuestType<T>): this;
+  resultArray(guest: GuestType<T>): this;
+  receiveKey<R>(key: string): GuestType<R>;
+}

package/src/Factory.test.ts

@@ -0,0 +1,16 @@
+import { expect, test } from "vitest";
+import { Factory } from "./Factory";
+import { Guest } from "./Guest";
+import { Source } from "./Source";
+
+test("factory", () => {
+  const sourceFactory = new Factory(Source);
+
+  const source = sourceFactory.create(42);
+
+  source.receiving(
+    new Guest((value) => {
+      expect(value).toBe(42);
+    }),
+  );
+});

package/src/Factory.ts

@@ -0,0 +1,21 @@
+import { FactoryType } from "./FactoryType";
+
+interface Constructable<T> {
+  new (...args: unknown[]): T;
+}
+
+interface Prototyped<T> {
+  prototype: T;
+}
+
+export class Factory<T> implements FactoryType<T> {
+  public constructor(private constructorFn: Prototyped<T>) {}
+
+  public create<R extends unknown[], CT = null>(
+    ...args: R
+  ): CT extends null ? T : CT {
+    return new (this.constructorFn as Constructable<T>)(
+      ...args,
+    ) as CT extends null ? T : CT;
+  }
+}

package/src/FactoryDynamic.ts

@@ -0,0 +1,11 @@
+import { FactoryType } from "./FactoryType";
+
+export class FactoryDynamic<T> implements FactoryType<T> {
+  public constructor(private creationFn: (...args: unknown[]) => T) {}
+
+  public create<R extends unknown[], CT = null>(
+    ...args: R
+  ): CT extends null ? T : CT {
+    return this.creationFn(...args) as CT extends null ? T : CT;
+  }
+}

package/src/FactoryType.ts

@@ -0,0 +1,3 @@
+export interface FactoryType<T> {
+  create<R extends unknown[], CT = null>(...args: R): CT extends null ? T : CT;
+}

package/src/FactoryWithFactories.ts

@@ -0,0 +1,25 @@
+import { FactoryType } from "./FactoryType";
+
+interface Constructable<T> {
+  new (...args: unknown[]): T;
+}
+
+interface Prototyped<T> {
+  prototype: T;
+}
+
+export class FactoryWithFactories<T> implements FactoryType<T> {
+  public constructor(
+    private constructorFn: Prototyped<T>,
+    private factories: Record<string, unknown> = {},
+  ) {}
+
+  public create<R extends unknown[], CT = null>(
+    ...args: R
+  ): CT extends null ? T : CT {
+    return new (this.constructorFn as Constructable<T>)(
+      ...args,
+      this.factories,
+    ) as CT extends null ? T : CT;
+  }
+}

package/src/Guest.test.ts

@@ -0,0 +1,13 @@
+import { expect, test } from "vitest";
+import { Guest } from "./Guest";
+import { Source } from "./Source";
+
+test("guest dynamic", () => {
+  const one = new Source(1);
+
+  one.receiving(
+    new Guest((value) => {
+      expect(value).toBe(1);
+    }),
+  );
+});

package/src/Guest.ts

@@ -0,0 +1,11 @@
+import { GuestExecutorType } from "./GuestExecutorType";
+import { GuestType, ReceiveOptions } from "./GuestType";
+
+export class Guest<T> implements GuestType<T> {
+  public constructor(private receiver: GuestExecutorType<T>) {}
+
+  public receive(value: T, options?: ReceiveOptions) {
+    this.receiver(value, options);
+    return this;
+  }
+}

package/src/GuestAware.ts

@@ -0,0 +1,11 @@
+import { GuestType } from "./GuestType";
+import { GuestAwareType } from "./GuestAwareType";
+
+export class GuestAware<T = unknown> implements GuestAwareType<T> {
+  public constructor(private guestReceiver: (guest: GuestType<T>) => void) {}
+
+  public receiving(guest: GuestType<T>): GuestType<T> {
+    this.guestReceiver(guest);
+    return guest;
+  }
+}

package/src/GuestAwareType.ts

@@ -0,0 +1,5 @@
+import { GuestType } from "./GuestType";
+
+export interface GuestAwareType<T = unknown> {
+  receiving(guest: GuestType<T>): unknown;
+}

package/src/GuestCast.ts

@@ -0,0 +1,20 @@
+import { GuestType, ReceiveOptions } from "./GuestType";
+
+export class GuestCast<T> implements GuestType<T> {
+  public constructor(
+    private sourceGuest: GuestType<unknown>,
+    private targetGuest: GuestType<T>,
+  ) {}
+
+  introduction() {
+    if (!this.sourceGuest.introduction) {
+      return "guest";
+    }
+    return this.sourceGuest.introduction();
+  }
+
+  receive(value: T, options?: ReceiveOptions): this {
+    this.targetGuest.receive(value, options);
+    return this;
+  }
+}

package/src/GuestExecutorType.ts

@@ -0,0 +1,3 @@
+import { ReceiveOptions } from "./GuestType";
+
+export type GuestExecutorType<T> = (value: T, options?: ReceiveOptions) => void;

package/src/GuestInTheMiddle.test.ts

@@ -0,0 +1,71 @@
+import { expect, test } from "vitest";
+import { Guest } from "./Guest";
+import { GuestInTheMiddle } from "./GuestInTheMiddle";
+import { Patron } from "./Patron";
+import { Chain } from "./Chain";
+import { Source } from "./Source";
+
+test("test guest in the middle", () => {
+  const one = new Source(1);
+
+  let accumValue = 0;
+  const guest = new Guest((value: number) => {
+    accumValue += value;
+  });
+  one.receiving(
+    new GuestInTheMiddle(guest, (value) => {
+      guest.receive(value + 3);
+    }),
+  );
+
+  expect(accumValue).toBe(4);
+});
+
+test("test patron in the middle", () => {
+  const one = new Source(1);
+
+  let accumValue = 0;
+  const guest = new Patron(
+    new Guest((value: number) => {
+      accumValue += value;
+    }),
+  );
+  one.receiving(
+    new GuestInTheMiddle(guest, (value) => {
+      guest.receive(value + 3);
+    }),
+  );
+  one.receive(3);
+
+  setTimeout(() => {
+    one.receive(3);
+  });
+
+  setTimeout(() => {
+    expect(accumValue).toBe(16);
+  });
+});
+
+test("test chain in the middle", () => {
+  const one = new Source(1);
+  const two = new Source(2);
+  const chain = new Chain<{ one: number; two: number }>();
+
+  one.receiving(new Patron(chain.receiveKey("one")));
+  two.receiving(new Patron(chain.receiveKey("two")));
+
+  one.receive(3);
+  one.receive(4);
+
+  const guest = new Patron(
+    new Guest((value: { one: number; two: number; three: number }) => {
+      expect(Object.values(value).length).toBe(3);
+    }),
+  );
+
+  chain.result(
+    new GuestInTheMiddle(guest, (value) => {
+      guest.receive({ ...value, three: 99 });
+    }),
+  );
+});

package/src/GuestInTheMiddle.ts

@@ -0,0 +1,20 @@
+import { GuestType, ReceiveOptions } from "./GuestType";
+
+export class GuestInTheMiddle<T> implements GuestType<T> {
+  public constructor(
+    private baseGuest: GuestType<unknown>,
+    private middleFn: (value: T, options?: ReceiveOptions) => void,
+  ) {}
+
+  introduction() {
+    if (!this.baseGuest.introduction) {
+      return "guest";
+    }
+    return this.baseGuest.introduction();
+  }
+
+  receive(value: T, options?: ReceiveOptions): this {
+    this.middleFn(value, options);
+    return this;
+  }
+}

package/src/GuestPool.test.ts

@@ -0,0 +1,41 @@
+import { expect, test } from "vitest";
+import { Guest } from "./Guest";
+import { Patron } from "./Patron";
+import { GuestPool } from "./GuestPool";
+
+test("patron pool with guests", () => {
+  const pool = new GuestPool(null);
+  let receivedCount = 0;
+
+  // 2 + 2
+  pool.add(
+    new Patron(
+      new Guest<number>((value) => {
+        receivedCount += value;
+      }),
+    ),
+  );
+  // 2 + 2
+  pool.add(
+    new Patron(
+      new Guest<number>((value) => {
+        receivedCount += value;
+      }),
+    ),
+  );
+  // 2
+  pool.add(
+    new Guest<number>((value) => {
+      receivedCount += value;
+    }),
+  );
+  pool.receive(2);
+
+  setTimeout(() => {
+    pool.receive(2);
+  });
+
+  setTimeout(() => {
+    expect(receivedCount).toBe(10);
+  }, 10);
+});

package/src/GuestPool.ts

@@ -0,0 +1,46 @@
+import { PatronPool } from "./PatronPool";
+import { PoolType } from "./PoolType";
+import { GuestType, ReceiveOptions } from "./GuestType";
+
+export class GuestPool<T> implements GuestType<T>, PoolType<T> {
+  private guests = new Set<GuestType<T>>();
+
+  private patronPool: PatronPool<T>;
+
+  public constructor(initiator: unknown) {
+    this.patronPool = new PatronPool(initiator);
+  }
+
+  public receive(value: T, options?: ReceiveOptions): this {
+    this.deliverToGuests(value, options);
+    this.patronPool.receive(value, options);
+    return this;
+  }
+
+  public add(guest: GuestType<T>): this {
+    if (!guest.introduction || guest.introduction() === "guest") {
+      this.guests.add(guest);
+    }
+    this.patronPool.add(guest);
+    return this;
+  }
+
+  public remove(patron: GuestType<T>): this {
+    this.guests.delete(patron);
+    this.patronPool.remove(patron);
+    return this;
+  }
+
+  public distribute(receiving: T, possiblePatron: GuestType<T>): this {
+    this.add(possiblePatron);
+    this.receive(receiving);
+    return this;
+  }
+
+  private deliverToGuests(value: T, options?: ReceiveOptions) {
+    this.guests.forEach((target) => {
+      target.receive(value, options);
+    });
+    this.guests.clear();
+  }
+}

package/src/GuestSync.test.ts

@@ -0,0 +1,11 @@
+import { expect, test } from "vitest";
+import { Source } from "./Source";
+import { GuestSync } from "./GuestSync";
+
+test("guest sync", () => {
+  const source = new Source(123);
+  const syncGuest = new GuestSync(222);
+  expect(syncGuest.value()).toBe(222);
+  source.receiving(syncGuest);
+  expect(syncGuest.value()).toBe(123);
+});

package/src/GuestSync.ts

@@ -0,0 +1,14 @@
+import { GuestValueType } from "./GuestValueType";
+
+export class GuestSync<T> implements GuestValueType<T> {
+  public constructor(private theValue: T) {}
+
+  public receive(value: T): this {
+    this.theValue = value;
+    return this;
+  }
+
+  public value() {
+    return this.theValue;
+  }
+}

package/src/GuestType.ts

@@ -0,0 +1,10 @@
+type GuestIntroduction = "guest" | "patron";
+
+export interface ReceiveOptions {
+  data?: unknown;
+}
+
+export interface GuestType<T = unknown> {
+  receive(value: T, options?: ReceiveOptions): this;
+  introduction?(): GuestIntroduction;
+}

package/src/GuestValueType.ts

@@ -0,0 +1,5 @@
+import { GuestType } from "./GuestType";
+
+export interface GuestValueType<T = unknown> extends GuestType<T> {
+  value(): T;
+}

package/src/Patron.test.ts

@@ -0,0 +1,20 @@
+import { expect, test } from "vitest";
+import { Patron } from "./Patron";
+import { Guest } from "./Guest";
+import { Source } from "./Source";
+
+test("patron always guest", () => {
+  const one = new Source(1);
+  let patronCalledTimes = 0;
+  const patron = new Patron(
+    new Guest(() => {
+      patronCalledTimes += 1;
+    }),
+  );
+  one.receiving(patron);
+  one.receive(2);
+
+  queueMicrotask(() => {
+    expect(patronCalledTimes).toBe(2);
+  });
+});

package/src/Patron.ts

@@ -0,0 +1,17 @@
+import { GuestType, ReceiveOptions } from "./GuestType";
+
+/**
+ * Патрон - это постоянный посетитель
+ */
+export class Patron<T> implements GuestType<T> {
+  public constructor(private willBePatron: GuestType<T>) {}
+
+  public introduction() {
+    return "patron" as const;
+  }
+
+  public receive(value: T, options?: ReceiveOptions): this {
+    this.willBePatron.receive(value, options);
+    return this;
+  }
+}

package/src/PatronOnce.test.ts

@@ -0,0 +1,18 @@
+import { expect, test } from "vitest";
+import { Source } from "./Source";
+import { PatronOnce } from "./PatronOnce";
+import { Guest } from "./Guest";
+
+test("patron once", () => {
+  const source = new Source(42);
+  let calls = 0;
+  const patron = new PatronOnce(
+    new Guest(() => {
+      calls += 1;
+    }),
+  );
+  source.receiving(patron);
+  source.receive(22);
+
+  expect(calls).toBe(1);
+});

package/src/PatronOnce.ts

@@ -0,0 +1,30 @@
+import { GuestType, ReceiveOptions } from "./GuestType";
+import { PoolType } from "./PoolType";
+
+type PoolAware = {
+  pool?: PoolType;
+};
+
+export class PatronOnce<T> implements GuestType<T> {
+  private received = false;
+
+  public constructor(private baseGuest: GuestType<T>) {}
+
+  public introduction() {
+    return "patron" as const;
+  }
+
+  public receive(value: T, options?: ReceiveOptions): this {
+    if (!this.received) {
+      this.baseGuest.receive(value, options);
+    }
+
+    const data = options?.data as PoolAware;
+    // Если есть пул, то удаляем себя из пула
+    if (data?.pool) {
+      data.pool.remove(this);
+    }
+
+    return this;
+  }
+}

package/src/PatronPool.test.ts

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

package/src/PatronPool.ts

@@ -0,0 +1,76 @@
+import { PoolType } from "./PoolType";
+import { GuestType, ReceiveOptions } from "./GuestType";
+
+const poolSets = new Map<PoolType, Set<GuestType>>();
+
+/**
+ * Удалить патрон из всех пулов
+ */
+export const removePatronFromPools = (patron: GuestType) => {
+  poolSets.forEach((pool) => {
+    pool.delete(patron);
+  });
+};
+
+export class PatronPool<T> implements PoolType<T> {
+  private patrons = new Set<GuestType<T>>();
+
+  public receive: (value: T, options?: ReceiveOptions) => this;
+
+  public constructor(private initiator: unknown) {
+    poolSets.set(this, this.patrons);
+
+    let lastMicrotask: (() => void) | null = null;
+    const doReceive = (value: T, options?: ReceiveOptions) => {
+      this.patrons.forEach((target) => {
+        this.sendValueToGuest(value, target, options);
+      });
+    };
+    this.receive = (value: T, options?: ReceiveOptions) => {
+      const currentMicroTask = () => {
+        if (currentMicroTask === lastMicrotask) {
+          doReceive(value, options);
+        }
+      };
+      lastMicrotask = currentMicroTask;
+      queueMicrotask(currentMicroTask);
+      return this;
+    };
+  }
+
+  public add(shouldBePatron: GuestType<T>) {
+    if (
+      shouldBePatron.introduction &&
+      shouldBePatron.introduction() === "patron"
+    ) {
+      this.patrons.add(shouldBePatron);
+    }
+    return this;
+  }
+
+  public remove(patron: GuestType<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>,
+    options?: ReceiveOptions,
+  ) {
+    guest.receive(value, {
+      ...options,
+      data: {
+        ...((options?.data as Record<string, unknown>) ?? {}),
+        initiator: this.initiator,
+        pool: this,
+      },
+    });
+  }
+}

package/src/PoolType.ts

@@ -0,0 +1,7 @@
+import { GuestType } from "./GuestType";
+
+export interface PoolType<T = unknown> extends GuestType<T> {
+  add(guest: GuestType<T>): this;
+  distribute(receiving: T, possiblePatron: GuestType<T>): this;
+  remove(patron: GuestType<T>): this;
+}