patron-oop 1.6.0 → 1.7.0

package/src/Guest/GuestChain.ts

@@ -1,12 +1,12 @@
-import { GuestCallback, GuestType } from "./GuestCallback";
+import { Guest, GuestObjectType } from "./Guest";
 import { GuestPool } from "./GuestPool";
 import { GuestInTheMiddle } from "./GuestInTheMiddle";
 import { SourceOfValue } from "../Source/SourceOfValue";
 
 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> {
@@ -22,7 +22,7 @@ export class GuestChain<T> implements ChainType<T> {
     this.theChain = new SourceOfValue<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 { Patron } from "../Patron/Patron";
 
 test("test guest in the middle", () => {
   const one = new SourceOfValue(1);
 
   let accumValue = 0;
-  const guest = new GuestCallback((value: number) => {
+  const guest = new Guest((value: number) => {
     accumValue += value;
   });
   one.receiving(
@@ -25,8 +25,8 @@ test("test patron in the middle", () => {
   const one = new SourceOfValue(1);
 
   let accumValue = 0;
-  const guest = new PatronOfGuest(
-    new GuestCallback((value: number) => {
+  const guest = new Patron(
+    new Guest((value: number) => {
       accumValue += value;
     }),
   );
@@ -51,14 +51,14 @@ test("test chain in the middle", () => {
   const two = new SourceOfValue(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 { Guest } from "./Guest";
 
 test("guest sync", () => {
   const source = new SourceOfValue(123);
-  const syncGuest = new GuestSync(new GuestCallback(() => {}));
+  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/{PatronOfGuest.test.ts → Patron.test.ts}

@@ -1,16 +1,13 @@
 import { expect, test } from "vitest";
-import { PatronOfGuest } from "./PatronOfGuest";
+import { Patron } from "./Patron";
 import { SourceOfValue } from "../Source/SourceOfValue";
-import { GuestCallback } from "../Guest/GuestCallback";
 
 test("patron always guest", () => {
   const one = new SourceOfValue(1);
   let patronCalledTimes = 0;
-  const patron = new PatronOfGuest(
-    new GuestCallback(() => {
-      patronCalledTimes += 1;
-    }),
-  );
+  const patron = new Patron(() => {
+    patronCalledTimes += 1;
+  });
   one.receiving(patron);
   one.receive(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";
 
 test("patron once", () => {
   const source = new SourceOfValue(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>) ?? {}),

package/src/Source/SourceOfValue.test.ts

@@ -1,13 +1,10 @@
 import { expect, test } from "vitest";
 import { SourceOfValue } from "./SourceOfValue";
-import { GuestCallback } from "../Guest/GuestCallback";
 
 test("source", () => {
   const source = new SourceOfValue(42);
 
-  source.receiving(
-    new GuestCallback((value) => {
-      expect(value).toBe(42);
-    }),
-  );
+  source.receiving((value) => {
+    expect(value).toBe(42);
+  });
 });

package/src/Source/SourceOfValue.ts

@@ -1,8 +1,8 @@
 import { GuestAwareType } from "../Guest/GuestAware";
-import { GuestType } from "../Guest/GuestCallback";
+import { Guest, GuestObjectType, GuestType } from "../Guest/Guest";
 import { PatronPool } from "../Patron/PatronPool";
 
-export type SourceType<T = unknown> = GuestAwareType<T> & GuestType<T>;
+export type SourceType<T = unknown> = GuestAwareType<T> & GuestObjectType<T>;
 
 export class SourceOfValue<T> implements SourceType<T> {
   private pool = new PatronPool(this);
@@ -16,7 +16,11 @@ export class SourceOfValue<T> implements SourceType<T> {
   }
 
   public receiving(guest: GuestType<T>): this {
-    this.pool.distribute(this.sourceDocument, guest);
+    if (typeof guest === "function") {
+      this.pool.distribute(this.sourceDocument, new Guest(guest));
+    } else {
+      this.pool.distribute(this.sourceDocument, guest);
+    }
     return this;
   }
 }

package/src/index.ts

@@ -1,21 +1,43 @@
-export * from "./Guest/GuestCallback";
+import { give, Guest } from "./Guest/Guest";
+import { PatronPool, removePatronFromPools } from "./Patron/PatronPool";
+import { GuestAware } from "./Guest/GuestAware";
+import { GuestCast } from "./Guest/GuestCast";
+import { GuestChain } from "./Guest/GuestChain";
+import { GuestInTheMiddle } from "./Guest/GuestInTheMiddle";
+import { GuestPool } from "./Guest/GuestPool";
+import { GuestSync } from "./Guest/GuestSync";
+import { Patron } from "./Patron/Patron";
+import { PatronOnce } from "./Patron/PatronOnce";
+import { SourceOfValue } from "./Source/SourceOfValue";
+
+export * from "./Guest/GuestAware";
+export * from "./Guest/Guest";
+export * from "./Guest/GuestCast";
 export * from "./Guest/GuestChain";
+export * from "./Guest/GuestInTheMiddle";
+export * from "./Guest/GuestPool";
 export * from "./Guest/GuestSync";
+export * from "./Patron/Patron";
+export * from "./Patron/PatronOnce";
 export * from "./Patron/PatronPool";
 export * from "./Source/SourceOfValue";
 
-import { Guest } from "./Guest/Guest";
-import { Patron } from "./Patron/Patron";
-import { Source } from "./Source/Source";
-
-export { Guest, Patron, Source };
-
-declare var window: any;
+declare var globalThis: any;
 
-if (window) {
-  window["GUEST_LIBRARY"] = {
-    guest: new Guest(),
-    patron: new Patron(),
-    source: new Source(),
+if (globalThis) {
+  globalThis["GUEST_LIBRARY"] = {
+    give,
+    removePatronFromPools,
+    GuestAware,
+    Guest,
+    GuestCast,
+    GuestChain,
+    GuestInTheMiddle,
+    GuestPool,
+    GuestSync,
+    Patron,
+    PatronOnce,
+    PatronPool,
+    SourceOfValue,
   };
 }

package/src/Guest/GuestCallback.test.ts

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

package/src/Guest/GuestCallback.ts

@@ -1,21 +0,0 @@
-type GuestIntroduction = "guest" | "patron";
-
-export interface ReceiveOptions {
-  data?: unknown;
-}
-
-export type GuestExecutorType<T> = (value: T, options?: ReceiveOptions) => void;
-
-export interface GuestType<T = unknown> {
-  receive(value: T, options?: ReceiveOptions): this;
-  introduction?(): GuestIntroduction;
-}
-
-export class GuestCallback<T> implements GuestType<T> {
-  public constructor(private receiver: GuestExecutorType<T>) {}
-
-  public receive(value: T, options?: ReceiveOptions) {
-    this.receiver(value, options);
-    return this;
-  }
-}

package/src/Patron/PatronOfGuest.ts

@@ -1,17 +0,0 @@
-import { GuestType, ReceiveOptions } from "../Guest/GuestCallback";
-
-/**
- * Патрон - это постоянный посетитель
- */
-export class PatronOfGuest<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/Source/Source.ts

@@ -1,12 +0,0 @@
-import { SourceOfValue } from "./SourceOfValue";
-import { sourcesApplied } from "./SourcesApplied";
-
-export class Source {
-  public ofValue<P>(sourceDocument: P) {
-    return new SourceOfValue(sourceDocument);
-  }
-
-  public applySources<P>(target: P, methodsSources: Record<string, unknown[]>) {
-    return sourcesApplied(target, methodsSources);
-  }
-}

package/src/Source/SourcesApplied.test.ts

@@ -1,26 +0,0 @@
-import { expect, test } from "vitest";
-import { sourcesApplied } from "./SourcesApplied";
-
-test("sources applied", () => {
-  const target = {
-    one(data: { one: string }, after: string) {
-      return data.one + " " + after;
-    },
-  };
-  const targetApplied = sourcesApplied(target, {
-    one: [{ one: "hello world" }, "after"],
-  });
-  expect(targetApplied.one()).toBe("hello world after");
-});
-
-test("sources applied classes", () => {
-  class Target {
-    one(data: { one: string }, after: string) {
-      return data.one + " " + after;
-    }
-  }
-  const targetApplied = sourcesApplied(new Target(), {
-    one: [{ one: "good bye" }, "after"],
-  });
-  expect(targetApplied.one()).toBe("good bye after");
-});