patron-oop 1.40.0 → 1.41.0

package/src/Guest/GuestAwareRace.ts

@@ -6,19 +6,26 @@ import { GuestCast } from "./GuestCast";
  * @url https://kosukhin.github.io/patron.site/#/guest/guest-aware-race
  */
 export class GuestAwareRace<T> implements GuestAwareObjectType<T> {
-  public constructor(private guestAwares: GuestAwareType<T>[]) { }
+  public constructor(private guestAwares: GuestAwareType<T>[]) {
+    if (guestAwares === undefined) {
+      throw new Error("GuestAwareRace didnt receive guestAwares argument");
+    }
+  }
 
   public value(guest: GuestType<T>): this {
     let connectedWithGuestAware: GuestAwareType | null = null;
-    this.guestAwares.forEach(guestAware => {
+    this.guestAwares.forEach((guestAware) => {
       value(
         guestAware,
         new GuestCast(<GuestType>guest, (value) => {
-          if (!connectedWithGuestAware || connectedWithGuestAware === guestAware) {
+          if (
+            !connectedWithGuestAware ||
+            connectedWithGuestAware === guestAware
+          ) {
             give(value as T, guest);
-            connectedWithGuestAware = guestAware
+            connectedWithGuestAware = guestAware;
           }
-        })
+        }),
       );
     });
     return this;

package/src/Guest/GuestAwareSequence.defered.test.ts

@@ -1,6 +1,11 @@
 import { GuestAwareSequence } from "./GuestAwareSequence";
 import { give } from "./Guest";
-import { GuestAware, GuestAwareObjectType, GuestAwareType, value } from "./GuestAware";
+import {
+  GuestAware,
+  GuestAwareObjectType,
+  GuestAwareType,
+  value,
+} from "./GuestAware";
 import { GuestCast } from "./GuestCast";
 import { GuestType } from "./Guest";
 import { afterEach, beforeEach, expect, test, vi } from "vitest";
@@ -18,38 +23,36 @@ afterEach(() => {
 });
 
 class X2 implements GuestAwareObjectType<number> {
-  public constructor(private baseNumber: GuestAwareType<number>) { }
+  public constructor(private baseNumber: GuestAwareType<number>) {}
 
   public value(guest: GuestType<number>) {
     value(
       this.baseNumber,
       new GuestCast(<GuestType>guest, (v) => {
         give(v * 2, guest);
-      })
+      }),
     );
     return this;
   }
 }
 
-test('GuestAwareSequence.defered.test', async () => {
-  const guestAwareOf = (val: number) => new GuestAware((guest) => {
-    setTimeout(() => {
-      give(val, guest);
-    }, 10);
-  });
+test("GuestAwareSequence.defered.test", async () => {
+  const guestAwareOf = (val: number) =>
+    new GuestAware((guest) => {
+      setTimeout(() => {
+        give(val, guest);
+      }, 10);
+    });
   const source = new Source([1, 2, 3, 9].map(guestAwareOf));
 
-  const sequence = new GuestAwareSequence(
-    source,
-    new PrivateClass(X2)
-  );
+  const sequence = new GuestAwareSequence(source, new PrivateClass(X2));
 
   const callFn = vi.fn();
   sequence.value((v) => {
-    expect(v.join()).toBe('2,4,6,18');
+    expect(v.join()).toBe("2,4,6,18");
     callFn();
   });
 
   await wait(51);
   expect(callFn).toBeCalled();
-})
+});

package/src/Guest/GuestAwareSequence.test.ts

@@ -8,26 +8,23 @@ import { Source } from "../Source/Source";
 import { PrivateClass } from "../Private/PrivateClass";
 
 class X2 implements GuestAwareObjectType<number> {
-  public constructor(private baseNumber: GuestAwareType<number>) { }
+  public constructor(private baseNumber: GuestAwareType<number>) {}
 
   public value(guest: GuestType<number>) {
     value(
       this.baseNumber,
       new GuestCast(<GuestType>guest, (v) => {
         give(v * 2, guest);
-      })
+      }),
     );
     return this;
   }
 }
 
