patron-oop 1.6.0 → 1.8.0

package/src/Guest/GuestAware.test.ts

@@ -1,15 +1,13 @@
 import { expect, test } from "vitest";
 import { GuestAware } from "./GuestAware";
-import { GuestCallback } from "./GuestCallback";
+import { give } from "./Guest";
 
 test("guest aware", () => {
-  const awared = new GuestAware((guest) => {
-    guest.receive(111);
+  const aware = new GuestAware((guest) => {
+    give(111, guest);
   });
 
-  awared.receiving(
-    new GuestCallback((value) => {
-      expect(value).toBe(111);
-    }),
-  );
+  aware.receiving((value) => {
+    expect(value).toBe(111);
+  });
 });

package/src/Guest/GuestAware.ts

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

package/src/Guest/GuestCast.test.ts

@@ -1,21 +1,21 @@
 import { expect, test } from "vitest";
-import { SourceOfValue } from "../Source/SourceOfValue";
-import { PatronOfGuest } from "../Patron/PatronOfGuest";
-import { GuestCallback } from "./GuestCallback";
+import { Source } from "../Source/Source";
+import { Patron } from "../Patron/Patron";
+import { give, Guest } from "./Guest";
 import { GuestCast } from "./GuestCast";
 
 test("chain guest returns 2 values after result guest", () => {
-  const source = new SourceOfValue(1);
+  const source = new Source(1);
   let acc = 0;
-  const mainGuest = new PatronOfGuest(
-    new GuestCallback((value: number) => {
+  const mainGuest = new Patron(
+    new Guest((value: number) => {
       acc += value;
     }),
   );
   // Становится патроном тоже, тк наследует это сойство от mainGuest
   const secondGuest = new GuestCast(
     mainGuest,
-    new GuestCallback((value: number) => {
+    new Guest((value: number) => {
       acc += value;
     }),
   );
@@ -23,7 +23,7 @@ test("chain guest returns 2 values after result guest", () => {
   source.receiving(mainGuest);
   source.receiving(secondGuest);
 
-  source.receive(2);
+  give(2, source);
 
   setTimeout(() => {
     expect(acc).toBe(6);

package/src/Guest/GuestCast.ts

@@ -1,12 +1,16 @@
-import { GuestType, ReceiveOptions } from "./GuestCallback";
+import { give, GuestObjectType, GuestType, ReceiveOptions } from "./Guest";
 
-export class GuestCast<T> implements GuestType<T> {
+export class GuestCast<T> implements GuestObjectType<T> {
   public constructor(
     private sourceGuest: GuestType<unknown>,
     private targetGuest: GuestType<T>,
   ) {}
 
   introduction() {
+    if (typeof this.sourceGuest === "function") {
+      return "guest";
+    }
+
     if (!this.sourceGuest.introduction) {
       return "guest";
     }
@@ -14,7 +18,7 @@ export class GuestCast<T> implements GuestType<T> {
   }
 
   receive(value: T, options?: ReceiveOptions): this {
-    this.targetGuest.receive(value, options);
+    give(value, this.targetGuest, options);
     return this;
   }
 }

package/src/Guest/GuestChain.test.ts

@@ -1,16 +1,16 @@
 import { expect, test } from "vitest";
 import { GuestChain } from "./GuestChain";
-import { GuestCallback } from "./GuestCallback";
-import { SourceOfValue } from "../Source/SourceOfValue";
-import { PatronOfGuest } from "../Patron/PatronOfGuest";
+import { Guest } from "./Guest";
+import { Source } from "../Source/Source";
+import { Patron } from "../Patron/Patron";
 
 test("chain guest returns 2 values after result guest", () => {
-  const one = new SourceOfValue(1);
-  const two = new SourceOfValue(2);
+  const one = new Source(1);
+  const two = new Source(2);
   const chain = new GuestChain<{ one: number; two: number }>();
 
   chain.result(
-    new GuestCallback((value) => {
+    new Guest((value) => {
       expect(Object.values(value).join()).toBe("1,2");
     }),
   );
@@ -20,34 +20,34 @@ test("chain guest returns 2 values after result guest", () => {
 });
 
 test("chain guest returns 2 values before result guest", () => {
-  const one = new SourceOfValue(1);
-  const two = new SourceOfValue(2);
+  const one = new Source(1);
+  const two = new Source(2);
   const chain = new GuestChain<{ one: number; two: number }>();
 
   one.receiving(chain.receiveKey("one"));
   two.receiving(chain.receiveKey("two"));
 
   chain.result(
-    new GuestCallback((value) => {
+    new Guest((value) => {
       expect(Object.values(value).join()).toBe("1,2");
     }),
   );
 });
 
 test("chain with patron", () => {
-  const one = new SourceOfValue(1);
-  const two = new SourceOfValue(2);
+  const one = new Source(1);
+  const two = new Source(2);
   const chain = new GuestChain<{ one: number; two: number }>();
 
-  one.receiving(new PatronOfGuest(chain.receiveKey("one")));
-  two.receiving(new PatronOfGuest(chain.receiveKey("two")));
+  one.receiving(new Patron(chain.receiveKey("one")));
+  two.receiving(new Patron(chain.receiveKey("two")));
 
   one.receive(3);
   one.receive(4);
 
   chain.result(
-    new PatronOfGuest(
-      new GuestCallback((value: Record<string, unknown>) => {
+    new Patron(
+      new Guest((value: Record<string, unknown>) => {
         expect(Object.values(value).length).toBe(2);
       }),
     ),
@@ -55,16 +55,16 @@ test("chain with patron", () => {
 });
 
 test("chain as array", () => {
-  const one = new SourceOfValue(1);
-  const two = new SourceOfValue(2);
+  const one = new Source(1);
+  const two = new Source(2);
   const chain = new GuestChain<[number, number]>();
 
-  one.receiving(new PatronOfGuest(chain.receiveKey("0")));
-  two.receiving(new PatronOfGuest(chain.receiveKey("1")));
+  one.receiving(new Patron(chain.receiveKey("0")));
+  two.receiving(new Patron(chain.receiveKey("1")));
 
   chain.resultArray(
-    new PatronOfGuest(
-      new GuestCallback((value) => {
+    new Patron(
+      new Guest((value) => {
         expect(JSON.stringify(value)).toBe("[1, 2]");
       }),
     ),

package/src/Guest/GuestChain.ts

@@ -1,16 +1,16 @@
-import { GuestCallback, GuestType } from "./GuestCallback";
+import { Guest, GuestObjectType } from "./Guest";
 import { GuestPool } from "./GuestPool";
 import { GuestInTheMiddle } from "./GuestInTheMiddle";
-import { SourceOfValue } from "../Source/SourceOfValue";
+import { Source } from "../Source/Source";
 
 export interface ChainType<T = unknown> {
-  result(guest: GuestType<T>): this;
-  resultArray(guest: GuestType<T>): this;
-  receiveKey<R>(key: string): GuestType<R>;
+  result(guest: GuestObjectType<T>): this;
+  resultArray(guest: GuestObjectType<T>): this;
+  receiveKey<R>(key: string): GuestObjectType<R>;
 }
 
 export class GuestChain<T> implements ChainType<T> {
-  private theChain: SourceOfValue<Record<string, unknown>>;
+  private theChain: Source<Record<string, unknown>>;
 
   private keysKnown = new Set();
 
@@ -19,10 +19,10 @@ export class GuestChain<T> implements ChainType<T> {
   private filledChainPool = new GuestPool(this);
 
   public constructor() {
-    this.theChain = new SourceOfValue<Record<string, unknown>>({});
+    this.theChain = new Source<Record<string, unknown>>({});
   }
 
-  public resultArray(guest: GuestType<T>) {
+  public resultArray(guest: GuestObjectType<T>) {
     this.filledChainPool.add(
       new GuestInTheMiddle(guest, (value: Record<string, unknown>) =>
         Object.values(value),
@@ -30,7 +30,7 @@ export class GuestChain<T> implements ChainType<T> {
     );
     if (this.isChainFilled()) {
       this.theChain.receiving(
-        new GuestCallback((chain: Record<string, unknown>) => {
+        new Guest((chain: Record<string, unknown>) => {
           this.filledChainPool.receive(Object.values(chain));
         }),
       );
@@ -39,11 +39,11 @@ export class GuestChain<T> implements ChainType<T> {
     return this;
   }
 
-  public result(guest: GuestType<T>) {
+  public result(guest: GuestObjectType<T>) {
     if (this.isChainFilled()) {
       this.filledChainPool.add(guest);
       this.theChain.receiving(
-        new GuestCallback((chain) => {
+        new Guest((chain) => {
           this.filledChainPool.receive(chain);
         }),
       );
@@ -53,13 +53,13 @@ export class GuestChain<T> implements ChainType<T> {
     return this;
   }
 
-  public receiveKey<R>(key: string): GuestType<R> {
+  public receiveKey<R>(key: string): GuestObjectType<R> {
     this.keysKnown.add(key);
-    return new GuestCallback((value) => {
+    return new Guest((value) => {
       // Обернул в очередь чтобы можно было синхронно наполнить очередь известных ключей
       queueMicrotask(() => {
         this.theChain.receiving(
-          new GuestCallback((chain: Record<string, unknown>) => {
+          new Guest((chain: Record<string, unknown>) => {
             this.keysFilled.add(key);
             const lastChain = {
               ...chain,

package/src/Guest/GuestInTheMiddle.test.ts

@@ -1,15 +1,15 @@
 import { expect, test } from "vitest";
-import { GuestCallback } from "./GuestCallback";
+import { Guest } from "./Guest";
 import { GuestInTheMiddle } from "./GuestInTheMiddle";
 import { GuestChain } from "./GuestChain";
-import { SourceOfValue } from "../Source/SourceOfValue";
-import { PatronOfGuest } from "../Patron/PatronOfGuest";
+import { Source } from "../Source/Source";
+import { Patron } from "../Patron/Patron";
 
 test("test guest in the middle", () => {
-  const one = new SourceOfValue(1);
+  const one = new Source(1);
 
   let accumValue = 0;
-  const guest = new GuestCallback((value: number) => {
+  const guest = new Guest((value: number) => {
     accumValue += value;
   });
   one.receiving(
@@ -22,11 +22,11 @@ test("test guest in the middle", () => {
 });
 
 test("test patron in the middle", () => {
-  const one = new SourceOfValue(1);
+  const one = new Source(1);
 
   let accumValue = 0;
-  const guest = new PatronOfGuest(
-    new GuestCallback((value: number) => {
+  const guest = new Patron(
+    new Guest((value: number) => {
       accumValue += value;
     }),
   );
@@ -47,18 +47,18 @@ test("test patron in the middle", () => {
 });
 
 test("test chain in the middle", () => {
-  const one = new SourceOfValue(1);
-  const two = new SourceOfValue(2);
+  const one = new Source(1);
+  const two = new Source(2);
   const chain = new GuestChain<{ one: number; two: number }>();
 
-  one.receiving(new PatronOfGuest(chain.receiveKey("one")));
-  two.receiving(new PatronOfGuest(chain.receiveKey("two")));
+  one.receiving(new Patron(chain.receiveKey("one")));
+  two.receiving(new Patron(chain.receiveKey("two")));
 
   one.receive(3);
   one.receive(4);
 
-  const guest = new PatronOfGuest(
-    new GuestCallback((value: { one: number; two: number; three: number }) => {
+  const guest = new Patron(
+    new Guest((value: { one: number; two: number; three: number }) => {
       expect(Object.values(value).length).toBe(3);
     }),
   );

package/src/Guest/GuestInTheMiddle.ts

@@ -1,8 +1,8 @@
-import { GuestType, ReceiveOptions } from "./GuestCallback";
+import { GuestObjectType, ReceiveOptions } from "./Guest";
 
-export class GuestInTheMiddle<T> implements GuestType<T> {
+export class GuestInTheMiddle<T> implements GuestObjectType<T> {
   public constructor(
-    private baseGuest: GuestType<unknown>,
+    private baseGuest: GuestObjectType<unknown>,
     private middleFn: (value: T, options?: ReceiveOptions) => void,
   ) {}
 

package/src/Guest/GuestPool.test.ts

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

package/src/Guest/GuestPool.ts

@@ -1,8 +1,8 @@
 import { PatronPool } from "../Patron/PatronPool";
 import { PoolType } from "../Patron/PatronPool";
-import { GuestType, ReceiveOptions } from "./GuestCallback";
+import { give, GuestObjectType, GuestType, ReceiveOptions } from "./Guest";
 
-export class GuestPool<T> implements GuestType<T>, PoolType<T> {
+export class GuestPool<T> implements GuestObjectType<T>, PoolType<T> {
   private guests = new Set<GuestType<T>>();
 
   private patronPool: PatronPool<T>;
@@ -18,20 +18,24 @@ export class GuestPool<T> implements GuestType<T>, PoolType<T> {
   }
 
   public add(guest: GuestType<T>): this {
-    if (!guest.introduction || guest.introduction() === "guest") {
+    if (
+      typeof guest === "function" ||
+      !guest.introduction ||
+      guest.introduction() === "guest"
+    ) {
       this.guests.add(guest);
     }
     this.patronPool.add(guest);
     return this;
   }
 
-  public remove(patron: GuestType<T>): this {
+  public remove(patron: GuestObjectType<T>): this {
     this.guests.delete(patron);
     this.patronPool.remove(patron);
     return this;
   }
 
-  public distribute(receiving: T, possiblePatron: GuestType<T>): this {
+  public distribute(receiving: T, possiblePatron: GuestObjectType<T>): this {
     this.add(possiblePatron);
     this.receive(receiving);
     return this;
@@ -39,7 +43,7 @@ export class GuestPool<T> implements GuestType<T>, PoolType<T> {
 
   private deliverToGuests(value: T, options?: ReceiveOptions) {
     this.guests.forEach((target) => {
-      target.receive(value, options);
+      give(value, target, options);
     });
     this.guests.clear();
   }

package/src/Guest/GuestSync.test.ts

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

package/src/Guest/GuestSync.ts

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

package/src/Patron/Patron.test.ts

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

package/src/Patron/Patron.ts

@@ -1,18 +1,22 @@
-import { PatronOfGuest } from "./PatronOfGuest";
-import { GuestType } from "../Guest/GuestCallback";
-import { PatronOnce } from "./PatronOnce";
-import { PatronPool } from "./PatronPool";
+import {
+  give,
+  GuestObjectType,
+  GuestType,
+  ReceiveOptions,
+} from "../Guest/Guest";
 
-export class Patron {
-  public ofGuest<P>(willBePatron: GuestType<P>) {
-    return new PatronOfGuest(willBePatron);
-  }
+/**
+ * Патрон - это постоянный посетитель
+ */
+export class Patron<T> implements GuestObjectType<T> {
+  public constructor(private willBePatron: GuestType<T>) {}
 
-  public once<P>(baseGuest: GuestType<P>) {
-    return new PatronOnce(baseGuest);
+  public introduction() {
+    return "patron" as const;
   }
 
-  public pool(initiator: unknown) {
-    return new PatronPool(initiator);
+  public receive(value: T, options?: ReceiveOptions): this {
+    give(value, this.willBePatron, options);
+    return this;
   }
 }

package/src/Patron/PatronOnce.test.ts

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

package/src/Patron/PatronOnce.ts

@@ -1,11 +1,16 @@
 import { PoolType } from "./PatronPool";
-import { GuestType, ReceiveOptions } from "../Guest/GuestCallback";
+import {
+  give,
+  GuestObjectType,
+  GuestType,
+  ReceiveOptions,
+} from "../Guest/Guest";
 
 type PoolAware = {
   pool?: PoolType;
 };
 
-export class PatronOnce<T> implements GuestType<T> {
+export class PatronOnce<T> implements GuestObjectType<T> {
   private received = false;
 
   public constructor(private baseGuest: GuestType<T>) {}
@@ -16,7 +21,7 @@ export class PatronOnce<T> implements GuestType<T> {
 
   public receive(value: T, options?: ReceiveOptions): this {
     if (!this.received) {
-      this.baseGuest.receive(value, options);
+      give(value, this.baseGuest, options);
     }
 
     const data = options?.data as PoolAware;

package/src/Patron/PatronPool.test.ts

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

package/src/Patron/PatronPool.ts

@@ -1,24 +1,29 @@
-import { GuestType, ReceiveOptions } from "../Guest/GuestCallback";
+import {
+  give,
+  GuestObjectType,
+  GuestType,
+  ReceiveOptions,
+} from "../Guest/Guest";
 
-const poolSets = new Map<PoolType, Set<GuestType>>();
+const poolSets = new Map<PoolType, Set<GuestObjectType>>();
 
 /**
  * Удалить патрон из всех пулов
  */
-export const removePatronFromPools = (patron: GuestType) => {
+export const removePatronFromPools = (patron: GuestObjectType) => {
   poolSets.forEach((pool) => {
     pool.delete(patron);
   });
 };
 
-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;
+export interface PoolType<T = unknown> extends GuestObjectType<T> {
+  add(guest: GuestObjectType<T>): this;
+  distribute(receiving: T, possiblePatron: GuestObjectType<T>): this;
+  remove(patron: GuestObjectType<T>): this;
 }
 
 export class PatronPool<T> implements PoolType<T> {
-  private patrons = new Set<GuestType<T>>();
+  private patrons = new Set<GuestObjectType<T>>();
 
   public receive: (value: T, options?: ReceiveOptions) => this;
 
@@ -45,6 +50,7 @@ export class PatronPool<T> implements PoolType<T> {
 
   public add(shouldBePatron: GuestType<T>) {
     if (
+      typeof shouldBePatron !== "function" &&
       shouldBePatron.introduction &&
       shouldBePatron.introduction() === "patron"
     ) {
@@ -53,7 +59,7 @@ export class PatronPool<T> implements PoolType<T> {
     return this;
   }
 
-  public remove(patron: GuestType<T>) {
+  public remove(patron: GuestObjectType<T>) {
     this.patrons.delete(patron);
     return this;
   }
@@ -69,7 +75,7 @@ export class PatronPool<T> implements PoolType<T> {
     guest: GuestType<T>,
     options?: ReceiveOptions,
   ) {
-    guest.receive(value, {
+    give(value, guest, {
       ...options,
       data: {
         ...((options?.data as Record<string, unknown>) ?? {}),