patron-oop 1.15.0 → 1.17.0

package/src/Guest/GuestCast.ts

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

package/src/Guest/GuestChain.test.ts

@@ -12,8 +12,8 @@ test("chain guest returns 2 values after result guest", () => {
     expect(Object.values(value).join()).toBe("1,2");
   });
 
-  one.receiving(chain.receiveKey("one"));
-  two.receiving(chain.receiveKey("two"));
+  one.value(chain.receiveKey("one"));
+  two.value(chain.receiveKey("two"));
 });
 
 test("chain guest returns 2 values before result guest", () => {
@@ -21,8 +21,8 @@ test("chain guest returns 2 values before result guest", () => {
   const two = new Source(2);
   const chain = new GuestChain<{ one: number; two: number }>();
 
-  one.receiving(chain.receiveKey("one"));
-  two.receiving(chain.receiveKey("two"));
+  one.value(chain.receiveKey("one"));
+  two.value(chain.receiveKey("two"));
 
   chain.result((value) => {
     expect(Object.values(value).join()).toBe("1,2");
@@ -34,11 +34,11 @@ test("chain with patron", () => {
   const two = new Source(2);
   const chain = new GuestChain<{ one: number; two: number }>();
 
-  one.receiving(new Patron(chain.receiveKey("one")));
-  two.receiving(new Patron(chain.receiveKey("two")));
+  one.value(new Patron(chain.receiveKey("one")));
+  two.value(new Patron(chain.receiveKey("two")));
 
-  one.receive(3);
-  one.receive(4);
+  one.give(3);
+  one.give(4);
 
   chain.result(
     new Patron((value: Record<string, unknown>) => {
@@ -52,8 +52,8 @@ test("chain as array", () => {
   const two = new Source(2);
   const chain = new GuestChain<[number, number]>();
 
-  one.receiving(new Patron(chain.receiveKey("0")));
-  two.receiving(new Patron(chain.receiveKey("1")));
+  one.value(new Patron(chain.receiveKey("0")));
+  two.value(new Patron(chain.receiveKey("1")));
 
   chain.resultArray(
     new Patron((value) => {

package/src/Guest/GuestChain.ts

@@ -31,13 +31,12 @@ export class GuestChain<T> implements ChainType<T> {
       ),
     );
     if (this.isChainFilled()) {
-      this.theChain.receiving(
+      this.theChain.value(
         new Guest((chain: Record<string, unknown>) => {
-          this.filledChainPool.receive(Object.values(chain));
+          this.filledChainPool.give(Object.values(chain));
         }),
       );
     }
-
     return this;
   }
 
@@ -45,9 +44,9 @@ export class GuestChain<T> implements ChainType<T> {
     const guestObject = new GuestObject(guest);
     if (this.isChainFilled()) {
       this.filledChainPool.add(guestObject);
-      this.theChain.receiving(
+      this.theChain.value(
         new Guest((chain) => {
-          this.filledChainPool.receive(chain);
+          this.filledChainPool.give(chain);
         }),
       );
     } else {
@@ -61,16 +60,16 @@ export class GuestChain<T> implements ChainType<T> {
     return new Guest((value) => {
       // Обернул в очередь чтобы можно было синхронно наполнить очередь известных ключей
       queueMicrotask(() => {
-        this.theChain.receiving(
+        this.theChain.value(
           new Guest((chain: Record<string, unknown>) => {
             this.keysFilled.add(key);
             const lastChain = {
               ...chain,
               [key]: value,
             };
-            this.theChain.receive(lastChain);
+            this.theChain.give(lastChain);
             if (this.isChainFilled()) {
-              this.filledChainPool.receive(lastChain);
+              this.filledChainPool.give(lastChain);
             }
           }),
         );

package/src/Guest/GuestMiddle.test.ts

@@ -12,9 +12,9 @@ test("test guest in the middle", () => {
   const guest = new Guest((value: number) => {
     accumValue += value;
   });
-  one.receiving(
+  one.value(
     new GuestMiddle(guest, (value: number) => {
-      guest.receive(value + 3);
+      guest.give(value + 3);
     }),
   );
 
@@ -30,15 +30,15 @@ test("test patron in the middle", () => {
       accumValue += value;
     }),
   );
-  one.receiving(
+  one.value(
     new GuestMiddle(guest, (value: number) => {
-      guest.receive(value + 3);
+      guest.give(value + 3);
     }),
   );
-  one.receive(3);
+  one.give(3);
 
   setTimeout(() => {
-    one.receive(3);
+    one.give(3);
   });
 
   setTimeout(() => {
@@ -51,11 +51,11 @@ test("test chain in the middle", () => {
   const two = new Source(2);
   const chain = new GuestChain<{ one: number; two: number }>();
 
-  one.receiving(new Patron(chain.receiveKey("one")));
-  two.receiving(new Patron(chain.receiveKey("two")));
+  one.value(new Patron(chain.receiveKey("one")));
+  two.value(new Patron(chain.receiveKey("two")));
 
-  one.receive(3);
-  one.receive(4);
+  one.give(3);
+  one.give(4);
 
   const guest = new Patron(
     new Guest((value: { one: number; two: number; three: number }) => {
@@ -65,7 +65,7 @@ test("test chain in the middle", () => {
 
   chain.result(
     new GuestMiddle(guest, (value) => {
-      guest.receive({ ...value, three: 99 });
+      guest.give({ ...value, three: 99 });
     }),
   );
 });

package/src/Guest/GuestMiddle.ts

@@ -1,19 +1,19 @@
-import { GuestObjectType, GuestType, ReceiveOptions } from "./Guest";
+import { GuestObjectType, GuestType, GiveOptions } from "./Guest";
 
 export class GuestMiddle<T> implements GuestObjectType<T> {
   public constructor(
     private baseGuest: GuestType<unknown>,
-    private middleFn: (value: T, options?: ReceiveOptions) => void,
+    private middleFn: (value: T, options?: GiveOptions) => void,
   ) {}
 
-  introduction() {
+  public introduction() {
     if (typeof this.baseGuest === "function" || !this.baseGuest.introduction) {
       return "guest";
     }
     return this.baseGuest.introduction();
   }
 
-  receive(value: T, options?: ReceiveOptions): this {
+  public give(value: T, options?: GiveOptions): this {
     this.middleFn(value, options);
     return this;
   }

package/src/Guest/GuestObject.test.ts

@@ -7,5 +7,5 @@ test("guest object", () => {
   const fnGuest = (value: number) => {
     expect(value).toBe(1);
   };
-  source.receiving(new GuestObject(fnGuest));
+  source.value(new GuestObject(fnGuest));
 });

package/src/Guest/GuestObject.ts

@@ -1,14 +1,14 @@
-import { Guest, GuestObjectType, GuestType, ReceiveOptions } from "./Guest";
+import { Guest, GuestObjectType, GuestType, GiveOptions } from "./Guest";
 
 export class GuestObject<T> implements GuestObjectType<T> {
   public constructor(private baseGuest: GuestType<T>) {}
 
-  public receive(value: T, options?: ReceiveOptions): this {
+  public give(value: T, options?: GiveOptions): this {
     let guest = this.baseGuest;
     if (typeof guest === "function") {
       guest = new Guest(guest);
     }
-    guest.receive(value, options);
+    guest.give(value, options);
     return this;
   }
 
@@ -16,7 +16,6 @@ export class GuestObject<T> implements GuestObjectType<T> {
     if (typeof this.baseGuest === "function" || !this.baseGuest.introduction) {
       return "guest";
     }
-
     return this.baseGuest.introduction();
   }
 }

package/src/Guest/GuestPool.test.ts

@@ -22,10 +22,10 @@ test("patron pool with guests", () => {
   pool.add((value) => {
     receivedCount += value;
   });
-  pool.receive(2);
+  pool.give(2);
 
   setTimeout(() => {
-    pool.receive(2);
+    pool.give(2);
   });
 
   setTimeout(() => {

package/src/Guest/GuestPool.ts

@@ -1,6 +1,6 @@
 import { PatronPool } from "../Patron/PatronPool";
 import { PoolType } from "../Patron/PatronPool";
-import { give, GuestObjectType, GuestType, ReceiveOptions } from "./Guest";
+import { give, GuestObjectType, GuestType, GiveOptions } from "./Guest";
 
 export class GuestPool<T> implements GuestObjectType<T>, PoolType<T> {
   private guests = new Set<GuestType<T>>();
@@ -11,9 +11,9 @@ export class GuestPool<T> implements GuestObjectType<T>, PoolType<T> {
     this.patronPool = new PatronPool(initiator);
   }
 
-  public receive(value: T, options?: ReceiveOptions): this {
+  public give(value: T, options?: GiveOptions): this {
     this.deliverToGuests(value, options);
-    this.patronPool.receive(value, options);
+    this.patronPool.give(value, options);
     return this;
   }
 
@@ -37,11 +37,11 @@ export class GuestPool<T> implements GuestObjectType<T>, PoolType<T> {
 
   public distribute(receiving: T, possiblePatron: GuestObjectType<T>): this {
     this.add(possiblePatron);
-    this.receive(receiving);
+    this.give(receiving);
     return this;
   }
 
-  private deliverToGuests(value: T, options?: ReceiveOptions) {
+  private deliverToGuests(value: T, options?: GiveOptions) {
     this.guests.forEach((target) => {
       give(value, target, options);
     });

package/src/Guest/GuestSync.test.ts

@@ -5,8 +5,8 @@ import { Source } from "../Source/Source";
 test("guest sync", () => {
   const source = new Source(123);
   const syncGuest = new GuestSync(111);
-  syncGuest.receive(222);
+  syncGuest.give(222);
   expect(syncGuest.value()).toBe(222);
-  source.receiving(syncGuest);
+  source.value(syncGuest);
   expect(syncGuest.value()).toBe(123);
 });

package/src/Guest/GuestSync.ts

@@ -7,7 +7,7 @@ export interface GuestValueType<T = unknown> extends GuestObjectType<T> {
 export class GuestSync<T> implements GuestValueType<T> {
   public constructor(private theValue: T) {}
 
-  public receive(value: T): this {
+  public give(value: T): this {
     this.theValue = value;
     return this;
   }

package/src/Patron/Patron.test.ts

@@ -8,8 +8,8 @@ test("patron always guest", () => {
   const patron = new Patron(() => {
     patronCalledTimes += 1;
   });
-  one.receiving(patron);
-  one.receive(2);
+  one.value(patron);
+  one.give(2);
 
   queueMicrotask(() => {
     expect(patronCalledTimes).toBe(2);

package/src/Patron/Patron.ts

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

package/src/Patron/PatronOnce.test.ts

@@ -8,8 +8,10 @@ test("patron once", () => {
   const patron = new PatronOnce(() => {
     calls += 1;
   });
-  source.receiving(patron);
-  source.receive(22);
+  source.value(patron);
+  source.give(22);
+  source.give(22);
+  source.give(22);
 
   expect(calls).toBe(1);
 });

package/src/Patron/PatronOnce.ts

@@ -1,10 +1,5 @@
 import { PoolType } from "./PatronPool";
-import {
-  give,
-  GuestObjectType,
-  GuestType,
-  ReceiveOptions,
-} from "../Guest/Guest";
+import { give, GuestObjectType, GuestType, GiveOptions } from "../Guest/Guest";
 
 type PoolAware = {
   pool?: PoolType;
@@ -19,17 +14,14 @@ export class PatronOnce<T> implements GuestObjectType<T> {
     return "patron" as const;
   }
 
-  public receive(value: T, options?: ReceiveOptions): this {
+  public give(value: T, options?: GiveOptions): this {
     if (!this.received) {
       give(value, this.baseGuest, options);
     }
-
     const data = options?.data as PoolAware;
-
     if (data?.pool) {
       data.pool.remove(this);
     }
-
     return this;
   }
 }

package/src/Patron/PatronPool.test.ts

@@ -17,5 +17,5 @@ test("patron pool", () => {
       expect(receivedCount).toBe(4);
     }),
   );
-  pool.receive(2);
+  pool.give(2);
 });

package/src/Patron/PatronPool.ts

@@ -1,15 +1,8 @@
-import {
-  give,
-  GuestObjectType,
-  GuestType,
-  ReceiveOptions,
-} from "../Guest/Guest";
+import { give, GuestObjectType, GuestType, GiveOptions } from "../Guest/Guest";
 
 const poolSets = new Map<PoolType, Set<GuestObjectType>>();
 
-/**
- * Удалить патрон из всех пулов
- */
+// remove patron from all pools
 export const removePatronFromPools = (patron: GuestObjectType) => {
   poolSets.forEach((pool) => {
     pool.delete(patron);
@@ -25,18 +18,17 @@ export interface PoolType<T = unknown> extends GuestObjectType<T> {
 export class PatronPool<T> implements PoolType<T> {
   private patrons = new Set<GuestObjectType<T>>();
 
-  public receive: (value: T, options?: ReceiveOptions) => this;
+  public give: (value: T, options?: GiveOptions) => this;
 
   public constructor(private initiator: unknown) {
     poolSets.set(this, this.patrons);
-
     let lastMicrotask: (() => void) | null = null;
-    const doReceive = (value: T, options?: ReceiveOptions) => {
+    const doReceive = (value: T, options?: GiveOptions) => {
       this.patrons.forEach((target) => {
         this.sendValueToGuest(value, target, options);
       });
     };
-    this.receive = (value: T, options?: ReceiveOptions) => {
+    this.give = (value: T, options?: GiveOptions) => {
       const currentMicroTask = () => {
         if (currentMicroTask === lastMicrotask) {
           doReceive(value, options);
@@ -73,7 +65,7 @@ export class PatronPool<T> implements PoolType<T> {
   private sendValueToGuest(
     value: T,
     guest: GuestType<T>,
-    options?: ReceiveOptions,
+    options?: GiveOptions,
   ) {
     give(value, guest, {
       ...options,

package/src/Source/Source.test.ts

@@ -4,7 +4,7 @@ import { Source } from "./Source";
 test("source", () => {
   const source = new Source(42);
 
-  source.receiving((value) => {
+  source.value((value) => {
     expect(value).toBe(42);
   });
 });

package/src/Source/Source.ts

@@ -9,13 +9,13 @@ export class Source<T> implements SourceType<T> {
 
   public constructor(private sourceDocument: T) {}
 
-  public receive(value: T): this {
+  public give(value: T): this {
     this.sourceDocument = value;
-    this.pool.receive(this.sourceDocument);
+    this.pool.give(this.sourceDocument);
     return this;
   }
 
-  public receiving(guest: GuestType<T>): this {
+  public value(guest: GuestType<T>): this {
     if (typeof guest === "function") {
       this.pool.distribute(this.sourceDocument, new Guest(guest));
     } else {

package/src/Source/SourceEmpty.test.ts

@@ -6,13 +6,13 @@ test("source", () => {
   let accumulator = 0;
 
   // Не вызывается потому что нет значения
-  source.receiving(() => {
+  source.value(() => {
     accumulator += 100;
   });
 
   // Вызывается после прихода значения
-  source.receive(200);
-  source.receiving((value) => {
+  source.give(200);
+  source.value((value) => {
     accumulator += value;
   });
 

package/src/Source/SourceEmpty.ts

@@ -5,8 +5,8 @@ import { Source, SourceType } from "./Source";
 export class SourceEmpty<T> implements SourceType<T> {
   private baseSource = new Source<T | null>(null);
 
-  public receiving(guest: GuestType<T>) {
-    this.baseSource.receiving(
+  public value(guest: GuestType<T>) {
+    this.baseSource.value(
       new GuestMiddle(guest as GuestType, (value) => {
         if (value !== null) {
           give(value, guest);
@@ -16,8 +16,8 @@ export class SourceEmpty<T> implements SourceType<T> {
     return this;
   }
 
-  public receive(value: T): this {
-    this.baseSource.receive(value);
+  public give(value: T): this {
+    this.baseSource.give(value);
     return this;
   }
 }