patron-oop 1.4.0 → 1.5.0

package/CHANGELOG.md

@@ -2,6 +2,16 @@
 
 All notable changes to this project will be documented in this file. See [standard-version](https://github.com/conventional-changelog/standard-version) for commit guidelines.
 
+## [1.5.0](https://github.com/kosukhin/patron/compare/v1.4.0...v1.5.0) (2024-10-20)
+
+
+### Features
+
+* **issue-1:** доделал основные классы - фабрики ([a44fc85](https://github.com/kosukhin/patron/commit/a44fc853f7a1bd7ad8abf9428709eaec3d979b3f))
+* **issue-1:** заготовка для фабрик основного функционала ([4f22d35](https://github.com/kosukhin/patron/commit/4f22d357188add1baf374c207b321f4c47e99997))
+* **issue-1:** наработка для сорс апплиед ([c704597](https://github.com/kosukhin/patron/commit/c7045970265d843c77b6f657b60d629a1f0d3298))
+* **main:** guest cast поправить ([211e05c](https://github.com/kosukhin/patron/commit/211e05c576b7c86b5d39537a8da5f5f83d071b46))
+
 ## [1.4.0](https://github.com/kosukhin/patron/compare/v1.3.0...v1.4.0) (2024-10-13)
 
 

package/dist/patron.d.ts

@@ -1,5 +1,3 @@
-import { GuestAwareType as GuestAwareType$1 } from 'src/GuestAware';
-
 type GuestIntroduction = "guest" | "patron";
 interface ReceiveOptions {
     data?: unknown;
@@ -9,37 +7,18 @@ interface GuestType<T = unknown> {
     receive(value: T, options?: ReceiveOptions): this;
     introduction?(): GuestIntroduction;
 }
-declare class Guest<T> implements GuestType<T> {
+declare class GuestCallback<T> implements GuestType<T> {
     private receiver;
     constructor(receiver: GuestExecutorType<T>);
     receive(value: T, options?: ReceiveOptions): this;
 }
 
-interface GuestAwareType<T = unknown> {
-    receiving(guest: GuestType<T>): unknown;
-}
-declare class GuestAware<T = unknown> implements GuestAwareType<T> {
-    private guestReceiver;
-    constructor(guestReceiver: (guest: GuestType<T>) => void);
-    receiving(guest: GuestType<T>): GuestType<T>;
-}
-
-type CacheType<T = unknown> = GuestType<T> & GuestAwareType<T>;
-declare class Cache<T> implements CacheType<T> {
-    private defaultValue;
-    private theCache;
-    private pool;
-    constructor(initiator: unknown, defaultValue?: T | null, theCache?: T | null);
-    receive(value: T, options?: ReceiveOptions): this;
-    receiving(guest: GuestType<T>): this;
-}
-
 interface ChainType<T = unknown> {
     result(guest: GuestType<T>): this;
     resultArray(guest: GuestType<T>): this;
     receiveKey<R>(key: string): GuestType<R>;
 }
-declare class Chain<T> implements ChainType<T> {
+declare class GuestChain<T> implements ChainType<T> {
     private theChain;
     private keysKnown;
     private keysFilled;
@@ -51,32 +30,52 @@ declare class Chain<T> implements ChainType<T> {
     private isChainFilled;
 }
 
-interface Prototyped$1<T> {
-    prototype: T;
-}
-interface FactoryType<T> {
-    create<R extends unknown[], CT = null>(...args: R): CT extends null ? T : CT;
+interface GuestValueType<T = unknown> extends GuestType<T> {
+    value(): T;
 }
-declare class Factory<T> implements FactoryType<T> {
-    private constructorFn;
-    constructor(constructorFn: Prototyped$1<T>);
-    create<R extends unknown[], CT = null>(...args: R): CT extends null ? T : CT;
+declare class GuestSync<T> implements GuestValueType<T> {
+    private theValue;
+    constructor(theValue: T);
+    receive(value: T): this;
+    value(): T;
 }
 
-declare class FactoryDynamic<T> implements FactoryType<T> {
-    private creationFn;
-    constructor(creationFn: (...args: unknown[]) => T);
-    create<R extends unknown[], CT = null>(...args: R): CT extends null ? T : CT;
+/**
+ * Удалить патрон из всех пулов
+ */
+declare const removePatronFromPools: (patron: GuestType) => void;
+interface PoolType<T = unknown> extends GuestType<T> {
+    add(guest: GuestType<T>): this;
+    distribute(receiving: T, possiblePatron: GuestType<T>): this;
+    remove(patron: GuestType<T>): this;
+}
+declare class PatronPool<T> implements PoolType<T> {
+    private initiator;
+    private patrons;
+    receive: (value: T, options?: ReceiveOptions) => this;
+    constructor(initiator: unknown);
+    add(shouldBePatron: GuestType<T>): this;
+    remove(patron: GuestType<T>): this;
+    distribute(receiving: T, possiblePatron: GuestType<T>): this;
+    private sendValueToGuest;
 }
 
-interface Prototyped<T> {
-    prototype: T;
+interface GuestAwareType<T = unknown> {
+    receiving(guest: GuestType<T>): unknown;
 }
-declare class FactoryWithFactories<T> implements FactoryType<T> {
-    private constructorFn;
-    private factories;
-    constructor(constructorFn: Prototyped<T>, factories?: Record<string, unknown>);
-    create<R extends unknown[], CT = null>(...args: R): CT extends null ? T : CT;
+declare class GuestAware<T = unknown> implements GuestAwareType<T> {
+    private guestReceiver;
+    constructor(guestReceiver: (guest: GuestType<T>) => void);
+    receiving(guest: GuestType<T>): GuestType<T>;
+}
+
+type SourceType<T = unknown> = GuestAwareType<T> & GuestType<T>;
+declare class SourceOfValue<T> implements SourceType<T> {
+    private sourceDocument;
+    private pool;
+    constructor(sourceDocument: T);
+    receive(value: T): this;
+    receiving(guest: GuestType<T>): this;
 }
 
 declare class GuestCast<T> implements GuestType<T> {
@@ -95,12 +94,6 @@ declare class GuestInTheMiddle<T> implements GuestType<T> {
     receive(value: T, options?: ReceiveOptions): this;
 }
 
-interface PoolType<T = unknown> extends GuestType<T> {
-    add(guest: GuestType<T>): this;
-    distribute(receiving: T, possiblePatron: GuestType<T>): this;
-    remove(patron: GuestType<T>): this;
-}
-
 declare class GuestPool<T> implements GuestType<T>, PoolType<T> {
     private guests;
     private patronPool;
@@ -112,20 +105,20 @@ declare class GuestPool<T> implements GuestType<T>, PoolType<T> {
     private deliverToGuests;
 }
 
-interface GuestValueType<T = unknown> extends GuestType<T> {
-    value(): T;
-}
-declare class GuestSync<T> implements GuestValueType<T> {
-    private theValue;
-    constructor(theValue: T);
-    receive(value: T): this;
-    value(): T;
+declare class Guest {
+    callback<P>(receiver: GuestExecutorType<P>): GuestCallback<P>;
+    chain(): GuestChain<unknown>;
+    cast<P>(sourceGuest: GuestType<unknown>, targetGuest: GuestType<P>): GuestCast<P>;
+    middleware<P>(baseGuest: GuestType<unknown>, middleFn: (value: P, options?: ReceiveOptions) => void): GuestInTheMiddle<P>;
+    pool(initiator: unknown): GuestPool<unknown>;
+    aware<P>(guestReceiver: (guest: GuestType<P>) => void): GuestAware<P>;
+    sync<P>(value: P): GuestSync<P>;
 }
 
 /**
  * Патрон - это постоянный посетитель
  */
-declare class Patron<T> implements GuestType<T> {
+declare class PatronOfGuest<T> implements GuestType<T> {
     private willBePatron;
     constructor(willBePatron: GuestType<T>);
     introduction(): "patron";
@@ -140,28 +133,17 @@ declare class PatronOnce<T> implements GuestType<T> {
     receive(value: T, options?: ReceiveOptions): this;
 }
 
-/**
- * Удалить патрон из всех пулов
- */
-declare const removePatronFromPools: (patron: GuestType) => void;
-declare class PatronPool<T> implements PoolType<T> {
-    private initiator;
-    private patrons;
-    receive: (value: T, options?: ReceiveOptions) => this;
-    constructor(initiator: unknown);
-    add(shouldBePatron: GuestType<T>): this;
-    remove(patron: GuestType<T>): this;
-    distribute(receiving: T, possiblePatron: GuestType<T>): this;
-    private sendValueToGuest;
+declare class Patron {
+    ofGuest<P>(willBePatron: GuestType<P>): PatronOfGuest<P>;
+    once<P>(baseGuest: GuestType<P>): PatronOnce<P>;
+    pool(initiator: unknown): PatronPool<unknown>;
 }
 
-type SourceType<T = unknown> = GuestAwareType$1<T> & GuestType<T>;
-declare class Source<T> implements SourceType<T> {
-    private sourceDocument;
-    private pool;
-    constructor(sourceDocument: T);
-    receive(value: T): this;
-    receiving(guest: GuestType<T>): this;
+declare class Source {
+    ofValue<P>(sourceDocument: P): SourceOfValue<P>;
+    applySources<P>(target: P, methodsSources: Record<string, unknown[]>): {
+        [k: string]: any;
+    };
 }
 
-export { Cache, type CacheType, Chain, type ChainType, Factory, FactoryDynamic, type FactoryType, FactoryWithFactories, Guest, GuestAware, type GuestAwareType, GuestCast, type GuestExecutorType, GuestInTheMiddle, GuestPool, GuestSync, type GuestType, type GuestValueType, Patron, PatronOnce, PatronPool, type ReceiveOptions, Source, type SourceType, removePatronFromPools };
+export { type ChainType, Guest, GuestCallback, GuestChain, type GuestExecutorType, GuestSync, type GuestType, type GuestValueType, Patron, PatronPool, type PoolType, type ReceiveOptions, Source, SourceOfValue, type SourceType, removePatronFromPools };

package/dist/patron.js

@@ -1,8 +1,18 @@
 'use strict';
 
-var __defProp$5 = Object.defineProperty;
-var __defNormalProp$5 = (obj, key, value) => key in obj ? __defProp$5(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
-var __publicField$5 = (obj, key, value) => __defNormalProp$5(obj, typeof key !== "symbol" ? key + "" : key, value);
+class GuestCallback {
+  constructor(receiver) {
+    this.receiver = receiver;
+  }
+  receive(value, options) {
+    this.receiver(value, options);
+    return this;
+  }
+}
+
+var __defProp$4 = Object.defineProperty;
+var __defNormalProp$4 = (obj, key, value) => key in obj ? __defProp$4(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __publicField$4 = (obj, key, value) => __defNormalProp$4(obj, typeof key !== "symbol" ? key + "" : key, value);
 const poolSets = /* @__PURE__ */ new Map();
 const removePatronFromPools = (patron) => {
   poolSets.forEach((pool) => {
@@ -12,8 +22,8 @@ const removePatronFromPools = (patron) => {
 class PatronPool {
   constructor(initiator) {
     this.initiator = initiator;
-    __publicField$5(this, "patrons", /* @__PURE__ */ new Set());
-    __publicField$5(this, "receive");
+    __publicField$4(this, "patrons", /* @__PURE__ */ new Set());
+    __publicField$4(this, "receive");
     poolSets.set(this, this.patrons);
     let lastMicrotask = null;
     const doReceive = (value, options) => {
@@ -59,42 +69,6 @@ class PatronPool {
   }
 }
 
-var __defProp$4 = Object.defineProperty;
-var __defNormalProp$4 = (obj, key, value) => key in obj ? __defProp$4(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
-var __publicField$4 = (obj, key, value) => __defNormalProp$4(obj, key + "" , value);
-class Cache {
-  constructor(initiator, defaultValue = null, theCache = null) {
-    this.defaultValue = defaultValue;
-    this.theCache = theCache;
-    __publicField$4(this, "pool");
-    this.pool = new PatronPool(initiator);
-  }
-  receive(value, options) {
-    this.theCache = value;
-    this.pool.receive(value, options);
-    return this;
-  }
-  receiving(guest) {
-    if (this.theCache !== null) {
-      guest.receive(this.theCache);
-    } else if (this.defaultValue !== null) {
-      guest.receive(this.defaultValue);
-    }
-    this.pool.add(guest);
-    return this;
-  }
-}
-
-class Guest {
-  constructor(receiver) {
-    this.receiver = receiver;
-  }
-  receive(value, options) {
-    this.receiver(value, options);
-    return this;
-  }
-}
-
 var __defProp$3 = Object.defineProperty;
 var __defNormalProp$3 = (obj, key, value) => key in obj ? __defProp$3(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
 var __publicField$3 = (obj, key, value) => __defNormalProp$3(obj, typeof key !== "symbol" ? key + "" : key, value);
@@ -153,14 +127,33 @@ class GuestInTheMiddle {
 
 var __defProp$2 = Object.defineProperty;
 var __defNormalProp$2 = (obj, key, value) => key in obj ? __defProp$2(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
-var __publicField$2 = (obj, key, value) => __defNormalProp$2(obj, typeof key !== "symbol" ? key + "" : key, value);
-class Chain {
+var __publicField$2 = (obj, key, value) => __defNormalProp$2(obj, key + "" , value);
+class SourceOfValue {
+  constructor(sourceDocument) {
+    this.sourceDocument = sourceDocument;
+    __publicField$2(this, "pool", new PatronPool(this));
+  }
+  receive(value) {
+    this.sourceDocument = value;
+    this.pool.receive(this.sourceDocument);
+    return this;
+  }
+  receiving(guest) {
+    this.pool.distribute(this.sourceDocument, guest);
+    return this;
+  }
+}
+
+var __defProp$1 = Object.defineProperty;
+var __defNormalProp$1 = (obj, key, value) => key in obj ? __defProp$1(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __publicField$1 = (obj, key, value) => __defNormalProp$1(obj, typeof key !== "symbol" ? key + "" : key, value);
+class GuestChain {
   constructor() {
-    __publicField$2(this, "theChain");
-    __publicField$2(this, "keysKnown", /* @__PURE__ */ new Set());
-    __publicField$2(this, "keysFilled", /* @__PURE__ */ new Set());
-    __publicField$2(this, "filledChainPool", new GuestPool(this));
-    this.theChain = new Cache(this, {});
+    __publicField$1(this, "theChain");
+    __publicField$1(this, "keysKnown", /* @__PURE__ */ new Set());
+    __publicField$1(this, "keysFilled", /* @__PURE__ */ new Set());
+    __publicField$1(this, "filledChainPool", new GuestPool(this));
+    this.theChain = new SourceOfValue({});
   }
   resultArray(guest) {
     this.filledChainPool.add(
@@ -171,7 +164,7 @@ class Chain {
     );
     if (this.isChainFilled()) {
       this.theChain.receiving(
-        new Guest((chain) => {
+        new GuestCallback((chain) => {
           this.filledChainPool.receive(Object.values(chain));
         })
       );
@@ -182,7 +175,7 @@ class Chain {
     if (this.isChainFilled()) {
       this.filledChainPool.add(guest);
       this.theChain.receiving(
-        new Guest((chain) => {
+        new GuestCallback((chain) => {
           this.filledChainPool.receive(chain);
         })
       );
@@ -193,10 +186,10 @@ class Chain {
   }
   receiveKey(key) {
     this.keysKnown.add(key);
-    return new Guest((value) => {
+    return new GuestCallback((value) => {
       queueMicrotask(() => {
         this.theChain.receiving(
-          new Guest((chain) => {
+          new GuestCallback((chain) => {
             this.keysFilled.add(key);
             const lastChain = {
               ...chain,
@@ -216,46 +209,16 @@ class Chain {
   }
 }
 
-class Factory {
-  constructor(constructorFn) {
-    this.constructorFn = constructorFn;
-  }
-  create(...args) {
-    return new this.constructorFn(
-      ...args
-    );
-  }
-}
-
-class FactoryDynamic {
-  constructor(creationFn) {
-    this.creationFn = creationFn;
-  }
-  create(...args) {
-    return this.creationFn(...args);
-  }
-}
-
-class FactoryWithFactories {
-  constructor(constructorFn, factories = {}) {
-    this.constructorFn = constructorFn;
-    this.factories = factories;
-  }
-  create(...args) {
-    return new this.constructorFn(
-      ...args,
-      this.factories
-    );
+class GuestSync {
+  constructor(theValue) {
+    this.theValue = theValue;
   }
-}
-
-class GuestAware {
-  constructor(guestReceiver) {
-    this.guestReceiver = guestReceiver;
+  receive(value) {
+    this.theValue = value;
+    return this;
   }
-  receiving(guest) {
-    this.guestReceiver(guest);
-    return guest;
+  value() {
+    return this.theValue;
   }
 }
 
@@ -276,20 +239,41 @@ class GuestCast {
   }
 }
 
-class GuestSync {
-  constructor(theValue) {
-    this.theValue = theValue;
+class GuestAware {
+  constructor(guestReceiver) {
+    this.guestReceiver = guestReceiver;
   }
-  receive(value) {
-    this.theValue = value;
-    return this;
+  receiving(guest) {
+    this.guestReceiver(guest);
+    return guest;
   }
-  value() {
-    return this.theValue;
+}
+
+class Guest {
+  callback(receiver) {
+    return new GuestCallback(receiver);
+  }
+  chain() {
+    return new GuestChain();
+  }
+  cast(sourceGuest, targetGuest) {
+    return new GuestCast(sourceGuest, targetGuest);
+  }
+  middleware(baseGuest, middleFn) {
+    return new GuestInTheMiddle(baseGuest, middleFn);
+  }
+  pool(initiator) {
+    return new GuestPool(initiator);
+  }
+  aware(guestReceiver) {
+    return new GuestAware(guestReceiver);
+  }
+  sync(value) {
+    return new GuestSync(value);
   }
 }
 
-class Patron {
+class PatronOfGuest {
   constructor(willBePatron) {
     this.willBePatron = willBePatron;
   }
@@ -302,13 +286,13 @@ class Patron {
   }
 }
 
-var __defProp$1 = Object.defineProperty;
-var __defNormalProp$1 = (obj, key, value) => key in obj ? __defProp$1(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
-var __publicField$1 = (obj, key, value) => __defNormalProp$1(obj, key + "" , value);
+var __defProp = Object.defineProperty;
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __publicField = (obj, key, value) => __defNormalProp(obj, key + "" , value);
 class PatronOnce {
   constructor(baseGuest) {
     this.baseGuest = baseGuest;
-    __publicField$1(this, "received", false);
+    __publicField(this, "received", false);
   }
   introduction() {
     return "patron";
@@ -325,39 +309,56 @@ class PatronOnce {
   }
 }
 
-var __defProp = Object.defineProperty;
-var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
-var __publicField = (obj, key, value) => __defNormalProp(obj, key + "" , value);
-class Source {
-  constructor(sourceDocument) {
-    this.sourceDocument = sourceDocument;
-    __publicField(this, "pool", new PatronPool(this));
+class Patron {
+  ofGuest(willBePatron) {
+    return new PatronOfGuest(willBePatron);
   }
-  receive(value) {
-    this.sourceDocument = value;
-    this.pool.receive(this.sourceDocument);
-    return this;
+  once(baseGuest) {
+    return new PatronOnce(baseGuest);
   }
-  receiving(guest) {
-    this.pool.distribute(this.sourceDocument, guest);
-    return this;
+  pool(initiator) {
+    return new PatronPool(initiator);
+  }
+}
+
+const sourcesApplied = (target, methodsSources) => {
+  return Object.fromEntries(
+    Object.entries(target).map(([key, value]) => {
+      if (value instanceof Function && methodsSources[key]) {
+        methodsSources[key];
+        return [
+          key,
+          new Proxy(value, {
+            apply(target2, thisArg, argArray) {
+              return target2.apply(thisArg, [
+                ...methodsSources[key],
+                ...argArray
+              ]);
+            }
+          })
+        ];
+      }
+      return [key, value];
+    })
+  );
+};
+
+class Source {
+  ofValue(sourceDocument) {
+    return new SourceOfValue(sourceDocument);
+  }
+  applySources(target, methodsSources) {
+    return sourcesApplied(target, methodsSources);
   }
 }
 
-exports.Cache = Cache;
-exports.Chain = Chain;
-exports.Factory = Factory;
-exports.FactoryDynamic = FactoryDynamic;
-exports.FactoryWithFactories = FactoryWithFactories;
 exports.Guest = Guest;
-exports.GuestAware = GuestAware;
-exports.GuestCast = GuestCast;
-exports.GuestInTheMiddle = GuestInTheMiddle;
-exports.GuestPool = GuestPool;
+exports.GuestCallback = GuestCallback;
+exports.GuestChain = GuestChain;
 exports.GuestSync = GuestSync;
 exports.Patron = Patron;
-exports.PatronOnce = PatronOnce;
 exports.PatronPool = PatronPool;
 exports.Source = Source;
+exports.SourceOfValue = SourceOfValue;
 exports.removePatronFromPools = removePatronFromPools;
 //# sourceMappingURL=patron.js.map