singleton-pattern 1.0.0

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2025 kasukabe tsumugi
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,71 @@
+# Singleton Pattern
+
+🦄 Wrap your class to make it a true singleton!
+
+> Note: Your environment must support Proxy
+
+## 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.
+
+## Features
+
+- Make any class a singleton with one line
+- Optionally control prototype.constructor behavior
+- Retrieve the original class from a singletonified class
+- Fully type-safe
+
+## Installation
+
+```bash
+npm install singleton-pattern
+# or
+pnpm add singleton-pattern
+```
+
+## Usage
+
+```typescript
+import { singletonify, getSingletonTarget } from 'singleton-pattern';
+
+class MyClass {
+  value: number;
+  constructor(v: number) {
+    this.value = v;
+  }
+}
+
+const Singleton = singletonify(MyClass);
+const a = new Singleton(1);
+const b = new Singleton(2);
+console.log(a === b); // true
+console.log(a.value); // 1
+
+// Option: keep original prototype.constructor
+const Singleton2 = singletonify(MyClass, { hideProtoConstructor: false });
+console.log(Singleton2.prototype.constructor === MyClass); // true
+
+// Retrieve original class
+console.log(getSingletonTarget(Singleton)); // MyClass
+```
+
+## API
+
+### `singletonify<T extends Class>(target: T, options?: SingletonifyOptions): T`
+
+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.
+
+### `getSingletonTarget<T extends Class>(singleton: T): T | undefined`
+
+Returns the original class for a singletonified class, or `undefined` if not singletonified.
+
+## License
+
+MIT
+
+## Author
+
+Kasukabe Tsumugi <futami16237@gmail.com>

package/dist/index.d.ts

@@ -0,0 +1,40 @@
+// # from: global.d.ts
+type Class = 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
+   * - will change `Origin.prototype.constructor` to the singletonified class
+   *   - this means Origin.prototype.constructor !== origin
+   */
+  hideProtoConstructor?: boolean;
+}
+
+// # index.d.ts
+/**
+ * ## Usage
+ * 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
+ *
+ * ## About
+ * @package SingletonPattern
+ * @author Kasukabe Tsumugi <futami16237@gmail.com>
+ * @version 1.0.0 (Last Update: 2025.08.15 10:00:01.902)
+ * @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.
+ * @copyright Copyright (c) 2025 Kasukabe Tsumugi. All rights reserved.
+ */
+declare const singletonify: <T extends Class>(target: T, options?: SingletonifyOptions) => T;
+/**
+ * Retrieves the original class from the singletonified class
+ * @param singleton The singletonified class
+ * @returns `undefined` if the class is not singletonified, otherwise returns the original class
+ */
+declare const getSingletonTarget: <T extends Class>(singleton: T) => T | undefined;
+
+export { getSingletonTarget, singletonify };

package/dist/index.mjs

@@ -0,0 +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};

package/package.json

@@ -0,0 +1,62 @@
+{
+	"name": "singleton-pattern",
+	"version": "1.0.0",
+	"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.",
+	"type": "module",
+	"exports": {
+		"import": "./dist/index.mjs",
+		"default": "./dist/index.mjs",
+		"types": "./dist/index.d.ts"
+	},
+	"files": [
+		"dist"
+	],
+	"homepage": "https://github.com/baendlorel/singleton-pattern#readme",
+	"repository": {
+		"type": "git",
+		"url": "https://github.com/baendlorel/singleton-pattern"
+	},
+	"keywords": [
+		"deep",
+		"clone",
+		"reflect",
+		"property",
+		"path",
+		"object",
+		"nested",
+		"typescript",
+		"javascript"
+	],
+	"scripts": {
+		"test": "clear & vitest",
+		"lint": "oxlint .",
+		"cover": "clear & vitest --coverage",
+		"build": "rimraf dist && rollup -c"
+	},
+	"license": "MIT",
+	"devDependencies": {
+		"@babel/plugin-proposal-decorators": "^7.28.0",
+		"@babel/preset-env": "^7.28.3",
+		"@rollup/plugin-alias": "^5.1.1",
+		"@rollup/plugin-babel": "^6.0.4",
+		"@rollup/plugin-commonjs": "^28.0.6",
+		"@rollup/plugin-node-resolve": "^16.0.1",
+		"@rollup/plugin-replace": "^6.0.2",
+		"@rollup/plugin-terser": "^0.4.4",
+		"@rollup/plugin-typescript": "^12.1.4",
+		"@types/node": "^24.2.1",
+		"@vitest/coverage-v8": "^3.2.4",
+		"oxlint": "^1.11.2",
+		"prettier": "^3.6.2",
+		"rimraf": "^6.0.1",
+		"rollup": "^4.46.2",
+		"rollup-plugin-dts": "^6.2.1",
+		"tslib": "^2.8.1",
+		"typescript": "^5.9.2",
+		"vitest": "^3.2.4"
+	}
+}