unreflect 0.0.2 → 0.0.4

package/dist/index.d.mts

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

package/dist/index.mjs

@@ -14,6 +14,93 @@ var ReflectionClass = class {
 	getBaseName(name) {
 		return name.startsWith("#") ? name.slice(1) : name;
 	}
+	stripPrivateInitializers(source) {
+		const lines = source.split("\n");
+		const result = [];
+		let skipUntilBalanced = false;
+		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) {
+				result.push(fieldMatch[1] + fieldMatch[2]);
+				if (line.includes("=")) {
+					for (const ch of line) switch (ch) {
+						case "{":
+							braceDepth++;
+							break;
+						case "}":
+							braceDepth--;
+							break;
+						case "[":
+							bracketDepth++;
+							break;
+						case "]":
+							bracketDepth--;
+							break;
+						case "(":
+							parenDepth++;
+							break;
+						case ")":
+							parenDepth--;
+							break;
+					}
+					if (braceDepth > 0 || bracketDepth > 0 || parenDepth > 0) skipUntilBalanced = true;
+				}
+				continue;
+			}
+			if (skipUntilBalanced) {
+				for (const ch of line) switch (ch) {
+					case "{":
+						braceDepth++;
+						break;
+					case "}":
+						braceDepth--;
+						break;
+					case "[":
+						bracketDepth++;
+						break;
+					case "]":
+						bracketDepth--;
+						break;
+					case "(":
+						parenDepth++;
+						break;
+					case ")":
+						parenDepth--;
+						break;
+				}
+				if (braceDepth === 0 && bracketDepth === 0 && parenDepth === 0) skipUntilBalanced = false;
+				continue;
+			}
+			result.push(line);
+		}
+		return result.join("\n");
+	}
 	setProperty(name, value) {
 		const obj = this.obj;
 		const isPrivate = this.isPrivateName(name);
@@ -25,7 +112,7 @@ var ReflectionClass = class {
 		const proto = Object.getPrototypeOf(obj);
 		const classSource = proto.constructor.toString();
 		if (!classSource.includes(`#${baseName}`)) return;
-		const modifiedSource = classSource.replace(/#(\w+)\s*=\s*[^;]+;/g, "#$1;").replace(/^(class\s+\w+)\s*\{/, `$1 { static __reflectionSet__(obj, val) { obj.#${baseName} = val; } static __reflectionGet__(obj) { return obj.#${baseName}; }`);
+		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);
@@ -37,14 +124,35 @@ var ReflectionClass = class {
 			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 (typeof descriptor.value === "function") {
+				if (descriptor.value.toString().includes(`#${baseName}`)) {
+					const boundMethod = ModifiedClass.prototype[propName].bind(freshInstance);
+					Object.defineProperty(obj, propName, {
+						value: boundMethod,
+						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) {

package/package.json

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