patron-oop 1.44.1 → 1.46.0

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

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;
+  }
+}