patron-oop 1.3.0 → 1.5.0

package/src/Guest/GuestAware.test.ts

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

package/src/{GuestAware.ts → Guest/GuestAware.ts}

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

package/src/Guest/GuestCallback.test.ts

@@ -0,0 +1,13 @@
+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

@@ -0,0 +1,21 @@
+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/Guest/GuestCast.test.ts

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

package/src/{GuestCast.ts → Guest/GuestCast.ts}

@@ -1,4 +1,4 @@
-import { GuestType, ReceiveOptions } from "./GuestType";
+import { GuestType, ReceiveOptions } from "./GuestCallback";
 
 export class GuestCast<T> implements GuestType<T> {
   public constructor(

package/src/Guest/GuestChain.test.ts

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

package/src/{Chain.ts → Guest/GuestChain.ts}

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

package/src/Guest/GuestInTheMiddle.test.ts

@@ -0,0 +1,71 @@
+import { expect, test } from "vitest";
+import { GuestCallback } from "./GuestCallback";
+import { GuestInTheMiddle } from "./GuestInTheMiddle";
+import { GuestChain } from "./GuestChain";
+import { SourceOfValue } from "../Source/SourceOfValue";
+import { PatronOfGuest } from "../Patron/PatronOfGuest";
+
+test("test guest in the middle", () => {
+  const one = new SourceOfValue(1);
+
+  let accumValue = 0;
+  const guest = new GuestCallback((value: number) => {
+    accumValue += value;
+  });
+  one.receiving(
+    new GuestInTheMiddle(guest, (value: number) => {
+      guest.receive(value + 3);
+    }),
+  );
+
+  expect(accumValue).toBe(4);
+});
+
+test("test patron in the middle", () => {
+  const one = new SourceOfValue(1);
+
+  let accumValue = 0;
+  const guest = new PatronOfGuest(
+    new GuestCallback((value: number) => {
+      accumValue += value;
+    }),
+  );
+  one.receiving(
+    new GuestInTheMiddle(guest, (value: number) => {
+      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 SourceOfValue(1);
+  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.receive(3);
+  one.receive(4);
+
+  const guest = new PatronOfGuest(
+    new GuestCallback((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 → Guest/GuestInTheMiddle.ts}

@@ -1,4 +1,4 @@
-import { GuestType, ReceiveOptions } from "./GuestType";
+import { GuestType, ReceiveOptions } from "./GuestCallback";
 
 export class GuestInTheMiddle<T> implements GuestType<T> {
   public constructor(

package/src/{GuestPool.test.ts → Guest/GuestPool.test.ts}

@@ -1,7 +1,7 @@
 import { expect, test } from "vitest";
-import { Guest } from "./Guest";
-import { Patron } from "./Patron";
+import { GuestCallback } from "./GuestCallback";
 import { GuestPool } from "./GuestPool";
+import { PatronOfGuest } from "../Patron/PatronOfGuest";
 
 test("patron pool with guests", () => {
   const pool = new GuestPool(null);
@@ -9,23 +9,23 @@ test("patron pool with guests", () => {
 
   // 2 + 2
   pool.add(
-    new Patron(
-      new Guest<number>((value) => {
+    new PatronOfGuest(
+      new GuestCallback<number>((value) => {
         receivedCount += value;
       }),
     ),
   );
   // 2 + 2
   pool.add(
-    new Patron(
-      new Guest<number>((value) => {
+    new PatronOfGuest(
+      new GuestCallback<number>((value) => {
         receivedCount += value;
       }),
     ),
   );
   // 2
   pool.add(
-    new Guest<number>((value) => {
+    new GuestCallback<number>((value) => {
       receivedCount += value;
     }),
   );

package/src/{GuestPool.ts → Guest/GuestPool.ts}

@@ -1,6 +1,6 @@
-import { PatronPool } from "./PatronPool";
-import { PoolType } from "./PoolType";
-import { GuestType, ReceiveOptions } from "./GuestType";
+import { PatronPool } from "../Patron/PatronPool";
+import { PoolType } from "../Patron/PatronPool";
+import { GuestType, ReceiveOptions } from "./GuestCallback";
 
 export class GuestPool<T> implements GuestType<T>, PoolType<T> {
   private guests = new Set<GuestType<T>>();

package/src/Guest/GuestSync.test.ts

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

package/src/{GuestSync.ts → Guest/GuestSync.ts}

@@ -1,4 +1,8 @@
-import { GuestValueType } from "./GuestValueType";
+import { GuestType } from "./GuestCallback";
+
+export interface GuestValueType<T = unknown> extends GuestType<T> {
+  value(): T;
+}
 
 export class GuestSync<T> implements GuestValueType<T> {
   public constructor(private theValue: T) {}

package/src/Patron/Patron.ts

@@ -0,0 +1,18 @@
+import { PatronOfGuest } from "./PatronOfGuest";
+import { GuestType } from "../Guest/GuestCallback";
+import { PatronOnce } from "./PatronOnce";
+import { PatronPool } from "./PatronPool";
+
+export class Patron {
+  public ofGuest<P>(willBePatron: GuestType<P>) {
+    return new PatronOfGuest(willBePatron);
+  }
+
+  public once<P>(baseGuest: GuestType<P>) {
+    return new PatronOnce(baseGuest);
+  }
+
+  public pool(initiator: unknown) {
+    return new PatronPool(initiator);
+  }
+}

package/src/{Patron.test.ts → Patron/PatronOfGuest.test.ts}

@@ -1,13 +1,13 @@
 import { expect, test } from "vitest";
-import { Patron } from "./Patron";
-import { Guest } from "./Guest";
-import { Source } from "./Source";
+import { PatronOfGuest } from "./PatronOfGuest";
+import { SourceOfValue } from "../Source/SourceOfValue";
+import { GuestCallback } from "../Guest/GuestCallback";
 
 test("patron always guest", () => {
-  const one = new Source(1);
+  const one = new SourceOfValue(1);
   let patronCalledTimes = 0;
-  const patron = new Patron(
-    new Guest(() => {
+  const patron = new PatronOfGuest(
+    new GuestCallback(() => {
       patronCalledTimes += 1;
     }),
   );

package/src/{Patron.ts → Patron/PatronOfGuest.ts}

@@ -1,9 +1,9 @@
-import { GuestType, ReceiveOptions } from "./GuestType";
+import { GuestType, ReceiveOptions } from "../Guest/GuestCallback";
 
 /**
  * Патрон - это постоянный посетитель
  */
-export class Patron<T> implements GuestType<T> {
+export class PatronOfGuest<T> implements GuestType<T> {
   public constructor(private willBePatron: GuestType<T>) {}
 
   public introduction() {

package/src/{PatronOnce.test.ts → Patron/PatronOnce.test.ts}

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

package/src/{PatronOnce.ts → Patron/PatronOnce.ts}

@@ -1,5 +1,5 @@
-import { GuestType, ReceiveOptions } from "./GuestType";
-import { PoolType } from "./PoolType";
+import { PoolType } from "./PatronPool";
+import { GuestType, ReceiveOptions } from "../Guest/GuestCallback";
 
 type PoolAware = {
   pool?: PoolType;
@@ -20,7 +20,7 @@ export class PatronOnce<T> implements GuestType<T> {
     }
 
     const data = options?.data as PoolAware;
-    // Если есть пул, то удаляем себя из пула
+
     if (data?.pool) {
       data.pool.remove(this);
     }

package/src/{PatronPool.test.ts → Patron/PatronPool.test.ts}

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

package/src/{PatronPool.ts → Patron/PatronPool.ts}

@@ -1,5 +1,4 @@
-import { PoolType } from "./PoolType";
-import { GuestType, ReceiveOptions } from "./GuestType";
+import { GuestType, ReceiveOptions } from "../Guest/GuestCallback";
 
 const poolSets = new Map<PoolType, Set<GuestType>>();
 
@@ -12,6 +11,12 @@ export const removePatronFromPools = (patron: 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;
+}
+
 export class PatronPool<T> implements PoolType<T> {
   private patrons = new Set<GuestType<T>>();
 

package/src/Source/Source.ts

@@ -0,0 +1,12 @@
+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/SourceOfValue.test.ts

@@ -0,0 +1,13 @@
+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);
+    }),
+  );
+});

package/src/{Source.ts → Source/SourceOfValue.ts}

@@ -1,8 +1,10 @@
-import { GuestType } from "./GuestType";
-import { PatronPool } from "./PatronPool";
-import { SourceType } from "./SourceType";
+import { GuestAwareType } from "../Guest/GuestAware";
+import { GuestType } from "../Guest/GuestCallback";
+import { PatronPool } from "../Patron/PatronPool";
 
-export class Source<T> implements SourceType<T> {
+export type SourceType<T = unknown> = GuestAwareType<T> & GuestType<T>;
+
+export class SourceOfValue<T> implements SourceType<T> {
   private pool = new PatronPool(this);
 
   public constructor(private sourceDocument: T) {}

package/src/Source/SourcesApplied.test.ts

@@ -0,0 +1,14 @@
+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");
+});

package/src/Source/SourcesApplied.ts

@@ -0,0 +1,40 @@
+type TupleSplit<
+  T,
+  N extends number,
+  O extends readonly any[] = readonly [],
+> = O["length"] extends N
+  ? [O, T]
+  : T extends readonly [infer F, ...infer R]
+    ? TupleSplit<readonly [...R], N, readonly [...O, F]>
+    : [O, T];
+
+type SkipFirst<T extends readonly any[], N extends number> = TupleSplit<
+  T,
+  N
+>[1];
+
+export const sourcesApplied = <T>(
+  target: T,
+  methodsSources: Record<string, unknown[]>,
+) => {
+  return Object.fromEntries(
+    Object.entries(target as object).map(([key, value]) => {
+      if (value instanceof Function && methodsSources[key]) {
+        const methodArgs = methodsSources[key];
+        return [
+          key,
+          new Proxy(value, {
+            apply(target: Function, thisArg: any, argArray: any[]): any {
+              return target.apply(thisArg, [
+                ...methodsSources[key],
+                ...argArray,
+              ]);
+            },
+          }) as (...args: Parameters<typeof value>) => ReturnType<typeof value>,
+        ];
+      }
+
+      return [key, value];
+    }),
+  );
+};

package/src/index.ts

@@ -1,16 +1,9 @@
-export * from "./Cache";
-export * from "./Chain";
-export * from "./Factory";
-export * from "./FactoryDynamic";
-export * from "./FactoryType";
-export * from "./FactoryWithFactories";
-export * from "./Guest";
-export * from "./GuestAware";
-export * from "./GuestCast";
-export * from "./GuestInTheMiddle";
-export * from "./GuestPool";
-export * from "./GuestSync";
-export * from "./Patron";
-export * from "./PatronOnce";
-export * from "./PatronPool";
-export * from "./Source";
+export * from "./Guest/GuestCallback";
+export * from "./Guest/GuestChain";
+export * from "./Guest/GuestSync";
+export * from "./Patron/PatronPool";
+export * from "./Source/SourceOfValue";
+
+export * from "./Guest/Guest";
+export * from "./Patron/Patron";
+export * from "./Source/Source";