patron-oop 1.43.0 → 1.45.0

package/src/Source/SourceDynamic.test.ts

@@ -1,7 +1,7 @@
 import { SourceDynamic } from "./SourceDynamic";
-import { expect, test } from "vitest";
+import { expect, test, vitest } from "vitest";
 import { give, Guest } from "../Guest/Guest";
-import { GuestAware } from "../Guest/GuestAware";
+import { Source } from "./Source";
 
 test("SourceDynamic", () => {
   let theValue = 1;
@@ -9,18 +9,18 @@ test("SourceDynamic", () => {
     new Guest((value: number) => {
       theValue = value;
     }),
-    new GuestAware((guest) => {
+    new Source((guest) => {
       give(theValue, guest);
     }),
   );
 
-  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);
-  });
+  const g2 = vitest.fn();
+  sourceDynamic.value(g2);
+  expect(g2).toBeCalledWith(2);
 });

package/src/Source/SourceDynamic.ts

@@ -1,26 +1,26 @@
 import { give, GuestType } from "../Guest/Guest";
-import { GuestAwareType, value } from "../Guest/GuestAware";
+import { SourceType, value } from "./Source";
 import { PatronPool } from "../Patron/PatronPool";
-import { SourceType } from "./Source";
+import { SourceWithPoolType } from "./SourceWithPool";
 
 /**
  * @url https://kosukhin.github.io/patron.site/#/source-dynamic
  */
