unreflect 0.0.3 → 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
@@ -21,7 +20,29 @@ var ReflectionClass = class {
 		let braceDepth = 0;
 		let bracketDepth = 0;
 		let parenDepth = 0;
+		let inConstructor = false;
+		let constructorBraceDepth = 0;
 		for (const line of lines) {
+			if (/^\s*constructor\s*\(/.test(line)) {
+				inConstructor = true;
+				constructorBraceDepth = 0;
+				for (const ch of line) {
+					if (ch === "{") constructorBraceDepth++;
+					if (ch === "}") constructorBraceDepth--;
+				}
+				result.push(line.replace(/\{.*$/, "{}"));
+				if (constructorBraceDepth > 0) continue;
+				inConstructor = false;
+				continue;
+			}
+			if (inConstructor) {
+				for (const ch of line) {
+					if (ch === "{") constructorBraceDepth++;
+					if (ch === "}") constructorBraceDepth--;
+				}
+				if (constructorBraceDepth === 0) inConstructor = false;
+				continue;
+			}
 			const isMethod = /^\s*#\w+\s*\(/.test(line);
 			const fieldMatch = line.match(/^(\s*)(#\w+)/);
 			if (!isMethod && fieldMatch?.[1] !== void 0 && fieldMatch[2] && !skipUntilBalanced) {
@@ -79,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);
@@ -87,29 +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 methodNames = Object.getOwnPropertyNames(proto).filter((n) => n !== "constructor" && typeof proto[n] === "function");
-		for (const methodName of methodNames) if (proto[methodName].toString().includes(`#${baseName}`)) {
-			const boundMethod = ModifiedClass.prototype[methodName].bind(freshInstance);
-			Object.defineProperty(obj, methodName, {
-				value: boundMethod,
-				writable: true,
-				configurable: true
-			});
+		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") {
+				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: wrappedMethod,
+						writable: true,
+						configurable: true
+					});
+				}
+			}
 		}
 	}
 	async getProperty(name) {
@@ -124,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.3",
+  "version": "0.0.5",
   "description": "Access and modify private class fields and methods in JavaScript",
   "repository": "KABBOUCHI/unreflect",
   "license": "MIT",