patron-oop 1.42.1 → 1.44.1

package/src/Guest/GuestAwareAll._twoValuesAfter.test.ts

@@ -5,7 +5,7 @@ import { GuestAwareAll } from "./GuestAwareAll";
 test("GuestAwareAll._twoValuesAfter.test", () => {
   const one = new Source(1);
   const two = new Source(2);
-  const all = new GuestAwareAll<{ one: number; two: number }>();
+  const all = new GuestAwareAll<{ one: number; two: number }>(["one", "two"]);
 
   all.value((value) => {
     expect(Object.values(value).join()).toBe("1,2");

package/src/Guest/GuestAwareAll.ts

@@ -16,14 +16,15 @@ export interface GuestAwareAllType<T = any> extends GuestAwareObjectType<T> {
 export class GuestAwareAll<T> implements GuestAwareAllType<T> {
   private theAll: Source<Record<string, unknown>>;
 
-  private keysKnown = new Set();
+  private keysKnown: Set<string>;
 
   private keysFilled = new Set();
 
   private filledAllPool = new GuestPool(this);
 
-  public constructor() {
+  public constructor(initialKnownKeys: string[] = []) {
     this.theAll = new Source<Record<string, unknown>>({});
+    this.keysKnown = new Set(initialKnownKeys);
   }
 
   public valueArray(guest: GuestType<T>) {
@@ -61,22 +62,19 @@ export class GuestAwareAll<T> implements GuestAwareAllType<T> {
   public guestKey<R>(key: string): GuestObjectType<R> {
     this.keysKnown.add(key);
     return new Guest((value) => {
-      // Обернул в очередь чтобы можно было синхронно наполнить очередь известных ключей
-      queueMicrotask(() => {
-        this.theAll.value(
-          new Guest((all: Record<string, unknown>) => {
-            this.keysFilled.add(key);
-            const lastAll = {
-              ...all,
-              [key]: value,
-            };
-            this.theAll.give(lastAll);
-            if (this.isAllFilled()) {
-              this.filledAllPool.give(lastAll);
-            }
-          }),
-        );
-      });
+      this.theAll.value(
+        new Guest((all: Record<string, unknown>) => {
+          this.keysFilled.add(key);
+          const lastAll = {
+            ...all,
+            [key]: value,
+          };
+          this.theAll.give(lastAll);
+          if (this.isAllFilled()) {
+            this.filledAllPool.give(lastAll);
+          }
+        }),
+      );
     });
   }
 

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

@@ -0,0 +1,13 @@
+import { expect, test, vi } 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);
+  source.value((v) => {
+    expect(v).toBe(111);
+  });
+});

package/src/Source/SourceOnce.test.ts

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

package/src/Source/SourceOnce.ts

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