-test('GuestAwareSequence.test', () => {
+test("GuestAwareSequence.test", () => {
   const source = new Source([1, 2, 3, 9]);
-  const guestMapped = new GuestAwareSequence(
-    source,
-    new PrivateClass(X2)
-  );
+  const guestMapped = new GuestAwareSequence(source, new PrivateClass(X2));
   guestMapped.value((v) => {
-    expect(v.join()).toBe('2,4,6,18')
+    expect(v.join()).toBe("2,4,6,18");
   });
-})
+});

package/src/Guest/GuestAwareSequence.ts

@@ -2,7 +2,12 @@ import { PatronOnce } from "../Patron/PatronOnce";
 import { PrivateType } from "../Private/Private";
 import { SourceEmpty } from "../Source/SourceEmpty";
 import { give, GuestType } from "./Guest";
-import { GuestAwareObjectType, GuestAwareType, isGuestAware, value } from "./GuestAware";
+import {
+  GuestAwareObjectType,
+  GuestAwareType,
+  isGuestAware,
+  value,
+} from "./GuestAware";
 import { GuestAwareAll } from "./GuestAwareAll";
 import { GuestCast } from "./GuestCast";
 
@@ -12,15 +17,20 @@ import { GuestCast } from "./GuestCast";
 export class GuestAwareSequence<T, TG> implements GuestAwareObjectType<TG[]> {
   public constructor(
     private baseSource: GuestAwareType<T[]>,
-    private targetSource: PrivateType<GuestAwareType<TG>>
-  ) { }
+    private targetSource: PrivateType<GuestAwareType<TG>>,
+  ) {
+    if (baseSource === undefined) {
+      throw new Error("GuestAwareSequence didnt receive baseSource argument");
+    }
+    if (targetSource === undefined) {
+      throw new Error("GuestAwareSequence didnt receive targetSource argument");
+    }
+  }
 
   public value(guest: GuestType<TG[]>) {
     const all = new GuestAwareAll<TG[]>();
     const sequenceSource = new SourceEmpty();
-    const targetSource = this.targetSource.get(
-      sequenceSource
-    )
+    const targetSource = this.targetSource.get(sequenceSource);
 
     value(
       this.baseSource,
@@ -34,17 +44,20 @@ export class GuestAwareSequence<T, TG> implements GuestAwareObjectType<TG[]> {
           } else {
             all.valueArray(guest);
           }
-        }
+        };
 
         function handle() {
           sequenceSource.give(null);
           const nextValue = theValue[index];
           if (isGuestAware(nextValue)) {
-            value(nextValue, new PatronOnce((theNextValue) => {
-              sequenceSource.give(theNextValue);
-              value(targetSource, all.guestKey(index.toString()));
-              nextItemHandle();
-            }));
+            value(
+              nextValue,
+              new PatronOnce((theNextValue) => {
+                sequenceSource.give(theNextValue);
+                value(targetSource, all.guestKey(index.toString()));
+                nextItemHandle();
+              }),
+            );
           } else {
             sequenceSource.give(nextValue);
             value(targetSource, all.guestKey(index.toString()));
@@ -57,7 +70,7 @@ export class GuestAwareSequence<T, TG> implements GuestAwareObjectType<TG[]> {
         } else {
           give([], guest);
         }
-      })
+      }),
     );
     return this;
   }

package/src/Guest/GuestCast.ts

@@ -1,7 +1,4 @@
-import {
-  GuestDisposableType,
-  MaybeDisposableType,
-} from "./GuestDisposable";
+import { GuestDisposableType, MaybeDisposableType } from "./GuestDisposable";
 import { give, GiveOptions, GuestType } from "./Guest";
 import { PoolAwareOptions } from "../Patron/PatronOnce";
 
