singleton-pattern 1.0.0 → 1.1.1

package/README.md

@@ -1,17 +1,18 @@
-# Singleton Pattern
+# singleton-pattern
 
 🦄 Wrap your class to make it a true singleton!
 
-> Note: Your environment must support Proxy
+> **Note**: Your environment must support ES6 Proxies.
 
 ## Overview
 
-`singleton-pattern` is a lightweight TypeScript/JavaScript utility that wraps a class constructor so that every `new` call returns the same instance. It uses Proxy to ensure singleton safety, and provides options for prototype handling.
+`singleton-pattern` is a lightweight TypeScript/JavaScript utility that wraps a class constructor so that every `new` call returns the same instance. It uses Proxy to ensure singleton safety, and provides options for prototype and proxy reuse.
 
 ## Features
 
 - Make any class a singleton with one line
 - Optionally control prototype.constructor behavior
+- Optionally reuse proxy for the same class (`options.onlyOnce`)
 - Retrieve the original class from a singletonified class
 - Fully type-safe
 
@@ -28,25 +29,35 @@ pnpm add singleton-pattern
 ```typescript
 import { singletonify, getSingletonTarget } from 'singleton-pattern';
 
-class MyClass {
+class Target {
   value: number;
   constructor(v: number) {
     this.value = v;
   }
 }
 
-const Singleton = singletonify(MyClass);
-const a = new Singleton(1);
-const b = new Singleton(2);
+// Basic singleton
+const S = singletonify(Target);
+const a = new S(1);
+const b = new S(2);
 console.log(a === b); // true
 console.log(a.value); // 1
 
+// Retrieve original class
+console.log(getSingletonTarget(S)); // Target
+
 // Option: keep original prototype.constructor
-const Singleton2 = singletonify(MyClass, { hideProtoConstructor: false });
-console.log(Singleton2.prototype.constructor === MyClass); // true
+const S2 = singletonify(Target, { changeProtoConstructor: false });
+console.log(S2.prototype.constructor === Target); // true
 
-// Retrieve original class
-console.log(getSingletonTarget(Singleton)); // MyClass
+// Option: onlyOnce (reuse proxy for same class)
+const S3 = singletonify(Target); // equivalent to (Target, { onlyOnce: true })
+const S4 = singletonify(Target); // equivalent to (Target, { onlyOnce: true })
+console.log(S3 === S4);
+
+const S5 = singletonify(Target, { onlyOnce: false });
+const S6 = singletonify(Target, { onlyOnce: false });
+console.log(S5 !== S6);
 ```
 
 ## API
@@ -56,7 +67,10 @@ console.log(getSingletonTarget(Singleton)); // MyClass
 Wraps a class constructor so that all `new` calls return the same instance.
 
 - `target`: The class to wrap
-- `options.hideProtoConstructor` (default: `true`): If not `false`, sets `prototype.constructor` to the singletonified class. If `false`, keeps the original constructor.
+- `options.changeProtoConstructor` (default: `true`): Boolean. If `true`, sets `prototype.constructor` to the singletonified class. If `false`, keeps the original constructor.
+- `options.onlyOnce` (default: `true`): Boolean. If `true`, reuses the same proxy for the same class. If `false`, creates a new proxy each time.
+
+> **Note**: the options object uses Boolean Evaluation(aka. Boolean(x) / if (x))
 
 ### `getSingletonTarget<T extends Class>(singleton: T): T | undefined`
 

package/dist/index.d.ts

@@ -1,15 +1,28 @@
 // # from: global.d.ts
 type Class = new (...args: any[]) => any;
+type ProxiedClass = new (...args: any[]) => any;
 
 interface SingletonifyOptions {
   /**
    * Preventing the `.prototype.constructor` from being accessed
-   * - default is `true`
-   *   - **Only** when it is `false`, will remain the original constructor unchanged
+   *
+   * Default is `true`
+   * - use Boolean Evaluation
+   * - it is **not recommended** to set this to `false`
+   *   - if it is falsy, will remain the original constructor unchanged
    * - will change `Origin.prototype.constructor` to the singletonified class
    *   - this means Origin.prototype.constructor !== origin
    */
-  hideProtoConstructor?: boolean;
+  changeProtoConstructor?: boolean;
+
+  /**
+   * Default is `true`
+   * - use Boolean Evaluation
+   * - it is **not recommended** to set this to `false`
+   *   - if it is falsy, it will create a new singletonified class every time and will not cache it
+   * - by default, wrap a class multiple times will always return the same singletonified class
+   */
+  onlyOnce?: boolean;
 }
 
 // # index.d.ts
@@ -18,12 +31,13 @@ interface SingletonifyOptions {
  * Just wrap your class with this function to create a new class that always returns the same instance
  * @param target The class to be wrapped
  * @param options Advanced options
- * - hideProtoConstructor(default: `true`) when it is **not** `false`, will set `target.prototype.constructor` to the singletonified class
+ * - changeProtoConstructor(default: `true`) will set `target.prototype.constructor` to the singletonified class
+ * - onlyOnce(default: `true`) will cache the input and always return the same proxied class
  *
  * ## About
  * @package SingletonPattern
  * @author Kasukabe Tsumugi <futami16237@gmail.com>
- * @version 1.0.0 (Last Update: 2025.08.15 10:00:01.902)
+ * @version 1.1.1 (Last Update: 2025.08.15 11:07:44.767)
  * @license MIT
  * @link https://github.com/baendlorel/singleton-pattern
  * @description Wrap a class with proxy to make it a safe singleton constructor. Using new Class() will return the same instance.

package/dist/index.mjs

@@ -1 +1 @@
-const n=Proxy;const t=new class{map=new WeakMap;singletonify(t,e){let o;const s=new n(t,{construct:(n,t)=>(o||(o=new n(...t)),o)});return!1!==(null==e?void 0:e.hideProtoConstructor)&&(s.prototype.constructor=s),this.map.set(s,t),s}getSingletonTarget(n){return this.map.get(n)}},e=t.singletonify.bind(t),o=t.getSingletonTarget.bind(t);export{o as getSingletonTarget,e as singletonify};
+const t=Proxy,n=Object;const e=new class{p2c=new WeakMap;c2p=new WeakMap;singletonify(e,o){const{changeProtoConstructor:s=!0,onlyOnce:c=!0}=n(o);if(c&&this.c2p.has(e))return this.c2p.get(e);let r;const i=new t(e,{construct:(t,n)=>(r||(r=new t(...n)),r)});return s&&(i.prototype.constructor=i),c&&(this.p2c.set(i,e),this.c2p.set(e,i)),i}getSingletonTarget(t){return this.p2c.get(t)}},o=e.singletonify.bind(e),s=e.getSingletonTarget.bind(e);export{s as getSingletonTarget,o as singletonify};

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "singleton-pattern",
-	"version": "1.0.0",
+	"version": "1.1.1",
 	"author": {
 		"name": "Kasukabe Tsumugi",
 		"email": "futami16237@gmail.com"