singleton-pattern 1.1.0 → 1.1.2

package/README.md

@@ -4,6 +4,8 @@
 
 > **Note**: Your environment must support ES6 Proxies.
 
+For more awesome packages, check out [my homepage💛](https://baendlorel.github.io/?repoType=npm)
+
 ## 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 and proxy reuse.

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,11 +1,12 @@
 {
 	"name": "singleton-pattern",
-	"version": "1.1.0",
+	"version": "1.1.2",
 	"author": {
 		"name": "Kasukabe Tsumugi",
 		"email": "futami16237@gmail.com"
 	},
 	"description": "Wrap a class with proxy to make it a safe singleton constructor. Using new Class() will return the same instance.",
+	"description_zh": "使用代理包装类以使其成为安全的单例构造函数（原型的构造函数也将被修改）。使用 new Class() 将返回相同的实例",
 	"type": "module",
 	"exports": {
 		"import": "./dist/index.mjs",