unreflect 0.0.5 → 0.0.7

package/dist/index.d.mts

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

package/dist/index.mjs

@@ -1,4 +1,4 @@
-import inspector from "node:inspector/promises";
+import inspector from "node:inspector";
 
 //#region src/index.ts
 var ReflectionClass = class {
@@ -13,105 +13,7 @@ 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");
-	}
-	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) {
+	async setProperty(name, value) {
 		const obj = this.obj;
 		const isPrivate = this.isPrivateName(name);
 		const baseName = this.getBaseName(name);
@@ -121,52 +23,125 @@ var ReflectionClass = class {
 		}
 		this.values.set(name, value);
 		const proto = Object.getPrototypeOf(obj);
+		const classSource = proto.constructor.toString();
+		if (!(/* @__PURE__ */ new RegExp(`#${baseName}\\b`)).test(classSource)) return;
 		const protoDescriptors = Object.getOwnPropertyDescriptors(proto);
+		let targetGetterName = null;
+		let isGetter = true;
 		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 (descriptor.get) {
+				if (descriptor.get.toString().includes(`#${baseName}`)) {
+					targetGetterName = propName;
+					break;
 				}
 			}
+		}
+		if (!targetGetterName) for (const [propName, descriptor] of Object.entries(protoDescriptors)) {
+			if (propName === "constructor") continue;
+			if (descriptor.get) {
+				targetGetterName = propName;
+				break;
+			}
+		}
+		if (!targetGetterName) for (const [propName, descriptor] of Object.entries(protoDescriptors)) {
+			if (propName === "constructor") continue;
 			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
-					});
+				if (descriptor.value.toString().includes(`#${baseName}`)) {
+					targetGetterName = propName;
+					isGetter = false;
+					break;
 				}
 			}
 		}
+		if (!targetGetterName) for (const [propName, descriptor] of Object.entries(protoDescriptors)) {
+			if (propName === "constructor") continue;
+			if (typeof descriptor.value === "function") {
+				targetGetterName = propName;
+				isGetter = false;
+				break;
+			}
+		}
+		if (!targetGetterName) return;
+		const objId = `__reflection_obj_${Date.now()}_${Math.random().toString(36).slice(2)}__`;
+		const valId = `__reflection_val_${Date.now()}_${Math.random().toString(36).slice(2)}__`;
+		globalThis[objId] = obj;
+		globalThis[valId] = value;
+		const session = new inspector.Session();
+		session.connect();
+		const capturedGetterName = targetGetterName;
+		return new Promise((resolve, reject) => {
+			let resolved = false;
+			const cleanup = () => {
+				if (!resolved) {
+					resolved = true;
+					delete globalThis[objId];
+					delete globalThis[valId];
+					session.disconnect();
+				}
+			};
+			session.on("Debugger.paused", (message) => {
+				const frames = message.params.callFrames;
+				if (frames && frames.length > 0) {
+					const callFrameId = frames[0].callFrameId;
+					session.post("Debugger.evaluateOnCallFrame", {
+						callFrameId,
+						expression: `this.#${baseName} = globalThis["${valId}"]`
+					}, () => {
+						session.post("Debugger.resume", () => {
+							cleanup();
+							resolve();
+						});
+					});
+				}
+			});
+			session.post("Debugger.enable", (err) => {
+				if (err) {
+					cleanup();
+					reject(err);
+					return;
+				}
+				session.post("Runtime.enable", (err$1) => {
+					if (err$1) {
+						cleanup();
+						reject(err$1);
+						return;
+					}
+					session.post("Runtime.evaluate", { expression: `(function() {
+                const proto = Object.getPrototypeOf(globalThis["${objId}"]);
+                const desc = Object.getOwnPropertyDescriptor(proto, "${capturedGetterName}");
+                return ${isGetter} ? (desc && desc.get) : (desc && desc.value);
+              })()` }, (err$2, fnResult) => {
+						if (err$2 || !fnResult?.result?.objectId) {
+							cleanup();
+							reject(err$2 || /* @__PURE__ */ new Error("Failed to get getter function"));
+							return;
+						}
+						session.post("Debugger.setBreakpointOnFunctionCall", { objectId: fnResult.result.objectId }, (err$3, bpResult) => {
+							if (err$3) {
+								cleanup();
+								reject(err$3);
+								return;
+							}
+							const breakpointId = bpResult?.breakpointId;
+							setTimeout(() => {
+								try {
+									if (isGetter) obj[capturedGetterName];
+									else obj[capturedGetterName]();
+								} catch {}
+							}, 0);
+							setTimeout(() => {
+								if (!resolved) {
+									if (breakpointId) session.post("Debugger.removeBreakpoint", { breakpointId }, () => {});
+									cleanup();
+									reject(/* @__PURE__ */ new Error("Timeout waiting for breakpoint"));
+								}
+							}, 5e3);
+						});
+					});
+				});
+			});
+		});
 	}
 	async getProperty(name) {
 		const obj = this.obj;
@@ -189,33 +164,65 @@ var ReflectionClass = class {
 		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 === `#${baseName}`);
-			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; }`
+		return new Promise((resolve, reject) => {
+			session.post("Runtime.enable", (err) => {
+				if (err) {
+					delete globalThis[id];
+					session.disconnect();
+					reject(err);
+					return;
+				}
+				session.post("Runtime.evaluate", { expression: `globalThis.${id}` }, (err$1, evalResult) => {
+					if (err$1 || !evalResult?.result?.objectId) {
+						delete globalThis[id];
+						session.disconnect();
+						if (err$1) reject(err$1);
+						else resolve(void 0);
+						return;
+					}
+					session.post("Runtime.getProperties", {
+						objectId: evalResult.result.objectId,
+						ownProperties: true
+					}, (err$2, propsResult) => {
+						if (err$2) {
+							delete globalThis[id];
+							session.disconnect();
+							reject(err$2);
+							return;
+						}
+						const privateProp = propsResult.privateProperties?.find((p) => p.name === `#${baseName}`);
+						if (!privateProp) {
+							delete globalThis[id];
+							session.disconnect();
+							resolve(void 0);
+							return;
+						}
+						const extractValue = (prop, callback) => {
+							if ((prop.value.type === "object" || prop.value.type === "function") && prop.value.objectId) {
+								const extractId = `__extract_${Date.now()}_${Math.random().toString(36).slice(2)}__`;
+								session.post("Runtime.callFunctionOn", {
+									objectId: prop.value.objectId,
+									functionDeclaration: `function() { globalThis["${extractId}"] = this; }`
+								}, () => {
+									const value = globalThis[extractId];
+									delete globalThis[extractId];
+									callback(value);
+								});
+							} else callback(prop.value.value);
+						};
+						extractValue(privateProp, (value) => {
+							delete globalThis[id];
+							session.disconnect();
+							resolve({
+								name,
+								visibility: "private",
+								value
+							});
+						});
+					});
 				});
