patron-oop 1.5.2 → 1.7.0

package/src/index.ts

@@ -1,21 +1,43 @@
-export * from "./Guest/GuestCallback";
+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 { SourceOfValue } from "./Source/SourceOfValue";
+
+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/SourceOfValue";
 
-import { Guest } from "./Guest/Guest";
-import { Patron } from "./Patron/Patron";
-import { Source } from "./Source/Source";
-
-export { Guest, Patron, 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,
+    SourceOfValue,
   };
 }

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

@@ -1,12 +0,0 @@
-import { SourceOfValue } from "./SourceOfValue";
-import { sourcesApplied } from "./SourcesApplied";
-
-export class Source {
-  public ofValue<P>(sourceDocument: P) {
-    return new SourceOfValue(sourceDocument);
-  }
-
-  public applySources<P>(target: P, methodsSources: Record<string, unknown[]>) {
-    return sourcesApplied(target, methodsSources);
-  }
-}

package/src/Source/SourcesApplied.test.ts

@@ -1,14 +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");
-});

package/src/Source/SourcesApplied.ts

@@ -1,40 +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 Object.fromEntries(
-    Object.entries(target as object).map(([key, value]) => {
-      if (value instanceof Function && methodsSources[key]) {
-        const methodArgs = methodsSources[key];
-        return [
-          key,
-          new Proxy(value, {
-            apply(target: Function, thisArg: any, argArray: any[]): any {
-              return target.apply(thisArg, [
-                ...methodsSources[key],
-                ...argArray,
-              ]);
-            },
-          }) as (...args: Parameters<typeof value>) => ReturnType<typeof value>,
-        ];
-      }
-
-      return [key, value];
-    }),
-  );
-};