objc-js 0.0.6 → 0.0.8

package/dist/index.js

@@ -1,4 +1,5 @@
 import { LoadLibrary, GetClassObject, ObjcObject, GetPointer, FromPointer, CreateProtocolImplementation } from "./native.js";
+const customInspectSymbol = Symbol.for("nodejs.util.inspect.custom");
 const NATIVE_OBJC_OBJECT = Symbol("nativeObjcObject");
 class NobjcLibrary {
     constructor(library) {
@@ -24,6 +25,7 @@ function ObjcSelectorToNobjcMethodName(selector) {
 }
 class NobjcObject {
     constructor(object) {
+        // Create the proxy handler
         const handler = {
             has(target, p) {
                 // Return true for the special Symbol to enable unwrapping
@@ -36,7 +38,12 @@ class NobjcObject {
                 if (p === "toString")
                     return true;
                 // check if the object responds to the selector
-                return target.$msgSend("respondsToSelector:", NobjcMethodNameToObjcSelector(p.toString()));
+                try {
+                    return target.$msgSend("respondsToSelector:", NobjcMethodNameToObjcSelector(p.toString()));
+                }
+                catch (e) {
+                    return false;
+                }
             },
             get(target, methodName, receiver) {
                 // Return the underlying native object when Symbol is accessed
@@ -49,7 +56,29 @@ class NobjcObject {
                 }
                 // handle toString separately
                 if (methodName === "toString") {
-                    return () => String(object.$msgSend("description"));
+                    // if the receiver has a UTF8String method, use it to get the string representation
+                    if ("UTF8String" in receiver) {
+                        return () => String(object.$msgSend("UTF8String"));
+                    }
+                    // Otherwise, use the description method
+                    return () => String(wrapObjCObjectIfNeeded(object.$msgSend("description")));
+                }
+                // handle other built-in Object.prototype properties
+                const builtInProps = [
+                    "constructor",
+                    "valueOf",
+                    "hasOwnProperty",
+                    "isPrototypeOf",
+                    "propertyIsEnumerable",
+                    "toLocaleString",
+                    "__proto__",
+                    "__defineGetter__",
+                    "__defineSetter__",
+                    "__lookupGetter__",
+                    "__lookupSetter__"
+                ];
+                if (builtInProps.includes(methodName)) {
+                    return Reflect.get(target, methodName);
                 }
                 if (!(methodName in receiver)) {
                     throw new Error(`Method ${methodName} not found on object ${receiver}`);
@@ -57,7 +86,12 @@ class NobjcObject {
                 return NobjcMethod(object, methodName);
             }
         };
-        return new Proxy(object, handler);
+        // Create the proxy
+        const proxy = new Proxy(object, handler);
+        // This is used to override the default inspect behavior for the object. (console.log)
+        object[customInspectSymbol] = () => proxy.toString();
+        // Return the proxy
+        return proxy;
     }
 }
 function unwrapArg(arg) {
@@ -66,6 +100,12 @@ function unwrapArg(arg) {
     }
     return arg;
 }
+function wrapObjCObjectIfNeeded(result) {
+    if (typeof result == "object" && result instanceof ObjcObject) {
+        return new NobjcObject(result);
+    }
+    return result;
+}
 // Note: This is actually a factory function that returns a callable Proxy
 const NobjcMethod = function (object, methodName) {
     const selector = NobjcMethodNameToObjcSelector(methodName);
@@ -73,10 +113,7 @@ const NobjcMethod = function (object, methodName) {
     function methodFunc() {
         const unwrappedArgs = Array.from(arguments).map(unwrapArg);
         const result = object.$msgSend(selector, ...unwrappedArgs);
-        if (typeof result == "object" && result instanceof ObjcObject) {
-            return new NobjcObject(result);
-        }
-        return result;
+        return wrapObjCObjectIfNeeded(result);
     }
     const handler = {};
     return new Proxy(methodFunc, handler);
@@ -87,19 +124,15 @@ class NobjcProtocol {
         const convertedMethods = {};
         for (const [methodName, impl] of Object.entries(methodImplementations)) {
             const selector = NobjcMethodNameToObjcSelector(methodName);
-            // Wrap the implementation to unwrap args and wrap return values
+            // Wrap the implementation to wrap args and unwrap return values
             convertedMethods[selector] = function (...args) {
-                const unwrappedArgs = args.map(unwrapArg);
-                const result = impl(...unwrappedArgs);
+                // Wrap native ObjcObject arguments in NobjcObject proxies
+                const wrappedArgs = args.map((arg) => {
+                    return wrapObjCObjectIfNeeded(arg);
+                });
+                const result = impl(...wrappedArgs);
                 // If the result is already a NobjcObject, unwrap it to get the native object
-                if (result && typeof result === "object" && NATIVE_OBJC_OBJECT in result) {
-                    return result[NATIVE_OBJC_OBJECT];
-                }
-                // If the result is a native ObjcObject, return it as-is
-                if (typeof result === "object" && result instanceof ObjcObject) {
-                    return result;
-                }
-                return result;
+                return unwrapArg(result);
             };
         }
         // Call native implementation

package/package.json

@@ -36,7 +36,7 @@
     "format": "prettier --write \"**/*.{ts,js,json,md}\"",
     "preinstall-disabled": "npm run build-scripts && npm run make-clangd-config"
   },
-  "version": "0.0.6",
+  "version": "0.0.8",
   "description": "Objective-C bridge for Node.js",
   "main": "dist/index.js",
   "devDependencies": {