unreflect 0.0.4 → 0.0.5

package/dist/index.d.mts

@@ -17,6 +17,7 @@ declare class ReflectionClass {
   private isPrivateName;
   private getBaseName;
   private stripPrivateInitializers;
+  private createShadowMethod;
   setProperty(name: string, value: any): void;
   getProperty(name: string): Promise<ReflectionProperty | undefined>;
   getPropertyValue(name: string): Promise<any>;

package/dist/index.mjs

@@ -1,4 +1,3 @@
-import vm from "node:vm";
 import inspector from "node:inspector/promises";
 
 //#region src/index.ts
@@ -101,6 +100,17 @@ var ReflectionClass = class {
 		}
 		return result.join("\n");
 	}
+	createShadowMethod(originalMethod, baseName, shadowValues, privateName) {
+		const methodSource = originalMethod.toString();
+		if (methodSource.includes(`return this.#${baseName}`) || methodSource.includes(`return this.#${baseName};`)) return function(...args) {
+			if (shadowValues.has(privateName)) return shadowValues.get(privateName);
+			return originalMethod.apply(this, args);
+		};
+		return function(...args) {
+			if (shadowValues.has(privateName)) return shadowValues.get(privateName);
+			return originalMethod.apply(this, args);
+		};
+	}
 	setProperty(name, value) {
 		const obj = this.obj;
 		const isPrivate = this.isPrivateName(name);
@@ -109,50 +119,53 @@ var ReflectionClass = class {
 			obj[baseName] = value;
 			return;
 		}
+		this.values.set(name, value);
 		const proto = Object.getPrototypeOf(obj);
-		const classSource = proto.constructor.toString();
-		if (!classSource.includes(`#${baseName}`)) return;
-		const modifiedSource = this.stripPrivateInitializers(classSource).replace(/^(class(?:\s+\w+)?)\s*\{/, `$1 { static __reflectionSet__(obj, val) { obj.#${baseName} = val; } static __reflectionGet__(obj) { return obj.#${baseName}; }`);
-		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 protoDescriptors = Object.getOwnPropertyDescriptors(proto);
 		for (const [propName, descriptor] of Object.entries(protoDescriptors)) {
 			if (propName === "constructor") continue;
+			if (descriptor.get || descriptor.set) {
+				const getterSource = descriptor.get?.toString() || "";
+				const setterSource = descriptor.set?.toString() || "";
+				if (getterSource.includes(`#${baseName}`) || setterSource.includes(`#${baseName}`)) {
+					const shadowValues = this.values;
+					const privateName = name;
+					const originalGetter = descriptor.get;
+					const originalSetter = descriptor.set;
+					const newDescriptor = {
+						configurable: true,
+						enumerable: descriptor.enumerable
+					};
+					if (originalGetter) newDescriptor.get = function() {
+						if (shadowValues.has(privateName)) return shadowValues.get(privateName);
+						return originalGetter.call(this);
+					};
+					if (originalSetter) newDescriptor.set = function(val) {
+						shadowValues.set(privateName, val);
+					};
+					Object.defineProperty(obj, propName, newDescriptor);
+				}
+			}
 			if (typeof descriptor.value === "function") {
-				if (descriptor.value.toString().includes(`#${baseName}`)) {
-					const boundMethod = ModifiedClass.prototype[propName].bind(freshInstance);
+				const methodSource = descriptor.value.toString();
+				if (methodSource.includes(`#${baseName}`)) {
+					const shadowValues = this.values;
+					const privateName = name;
+					const originalMethod = descriptor.value;
+					const isSimpleGetter = methodSource.includes(`return this.#${baseName}`) || methodSource.includes(`return this.#${baseName};`);
+					let wrappedMethod;
+					if (isSimpleGetter) wrappedMethod = function(...args) {
+						if (shadowValues.has(privateName)) return shadowValues.get(privateName);
+						return originalMethod.apply(this, args);
+					};
+					else wrappedMethod = this.createShadowMethod(originalMethod, baseName, shadowValues, privateName);
 					Object.defineProperty(obj, propName, {
-						value: boundMethod,
+						value: wrappedMethod,
 						writable: true,
 						configurable: true
 					});
 				}
 			}
-			if (descriptor.get || descriptor.set) {
-				const getterSource = descriptor.get?.toString() || "";
-				const setterSource = descriptor.set?.toString() || "";
-				if (getterSource.includes(`#${baseName}`) || setterSource.includes(`#${baseName}`)) {
-					const modifiedDescriptor = Object.getOwnPropertyDescriptor(ModifiedClass.prototype, propName);
-					if (modifiedDescriptor) {
-						const newDescriptor = {
-							configurable: true,
-							enumerable: descriptor.enumerable
-						};
-						if (modifiedDescriptor.get) newDescriptor.get = modifiedDescriptor.get.bind(freshInstance);
-						if (modifiedDescriptor.set) newDescriptor.set = modifiedDescriptor.set.bind(freshInstance);
-						Object.defineProperty(obj, propName, newDescriptor);
-					}
-				}
-			}
 		}
 	}
 	async getProperty(name) {
@@ -167,11 +180,10 @@ var ReflectionClass = class {
 			};
 			return;
 		}
-		const cached = this.values.get(name);
-		if (cached) return {
+		if (this.values.has(name)) return {
 			name,
 			visibility: "private",
-			value: cached.ModifiedClass.__reflectionGet__(cached.freshInstance)
+			value: this.values.get(name)
 		};
 		const id = `__ref_${Date.now()}_${Math.random().toString(36).slice(2)}__`;
 		globalThis[id] = obj;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "unreflect",
-  "version": "0.0.4",
+  "version": "0.0.5",
   "description": "Access and modify private class fields and methods in JavaScript",
   "repository": "KABBOUCHI/unreflect",
   "license": "MIT",