@iamevan/nobjc 0.0.1 → 0.0.3

package/dist/index.d.ts

@@ -1,4 +1,4 @@
-import { NobjcNative } from './native.js';
+import { NobjcNative } from "./native.js";
 declare class NobjcLibrary {
     [key: string]: NobjcObject;
     constructor(library: string);

package/dist/index.js

@@ -1,4 +1,5 @@
-import { LoadLibrary, GetClassObject, ObjcObject } from './native.js';
+import { LoadLibrary, GetClassObject, ObjcObject } from "./native.js";
+const NATIVE_OBJC_OBJECT = Symbol("nativeObjcObject");
 class NobjcLibrary {
     constructor(library) {
         const handler = {
@@ -9,56 +10,70 @@ class NobjcLibrary {
                     this.wasLoaded = true;
                 }
                 return new NobjcObject(GetClassObject(className));
-            }
+            },
         };
         return new Proxy({}, handler);
     }
 }
 function NobjcMethodNameToObjcSelector(methodName) {
-    return methodName.replace(/\$/g, ':');
+    return methodName.replace(/\$/g, ":");
 }
 // unused, might be useful for codegen later
 function ObjcSelectorToNobjcMethodName(selector) {
-    return selector.replace(/:/g, '$');
+    return selector.replace(/:/g, "$");
 }
 class NobjcObject {
     constructor(object) {
         const handler = {
             has(target, p) {
-                // guard against symbols
-                if (typeof p === 'symbol')
+                // Return true for the special Symbol to enable unwrapping
+                if (p === NATIVE_OBJC_OBJECT)
+                    return true;
+                // guard against other symbols
+                if (typeof p === "symbol")
                     return Reflect.has(target, p);
                 // toString is always present
-                if (p === 'toString')
+                if (p === "toString")
                     return true;
                 // check if the object responds to the selector
-                return target.$msgSend('respondsToSelector:', NobjcMethodNameToObjcSelector(p.toString()));
+                return target.$msgSend("respondsToSelector:", NobjcMethodNameToObjcSelector(p.toString()));
             },
-            get(_, methodName, receiver) {
+            get(target, methodName, receiver) {
+                // Return the underlying native object when Symbol is accessed
+                if (methodName === NATIVE_OBJC_OBJECT) {
+                    return target;
+                }
                 // guard against symbols
-                if (typeof methodName === 'symbol') {
+                if (typeof methodName === "symbol") {
                     return Reflect.get(object, methodName, receiver);
                 }
                 // handle toString separately
-                if (methodName === 'toString') {
-                    return () => String(object.$msgSend('description'));
+                if (methodName === "toString") {
+                    return () => String(object.$msgSend("description"));
                 }
                 if (!(methodName in receiver)) {
                     throw new Error(`Method ${methodName} not found on object ${receiver}`);
                 }
                 return new NobjcMethod(object, methodName);
-            }
+            },
         };
         return new Proxy(object, handler);
     }
 }
+function unwrapArg(arg) {
+    if (arg && typeof arg === "object" && NATIVE_OBJC_OBJECT in arg) {
+        return arg[NATIVE_OBJC_OBJECT];
+    }
+    return arg;
+}
 class NobjcMethod {
     constructor(object, methodName) {
         const selector = NobjcMethodNameToObjcSelector(methodName);
         // This cannot be an arrow function because we need to access `arguments`.
         function methodFunc() {
-            const result = object.$msgSend(selector, ...arguments);
-            if (typeof result == 'object' && result instanceof ObjcObject) {
+            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;

package/package.json

@@ -32,11 +32,13 @@
     "pretest": "npm run build",
     "test-native": "node ./scripts/test-native-code.js",
     "test-js": "node ./scripts/test-js-code.js",
-    "test": "npm run test-native && npm run test-js",
+    "test-string-lifetime": "node ./scripts/test-string-lifetime.js",
+    "test-object-arguments": "node ./scripts/test-object-arguments.js",
+    "test": "npm run test-native && npm run test-js && npm run test-string-lifetime && npm run test-object-arguments",
     "make-clangd-config": "node ./scripts/make-clangd-config.js",
-    "preinstall": "npm run build-scripts && npm run make-clangd-config"
+    "preinstall-disabled": "npm run build-scripts && npm run make-clangd-config"
   },
-  "version": "0.0.1",
+  "version": "0.0.3",
   "description": "Objective-C bridge for Node.js",
   "main": "dist/index.js",
   "devDependencies": {