patron-oop 1.33.0 → 1.35.0

package/src/Guest/GuestAware.ts

@@ -1,17 +1,29 @@
 import { GuestType } from "./Guest";
 
-export interface GuestAwareType<T = any> {
-  value(guest: GuestType<T>): unknown;
+export type GuestAwareExecutorType<T> = (guest: GuestType<T>) => unknown;
+
+export interface GuestAwareObjectType<T> {
+  value: GuestAwareExecutorType<T>
+}
+
+export type GuestAwareType<T = any> = GuestAwareExecutorType<T> | GuestAwareObjectType<T>
+
+export function value<T>(guestAware: GuestAwareType<T>, guest: GuestType<T>) {
+  if (typeof guestAware === 'function') {
+    return guestAware(guest);
+  } else {
+    return guestAware.value(guest);
+  }
 }
 
 /**
  * @url https://kosukhin.github.io/patron.site/#/guest/guest-aware
  */
-export class GuestAware<T = any> implements GuestAwareType<T> {
-  public constructor(private guestReceiver: (guest: GuestType<T>) => void) { }
+export class GuestAware<T = any> implements GuestAwareObjectType<T> {
+  public constructor(private guestAware: GuestAwareType<T>) { }
 
   public value(guest: GuestType<T>): GuestType<T> {
-    this.guestReceiver(guest);
+    value(this.guestAware, guest);
     return guest;
   }
 }

package/src/Guest/GuestAwareActive.ts

@@ -1,7 +1,7 @@
 import { SourceType } from "../Source/Source";
 import { SourceEmpty } from "../Source/SourceEmpty";
 import { GuestType } from "./Guest";
-import { GuestAwareType } from "./GuestAware";
+import { GuestAwareObjectType } from "./GuestAware";
 
 /**
  * @url https://kosukhin.github.io/patron.site/#/utils/action-type
@@ -10,7 +10,7 @@ export interface ActionType<P = any> {
   do(config: P): this;
 }
 
-export interface GuestAwareAcitveType<R = unknown, T = unknown> extends GuestAwareType<T>, ActionType<R> {
+export interface GuestAwareAcitveType<R = unknown, T = unknown> extends GuestAwareObjectType<T>, ActionType<R> {
 }
 
 /**

package/src/Guest/{GuestChain._asArray.test.ts → GuestAwareAll._asArray.test.ts}

@@ -1,17 +1,17 @@
 import { expect, test } from "vitest";
-import { GuestChain } from "./GuestChain";
+import { GuestAwareAll } from "./GuestAwareAll";
 import { Source } from "../Source/Source";
 import { Patron } from "../Patron/Patron";
 
-test("GuestChain._asArray.test", () => {
+test("GuestAwareAll._asArray.test", () => {
   const one = new Source(1);
   const two = new Source(2);
-  const chain = new GuestChain<[number, number]>();
+  const all = new GuestAwareAll<[number, number]>();
 
-  one.value(new Patron(chain.receiveKey("0")));
-  two.value(new Patron(chain.receiveKey("1")));
+  one.value(new Patron(all.guestKey("0")));
+  two.value(new Patron(all.guestKey("1")));
 
-  chain.resultArray(
+  all.valueArray(
     new Patron((value) => {
       expect(JSON.stringify(value)).toBe("[1,2]");
     }),

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

@@ -0,0 +1,16 @@
+import { expect, test } from "vitest";
+import { Source } from "../Source/Source";
+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 }>();
+
+  all.value((value) => {
+    expect(Object.values(value).join()).toBe("1,2");
+  });
+
+  one.value(all.guestKey("one"));
+  two.value(all.guestKey("two"));
+});

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

@@ -0,0 +1,16 @@
+import { expect, test } from "vitest";
+import { Source } from "../Source/Source";
+import { GuestAwareAll } from "./GuestAwareAll";
+
+test("GuestAwareAll._twoValuesBefore.test", () => {
+  const one = new Source(1);
+  const two = new Source(2);
+  const all = new GuestAwareAll<{ one: number; two: number }>();
+
+  one.value(all.guestKey("one"));
+  two.value(all.guestKey("two"));
+
+  all.value((value) => {
+    expect(Object.values(value).join()).toBe("1,2");
+  });
+});

package/src/Guest/{GuestChain._withPatron.test.ts → GuestAwareAll._withPatron.test.ts}

@@ -1,20 +1,20 @@
 import { expect, test } from "vitest";
-import { GuestChain } from "./GuestChain";
+import { GuestAwareAll } from "./GuestAwareAll";
 import { Source } from "../Source/Source";
 import { Patron } from "../Patron/Patron";
 
-test("GuestChain._withPatron.test", () => {
+test("GuestAwareAll._withPatron.test", () => {
   const one = new Source(1);
   const two = new Source(2);
-  const chain = new GuestChain<{ one: number; two: number }>();
+  const all = new GuestAwareAll<{ one: number; two: number }>();
 
-  one.value(new Patron(chain.receiveKey("one")));
-  two.value(new Patron(chain.receiveKey("two")));
+  one.value(new Patron(all.guestKey("one")));
+  two.value(new Patron(all.guestKey("two")));
 
   one.give(3);
   one.give(4);
 
-  chain.result(
+  all.value(
     new Patron((value: Record<string, unknown>) => {
       expect(Object.values(value).length).toBe(2);
     }),

package/src/Guest/GuestAwareAll.ts

@@ -0,0 +1,88 @@
+import { GuestAwareObjectType } from "src/Guest/GuestAware";
+import { Source } from "../Source/Source";
+import { Guest, GuestObjectType, GuestType } from "./Guest";
+import { GuestCast } from "./GuestCast";
+import { GuestObject } from "./GuestObject";
+import { GuestPool } from "./GuestPool";
+
+export interface GuestAwareAllType<T = any> extends GuestAwareObjectType<T> {
+  valueArray(guest: GuestObjectType<T>): this;
+  guestKey<R>(key: string): GuestObjectType<R>;
+}
+
+/**
+ * @url https://kosukhin.github.io/patron.site/#/guest/guest-aware-all
+ */
+export class GuestAwareAll<T> implements GuestAwareAllType<T> {
+  private theAll: Source<Record<string, unknown>>;
+
+  private keysKnown = new Set();
+
+  private keysFilled = new Set();
+
+  private filledAllPool = new GuestPool(this);
+
+  public constructor() {
+    this.theAll = new Source<Record<string, unknown>>({});
+  }
+
+  public valueArray(guest: GuestType<T>) {
+    const guestObject = new GuestObject(guest);
+    this.filledAllPool.add(
+      new GuestCast(guestObject, (value: Record<string, unknown>) => {
+        guestObject.give(Object.values(value) as T);
+      }),
+    );
+    if (this.isAllFilled()) {
+      this.theAll.value(
+        new Guest((all: Record<string, unknown>) => {
+          this.filledAllPool.give(Object.values(all));
+        }),
+      );
+    }
+    return this;
+  }
+
+  public value(guest: GuestType<T>) {
+    const guestObject = new GuestObject(guest);
+    if (this.isAllFilled()) {
+      this.filledAllPool.add(guestObject);
+      this.theAll.value(
+        new Guest((all) => {
+          this.filledAllPool.give(all);
+        }),
+      );
+    } else {
+      this.filledAllPool.add(guestObject);
+    }
+    return this;
+  }
+
+  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);
+            }
+          }),
+        );
+      });
+    });
+  }
+
+  private isAllFilled() {
+    return (
+      this.keysFilled.size > 0 && this.keysFilled.size === this.keysKnown.size
+    );
+  }
+}

