patron-oop 1.6.0 → 1.8.0

package/src/Source/Source.test.ts

@@ -0,0 +1,10 @@
+import { expect, test } from "vitest";
+import { Source } from "./Source";
+
+test("source", () => {
+  const source = new Source(42);
+
+  source.receiving((value) => {
+    expect(value).toBe(42);
+  });
+});

package/src/Source/Source.ts

@@ -1,12 +1,26 @@
-import { SourceOfValue } from "./SourceOfValue";
-import { sourcesApplied } from "./SourcesApplied";
+import { GuestAwareType } from "../Guest/GuestAware";
+import { Guest, GuestObjectType, GuestType } from "../Guest/Guest";
+import { PatronPool } from "../Patron/PatronPool";
 
-export class Source {
-  public ofValue<P>(sourceDocument: P) {
-    return new SourceOfValue(sourceDocument);
+export type SourceType<T = unknown> = GuestAwareType<T> & GuestObjectType<T>;
+
+export class Source<T> implements SourceType<T> {
+  private pool = new PatronPool(this);
+
+  public constructor(private sourceDocument: T) {}
+
+  public receive(value: T): this {
+    this.sourceDocument = value;
+    this.pool.receive(this.sourceDocument);
+    return this;
   }
 
-  public applySources<P>(target: P, methodsSources: Record<string, unknown[]>) {
-    return sourcesApplied(target, methodsSources);
+  public receiving(guest: GuestType<T>): this {
+    if (typeof guest === "function") {
+      this.pool.distribute(this.sourceDocument, new Guest(guest));
+    } else {
+      this.pool.distribute(this.sourceDocument, guest);
+    }
+    return this;
   }
 }

package/src/index.ts

@@ -1,21 +1,43 @@
-export * from "./Guest/GuestCallback";
-export * from "./Guest/GuestChain";
-export * from "./Guest/GuestSync";
-export * from "./Patron/PatronPool";
-export * from "./Source/SourceOfValue";
-
-import { Guest } from "./Guest/Guest";
+import { give, Guest } from "./Guest/Guest";
+import { PatronPool, removePatronFromPools } from "./Patron/PatronPool";
+import { GuestAware } from "./Guest/GuestAware";
+import { GuestCast } from "./Guest/GuestCast";
+import { GuestChain } from "./Guest/GuestChain";
+import { GuestInTheMiddle } from "./Guest/GuestInTheMiddle";
+import { GuestPool } from "./Guest/GuestPool";
+import { GuestSync } from "./Guest/GuestSync";
 import { Patron } from "./Patron/Patron";
+import { PatronOnce } from "./Patron/PatronOnce";
 import { Source } from "./Source/Source";
 
-export { Guest, Patron, Source };
+export * from "./Guest/GuestAware";
+export * from "./Guest/Guest";
+export * from "./Guest/GuestCast";
+export * from "./Guest/GuestChain";
+export * from "./Guest/GuestInTheMiddle";
+export * from "./Guest/GuestPool";
+export * from "./Guest/GuestSync";
+export * from "./Patron/Patron";
+export * from "./Patron/PatronOnce";
+export * from "./Patron/PatronPool";
+export * from "./Source/Source";
 
-declare var window: any;
+declare var globalThis: any;
 
-if (window) {
-  window["GUEST_LIBRARY"] = {
-    guest: new Guest(),
-    patron: new Patron(),
-    source: new Source(),
+if (globalThis) {
+  globalThis["GUEST_LIBRARY"] = {
+    give,
+    removePatronFromPools,
+    GuestAware,
+    Guest,
+    GuestCast,
+    GuestChain,
+    GuestInTheMiddle,
+    GuestPool,
+    GuestSync,
+    Patron,
+    PatronOnce,
+    PatronPool,
+    Source,
   };
 }

package/src/Guest/GuestCallback.test.ts

@@ -1,13 +0,0 @@
-import { expect, test } from "vitest";
-import { GuestCallback } from "./GuestCallback";
-import { SourceOfValue } from "../Source/SourceOfValue";
-
-test("guest dynamic", () => {
-  const one = new SourceOfValue(1);
-
-  one.receiving(
-    new GuestCallback((value) => {
-      expect(value).toBe(1);
-    }),
-  );
-});

package/src/Guest/GuestCallback.ts

@@ -1,21 +0,0 @@
-type GuestIntroduction = "guest" | "patron";
-
-export interface ReceiveOptions {
-  data?: unknown;
-}
-
-export type GuestExecutorType<T> = (value: T, options?: ReceiveOptions) => void;
-
-export interface GuestType<T = unknown> {
-  receive(value: T, options?: ReceiveOptions): this;
-  introduction?(): GuestIntroduction;
-}
-
-export class GuestCallback<T> implements GuestType<T> {
-  public constructor(private receiver: GuestExecutorType<T>) {}
-
-  public receive(value: T, options?: ReceiveOptions) {
-    this.receiver(value, options);
-    return this;
-  }
-}

package/src/Patron/PatronOfGuest.test.ts

@@ -1,20 +0,0 @@
-import { expect, test } from "vitest";
-import { PatronOfGuest } from "./PatronOfGuest";
-import { SourceOfValue } from "../Source/SourceOfValue";
-import { GuestCallback } from "../Guest/GuestCallback";
-
-test("patron always guest", () => {
-  const one = new SourceOfValue(1);
-  let patronCalledTimes = 0;
-  const patron = new PatronOfGuest(
-    new GuestCallback(() => {
-      patronCalledTimes += 1;
-    }),
-  );
-  one.receiving(patron);
-  one.receive(2);
-
-  queueMicrotask(() => {
-    expect(patronCalledTimes).toBe(2);
-  });
-});

package/src/Patron/PatronOfGuest.ts

@@ -1,17 +0,0 @@
-import { GuestType, ReceiveOptions } from "../Guest/GuestCallback";
-
-/**
- * Патрон - это постоянный посетитель
- */
-export class PatronOfGuest<T> implements GuestType<T> {
-  public constructor(private willBePatron: GuestType<T>) {}
-
-  public introduction() {
-    return "patron" as const;
-  }
-
-  public receive(value: T, options?: ReceiveOptions): this {
-    this.willBePatron.receive(value, options);
-    return this;
-  }
-}

package/src/Source/SourceOfValue.test.ts

@@ -1,13 +0,0 @@
-import { expect, test } from "vitest";
-import { SourceOfValue } from "./SourceOfValue";
-import { GuestCallback } from "../Guest/GuestCallback";
-
-test("source", () => {
-  const source = new SourceOfValue(42);
-
-  source.receiving(
-    new GuestCallback((value) => {
-      expect(value).toBe(42);
-    }),
-  );
-});

package/src/Source/SourceOfValue.ts

@@ -1,22 +0,0 @@
-import { GuestAwareType } from "../Guest/GuestAware";
-import { GuestType } from "../Guest/GuestCallback";
-import { PatronPool } from "../Patron/PatronPool";
-
-export type SourceType<T = unknown> = GuestAwareType<T> & GuestType<T>;
-
-export class SourceOfValue<T> implements SourceType<T> {
-  private pool = new PatronPool(this);
-
-  public constructor(private sourceDocument: T) {}
-
-  public receive(value: T): this {
-    this.sourceDocument = value;
-    this.pool.receive(this.sourceDocument);
-    return this;
-  }
-
-  public receiving(guest: GuestType<T>): this {
-    this.pool.distribute(this.sourceDocument, guest);
-    return this;
-  }
-}

package/src/Source/SourcesApplied.test.ts

@@ -1,26 +0,0 @@
-import { expect, test } from "vitest";
-import { sourcesApplied } from "./SourcesApplied";
-
-test("sources applied", () => {
-  const target = {
-    one(data: { one: string }, after: string) {
-      return data.one + " " + after;
-    },
-  };
-  const targetApplied = sourcesApplied(target, {
-    one: [{ one: "hello world" }, "after"],
-  });
-  expect(targetApplied.one()).toBe("hello world after");
-});
-
-test("sources applied classes", () => {
-  class Target {
-    one(data: { one: string }, after: string) {
-      return data.one + " " + after;
-    }
-  }
-  const targetApplied = sourcesApplied(new Target(), {
-    one: [{ one: "good bye" }, "after"],
-  });
-  expect(targetApplied.one()).toBe("good bye after");
-});

package/src/Source/SourcesApplied.ts

@@ -1,39 +0,0 @@
-type TupleSplit<
-  T,
-  N extends number,
-  O extends readonly any[] = readonly [],
-> = O["length"] extends N
-  ? [O, T]
-  : T extends readonly [infer F, ...infer R]
-    ? TupleSplit<readonly [...R], N, readonly [...O, F]>
-    : [O, T];
-
-type SkipFirst<T extends readonly any[], N extends number> = TupleSplit<
-  T,
-  N
->[1];
-
-export const sourcesApplied = <T>(
-  target: T,
-  methodsSources: Record<string, unknown[]>,
-) => {
-  return new Proxy(target as object, {
-    get: function (target: any, property) {
-      const maybeMethod = target[property];
-
-      if (typeof maybeMethod !== "function") {
-        return maybeMethod;
-      }
-
-      return (...args: any[]) => {
-        const appliedArgs = (methodsSources as any)[property];
-
-        if (appliedArgs) {
-          return maybeMethod(...appliedArgs, ...args);
-        }
-
-        return maybeMethod(...args);
-      };
-    },
-  });
-};