patron-oop 1.44.1 → 1.46.0

package/src/Guest/GuestApplied.test.ts

@@ -0,0 +1,13 @@
+import { GuestApplied } from "../Guest/GuestApplied";
+import { expect, test, vitest } from "vitest";
+import { SourceWithPool } from "../Source/SourceWithPool";
+
+test("GuestApplied.test", () => {
+  const one = new SourceWithPool(1);
+  const guest = vitest.fn();
+
+  one.value(new GuestApplied(guest, (v) => v * 2));
+
+  expect(guest).toBeCalled();
+  expect(guest).toBeCalledWith(2);
+});

package/src/Guest/GuestApplied.ts

@@ -0,0 +1,16 @@
+import { give, GuestObjectType, GuestType } from "../Guest/Guest";
+
+/**
+ * @url https://kosukhin.github.io/patron.site/#/guest/guest-applied
+ */
+export class GuestApplied<T, R> implements GuestObjectType<T> {
+  public constructor(
+    private baseGuest: GuestType<R>,
+    private applier: (value: T) => R,
+  ) {}
+
+  public give(value: T): this {
+    give(this.applier(value), this.baseGuest);
+    return this;
+  }
+}

package/src/Guest/GuestCast.test.ts

@@ -1,17 +1,18 @@
-import { SourceEmpty } from "../Source/SourceEmpty";
 import { expect, test } from "vitest";
 import { Patron } from "../Patron/Patron";
 import { give, Guest } from "./Guest";
 import { GuestCast } from "./GuestCast";