package/src/Guest/GuestAwareMap.fn.test.ts

@@ -0,0 +1,31 @@
+import { Module } from "../Factory/Module";
+import { expect, test } from "vitest";
+import { Source } from "../Source/Source";
+import { give, GuestType } from "./Guest";
+import { GuestAwareType, value } from "./GuestAware";
+import { GuestAwareMap } from "./GuestAwareMap";
+import { GuestCast } from "./GuestCast";
+
+function x2(baseNumber: GuestAwareType<number>) {
+  return (guest: GuestType<number>) => {
+    value(
+      baseNumber,
+      new GuestCast(<GuestType>guest, (v) => {
+        give(v * 2, guest);
+      })
+    );
+    return guest;
+  };
+}
+
+test('GuestAwareMap.test', () => {
+  const source = new Source([1, 2, 3, 9])
+  const guestMapped = new GuestAwareMap(
+    source,
+    new Module(x2)
+  );
+  expect(true).toBe(true);
+  guestMapped.value((v) => {
+    expect(v.join()).toBe('2,4,6,18')
+  });
+});

package/src/Guest/GuestAwareMap.test.ts

@@ -1,16 +1,17 @@
 import { expect, test } from "vitest";
 import { give, GuestType } from "./Guest";
-import { GuestAwareType } from "./GuestAware";
+import { GuestAwareObjectType, GuestAwareType, value } from "./GuestAware";
 import { GuestAwareMap } from "./GuestAwareMap";
 import { GuestCast } from "./GuestCast";
 import { Source } from "../Source/Source";
 import { Factory } from "../Factory/Factory";
 