-				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) {
 		return (await this.getProperty(name))?.value;
@@ -239,34 +246,56 @@ var ReflectionClass = class {
 		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) properties.push({
-				name: prop.name,
-				visibility: "private"
+		return new Promise((resolve, reject) => {
+			session.post("Runtime.enable", (err) => {
+				if (err) {
+					delete globalThis[id];
+					session.disconnect();
+					reject(err);
+					return;
+				}
+				session.post("Runtime.evaluate", { expression: `globalThis.${id}` }, (err$1, evalResult) => {
+					if (err$1 || !evalResult?.result?.objectId) {
+						delete globalThis[id];
+						session.disconnect();
+						if (err$1) reject(err$1);
+						else resolve(properties);
+						return;
+					}
+					session.post("Runtime.getProperties", {
+						objectId: evalResult.result.objectId,
+						ownProperties: true
+					}, (err$2, propsResult) => {
+						delete globalThis[id];
+						session.disconnect();
+						if (err$2) {
+							reject(err$2);
+							return;
+						}
+						if (propsResult.privateProperties) for (const prop of propsResult.privateProperties) properties.push({
+							name: prop.name,
+							visibility: "private"
+						});
+						resolve(properties);
+					});
+				});
 			});
-		} 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 protoDescriptors = Object.getOwnPropertyDescriptors(proto);
+		for (const [name, descriptor] of Object.entries(protoDescriptors)) {
+			if (name === "constructor") continue;
+			if (typeof descriptor.value === "function") methods.push({
+				name,
+				visibility: "public",
+				isStatic: false
+			});
+		}
 		const staticMethods = Object.getOwnPropertyNames(constructor).filter((n) => typeof constructor[n] === "function" && ![
 			"length",
 			"name",
@@ -281,32 +310,63 @@ var ReflectionClass = class {
 		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
-					});
+		return new Promise((resolve, reject) => {
+			session.post("Runtime.enable", (err) => {
+				if (err) {
+					delete globalThis[id];
+					session.disconnect();
+					reject(err);
+					return;
 				}
-			}
-		} finally {
-			delete globalThis[id];
-			session.disconnect();
-		}
-		return methods;
+				session.post("Runtime.evaluate", { expression: `globalThis.${id}` }, (err$1, evalResult) => {
+					if (err$1 || !evalResult?.result?.objectId) {
+						delete globalThis[id];
+						session.disconnect();
+						if (err$1) reject(err$1);
+						else resolve(methods);
+						return;
+					}
+					session.post("Runtime.getProperties", {
+						objectId: evalResult.result.objectId,
+						ownProperties: true
+					}, (err$2, propsResult) => {
+						if (err$2) {
+							delete globalThis[id];
+							session.disconnect();
+							reject(err$2);
+							return;
+						}
+						const privateMethods = propsResult.internalProperties?.find((p) => p.name === "[[PrivateMethods]]");
+						if (!privateMethods?.value?.objectId) {
+							delete globalThis[id];
+							session.disconnect();
+							resolve(methods);
+							return;
+						}
+						session.post("Runtime.getProperties", {
+							objectId: privateMethods.value.objectId,
+							ownProperties: true
+						}, (err$3, methodsPropsResult) => {
+							delete globalThis[id];
+							session.disconnect();
+							if (err$3) {
+								reject(err$3);
+								return;
+							}
+							for (const prop of methodsPropsResult.result || []) {
+								const match = (prop.value?.description || "").match(/^(#\w+)\s*\(/);
+								if (match) methods.push({
+									name: match[1],
+									visibility: "private",
+									isStatic: false
+								});
+							}
+							resolve(methods);
+						});
+					});
+				});
+			});
+		});
 	}
 	async hasProperty(name) {
 		return await this.getProperty(name) !== void 0;

package/package.json

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