patron-oop 1.3.0 → 1.5.0

package/CHANGELOG.md

@@ -2,6 +2,24 @@
 
 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)
+
+
+### Features
+
+* **main:** заготовка для описания каждого класса ([03344dd](https://github.com/kosukhin/patron/commit/03344dd86952422e055c581a5b38944d89240db1))
+* **main:** убрать типы из отдельных файлов ([1b27b36](https://github.com/kosukhin/patron/commit/1b27b36870a3fb07ce5eb875f88a88d6efa86e65))
+
 ## [1.3.0](https://github.com/kosukhin/patron/compare/v1.2.1...v1.3.0) (2024-10-13)
 
 

package/README.md

@@ -7,3 +7,63 @@ Patron JS - это библиотека для ООП программирова
 
 Patron - это сущность, которая является посетителем какого-либо объекта и приходит к объекту за результатом вычисления.
 Guest - это почти такая же сущность как и Patron, разница только в том что Patron нужно постоянно уведомлять об изменениях а Guest не нужно.
+
+# Guest
+
+TODO
+
+# GuestAware
+
+TODO
+
+# GuestCast
+
+TODO
+
+# GuestInTheMiddle
+
+TODO
+
+# GuestPool
+
+TODO
+
+# GuestSync
+
+TODO
+
+# Patron
+
+TODO
+
+# PatronOnce
+
+TODO
+
+# PatronPool
+
+TODO
+
+# Source
+
+TODO
+
+# Factory
+
+TODO
+
+# FactoryDynamic
+
+TODO
+
+# FactoryWithFactories
+
+TODO
+
+# Chain
+
+TODO
+
+# Cache
+
+TODO

package/dist/patron.d.ts

@@ -2,24 +2,15 @@ type GuestIntroduction = "guest" | "patron";
 interface ReceiveOptions {
     data?: unknown;
 }
+type GuestExecutorType<T> = (value: T, options?: ReceiveOptions) => void;
 interface GuestType<T = unknown> {
     receive(value: T, options?: ReceiveOptions): this;
     introduction?(): GuestIntroduction;
 }
-
-interface GuestAwareType<T = unknown> {
-    receiving(guest: GuestType<T>): unknown;
-}
-
-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);
+declare class GuestCallback<T> implements GuestType<T> {
+    private receiver;
+    constructor(receiver: GuestExecutorType<T>);
     receive(value: T, options?: ReceiveOptions): this;
-    receiving(guest: GuestType<T>): this;
 }
 
 interface ChainType<T = unknown> {
@@ -27,8 +18,7 @@ interface ChainType<T = unknown> {
     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;
@@ -40,49 +30,54 @@ declare class Chain<T> implements ChainType<T> {
     private isChainFilled;
 }
 
-interface FactoryType<T> {
-    create<R extends unknown[], CT = null>(...args: R): CT extends null ? T : CT;
-}
-
-interface Prototyped$1<T> {
-    prototype: 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;
+interface GuestValueType<T = unknown> extends GuestType<T> {
+    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 class GuestSync<T> implements GuestValueType<T> {
+    private theValue;
+    constructor(theValue: T);
+    receive(value: T): this;
+    value(): T;
 }
 
-interface Prototyped<T> {
-    prototype: T;
+/**
+ * Удалить патрон из всех пулов
+ */
+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 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 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;
 }
 
-type GuestExecutorType<T> = (value: T, options?: ReceiveOptions) => void;
-
-declare class Guest<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 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> {
     private sourceGuest;
     private targetGuest;
@@ -99,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;
@@ -116,21 +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";
@@ -145,29 +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<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, Chain, Factory, FactoryDynamic, type FactoryType, FactoryWithFactories, Guest, GuestAware, GuestCast, GuestInTheMiddle, GuestPool, GuestSync, Patron, PatronOnce, PatronPool, Source, 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