-export class SourceDynamic<T = unknown> implements SourceType<T> {
+export class SourceDynamic<T = unknown> implements SourceWithPoolType<T> {
   public constructor(
     private baseGuest: GuestType<T>,
-    private baseGuestAware: GuestAwareType<T>,
+    private baseSource: SourceType<T>,
   ) {
     if (baseGuest === undefined) {
       throw new Error("SourceDynamic didnt receive baseGuest argument");
     }
-    if (baseGuestAware === undefined) {
-      throw new Error("SourceDynamic didnt receive baseGuestAware argument");
+    if (baseSource === undefined) {
+      throw new Error("SourceDynamic didnt receive baseSource argument");
     }
   }
 
   public value(guest: GuestType<T>) {
-    value(this.baseGuestAware, guest);
+    value(this.baseSource, guest);
     return this;
   }
 

package/src/Source/SourceExecutorApplied.test.ts

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

package/src/Source/SourceExecutorApplied.ts

@@ -0,0 +1,22 @@
+import {
+  SourceExecutorType,
+  SourceObjectType,
+  SourceType,
+  value,
+} from "../Source/Source";
+
+/**
+ * @url https://kosukhin.github.io/patron.site/#/source/source-executor-applied
+ */
+export class SourceExecutorApplied<T> implements SourceObjectType<T> {
+  public value: SourceExecutorType<T>;
+
+  public constructor(
+    source: SourceType<T>,
+    applier: (executor: SourceExecutorType<T>) => SourceExecutorType<T>,
+  ) {
+    this.value = applier((g) => {
+      value(source, g);
+    });
+  }
+}

package/src/Source/SourceMap.defered.test.ts

@@ -0,0 +1,46 @@
+import { wait } from "../../test-utils/wait";
+import { Private } from "../Private/Private";
+import { afterEach, beforeEach, expect, test, vi } from "vitest";
+import { SourceWithPool } from "./SourceWithPool";
+import { give, GuestType } from "../Guest/Guest";
+import { Source, SourceType, value } from "./Source";
+import { SourceMap } from "./SourceMap";
+import { GuestCast } from "../Guest/GuestCast";
+
+beforeEach(() => {
+  vi.useFakeTimers({ shouldAdvanceTime: true });
+});
+
+afterEach(() => {
+  vi.runOnlyPendingTimers();
+  vi.useRealTimers();
+});
+
+function x2(baseNumber: SourceType<number>) {
+  return (guest: GuestType<number>) => {
+    value(
+      baseNumber,
+      new GuestCast(guest, (v) => {
+        give(v * 2, guest);
+      }),
+    );
+    return guest;
+  };
+}
+
+test("SourceMap.defered.test", async () => {
+  const sourceOf = (val: number) =>
+    new Source(async (guest) => {
+      await wait(5);
+      give(val, guest);
+    });
+  const source = new SourceWithPool([1, 2, 3, 9].map(sourceOf));
+  const guestMapped = new SourceMap(source, new Private(x2));
+  const callFn = vi.fn();
+  guestMapped.value((v) => {
+    callFn(v.join());
+  });
+  await wait(50);
+  expect(callFn).toBeCalled();
+  expect(callFn).toBeCalledWith("2,4,6,18");
+});

package/src/Source/SourceMap.fn.test.ts

@@ -0,0 +1,27 @@
+import { Private } from "../Private/Private";
+import { expect, test, vitest } from "vitest";
+import { SourceWithPool } from "./SourceWithPool";
+import { give, GuestType } from "../Guest/Guest";
+import { SourceType, value } from "./Source";
+import { SourceMap } from "./SourceMap";
+import { GuestCast } from "../Guest/GuestCast";
+
+function x2(baseNumber: SourceType<number>) {
+  return (guest: GuestType<number>) => {
+    value(
+      baseNumber,
+      new GuestCast(<GuestType>guest, (v) => {
+        give(v * 2, guest);
+      }),
+    );
+    return guest;
+  };
+}
+
+test("SourceMap.test", () => {
+  const source = new SourceWithPool([1, 2, 3, 9]);
+  const guestMapped = new SourceMap(source, new Private(x2));
+  const g = vitest.fn();
+  guestMapped.value(g);
+  expect(g).toBeCalledWith([2, 4, 6, 18]);
+});

package/src/Source/SourceMap.test.ts

@@ -0,0 +1,32 @@
+import { expect, test } from "vitest";
+import { give, GuestType } from "../Guest/Guest";
+import { SourceObjectType, SourceType, value } from "./Source";
+import { SourceMap } from "./SourceMap";
+import { GuestCast } from "../Guest/GuestCast";
+import { SourceWithPool } from "./SourceWithPool";
+import { PrivateClass } from "../Private/PrivateClass";
+import { GuestSync } from "../Guest/GuestSync";
+
+class X2 implements SourceObjectType<number> {
+  public constructor(private baseNumber: SourceType<number>) {}
+
+  public value(guest: GuestType<number>) {
+    value(
+      this.baseNumber,
+      new GuestCast(<GuestType>guest, (v) => {
+        give(v * 2, guest);
+      }),
+    );
+    return this;
+  }
+}
+
+test("SourceMap.test", () => {
+  const source = new SourceWithPool([1, 2, 3, 9]);
+  const guestMapped = new SourceMap(source, new PrivateClass(X2));
+  const guest = new GuestSync([]);
+
+  guestMapped.value(guest);
+
+  expect(guest.value().join()).toBe("2,4,6,18");
+});

package/src/Source/SourceMap.ts

@@ -0,0 +1,48 @@
+import { PrivateType } from "../Private/Private";
+import { give, GuestType } from "../Guest/Guest";
+import {
+  Source,
+  SourceObjectType,
+  SourceType,
+  isSource,
+  value,
+} from "./Source";
+import { SourceAll } from "./SourceAll";
+import { GuestCast } from "../Guest/GuestCast";
+
+/**
+ * @url https://kosukhin.github.io/patron.site/#/guest/source-map
+ */
+export class SourceMap<T, TG> implements SourceObjectType<TG[]> {
+  public constructor(
+    private baseSource: SourceType<T[]>,
+    private targetSource: PrivateType<SourceType<TG>>,
+  ) {
+    if (baseSource === undefined) {
+      throw new Error("SourceMap didnt receive baseSource argument");
+    }
+    if (targetSource === undefined) {
+      throw new Error("SourceMap didnt receive targetSource argument");
+    }
+  }
+
+  public value(guest: GuestType<TG[]>) {
+    const all = new SourceAll();
+    value(
+      this.baseSource,
+      new GuestCast(<GuestType>guest, (theValue) => {
+        theValue.forEach((val, index) => {
+          const valueSource = isSource(val)
+            ? val
+            : new Source((innerGuest) => {
+                give(val, innerGuest);
+              });
+          const targetSource = this.targetSource.get(valueSource);
+          value(targetSource, all.guestKey(index.toString()));
+        });
+      }),
+    );
+    all.valueArray(<GuestType>guest);
+    return this;
+  }
+}

package/src/Source/SourceOnce.notcalled.test.ts

@@ -0,0 +1,13 @@
+import { expect, test, vi, vitest } from "vitest";
+import { SourceOnce } from "./SourceOnce";
+
+test("SourceOnce.notcalled.test", () => {
+  const source = new SourceOnce();
+  const guestNotCalled = vi.fn();
+  source.value(guestNotCalled);
+  expect(guestNotCalled).not.toHaveBeenCalled();
+  source.give(111);
+  const g = vitest.fn();
+  source.value(g);
+  expect(g).toBeCalledWith(111);
+});

package/src/Source/SourceOnce.test.ts

@@ -0,0 +1,10 @@
+import { SourceOnce } from "./SourceOnce";
+import { expect, test, vitest } from "vitest";
+
+test("SourceOnce.test", () => {
+  const source = new SourceOnce(123);
+  source.give(321);
+  const g = vitest.fn();
+  source.value(g);
+  expect(g).toBeCalledWith(123);
+});

package/src/Source/SourceOnce.ts

@@ -0,0 +1,31 @@
+import { GuestType } from "../Guest/Guest";
+import { PatronPool } from "../Patron/PatronPool";
+import { value } from "./Source";
+import { SourceWithPool, SourceWithPoolType } from "./SourceWithPool";
+
+/**
+ * @url https://kosukhin.github.io/patron.site/#/source/source-once
+ */
+export class SourceOnce<T> implements SourceWithPoolType<T> {
+  private source: SourceWithPool<T>;
+
+  public constructor(initialValue?: T) {
+    this.source = new SourceWithPool(initialValue);
+  }
+
+  public value(guest: GuestType<T>) {
+    value(this.source, guest);
+    return this;
+  }
+
+  public give(value: T): this {
+    if (!this.source.filled()) {
+      this.source.give(value);
+    }
+    return this;
+  }
+
+  public pool(): PatronPool<T> {
+    return this.source.pool();
+  }
+}

package/src/Source/SourceRace.test.ts

@@ -0,0 +1,46 @@
+import { SourceWithPool } from "../Source/SourceWithPool";
+import { SourceRace } from "./SourceRace";
+import { afterEach, beforeEach, expect, test, vi, vitest } from "vitest";
+
+beforeEach(() => {
+  vi.useFakeTimers();
+});
+
+afterEach(() => {
+  vi.useRealTimers();
+});
+
+test("SourceRace.test", async () => {
+  const sBuild = (result: number, delay: number) => {
+    const s = new SourceWithPool();
+
+    setTimeout(() => {
+      s.give(result);
+    }, delay);
+
+    return s;
+  };
+
+  const s2 = sBuild(2, 100);
+  const s1 = sBuild(1, 200);
+
+  const sAny = new SourceRace([s1, s2]);
+
+  await vi.advanceTimersByTime(201);
+
+  const g1 = vitest.fn();
+  sAny.value(g1);
+  expect(g1).toBeCalledWith(1);
+
+  setTimeout(() => {
+    s1.give(3);
+    s2.give(4);
+  }, 300);
+
+  await vi.advanceTimersByTime(301);
+
+  const g2 = vitest.fn();
+  sAny.value(g2);
+  // ignores second value
+  expect(g2).toBeCalledWith(3);
+});

package/src/Source/SourceRace.ts

@@ -0,0 +1,30 @@
+import { give, GuestType } from "../Guest/Guest";
+import { SourceObjectType, SourceType, value } from "./Source";
+import { GuestCast } from "../Guest/GuestCast";
+
+/**
+ * @url https://kosukhin.github.io/patron.site/#/guest/source-race
+ */
+export class SourceRace<T> implements SourceObjectType<T> {
+  public constructor(private sources: SourceType<T>[]) {
+    if (sources === undefined) {
+      throw new Error("SourceRace didnt receive sources argument");
+    }
+  }
+
+  public value(guest: GuestType<T>): this {
+    let connectedWithSource: SourceType | null = null;
+    this.sources.forEach((source) => {
+      value(
+        source,
+        new GuestCast(<GuestType>guest, (value) => {
+          if (!connectedWithSource || connectedWithSource === source) {
+            give(value as T, guest);
+            connectedWithSource = source;
+          }
+        }),
+      );
+    });
+    return this;
+  }
+}

package/src/Source/SourceSequence.defered.test.ts

@@ -0,0 +1,53 @@
+import { SourceSequence } from "./SourceSequence";
+import { give } from "../Guest/Guest";
+import { Source, SourceObjectType, SourceType, value } from "./Source";
+import { GuestCast } from "../Guest/GuestCast";
+import { GuestType } from "../Guest/Guest";
+import { afterEach, beforeEach, expect, test, vi } from "vitest";
+import { SourceWithPool } from "./SourceWithPool";
+import { PrivateClass } from "../Private/PrivateClass";
+import { wait } from "../../test-utils/wait";
+
+beforeEach(() => {
+  vi.useFakeTimers({ shouldAdvanceTime: true });
+});
+
+afterEach(() => {
+  vi.runOnlyPendingTimers();
+  vi.useRealTimers();
+});
+
+class X2 implements SourceObjectType<number> {
+  public constructor(private baseNumber: SourceType<number>) {}
+
+  public value(guest: GuestType<number>) {
+    value(
+      this.baseNumber,
+      new GuestCast(<GuestType>guest, (v) => {
+        give(v * 2, guest);
+      }),
+    );
+    return this;
+  }
+}
+
+test("SourceSequence.defered.test", async () => {
+  const sourceOf = (val: number) =>
+    new Source((guest) => {
+      setTimeout(() => {
+        give(val, guest);
+      }, 10);
+    });
+  const source = new SourceWithPool([1, 2, 3, 9].map(sourceOf));
+
+  const sequence = new SourceSequence(source, new PrivateClass(X2));
+
+  const callFn = vi.fn();
+  sequence.value((v) => {
+    callFn(v.join());
+  });
+
+  await wait(51);
+  expect(callFn).toBeCalled();
+  expect(callFn).toBeCalledWith("2,4,6,18");
+});

package/src/Source/SourceSequence.test.ts

@@ -0,0 +1,30 @@
+import { SourceSequence } from "./SourceSequence";
+import { give } from "../Guest/Guest";
+import { SourceObjectType, SourceType, value } from "./Source";
+import { GuestCast } from "../Guest/GuestCast";
+import { GuestType } from "../Guest/Guest";
+import { expect, test, vitest } from "vitest";
+import { SourceWithPool } from "./SourceWithPool";
+import { PrivateClass } from "../Private/PrivateClass";
+
+class X2 implements SourceObjectType<number> {
+  public constructor(private baseNumber: SourceType<number>) {}
+
+  public value(guest: GuestType<number>) {
+    value(
+      this.baseNumber,
+      new GuestCast(<GuestType>guest, (v) => {
+        give(v * 2, guest);
+      }),
+    );
+    return this;
+  }
+}
+
+test("SourceSequence.test", () => {
+  const source = new SourceWithPool([1, 2, 3, 9]);
+  const guestMapped = new SourceSequence(source, new PrivateClass(X2));
+  const g = vitest.fn();
+  guestMapped.value(g);
+  expect(g).toBeCalledWith([2, 4, 6, 18]);
+});

package/src/{Guest/GuestAwareSequence.ts → Source/SourceSequence.ts}

@@ -1,35 +1,30 @@
+import { SourceWithPool } from "../Source/SourceWithPool";
+import { give, GuestType } from "../Guest/Guest";
+import { GuestCast } from "../Guest/GuestCast";
 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 { GuestAwareAll } from "./GuestAwareAll";
-import { GuestCast } from "./GuestCast";
+import { isSource, SourceObjectType, SourceType, value } from "./Source";
+import { SourceAll } from "./SourceAll";
 
 /**
- * @url https://kosukhin.github.io/patron.site/#/guest/guest-aware-sequence
+ * @url https://kosukhin.github.io/patron.site/#/guest/source-sequence
  */
-export class GuestAwareSequence<T, TG> implements GuestAwareObjectType<TG[]> {
+export class SourceSequence<T, TG> implements SourceObjectType<TG[]> {
   public constructor(
-    private baseSource: GuestAwareType<T[]>,
-    private targetSource: PrivateType<GuestAwareType<TG>>,
+    private baseSource: SourceType<T[]>,
+    private targetSource: PrivateType<SourceType<TG>>,
   ) {
     if (baseSource === undefined) {
-      throw new Error("GuestAwareSequence didnt receive baseSource argument");
+      throw new Error("SourceSequence didnt receive baseSource argument");
     }
     if (targetSource === undefined) {
-      throw new Error("GuestAwareSequence didnt receive targetSource argument");
+      throw new Error("SourceSequence didnt receive targetSource argument");
     }
   }
 
   public value(guest: GuestType<TG[]>) {
-    const all = new GuestAwareAll<TG[]>();
-    const sequenceSource = new SourceEmpty();
+    const all = new SourceAll<TG[]>();
+    const sequenceSource = new SourceWithPool();
     const targetSource = this.targetSource.get(sequenceSource);
 
     value(
@@ -49,7 +44,7 @@ export class GuestAwareSequence<T, TG> implements GuestAwareObjectType<TG[]> {
         function handle() {
           sequenceSource.give(null);
           const nextValue = theValue[index];
-          if (isGuestAware(nextValue)) {
+          if (isSource(nextValue)) {
             value(
               nextValue,
               new PatronOnce((theNextValue) => {

package/src/Source/SourceWithPool.empty.test.ts

@@ -0,0 +1,14 @@
+import { expect, test, vitest } from "vitest";
+import { SourceWithPool } from "./SourceWithPool";
+import { Patron } from "../Patron/Patron";
+
+test("SourceChangeable.test", () => {
+  const source = new SourceWithPool();
+  const guest = vitest.fn();
+
+  source.value(new Patron(guest));
+  source.give(42);
+
+  expect(guest).toBeCalled();
+  expect(guest).toBeCalledWith(42);
+});

package/src/Source/SourceWithPool.test.ts

@@ -0,0 +1,10 @@
+import { expect, test, vitest } from "vitest";
+import { SourceWithPool } from "./SourceWithPool";
+
+test("SourceChangeable.test", () => {
+  const source = new SourceWithPool(42);
+
+  const g = vitest.fn();
+  source.value(g);
+  expect(g).toBeCalledWith(42);
+});

package/src/Source/SourceWithPool.ts

@@ -0,0 +1,58 @@
+import { Guest, GuestObjectType, GuestType } from "../Guest/Guest";
+import { SourceObjectType } from "./Source";
+import { PatronPool } from "../Patron/PatronPool";
+import { isPatron } from "../Patron/Patron";
+
+export interface PoolAwareType<T = any> {
+  pool(): PatronPool<T>;
+}
+
+/**
+ * @url https://kosukhin.github.io/patron.site/#/source-with-pool
+ */
+export type SourceWithPoolType<T = any> = SourceObjectType<T> &
+  GuestObjectType<T> &
+  PoolAwareType<T>;
+
+export class SourceWithPool<T> implements SourceWithPoolType<T> {
+  private thePool = new PatronPool(this);
+  private theEmptyPool = new PatronPool(this);
+  private isEmpty: boolean;
+
+  public constructor(private sourceDocument?: T) {
+    this.isEmpty = sourceDocument === undefined;
+  }
+
+  public pool() {
+    return this.thePool;
+  }
+
+  public give(value: T): this {
+    this.isEmpty = false;
+    this.sourceDocument = value;
+    this.thePool.give(this.sourceDocument);
+    this.theEmptyPool.give(this.sourceDocument);
+    return this;
+  }
+
+  public value(guest: GuestType<T>): this {
+    if (this.isEmpty) {
+      if (isPatron(guest)) {
+        this.theEmptyPool.add(guest);
+      }
+      return this;
+    }
+
+    if (typeof guest === "function") {
+      this.thePool.distribute(this.sourceDocument, new Guest(guest));
+    } else {
+      this.thePool.distribute(this.sourceDocument, guest);
+    }
+
+    return this;
+  }
+
+  public filled() {
+    return !this.isEmpty;
+  }
+}

package/src/index.ts

@@ -1,20 +1,22 @@
-export * from "./Guest/GuestAware";
-export * from "./Guest/GuestAwareSequence";
-export * from "./Guest/GuestAwareMap";
-export * from "./Guest/GuestAwareRace";
-export * from "./Guest/GuestAwareActive";
 export * from "./Guest/Guest";
 export * from "./Guest/GuestCast";
-export * from "./Guest/GuestAwareAll";
 export * from "./Guest/GuestPool";
 export * from "./Guest/GuestSync";
 export * from "./Guest/GuestObject";
 export * from "./Guest/GuestDisposable";
+export * from "./Guest/GuestApplied";
 export * from "./Patron/Patron";
 export * from "./Patron/PatronOnce";
 export * from "./Patron/PatronPool";
+export * from "./Source/SourceAll";
 export * from "./Source/Source";
+export * from "./Source/SourceSequence";
+export * from "./Source/SourceMap";
+export * from "./Source/SourceRace";
+export * from "./Source/SourceActive";
+export * from "./Source/SourceWithPool";
 export * from "./Source/SourceDynamic";
-export * from "./Source/SourceEmpty";
+export * from "./Source/SourceApplied";
+export * from "./Source/SourceExecutorApplied";
 export * from "./Private/PrivateClass";
 export * from "./Private/Private";