+import { SourceWithPool } from "../Source/SourceWithPool";
 
 test("GuestCast.test", () => {
-  const source = new SourceEmpty();
+  const source = new SourceWithPool();
   let acc = 0;
   const mainGuest = new Patron(
     new Guest((value: number) => {
       acc += value;
     }),
   );
+
   // Становится патроном тоже, тк наследует это сойство от mainGuest
   const secondGuest = new GuestCast(
     mainGuest,
@@ -25,7 +26,5 @@ test("GuestCast.test", () => {
 
   give(2, source);
 
-  setTimeout(() => {
-    expect(acc).toBe(4);
-  });
+  expect(acc).toBe(4);
 });

package/src/Guest/GuestCast.ts

@@ -1,6 +1,5 @@
+import { give, GuestType } from "./Guest";
 import { GuestDisposableType, MaybeDisposableType } from "./GuestDisposable";
-import { give, GiveOptions, GuestType } from "./Guest";
-import { PoolAwareOptions } from "../Patron/PatronOnce";
 
 /**
  * @url https://kosukhin.github.io/patron.site/#/guest/guest-cast
@@ -28,14 +27,8 @@ export class GuestCast<T> implements GuestDisposableType<T> {
     return this.sourceGuest.introduction();
   }
 
-  public give(value: T, options?: GiveOptions): this {
-    give(value, this.targetGuest, {
-      ...options,
-      data: {
-        ...(options?.data ?? {}),
-        castedGuest: (options?.data as PoolAwareOptions)?.castedGuest ?? this,
-      },
-    });
+  public give(value: T): this {
+    give(value, this.targetGuest);
     return this;
   }
 

package/src/Guest/GuestDisposable.test.ts

@@ -1,30 +1,26 @@
 import { GuestDisposable } from "./GuestDisposable";
 import { Patron } from "../Patron/Patron";
-import { Source } from "../Source/Source";
-import { expect, test } from "vitest";
+import { SourceWithPool } from "../Source/SourceWithPool";
+import { expect, test, vitest } from "vitest";
 
 test("GuestDisposable.test", () => {
-  const source = new Source(1);
+  const source = new SourceWithPool(1);
+
+  const guest = vitest.fn();
 
   // Работает проверка один раз, потом патром себя удаляет
   source.value(
     new Patron(
-      new GuestDisposable(
-        (value) => {
-          expect(value).toBe(1);
-        },
-        (value) => {
-          return value !== null && value > 1;
-        },
-      ),
+      new GuestDisposable(guest, (value) => {
+        return value !== null && value > 1;
+      }),
     ),
   );
 
   // Эти выражения не вызывает expect
-  setTimeout(() => {
-    source.give(2);
-    setTimeout(() => {
-      source.give(3);
-    });
-  });
+  source.give(2);
+  source.give(3);
+
+  expect(guest).toBeCalledTimes(1);
+  expect(guest).toBeCalledWith(1);
 });

package/src/Guest/GuestDisposable.ts

@@ -1,4 +1,4 @@
-import { give, GiveOptions, GuestObjectType, GuestType } from "./Guest";
+import { give, GuestObjectType, GuestType } from "./Guest";
 
 export interface GuestDisposableType<T = any> extends GuestObjectType<T> {
   disposed(value: T | null): boolean;
@@ -26,8 +26,8 @@ export class GuestDisposable<T> implements GuestDisposableType<T> {
     return this.disposeCheck(value);
   }
 
-  public give(value: T, options?: GiveOptions): this {
-    give(value, this.guest, options);
+  public give(value: T): this {
+    give(value, this.guest);
     return this;
   }
 }

package/src/Guest/GuestExecutorApplied.test.ts

@@ -0,0 +1,27 @@
+import { Patron } from "../Patron/Patron";
+import { expect, test, vi } from "vitest";
+import { SourceWithPool } from "../Source/SourceWithPool";
+import { GuestExecutorApplied } from "../Guest/GuestExecutorApplied";
+import { debounce } from "../../test-utils/debounce";
+
+test("GuestExecutorApplied.test", () => {
+  vi.useFakeTimers({ shouldAdvanceTime: true });
+  let counter = 0;
+  const guest = (v: number) => {
+    counter += v;
+  };
+
+  const source = new SourceWithPool();
+  source.value(
+    new Patron(new GuestExecutorApplied(guest, debounce.bind(null, 100))),
+  );
+
+  source.give(1);
+  source.give(1);
+  source.give(1);
+
+  vi.runOnlyPendingTimers();
+
+  expect(counter).toBe(1);
+  vi.useRealTimers();
+});

package/src/Guest/GuestExecutorApplied.ts

@@ -0,0 +1,23 @@
+import {
+  give,
+  GuestExecutorType,
+  GuestObjectType,
+  GuestType,
+} from "../Guest/Guest";
+
+/**
+ * @url https://kosukhin.github.io/patron.site/#/guest/guest-executor-applied
+ */
+export class GuestExecutorApplied<T> implements GuestObjectType<T> {
+  public give: GuestExecutorType<T, this>;
+
+  public constructor(
+    baseGuest: GuestType<T>,
+    applier: (executor: GuestExecutorType) => GuestExecutorType,
+  ) {
+    this.give = applier((v) => give(v, baseGuest)) as GuestExecutorType<
+      T,
+      this
+    >;
+  }
+}

package/src/Guest/GuestObject.test.ts

@@ -1,11 +1,11 @@
-import { expect, test } from "vitest";
-import { Source } from "../Source/Source";
+import { expect, test, vitest } from "vitest";
+import { SourceWithPool } from "../Source/SourceWithPool";
 import { GuestObject } from "./GuestObject";
 
 test("GuestObject.test", () => {
-  const source = new Source(1);
-  const fnGuest = (value: number) => {
-    expect(value).toBe(1);
-  };
+  const source = new SourceWithPool(1);
+  const fnGuest = vitest.fn();
   source.value(new GuestObject(fnGuest));
+  expect(fnGuest).toBeCalled();
+  expect(fnGuest).toBeCalledWith(1);
 });

package/src/Guest/GuestObject.ts

@@ -1,5 +1,5 @@
+import { Guest, GuestType } from "./Guest";
 import { GuestDisposableType, MaybeDisposableType } from "./GuestDisposable";
-import { GiveOptions, Guest, GuestType } from "./Guest";
 
 /**
  * @url https://kosukhin.github.io/patron.site/#/guest/guest-object
@@ -11,12 +11,12 @@ export class GuestObject<T> implements GuestDisposableType<T> {
     }
   }
 
-  public give(value: T, options?: GiveOptions): this {
+  public give(value: T): this {
     let guest = this.baseGuest;
     if (typeof guest === "function") {
       guest = new Guest(guest);
     }
-    guest.give(value, options);
+    guest.give(value);
     return this;
   }
 

package/src/Guest/GuestPool.test.ts

@@ -1,16 +1,6 @@
-import { expect, test, vi, beforeEach, afterEach } from "vitest";
-import { GuestPool } from "./GuestPool";
+import { expect, test } from "vitest";
 import { Patron } from "../Patron/Patron";
-import { wait } from "test-utils/wait";
-
-beforeEach(() => {
-  vi.useFakeTimers({ shouldAdvanceTime: true });
-});
-
-afterEach(() => {
-  vi.runOnlyPendingTimers();
-  vi.useRealTimers();
-});
+import { GuestPool } from "./GuestPool";
 
 test("GuestPool.test", async () => {
   const pool = new GuestPool<number>(null);
@@ -32,16 +22,9 @@ test("GuestPool.test", async () => {
   pool.add((value) => {
     receivedCount += value;
   });
-  pool.give(2);
-
-  setTimeout(() => {
-    pool.give(2);
-  });
 
-  await wait(50);
+  pool.give(2);
+  pool.give(2);
 
-  setTimeout(() => {
-    pool.give(2);
-    expect(receivedCount).toBe(10);
-  }, 10);
+  expect(receivedCount).toBe(10);
 });

package/src/Guest/GuestPool.ts

@@ -1,6 +1,5 @@
-import { PatronPool } from "../Patron/PatronPool";
-import { PoolType } from "../Patron/PatronPool";
-import { give, GuestObjectType, GuestType, GiveOptions } from "./Guest";
+import { PatronPool, PoolType } from "../Patron/PatronPool";
+import { give, GuestObjectType, GuestType } from "./Guest";
 
 /**
  * @url https://kosukhin.github.io/patron.site/#/guest/guest-pool
@@ -14,9 +13,9 @@ export class GuestPool<T> implements GuestObjectType<T>, PoolType<T> {
     this.patronPool = new PatronPool(initiator);
   }
 
-  public give(value: T, options?: GiveOptions): this {
-    this.deliverToGuests(value, options);
-    this.patronPool.give(value, options);
+  public give(value: T): this {
+    this.deliverToGuests(value);
+    this.patronPool.give(value);
     return this;
   }
 
@@ -48,9 +47,9 @@ export class GuestPool<T> implements GuestObjectType<T>, PoolType<T> {
     return this.patronPool.size() + this.guests.size;
   }
 
-  private deliverToGuests(value: T, options?: GiveOptions) {
+  private deliverToGuests(value: T) {
     this.guests.forEach((target) => {
-      give(value, target, options);
+      give(value, target);
     });
     this.guests.clear();
   }

package/src/Guest/GuestSync.test.ts

@@ -1,9 +1,9 @@
 import { expect, test } from "vitest";
 import { GuestSync } from "./GuestSync";
-import { Source } from "../Source/Source";
+import { SourceWithPool } from "../Source/SourceWithPool";
 
 test("GuestSync.test", () => {
-  const source = new Source(123);
+  const source = new SourceWithPool(123);
   const syncGuest = new GuestSync(111);
   syncGuest.give(222);
   expect(syncGuest.value()).toBe(222);

package/src/Patron/Patron.test.ts

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

package/src/Patron/Patron.ts

@@ -1,5 +1,5 @@
+import { give, GuestType } from "../Guest/Guest";
 import { GuestDisposableType } from "../Guest/GuestDisposable";
-import { give, GiveOptions, GuestType } from "../Guest/Guest";
 
 /**
  * @url https://kosukhin.github.io/patron.site/#/patron
@@ -15,8 +15,8 @@ export class Patron<T> implements GuestDisposableType<T> {
     return "patron" as const;
   }
 
-  public give(value: T, options?: GiveOptions): this {
-    give(value, this.willBePatron, options);
+  public give(value: T): this {
+    give(value, this.willBePatron);
     return this;
   }
 
@@ -25,3 +25,11 @@ export class Patron<T> implements GuestDisposableType<T> {
     return maybeDisposable?.disposed?.(value) || false;
   }
 }
+
+/**
+ * @url https://kosukhin.github.io/patron.site/#/utils/is-patron
+ */
+export const isPatron = (guest: GuestType): guest is Patron<unknown> =>
+  typeof guest === "object" &&
+  guest !== null &&
+  guest?.introduction?.() === "patron";

package/src/Patron/PatronApplied.ts

@@ -0,0 +1,22 @@
+import { GuestObjectType, GuestType } from "../Guest/Guest";
+import { GuestApplied } from "../Guest/GuestApplied";
+
+/**
+ * @url https://kosukhin.github.io/patron.site/#/patron/patron-applied
+ */
+export class PatronApplied<T, R> implements GuestObjectType<T> {
+  private guestApplied: GuestApplied<T, R>;
+
+  public constructor(baseGuest: GuestType<R>, applier: (value: T) => R) {
+    this.guestApplied = new GuestApplied(baseGuest, applier);
+  }
+
+  public give(value: T): this {
+    this.guestApplied.give(value);
+    return this;
+  }
+
+  public introduction(): "guest" | "patron" {
+    return "patron";
+  }
+}

package/src/Patron/PatronExecutorApplied.ts

@@ -0,0 +1,25 @@
+import { GuestExecutorType, GuestObjectType, GuestType } from "../Guest/Guest";
+import { GuestExecutorApplied } from "../Guest/GuestExecutorApplied";
+
+/**
+ * @url https://kosukhin.github.io/patron.site/#/patron/patron-executor-applied
+ */
+export class PatronExecutorApplied<T> implements GuestObjectType<T> {
+  private guestApplied: GuestExecutorApplied<T>;
+
+  public constructor(
+    baseGuest: GuestType<T>,
+    applier: (executor: GuestExecutorType) => GuestExecutorType,
+  ) {
+    this.guestApplied = new GuestExecutorApplied(baseGuest, applier);
+  }
+
+  public give(value: T): this {
+    this.guestApplied.give(value);
+    return this;
+  }
+
+  public introduction(): "guest" | "patron" {
+    return "patron";
+  }
+}

package/src/Patron/PatronOnce.sourceEmpty.test.ts

@@ -1,6 +1,6 @@
 import { afterEach, beforeEach, expect, test, vi } from "vitest";
 import { PatronOnce } from "./PatronOnce";
-import { SourceEmpty } from "../Source/SourceEmpty";
+import { SourceWithPool } from "../Source/SourceWithPool";
 
 beforeEach(() => {
   vi.useFakeTimers({ shouldAdvanceTime: true });
@@ -19,7 +19,7 @@ const wait = (ms: number) =>
   });
 
 test("PatronOnce.sourceEmpty.test", async () => {
-  const source = new SourceEmpty();
+  const source = new SourceWithPool();
   let calls = 0;
   const patron = new PatronOnce(() => {
     calls += 1;

package/src/Patron/PatronOnce.test.ts

@@ -1,6 +1,6 @@
 import { wait } from "./../../test-utils/wait";
 import { afterEach, beforeEach, expect, test, vi } from "vitest";
-import { Source } from "../Source/Source";
+import { SourceWithPool } from "../Source/SourceWithPool";
 import { PatronOnce } from "./PatronOnce";
 
 beforeEach(() => {
@@ -13,7 +13,7 @@ afterEach(() => {
 });
 
 test("PatronOnce.test", async () => {
-  const source = new Source(12);
+  const source = new SourceWithPool(12);
   let calls = 0;
   const patron = new PatronOnce(() => {
     calls += 1;

package/src/Patron/PatronOnce.ts

@@ -1,15 +1,9 @@
-import { PoolType } from "./PatronPool";
-import { give, GuestType, GiveOptions, GuestObjectType } from "../Guest/Guest";
+import { give, GuestType } from "../Guest/Guest";
 import {
   GuestDisposableType,
   MaybeDisposableType,
 } from "../Guest/GuestDisposable";
 
-export type PoolAwareOptions = {
-  pool?: PoolType;
-  castedGuest?: GuestObjectType;
-};
-
 /**
  * @url https://kosukhin.github.io/patron.site/#/patron/patron-once
  */
@@ -26,10 +20,10 @@ export class PatronOnce<T> implements GuestDisposableType<T> {
     return "patron" as const;
   }
 
-  public give(value: T, options?: GiveOptions): this {
+  public give(value: T): this {
     if (!this.received) {
       this.received = true;
-      give(value, this.baseGuest, options);
+      give(value, this.baseGuest);
     }
     return this;
   }

package/src/Patron/PatronPool.test.ts

@@ -14,8 +14,9 @@ test("PatronPool.test", () => {
   pool.add(
     new Patron((value) => {
       receivedCount += value;
-      expect(receivedCount).toBe(4);
     }),
   );
   pool.give(2);
+
+  expect(receivedCount).toBe(4);
 });

package/src/Patron/PatronPool.ts

@@ -1,8 +1,21 @@
+import { give, GuestObjectType, GuestType } from "../Guest/Guest";
 import { GuestDisposableType } from "../Guest/GuestDisposable";
-import { give, GuestObjectType, GuestType, GiveOptions } from "../Guest/Guest";
 
 const poolSets = new Map<PoolType, Set<GuestObjectType>>();
 
+/**
+ * @url https://kosukhin.github.io/patron.site/#/utils/patron-pools
+ */
+export const patronPools = (patron: GuestObjectType) => {
+  const pools: PoolType[] = [];
+  poolSets.forEach((pool, poolInstance) => {
+    if (pool.has(patron)) {
+      pools.push(poolInstance);
+    }
+  });
+  return pools;
+};
+
 /**
  * @url https://kosukhin.github.io/patron.site/#/utils/remove-patron-from-pools
  */
@@ -44,25 +57,18 @@ export interface PoolType<T = any> extends GuestObjectType<T> {
 export class PatronPool<T> implements PoolType<T> {
   private patrons: Set<GuestObjectType<T>>;
 
-  public give: (value: T, options?: GiveOptions) => this;
+  public give: (value: T) => this;
 
   public constructor(private initiator: unknown) {
     this.patrons = new Set<GuestObjectType<T>>();
     poolSets.set(this, this.patrons);
-    let lastMicrotask: (() => void) | null = null;
-    const doReceive = (value: T, options?: GiveOptions) => {
+    const doReceive = (value: T) => {
       this.patrons.forEach((target) => {
-        this.sendValueToGuest(value, target, options);
+        this.sendValueToGuest(value, target);
       });
     };
-    this.give = (value: T, options?: GiveOptions) => {
-      const currentMicroTask = () => {
-        if (currentMicroTask === lastMicrotask) {
-          doReceive(value, options);
-        }
-      };
-      lastMicrotask = currentMicroTask;
-      queueMicrotask(currentMicroTask);
+    this.give = (value: T) => {
+      doReceive(value);
       return this;
     };
   }
@@ -92,26 +98,15 @@ export class PatronPool<T> implements PoolType<T> {
 
   public distribute(receiving: T, possiblePatron: GuestType<T>): this {
     this.add(possiblePatron);
-    this.sendValueToGuest(receiving, possiblePatron, {});
+    this.sendValueToGuest(receiving, possiblePatron);
     return this;
   }
 
-  private sendValueToGuest(
-    value: T,
-    guest: GuestType<T>,
-    options?: GiveOptions,
-  ) {
+  private sendValueToGuest(value: T, guest: GuestType<T>) {
     const isDisposed = this.guestDisposed(value, guest);
 
     if (!isDisposed) {
-      give(value, guest, {
-        ...options,
-        data: {
-          ...((options?.data as Record<string, unknown>) ?? {}),
-          initiator: this.initiator,
-          pool: this,
-        },
-      });
+      give(value, guest);
     }
   }
 

package/src/Private/PrivateClass.modules.test.ts

@@ -1,15 +1,15 @@
 import { PrivateClass } from "./PrivateClass";
 import { GuestType } from "../Guest/Guest";
-import { Source, SourceType } from "../Source/Source";
-import { expect, test } from "vitest";
+import { SourceWithPool, SourceWithPoolType } from "../Source/SourceWithPool";
+import { expect, test, vitest } from "vitest";
 import { PrivateType } from "./Private";
 
 class TestClass {
-  private source: SourceType;
+  private source: SourceWithPoolType;
 
   public constructor(
     baseNum: number,
-    modules: { main: PrivateType<SourceType> },
+    modules: { main: PrivateType<SourceWithPoolType> },
   ) {
     this.source = modules.main.get(baseNum + 55);
   }
@@ -21,13 +21,16 @@ class TestClass {
 }
 
 test("PrivateClass.modules.test", () => {
-  const main = new PrivateClass(Source);
+  const main = new PrivateClass(SourceWithPool);
   const testSource = new PrivateClass(TestClass, {
     main,
   });
 
   const source = testSource.get(42);
-  source.value((value) => {
-    expect(value).toBe(97);
-  });
+
+  const guest = vitest.fn();
+  source.value(guest);
+
+  expect(guest).toBeCalled();
+  expect(guest).toBeCalledWith(97);
 });

package/src/Private/PrivateClass.test.ts

@@ -1,12 +1,13 @@
-import { expect, test } from "vitest";
-import { Source } from "../Source/Source";
+import { expect, test, vitest } from "vitest";
+import { SourceWithPool } from "../Source/SourceWithPool";
 import { PrivateClass } from "./PrivateClass";
 
 test("PrivateClass.test", () => {
-  const sourcePrivate = new PrivateClass(Source);
+  const sourcePrivate = new PrivateClass(SourceWithPool);
   const source = sourcePrivate.get(42);
 
-  source.value((value) => {
-    expect(value).toBe(42);
-  });
+  const guest = vitest.fn();
+  source.value(guest);
+
+  expect(guest).toBeCalledWith(42);
 });