patron-oop 1.43.0 → 1.45.0

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/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);
 });

package/src/Source/Source.test.ts

@@ -1,10 +1,14 @@
-import { expect, test } from "vitest";
+import { expect, test, vitest } from "vitest";
 import { Source } from "./Source";
+import { give } from "../Guest/Guest";
 
 test("Source.test", () => {
-  const source = new Source(42);
-
-  source.value((value) => {
-    expect(value).toBe(42);
+  const aware = new Source((guest) => {
+    give(111, guest);
   });
+
+  const guest = vitest.fn();
+  aware.value(guest);
+
+  expect(guest).toBeCalledWith(111);
 });

package/src/Source/Source.ts

@@ -1,43 +1,59 @@
-import { Guest, GuestObjectType, GuestType } from "../Guest/Guest";
-import { GuestAwareObjectType } from "../Guest/GuestAware";
-import { PatronPool } from "../Patron/PatronPool";
+import { give, GuestType } from "../Guest/Guest";
 
-export interface PoolAware<T = any> {
-  pool(): PatronPool<T>;
+export type SourceExecutorType<T> = (guest: GuestType<T>) => unknown;
+
+export interface SourceObjectType<T> {
+  value: SourceExecutorType<T>;
 }
 
+export type SourceType<T = any> = SourceExecutorType<T> | SourceObjectType<T>;
+
 /**
- * @url https://kosukhin.github.io/patron.site/#/source
+ * @url https://kosukhin.github.io/patron.site/#/utils/value
  */
-export type SourceType<T = any> = GuestAwareObjectType<T> &
-  GuestObjectType<T> &
-  PoolAware<T>;
-
-export class Source<T> implements SourceType<T> {
-  private thePool = new PatronPool(this);
-
-  public constructor(private sourceDocument: T) {
-    if (sourceDocument === undefined) {
-      throw new Error("Source didnt receive sourceDocument argument");
-    }
+export function value<T>(source: SourceType<T>, guest: GuestType<T>) {
+  if (source === undefined) {
+    throw new Error("value didnt receive source argument");
   }
-
-  public pool() {
-    return this.thePool;
+  if (guest === undefined) {
+    throw new Error("value didnt receive guest argument");
+  }
+  if (typeof source === "function") {
+    return source(guest);
+  } else {
+    return source.value(guest);
   }
+}
 
-  public give(value: T): this {
-    this.sourceDocument = value;
-    this.thePool.give(this.sourceDocument);
-    return this;
+/**
+ * @url https://kosukhin.github.io/patron.site/#/utils/is-source
+ */
+export function isSource(mbSource: any): mbSource is SourceType {
+  if (mbSource === undefined) {
+    throw new Error("isSource didnt receive mbSource argument");
   }
+  return (
+    typeof mbSource === "function" || typeof mbSource?.value === "function"
+  );
+}
 
-  public value(guest: GuestType<T>): this {
-    if (typeof guest === "function") {
-      this.thePool.distribute(this.sourceDocument, new Guest(guest));
-    } else {
-      this.thePool.distribute(this.sourceDocument, guest);
+/**
+ * @url https://kosukhin.github.io/patron.site/#/guest/source
+ */
+export class Source<T = any> implements SourceObjectType<T> {
+  public constructor(private source: SourceType<T>) {
+    if (source === undefined) {
+      throw new Error("Source constructor didnt receive executor function");
     }
-    return this;
+  }
+
+  public value(guest: GuestType<T>): GuestType<T> {
+    value(this.source, guest);
+    return guest;
   }
 }
+
+/**
+ * @url https://kosukhin.github.io/patron.site/#/utils/source-of
+ */
+export const sourceOf = <T>(value: T) => new Source<T>((g) => give(value, g));

package/src/Source/SourceActive.test.ts

@@ -0,0 +1,13 @@
+import { SourceActive } from "./SourceActive";
+import { expect, test, vitest } from "vitest";
+
+test("SourceActive.test", () => {
+  const active = new SourceActive<number, number>((config, source) => {
+    source.give(config * 3);
+  });
+
+  const guest = vitest.fn();
+  active.do(4).value(guest);
+
+  expect(guest).toBeCalledWith(12);
+});

package/src/Source/SourceActive.ts

@@ -0,0 +1,41 @@
+import { GuestType } from "../Guest/Guest";
+import { SourceObjectType } from "./Source";
+import { SourceWithPool, SourceWithPoolType } from "./SourceWithPool";
+
+/**
+ * @url https://kosukhin.github.io/patron.site/#/utils/action-type
+ */
+export interface ActionType<P = any> {
+  do(config: P): this;
+}
+
+export interface SourceAcitveType<R = unknown, T = unknown>
+  extends SourceObjectType<T>,
+    ActionType<R> {}
+
+/**
+ * @url https://kosukhin.github.io/patron.site/#/guest/source-active
+ */
+export class SourceActive<R, T> implements SourceAcitveType<R, T> {
+  private source = new SourceWithPool<T>();
+
+  public constructor(
+    private configExecutor: (config: R, source: SourceWithPoolType<T>) => void,
+  ) {
+    if (configExecutor === undefined) {
+      throw new Error(
+        "SourceActive constructor didnt receive executor function",
+      );
+    }
+  }
+
+  public do(config: R): this {
+    this.configExecutor(config, this.source);
+    return this;
+  }
+
+  public value(guest: GuestType<T>): this {
+    this.source.value(guest);
+    return this;
+  }
+}

package/src/Source/SourceAll._asArray.test.ts

@@ -0,0 +1,22 @@
+import { expect, test, vitest } from "vitest";
+import { SourceAll } from "./SourceAll";
+import { SourceWithPool } from "./SourceWithPool";
+import { Patron } from "../Patron/Patron";
+
+test("SourceAll._asArray.test", () => {
+  const one = new SourceWithPool(1);
+  const two = new SourceWithPool(2);
+  const all = new SourceAll<[number, number]>();
+
+  one.value(new Patron(all.guestKey("0")));
+  two.value(new Patron(all.guestKey("1")));
+
+  const guest = vitest.fn();
+  all.valueArray(
+    new Patron((value) => {
+      guest(JSON.stringify(value));
+    }),
+  );
+
+  expect(guest).toBeCalledWith("[1,2]");
+});

package/src/Source/SourceAll._twoValuesAfter.test.ts

@@ -0,0 +1,19 @@
+import { expect, test, vitest } from "vitest";
+import { SourceWithPool } from "./SourceWithPool";
+import { SourceAll } from "./SourceAll";
+
+test("SourceAll._twoValuesAfter.test", () => {
+  const one = new SourceWithPool(1);
+  const two = new SourceWithPool(2);
+  const all = new SourceAll<{ one: number; two: number }>(["one", "two"]);
+
+  const g = vitest.fn();
+  all.value((value) => {
+    g(Object.values(value).join());
+  });
+
+  one.value(all.guestKey("one"));
+  two.value(all.guestKey("two"));
+
+  expect(g).toBeCalledWith("1,2");
+});

package/src/Source/SourceAll._twoValuesBefore.test.ts

@@ -0,0 +1,19 @@
+import { expect, test, vitest } from "vitest";
+import { SourceWithPool } from "./SourceWithPool";
+import { SourceAll } from "./SourceAll";
+
+test("SourceAll._twoValuesBefore.test", () => {
+  const one = new SourceWithPool(1);
+  const two = new SourceWithPool(2);
+  const all = new SourceAll<{ one: number; two: number }>();
+
+  one.value(all.guestKey("one"));
+  two.value(all.guestKey("two"));
+
+  const g = vitest.fn();
+  all.value((value) => {
+    g(Object.values(value).join());
+  });
+
+  expect(g).toBeCalledWith("1,2");
+});

package/src/Source/SourceAll._withPatron.test.ts

@@ -0,0 +1,25 @@
+import { expect, test, vitest } from "vitest";
+import { SourceAll } from "./SourceAll";
+import { SourceWithPool } from "./SourceWithPool";
+import { Patron } from "../Patron/Patron";
+
+test("SourceAll._withPatron.test", () => {
+  const one = new SourceWithPool(1);
+  const two = new SourceWithPool(2);
+  const all = new SourceAll<{ one: number; two: number }>();
+
+  one.value(new Patron(all.guestKey("one")));
+  two.value(new Patron(all.guestKey("two")));
+
+  one.give(3);
+  one.give(4);
+
+  const g = vitest.fn();
+  all.value(
+    new Patron((value: Record<string, unknown>) => {
+      g(Object.values(value).length);
+    }),
+  );
+
+  expect(g).toBeCalledWith(2);
+});

package/src/{Guest/GuestAwareAll.ts → Source/SourceAll.ts}

@@ -1,20 +1,20 @@
-import { GuestAwareObjectType } from "./GuestAware";
-import { Source } from "../Source/Source";
-import { Guest, GuestObjectType, GuestType } from "./Guest";
-import { GuestCast } from "./GuestCast";
-import { GuestObject } from "./GuestObject";
-import { GuestPool } from "./GuestPool";
+import { SourceObjectType } from "./Source";
+import { SourceWithPool } from "./SourceWithPool";
+import { Guest, GuestObjectType, GuestType } from "../Guest/Guest";
+import { GuestCast } from "../Guest/GuestCast";
+import { GuestObject } from "../Guest/GuestObject";
+import { GuestPool } from "../Guest/GuestPool";
 
-export interface GuestAwareAllType<T = any> extends GuestAwareObjectType<T> {
+export interface SourceAllType<T = any> extends SourceObjectType<T> {
   valueArray(guest: GuestObjectType<T>): this;
   guestKey<R>(key: string): GuestObjectType<R>;
 }
 
 /**
- * @url https://kosukhin.github.io/patron.site/#/guest/guest-aware-all
+ * @url https://kosukhin.github.io/patron.site/#/guest/source-all
  */
-export class GuestAwareAll<T> implements GuestAwareAllType<T> {
-  private theAll: Source<Record<string, unknown>>;
+export class SourceAll<T> implements SourceAllType<T> {
+  private theAll: SourceWithPool<Record<string, unknown>>;
 
   private keysKnown: Set<string>;
 
@@ -23,7 +23,7 @@ export class GuestAwareAll<T> implements GuestAwareAllType<T> {
   private filledAllPool = new GuestPool(this);
 
   public constructor(initialKnownKeys: string[] = []) {
-    this.theAll = new Source<Record<string, unknown>>({});
+    this.theAll = new SourceWithPool<Record<string, unknown>>({});
     this.keysKnown = new Set(initialKnownKeys);
   }
 

package/src/Source/SourceApplied.test.ts

@@ -0,0 +1,14 @@
+import { GuestSync } from "../Guest/GuestSync";
+import { SourceApplied } from "../Source/SourceApplied";
+import { SourceWithPool } from "../Source/SourceWithPool";
+import { expect, test } from "vitest";
+
+test("SourceApplied.test", () => {
+  const source = new SourceWithPool(1);
+  const sourceDouble = new SourceApplied(source, (x) => x * 2);
+  const guest = new GuestSync(0);
+
+  sourceDouble.value(guest);
+
+  expect(guest.value()).toBe(2);
+});

package/src/Source/SourceApplied.ts

@@ -0,0 +1,23 @@
+import { give, GuestType } from "../Guest/Guest";
+import { GuestCast } from "../Guest/GuestCast";
+import { SourceObjectType, SourceType, value } from "../Source/Source";
+
+/**
+ * @url https://kosukhin.github.io/patron.site/#/source/source-applied
+ */
+export class SourceApplied<T, R> implements SourceObjectType<R> {
+  public constructor(
+    private baseSource: SourceType<T>,
+    private applier: (v: T) => R,
+  ) {}
+
+  public value(g: GuestType<R>) {
+    value(
+      this.baseSource,
+      new GuestCast(g, (v) => {
+        give(this.applier(v), g);
+      }),
+    );
+    return this;
+  }
+}

package/src/Source/SourceDynamic.ofSource.test.ts

@@ -1,21 +1,21 @@
 import { SourceDynamic } from "./SourceDynamic";
-import { Source } from "./Source";
-import { expect, test } from "vitest";
+import { SourceWithPool } from "./SourceWithPool";
+import { expect, test, vitest } from "vitest";
 
 test("SourceDynamic.ofSource.test", () => {
-  const source = new Source(1);
+  const source = new SourceWithPool(1);
   const sourceDynamic = new SourceDynamic(source, source);
 
-  sourceDynamic.value((value) => {
-    expect(value).toBe(1);
-  });
+  const g1 = vitest.fn();
+  sourceDynamic.value(g1);
+  expect(g1).toBeCalledWith(1);
 
   sourceDynamic.give(2);
 
-  sourceDynamic.value((value) => {
-    expect(value).toBe(2);
-  });
-  source.value((value) => {
-    expect(value).toBe(2);
-  });
+  const g2 = vitest.fn();
+  sourceDynamic.value(g2);
+  expect(g2).toBeCalledWith(2);
+  const g3 = vitest.fn();
+  source.value(g3);
+  expect(g3).toBeCalledWith(2);
 });