silentium 0.0.2

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/Source/SourceSequence.ts

@@ -0,0 +1,72 @@
+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 { isSource, SourceObjectType, SourceType, value } from "./Source";
+import { SourceAll } from "./SourceAll";
+
+/**
+ * @url https://kosukhin.github.io/patron.site/#/guest/source-sequence
+ */
+export class SourceSequence<T, TG> implements SourceObjectType<TG[]> {
+  public constructor(
+    private baseSource: SourceType<T[]>,
+    private targetSource: PrivateType<SourceType<TG>>,
+  ) {
+    if (baseSource === undefined) {
+      throw new Error("SourceSequence didnt receive baseSource argument");
+    }
+    if (targetSource === undefined) {
+      throw new Error("SourceSequence didnt receive targetSource argument");
+    }
+  }
+
+  public value(guest: GuestType<TG[]>) {
+    const all = new SourceAll<TG[]>();
+    const sequenceSource = new SourceWithPool();
+    const targetSource = this.targetSource.get(sequenceSource);
+
+    value(
+      this.baseSource,
+      new GuestCast(guest, (theValue) => {
+        let index = 0;
+
+        const nextItemHandle = () => {
+          if (theValue[index + 1] !== undefined) {
+            index = index + 1;
+            handle();
+          } else {
+            all.valueArray(guest);
+          }
+        };
+
+        function handle() {
+          sequenceSource.give(null);
+          const nextValue = theValue[index];
+          if (isSource(nextValue)) {
+            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()));
+            nextItemHandle();
+          }
+        }
+
+        if (theValue[index] !== undefined) {
+          handle();
+        } else {
+          give([], guest);
+        }
+      }),
+    );
+    return this;
+  }
+}

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

@@ -0,0 +1,26 @@
+export * from "./Guest/Guest";
+export * from "./Guest/GuestCast";
+export * from "./Guest/GuestPool";
+export * from "./Guest/GuestSync";
+export * from "./Guest/GuestObject";
+export * from "./Guest/GuestDisposable";
+export * from "./Guest/GuestApplied";
+export * from "./Guest/GuestExecutorApplied";
+export * from "./Patron/Patron";
+export * from "./Patron/PatronOnce";
+export * from "./Patron/PatronPool";
+export * from "./Patron/PatronApplied";
+export * from "./Patron/PatronExecutorApplied";
+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/SourceApplied";
+export * from "./Source/SourceExecutorApplied";
+export * from "./Source/SourceOnce";
+export * from "./Private/PrivateClass";
+export * from "./Private/Private";

package/test-utils/debounce.ts

@@ -0,0 +1,11 @@
+export function debounce(wait: number, func: any) {
+  let timeout: number;
+
+  return function (...args: any[]) {
+    clearTimeout(timeout);
+
+    timeout = setTimeout(() => {
+      func(...args);
+    }, wait);
+  };
+}

package/test-utils/id.ts

@@ -0,0 +1 @@
+export const id = (v: unknown) => v;

package/test-utils/wait.ts

@@ -0,0 +1,6 @@
+export const wait = (ms: number) =>
+  new Promise((resolve) => {
+    setTimeout(() => {
+      resolve(1);
+    }, ms);
+  });

package/tsconfig.json

@@ -0,0 +1,26 @@
+{
+  "compilerOptions": {
+    "target": "esnext",
+    "module": "esnext",
+    "strict": true,
+    "moduleResolution": "node",
+    "skipLibCheck": true,
+    "esModuleInterop": true,
+    "allowSyntheticDefaultImports": true,
+    "forceConsistentCasingInFileNames": true,
+    "useDefineForClassFields": true,
+    "sourceMap": true,
+    "baseUrl": ".",
+    "resolveJsonModule": true,
+    "lib": [
+      "es2022",
+      "dom"
+    ]
+  },
+  "include": [
+    "src/**/*.ts",
+  ],
+  "exclude": [
+    "node_modules"
+  ]
+}