unreflect 0.0.1

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c)
+
+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,82 @@
+# unreflect
+
+<!-- automd:badges color=yellow -->
+
+[![npm version](https://img.shields.io/npm/v/unreflect?color=yellow)](https://npmjs.com/package/unreflect)
+[![npm downloads](https://img.shields.io/npm/dm/unreflect?color=yellow)](https://npm.chart.dev/unreflect)
+
+<!-- /automd -->
+
+Access and modify private class fields and methods in JavaScript using the V8 inspector API.
+
+## Installation
+
+```sh
+npx nypm install unreflect
+```
+
+## Usage
+
+```js
+import { ReflectionClass } from "unreflect";
+
+class User {
+  #name = "John";
+  public email = "john@example.com";
+
+  getName() {
+    return this.#name;
+  }
+}
+
+const user = new User();
+const ref = new ReflectionClass(user);
+
+// Get class name
+ref.getClassName(); // "User"
+
+// Get/set property values (public and private)
+await ref.getPropertyValue("name"); // "John"
+await ref.getPropertyValue("email"); // "john@example.com"
+
+ref.setProperty("name", "Jane");
+user.getName(); // "Jane"
+
+// Get property metadata
+await ref.getProperty("name");
+// { name: "name", visibility: "private", value: "Jane" }
+
+// List all properties
+await ref.getProperties();
+// [
+//   { name: "email", visibility: "public", value: "john@example.com" },
+//   { name: "name", visibility: "private" }
+// ]
+
+// List all methods (including private)
+await ref.getMethods();
+// [
+//   { name: "getName", visibility: "public", isStatic: false }
+// ]
+
+// Check existence
+await ref.hasProperty("name"); // true
+await ref.hasMethod("getName"); // true
+```
+
+## API
+
+| Method                     | Description                                         |
+| -------------------------- | --------------------------------------------------- |
+| `getClassName()`           | Returns the class name                              |
+| `setProperty(name, value)` | Sets a property value (public or private)           |
+| `getProperty(name)`        | Returns property metadata with visibility and value |
+| `getPropertyValue(name)`   | Returns just the property value                     |
+| `getProperties()`          | Returns all properties with visibility              |
+| `getMethods()`             | Returns all methods with visibility and static flag |
+| `hasProperty(name)`        | Checks if a property exists                         |
+| `hasMethod(name)`          | Checks if a method exists                           |
+
+## License
+
+Published under the [MIT](https://github.com/KABBOUCHI/unreflect/blob/main/LICENSE) license.

package/dist/index.d.mts

@@ -0,0 +1,27 @@
+//#region src/index.d.ts
+type PropertyVisibility = "public" | "private";
+interface ReflectionProperty {
+  name: string;
+  visibility: PropertyVisibility;
+  value?: any;
+}
+interface ReflectionMethod {
+  name: string;
+  visibility: PropertyVisibility;
+  isStatic: boolean;
+}
+declare class ReflectionClass {
+  private obj;
+  private values;
+  constructor(obj: any);
+  setProperty(name: string, value: any): void;
+  getProperty(name: string): Promise<ReflectionProperty | undefined>;
+  getPropertyValue(name: string): Promise<any>;
+  getClassName(): string;
+  getProperties(): Promise<ReflectionProperty[]>;
+  getMethods(): Promise<ReflectionMethod[]>;
+  hasProperty(name: string): Promise<boolean>;
+  hasMethod(name: string): Promise<boolean>;
+}
+//#endregion
+export { PropertyVisibility, ReflectionClass, ReflectionMethod, ReflectionProperty };

package/dist/index.mjs

@@ -0,0 +1,189 @@
+import vm from "node:vm";
+import inspector from "node:inspector/promises";
+
+//#region src/index.ts
+var ReflectionClass = class {
+	obj;
+	values = /* @__PURE__ */ new Map();
+	constructor(obj) {
+		this.obj = obj;
+	}
+	setProperty(name, value) {
+		const obj = this.obj;
+		if (Object.prototype.hasOwnProperty.call(obj, name)) {
+			obj[name] = value;
+			return;
+		}
+		const proto = Object.getPrototypeOf(obj);
+		const classSource = proto.constructor.toString();
+		if (!classSource.includes(`#${name}`)) {
+			obj[name] = value;
+			return;
+		}
+		const modifiedSource = classSource.replace(/#(\w+)\s*=\s*[^;]+;/g, "#$1;").replace(/^(class\s+\w+)\s*\{/, `$1 { static __reflectionSet__(obj, val) { obj.#${name} = val; } static __reflectionGet__(obj) { return obj.#${name}; }`);
+		const ModifiedClass = vm.runInThisContext(`(${modifiedSource})`);
+		Object.setPrototypeOf(obj, ModifiedClass.prototype);
+		const originalProps = Object.getOwnPropertyDescriptors(obj);
+		const freshInstance = new ModifiedClass();
+		for (const key of Object.getOwnPropertyNames(originalProps)) Object.defineProperty(freshInstance, key, originalProps[key]);
+		ModifiedClass.__reflectionSet__(freshInstance, value);
+		this.values.set(name, {
+			freshInstance,
+			ModifiedClass
+		});
+		Object.setPrototypeOf(obj, proto);
+		const methodNames = Object.getOwnPropertyNames(proto).filter((n) => n !== "constructor" && typeof proto[n] === "function");
+		for (const methodName of methodNames) if (proto[methodName].toString().includes(`#${name}`)) {
+			const boundMethod = ModifiedClass.prototype[methodName].bind(freshInstance);
+			Object.defineProperty(obj, methodName, {
+				value: boundMethod,
+				writable: true,
+				configurable: true
+			});
+		}
+	}
+	async getProperty(name) {
+		const obj = this.obj;
+		if (Object.prototype.hasOwnProperty.call(obj, name)) return {
+			name,
+			visibility: "public",
+			value: obj[name]
+		};
+		const id = `__ref_${Date.now()}_${Math.random().toString(36).slice(2)}__`;
+		globalThis[id] = obj;
+		const session = new inspector.Session();
+		session.connect();
+		try {
+			await session.post("Runtime.enable");
+			const { result } = await session.post("Runtime.evaluate", { expression: `globalThis.${id}` });
+			const privateProp = (await session.post("Runtime.getProperties", {
+				objectId: result.objectId,
+				ownProperties: true
+			})).privateProperties?.find((p) => p.name === `#${name}`);
+			if (!privateProp) return;
+			let value;
+			if (privateProp.value.type === "object" && privateProp.value.objectId) {
+				const extractId = `__extract_${Date.now()}_${Math.random().toString(36).slice(2)}__`;
+				await session.post("Runtime.callFunctionOn", {
+					objectId: privateProp.value.objectId,
+					functionDeclaration: `function() { globalThis.${extractId} = this; }`
+				});
+				value = globalThis[extractId];
+				delete globalThis[extractId];
+			} else value = privateProp.value.value;
+			return {
+				name,
+				visibility: "private",
+				value
+			};
+		} finally {
+			delete globalThis[id];
+			session.disconnect();
+		}
+	}
+	async getPropertyValue(name) {
+		const cached = this.values.get(name);
+		if (cached) return cached.ModifiedClass.__reflectionGet__(cached.freshInstance);
+		return (await this.getProperty(name))?.value;
+	}
+	getClassName() {
+		return Object.getPrototypeOf(this.obj).constructor.name;
+	}
+	async getProperties() {
+		const obj = this.obj;
+		const properties = [];
+		const publicProps = Object.getOwnPropertyNames(obj);
+		for (const name of publicProps) {
+			const descriptor = Object.getOwnPropertyDescriptor(obj, name);
+			if (descriptor && typeof descriptor.value !== "function") properties.push({
+				name,
+				visibility: "public",
+				value: descriptor.value
+			});
+		}
+		const id = `__ref_${Date.now()}_${Math.random().toString(36).slice(2)}__`;
+		globalThis[id] = obj;
+		const session = new inspector.Session();
+		session.connect();
+		try {
+			await session.post("Runtime.enable");
+			const { result } = await session.post("Runtime.evaluate", { expression: `globalThis.${id}` });
+			const props = await session.post("Runtime.getProperties", {
+				objectId: result.objectId,
+				ownProperties: true
+			});
+			if (props.privateProperties) for (const prop of props.privateProperties) {
+				const name = prop.name.replace(/^#/, "");
+				properties.push({
+					name,
+					visibility: "private"
+				});
+			}
+		} finally {
+			delete globalThis[id];
+			session.disconnect();
+		}
+		return properties;
+	}
+	async getMethods() {
+		const obj = this.obj;
+		const proto = Object.getPrototypeOf(obj);
+		const constructor = proto.constructor;
+		const methods = [];
+		const protoMethods = Object.getOwnPropertyNames(proto).filter((n) => n !== "constructor" && typeof proto[n] === "function");
+		for (const name of protoMethods) methods.push({
+			name,
+			visibility: "public",
+			isStatic: false
+		});
+		const staticMethods = Object.getOwnPropertyNames(constructor).filter((n) => typeof constructor[n] === "function" && ![
+			"length",
+			"name",
+			"prototype"
+		].includes(n));
+		for (const name of staticMethods) methods.push({
+			name,
+			visibility: "public",
+			isStatic: true
+		});
+		const id = `__ref_${Date.now()}_${Math.random().toString(36).slice(2)}__`;
+		globalThis[id] = obj;
+		const session = new inspector.Session();
+		session.connect();
+		try {
+			await session.post("Runtime.enable");
+			const { result } = await session.post("Runtime.evaluate", { expression: `globalThis.${id}` });
+			const privateMethods = (await session.post("Runtime.getProperties", {
+				objectId: result.objectId,
+				ownProperties: true
+			})).internalProperties?.find((p) => p.name === "[[PrivateMethods]]");
+			if (privateMethods?.value?.objectId) {
+				const methodsProps = await session.post("Runtime.getProperties", {
+					objectId: privateMethods.value.objectId,
+					ownProperties: true
+				});
+				for (const prop of methodsProps.result || []) {
+					const match = (prop.value?.description || "").match(/^#(\w+)\s*\(/);
+					if (match) methods.push({
+						name: match[1],
+						visibility: "private",
+						isStatic: false
+					});
+				}
+			}
+		} finally {
+			delete globalThis[id];
+			session.disconnect();
+		}
+		return methods;
+	}
+	async hasProperty(name) {
+		return (await this.getProperties()).some((p) => p.name === name);
+	}
+	async hasMethod(name) {
+		return (await this.getMethods()).some((m) => m.name === name);
+	}
+};
+
+//#endregion
+export { ReflectionClass };

package/package.json

@@ -0,0 +1,37 @@
+{
+  "name": "unreflect",
+  "version": "0.0.1",
+  "description": "Access and modify private class fields and methods in JavaScript",
+  "repository": "KABBOUCHI/unreflect",
+  "license": "MIT",
+  "sideEffects": false,
+  "type": "module",
+  "exports": {
+    ".": "./dist/index.mjs"
+  },
+  "types": "./dist/index.d.mts",
+  "files": [
+    "dist"
+  ],
+  "devDependencies": {
+    "@types/node": "^25.0.3",
+    "@vitest/coverage-v8": "^4.0.16",
+    "automd": "^0.4.2",
+    "changelogen": "^0.6.2",
+    "eslint": "^9.39.2",
+    "eslint-config-unjs": "^0.6.2",
+    "obuild": "^0.4.10",
+    "prettier": "^3.7.4",
+    "typescript": "^5.9.3",
+    "vitest": "^4.0.16"
+  },
+  "scripts": {
+    "build": "obuild",
+    "dev": "vitest dev",
+    "lint": "eslint . && prettier -c .",
+    "lint:fix": "automd && eslint . --fix && prettier -w .",
+    "release": "pnpm test && pnpm build && changelogen --release && npm publish && git push --follow-tags",
+    "test": "pnpm lint:fix && pnpm test:types && vitest run --coverage",
+    "test:types": "tsc --noEmit --skipLibCheck"
+  }
+}