@@ -12,7 +9,14 @@ export class GuestCast<T> implements GuestDisposableType<T> {
   public constructor(
     private sourceGuest: GuestType<any>,
     private targetGuest: GuestType<T>,
-  ) { }
+  ) {
+    if (sourceGuest === undefined) {
+      throw new Error("GuestCast didnt receive sourceGuest argument");
+    }
+    if (targetGuest === undefined) {
+      throw new Error("GuestCast didnt receive targetGuest argument");
+    }
+  }
 
   public introduction() {
     if (typeof this.sourceGuest === "function") {
@@ -30,7 +34,7 @@ export class GuestCast<T> implements GuestDisposableType<T> {
       data: {
         ...(options?.data ?? {}),
         castedGuest: (options?.data as PoolAwareOptions)?.castedGuest ?? this,
-      }
+      },
     });
     return this;
   }

package/src/Guest/GuestDisposable.ts

@@ -13,7 +13,14 @@ export class GuestDisposable<T> implements GuestDisposableType<T> {
   public constructor(
     private guest: GuestType,
     private disposeCheck: (value: T | null) => boolean,
-  ) { }
+  ) {
+    if (guest === undefined) {
+      throw new Error("GuestDisposable didnt receive guest argument");
+    }
+    if (disposeCheck === undefined) {
+      throw new Error("GuestDisposable didnt receive disposeCheck argument");
+    }
+  }
 
   public disposed(value: T | null): boolean {
     return this.disposeCheck(value);

package/src/Guest/GuestObject.ts

@@ -1,14 +1,15 @@
-import {
-  GuestDisposableType,
-  MaybeDisposableType,
-} from "./GuestDisposable";
+import { GuestDisposableType, MaybeDisposableType } from "./GuestDisposable";
 import { GiveOptions, Guest, GuestType } from "./Guest";
 
 /**
  * @url https://kosukhin.github.io/patron.site/#/guest/guest-object
  */
 export class GuestObject<T> implements GuestDisposableType<T> {
-  public constructor(private baseGuest: GuestType<T>) { }
+  public constructor(private baseGuest: GuestType<T>) {
+    if (baseGuest === undefined) {
+      throw new Error("GuestObject didnt receive baseGuest argument");
+    }
+  }
 
   public give(value: T, options?: GiveOptions): this {
     let guest = this.baseGuest;

package/src/Guest/GuestPool.test.ts

@@ -1,8 +1,18 @@
-import { expect, test } from "vitest";
+import { expect, test, vi, beforeEach, afterEach } from "vitest";
 import { GuestPool } from "./GuestPool";
 import { Patron } from "../Patron/Patron";
+import { wait } from "test-utils/wait";
 
-test("GuestPool.test", () => {
+beforeEach(() => {
+  vi.useFakeTimers({ shouldAdvanceTime: true });
+});
+
+afterEach(() => {
+  vi.runOnlyPendingTimers();
+  vi.useRealTimers();
+});
+
+test("GuestPool.test", async () => {
   const pool = new GuestPool<number>(null);
   let receivedCount = 0;
 
@@ -28,7 +38,10 @@ test("GuestPool.test", () => {
     pool.give(2);
   });
 
+  await wait(50);
+
   setTimeout(() => {
+    pool.give(2);
     expect(receivedCount).toBe(10);
   }, 10);
 });

package/src/Guest/GuestSync.ts

@@ -8,7 +8,11 @@ export interface GuestValueType<T = any> extends GuestObjectType<T> {
  * @url https://kosukhin.github.io/patron.site/#/guest/guest-sync
  */
 export class GuestSync<T> implements GuestValueType<T> {
-  public constructor(private theValue: T) { }
+  public constructor(private theValue: T) {
+    if (theValue === undefined) {
+      throw new Error("GuestSync didnt receive theValue argument");
+    }
+  }
 
   public give(value: T): this {
     this.theValue = value;

package/src/Patron/Patron.ts

@@ -5,7 +5,11 @@ import { give, GiveOptions, GuestType } from "../Guest/Guest";
  * @url https://kosukhin.github.io/patron.site/#/patron
  */
 export class Patron<T> implements GuestDisposableType<T> {
-  public constructor(private willBePatron: GuestType<T>) { }
+  public constructor(private willBePatron: GuestType<T>) {
+    if (willBePatron === undefined) {
+      throw new Error("Patron didnt receive willBePatron argument");
+    }
+  }
 
   public introduction() {
     return "patron" as const;

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

@@ -11,14 +11,17 @@ afterEach(() => {
   vi.useRealTimers();
 });
 
-const wait = (ms: number) => new Promise(resolve => {
-  setTimeout(() => { resolve(1) }, ms);
-})
+const wait = (ms: number) =>
+  new Promise((resolve) => {
+    setTimeout(() => {
+      resolve(1);
+    }, ms);
+  });
 
 test("PatronOnce.sourceEmpty.test", async () => {
   const source = new SourceEmpty();
   let calls = 0;
-  const patron = new PatronOnce((v) => {
+  const patron = new PatronOnce(() => {
     calls += 1;
   });
   source.value(patron);

package/src/Patron/PatronOnce.test.ts

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

package/src/Patron/PatronOnce.ts

@@ -16,7 +16,11 @@ export type PoolAwareOptions = {
 export class PatronOnce<T> implements GuestDisposableType<T> {
   private received = false;
 
-  public constructor(private baseGuest: GuestType<T>) { }
+  public constructor(private baseGuest: GuestType<T>) {
+    if (baseGuest === undefined) {
+      throw new Error("PatronOnce didnt receive baseGuest argument");
+    }
+  }
 
   public introduction() {
     return "patron" as const;

package/src/Patron/PatronPool.ts

@@ -7,6 +7,9 @@ const poolSets = new Map<PoolType, Set<GuestObjectType>>();
  * @url https://kosukhin.github.io/patron.site/#/utils/remove-patron-from-pools
  */
 export const removePatronFromPools = (patron: GuestObjectType) => {
+  if (patron === undefined) {
+    throw new Error("removePatronFromPools didnt receive patron argument");
+  }
   poolSets.forEach((pool) => {
     pool.delete(patron);
   });
@@ -16,6 +19,9 @@ export const removePatronFromPools = (patron: GuestObjectType) => {
  * @url https://kosukhin.github.io/patron.site/#/utils/is-patron-in-pools
  */
 export const isPatronInPools = (patron: GuestObjectType) => {
+  if (patron === undefined) {
+    throw new Error("isPatronInPools didnt receive patron argument");
+  }
   let inPool = false;
   poolSets.forEach((pool) => {
     if (!inPool) {

package/src/Private/Private.test.ts

@@ -1,11 +1,11 @@
 import { Private } from "./Private";
 import { expect, test } from "vitest";
 
-test('Private.test', () => {
+test("Private.test", () => {
   const privateNum = new Private((val) => {
     return {
       num: val,
-    }
+    };
   });
 
   expect(JSON.stringify(privateNum.get(11))).toBe('{"num":11}');

package/src/Private/Private.ts

@@ -2,13 +2,19 @@
  * @url https://kosukhin.github.io/patron.site/#/utils/private
  */
 export interface PrivateType<T> {
-    get<R extends unknown[], CT = null>(...args: R): CT extends null ? T : CT;
+  get<R extends unknown[], CT = null>(...args: R): CT extends null ? T : CT;
 }
 
 export class Private<T> implements PrivateType<T> {
-  public constructor(private buildingFn: (...args: any[]) => T) { }
+  public constructor(private buildingFn: (...args: any[]) => T) {
+    if (buildingFn === undefined) {
+      throw new Error("Private didnt receive buildingFn argument");
+    }
+  }
 
-  public get<R extends unknown[], CT = null>(...args: R): CT extends null ? T : CT {
+  public get<R extends unknown[], CT = null>(
+    ...args: R
+  ): CT extends null ? T : CT {
     return this.buildingFn(...args) as CT extends null ? T : CT;
   }
 }

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

@@ -23,7 +23,7 @@ class TestClass {
 test("PrivateClass.modules.test", () => {
   const main = new PrivateClass(Source);
   const testSource = new PrivateClass(TestClass, {
-     main,
+    main,
   });
 
   const source = testSource.get(42);

package/src/Private/PrivateClass.test.ts

@@ -1,8 +1,6 @@
-import { PrivateClass } from "./PrivateClass";
-import { GuestType } from "../Guest/Guest";
-import { Source, SourceType } from "../Source/Source";
 import { expect, test } from "vitest";
-import { PrivateType } from "./Private";
+import { Source } from "../Source/Source";
+import { PrivateClass } from "./PrivateClass";
 
 test("PrivateClass.test", () => {
   const sourcePrivate = new PrivateClass(Source);

package/src/Private/PrivateClass.ts

@@ -1,7 +1,7 @@
 import { PrivateType } from "./Private";
 
 interface Constructable<T> {
-  new(...args: unknown[]): T;
+  new (...args: unknown[]): T;
 }
 
 interface Prototyped<T> {
@@ -12,7 +12,11 @@ export class PrivateClass<T> implements PrivateType<T> {
   public constructor(
     private constructorFn: Prototyped<T>,
     private modules: Record<string, unknown> = {},
-  ) { }
+  ) {
+    if (constructorFn === undefined) {
+      throw new Error("PrivateClass didnt receive constructorFn argument");
+    }
+  }
 
   public get<R extends unknown[], CT = null>(
     ...args: R

package/src/Source/Source.ts

@@ -16,7 +16,11 @@ export type SourceType<T = any> = GuestAwareObjectType<T> &
 export class Source<T> implements SourceType<T> {
   private thePool = new PatronPool(this);
 
-  public constructor(private sourceDocument: T) { }
+  public constructor(private sourceDocument: T) {
+    if (sourceDocument === undefined) {
+      throw new Error("Source didnt receive sourceDocument argument");
+    }
+  }
 
   public pool() {
     return this.thePool;

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

@@ -1,8 +1,8 @@
-import { SourceDynamic } from './SourceDynamic';
-import { Source } from './Source';
-import { expect, test } from 'vitest';
+import { SourceDynamic } from "./SourceDynamic";
+import { Source } from "./Source";
+import { expect, test } from "vitest";
 
-test('SourceDynamic.ofSource.test', () => {
+test("SourceDynamic.ofSource.test", () => {
   const source = new Source(1);
   const sourceDynamic = new SourceDynamic(source, source);
 

package/src/Source/SourceDynamic.test.ts

@@ -1,9 +1,9 @@
 import { SourceDynamic } from "./SourceDynamic";
-import { expect, test } from 'vitest';
+import { expect, test } from "vitest";
 import { give, Guest } from "../Guest/Guest";
 import { GuestAware } from "../Guest/GuestAware";
 
-test('SourceDynamic', () => {
+test("SourceDynamic", () => {
   let theValue = 1;
   const sourceDynamic = new SourceDynamic(
     new Guest((value: number) => {

package/src/Source/SourceDynamic.ts

@@ -10,7 +10,14 @@ export class SourceDynamic<T = unknown> implements SourceType<T> {
   public constructor(
     private baseGuest: GuestType<T>,
     private baseGuestAware: GuestAwareType<T>,
-  ) { }
+  ) {
+    if (baseGuest === undefined) {
+      throw new Error("SourceDynamic didnt receive baseGuest argument");
+    }
+    if (baseGuestAware === undefined) {
+      throw new Error("SourceDynamic didnt receive baseGuestAware argument");
+    }
+  }
 
   public value(guest: GuestType<T>) {
     value(this.baseGuestAware, guest);
@@ -23,6 +30,6 @@ export class SourceDynamic<T = unknown> implements SourceType<T> {
   }
 
   public pool(): PatronPool<T> {
-    throw Error('No pool in SourceDynamic');
+    throw Error("No pool in SourceDynamic");
   }
 }