-class X2 implements GuestAwareType<number> {
+class X2 implements GuestAwareObjectType<number> {
   public constructor(private baseNumber: GuestAwareType<number>) { }
 
   public value(guest: GuestType<number>) {
-    this.baseNumber.value(
+    value(
+      this.baseNumber,
       new GuestCast(<GuestType>guest, (v) => {
         give(v * 2, guest);
       })

package/src/Guest/GuestAwareMap.ts

@@ -1,35 +1,36 @@
 import { FactoryType } from "../Factory/Factory";
 import { give } from "./Guest";
-import { GuestAwareType } from "./GuestAware";
+import { GuestAwareObjectType, GuestAwareType, value } from "./GuestAware";
 import { GuestCast } from "./GuestCast";
-import { GuestChain } from "./GuestChain";
+import { GuestAwareAll } from "./GuestAwareAll";
 import { GuestType } from "./Guest";
 import { GuestAware } from "./GuestAware";
 
 /**
  * @url https://kosukhin.github.io/patron.site/#/guest/guest-aware-map
  */
-export class GuestAwareMap<T, TG> implements GuestAwareType<TG[]> {
+export class GuestAwareMap<T, TG> implements GuestAwareObjectType<TG[]> {
   public constructor(
     private baseSource: GuestAwareType<T[]>,
     private targetSourceFactory: FactoryType<GuestAwareType<TG>>
   ) { }
 
-  value(guest: GuestType<TG[]>) {
-    const chain = new GuestChain();
-    this.baseSource.value(
-      new GuestCast(<GuestType>guest, (value) => {
-        value.forEach((val, index) => {
+  public value(guest: GuestType<TG[]>) {
+    const all = new GuestAwareAll();
+    value(
+      this.baseSource,
+      new GuestCast(<GuestType>guest, (theValue) => {
+        theValue.forEach((val, index) => {
           const targetSource = this.targetSourceFactory.create(
             new GuestAware((innerGuest) => {
               give(val, innerGuest);
             })
           )
-          targetSource.value(chain.receiveKey('' + index));
+          value(targetSource, all.guestKey(index.toString()));
         });
       })
-    );
-    chain.resultArray(<GuestType>guest);
+    )
+    all.valueArray(<GuestType>guest);
     return this;
   }
 }

package/src/Guest/GuestAwareRace.ts

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

package/src/Guest/GuestAwareSequence.test.ts

@@ -1,21 +1,22 @@
 import { GuestAwareSequence } from "./GuestAwareSequence";
 import { give } from "./Guest";
-import { GuestAwareType } from "./GuestAware";
+import { GuestAwareObjectType, GuestAwareType, value } from "./GuestAware";
 import { GuestCast } from "./GuestCast";
 import { GuestType } from "./Guest";
 import { expect, test } from "vitest";
 import { Source } from "../Source/Source";
 import { Factory } from "../Factory/Factory";
 
-class X2 implements GuestAwareType<number> {
+class X2 implements GuestAwareObjectType<number> {
   public constructor(private baseNumber: GuestAwareType<number>) { }
 
   public value(guest: GuestType<number>) {
-    this.baseNumber.value(
+    value(
+      this.baseNumber,
       new GuestCast(<GuestType>guest, (v) => {
         give(v * 2, guest);
       })
-    )
+    );
     return this;
   }
 }

package/src/Guest/GuestAwareSequence.ts

@@ -1,54 +1,54 @@
 import { FactoryType } from "../Factory/Factory";
 import { give } from "./Guest";
-import { GuestAwareType } from "./GuestAware";
+import { GuestAwareObjectType, GuestAwareType, value } from "./GuestAware";
 import { GuestCast } from "./GuestCast";
-import { GuestChain } from "./GuestChain";
+import { GuestAwareAll } from "./GuestAwareAll";
 import { GuestType } from "./Guest";
 import { SourceEmpty } from "../Source/SourceEmpty";
 
 /**
  * @url https://kosukhin.github.io/patron.site/#/guest/guest-aware-sequence
  */
-export class GuestAwareSequence<T, TG> implements GuestAwareType<TG[]> {
+export class GuestAwareSequence<T, TG> implements GuestAwareObjectType<TG[]> {
   public constructor(
     private baseSource: GuestAwareType<T[]>,
     private targetSourceFactory: FactoryType<GuestAwareType<TG>>
   ) { }
 
   public value(guest: GuestType<TG[]>) {
-    const chain = new GuestChain<TG[]>();
+    const all = new GuestAwareAll<TG[]>();
     const sequenceSource = new SourceEmpty();
     const targetSource = this.targetSourceFactory.create(
       sequenceSource
     )
 
-    this.baseSource.value(
-      new GuestCast(guest, (value) => {
+    value(
+      this.baseSource,
+      new GuestCast(guest, (theValue) => {
         let index = 0;
 
         const nextItemHandle = () => {
-          if (value[index + 1] !== undefined) {
+          if (theValue[index + 1] !== undefined) {
             index = index + 1;
             handle();
           } else {
-            chain.resultArray(guest);
+            all.valueArray(guest);
           }
         }
 
         function handle() {
-          sequenceSource.give(value[index]);
-          targetSource.value(chain.receiveKey('' + index));
-          targetSource.value(nextItemHandle);
+          sequenceSource.give(theValue[index]);
+          value(targetSource, all.guestKey(index.toString()));
+          value(targetSource, nextItemHandle);
         }
 
-        if (value[index] !== undefined) {
+        if (theValue[index] !== undefined) {
           handle();
         } else {
           give([], guest);
         }
       })
     );
-
     return this;
   }
 }

package/src/Source/Source.ts

@@ -1,5 +1,5 @@
-import { GuestAwareType } from "../Guest/GuestAware";
 import { Guest, GuestObjectType, GuestType } from "../Guest/Guest";
+import { GuestAwareObjectType } from "../Guest/GuestAware";
 import { PatronPool } from "../Patron/PatronPool";
 
 export interface PoolAware<T = any> {
@@ -9,7 +9,7 @@ export interface PoolAware<T = any> {
 /**
  * @url https://kosukhin.github.io/patron.site/#/source
  */
-export type SourceType<T = any> = GuestAwareType<T> &
+export type SourceType<T = any> = GuestAwareObjectType<T> &
   GuestObjectType<T> &
   PoolAware<T>;
 

package/src/Source/SourceDynamic.ts

@@ -1,5 +1,5 @@
 import { give, GuestType } from "../Guest/Guest";
-import { GuestAwareType } from "../Guest/GuestAware";
+import { GuestAwareType, value } from "../Guest/GuestAware";
 import { PatronPool } from "../Patron/PatronPool";
 import { SourceType } from "./Source";
 
@@ -13,7 +13,7 @@ export class SourceDynamic<T = unknown> implements SourceType<T> {
   ) { }
 
   public value(guest: GuestType<T>) {
-    this.baseGuestAware.value(guest);
+    value(this.baseGuestAware, guest);
     return this;
   }
 

package/src/index.ts

@@ -5,7 +5,7 @@ export * from "./Guest/GuestAwareRace";
 export * from "./Guest/GuestAwareActive";
 export * from "./Guest/Guest";
 export * from "./Guest/GuestCast";
-export * from "./Guest/GuestChain";
+export * from "./Guest/GuestAwareAll";
 export * from "./Guest/GuestPool";
 export * from "./Guest/GuestSync";
 export * from "./Guest/GuestObject";

package/examples/elegant_objects.html

@@ -1,118 +0,0 @@
-<!doctype html>
-<html lang="en">
-<head>
-    <meta charset="UTF-8"/>
-    <meta name="viewport" content="width=device-width, initial-scale=1.0"/>
-    <title>Document</title>
-</head>
-<body>
-<h1>Elegant Objects</h1>
-<p>Композиция объектов описывает поведение</p>
-<p>Умножение: num1 * num2 = result</p>
-<div>
-    <label>
-        num1:
-        <input type="number" class="input-1"/>
-    </label>
-</div>
-<div>
-    <label>
-        num2:
-        <input type="number" class="input-2"/>
-    </label>
-</div>
-<div>result = <b class="result"></b></div>
-<script type="module">
-  import 'https://cdn.jsdelivr.net/npm/patron-oop@1.8.0/dist/patron.min.js';
-
-  const {
-    Patron,
-    Source,
-    GuestChain,
-    GuestCast,
-    GuestInTheMiddle,
-  } = window.GUEST_LIBRARY;
-
-  class TextInDocument {
-    constructor(selector) {
-      this.element = document.querySelector(selector);
-    }
-
-    receive(value) {
-      this.element.innerText = value;
-    }
-  }
-
-  class Input {
-    constructor(source, selector) {
-      this.source = source;
-      const el = document.querySelector(selector);
-      this.source.value(
-          new Patron((value) => {
-            el.value = value;
-          }),
-      );
-      el.addEventListener('keyup', (e) => {
-        this.give(e.target.value);
-      });
-      el.addEventListener('change', (e) => {
-        this.give(e.target.value);
-      });
-    }
-
-    receiving(guest) {
-      this.source.value(guest);
-      return this;
-    }
-
-    receive(value) {
-      this.source.give(value);
-      return this;
-    }
-  }
-
-  class NumberOf {
-    constructor(source) {
-      this.source = source;
-    }
-
-    number(guest) {
-      this.source.value(guest);
-      return this;
-    }
-
-    receive(value) {
-      this.source.give(value);
-    }
-  }
-
-  class Mul {
-    constructor(num1, num2) {
-      this.num1 = num1;
-      this.num2 = num2;
-    }
-
-    result(guest) {
-      const chain = new GuestChain();
-      this.num1.number(new GuestCast(guest, chain.receiveKey('num1')));
-      this.num2.number(new GuestCast(guest, chain.receiveKey('num2')));
-      chain.result(
-          new GuestInTheMiddle(guest, ({num1, num2}) => {
-            guest.give(num1 * num2);
-          }),
-      );
-    }
-  }
-
-  const input1 = new Input(new Source(2), '.input-1');
-  const input2 = new Input(new Source(2), '.input-2');
-  const multiplication = new Mul(
-      new NumberOf(input1),
-      new NumberOf(input2),
-  );
-  multiplication.result(
-      new Patron(new TextInDocument('.result')),
-  );
-</script>
-</body>
-</html>