node-ctypes 1.3.0 → 1.4.0

package/lib/core/Library.js

@@ -74,6 +74,15 @@ export function createLibraryClasses(Library, LRUCache, _toNativeType, _toNative
           if (prop === "argtypes") return argtypes;
           if (prop === "restype") return restype;
           if (prop === "errcheck") return cachedFunc ? cachedFunc.errcheck : undefined;
+          if (prop === "callAsync") {
+            if (restype === undefined) {
+              throw new Error(`Function ${name}: restype not set`);
+            }
+            if (!cachedFunc) {
+              cachedFunc = cdll.func(name, restype, argtypes);
+            }
+            return cachedFunc.callAsync;
+          }
           return target[prop];
         },
         set(target, prop, value) {
@@ -172,39 +181,19 @@ export function createLibraryClasses(Library, LRUCache, _toNativeType, _toNative
       let callMethod;
 
       if (argCount === 0) {
-        // FAST PATH: No arguments - direct call
-        callMethod = function () {
-          return ffiFunc.call();
+        // FAST PATH: No declared arguments - but still support variadic
+        callMethod = function (...args) {
+          if (args.length === 0) {
+            return ffiFunc.call();
+          }
+          // Variadic: pass all args directly
+          return ffiFunc.call(...args);
         };
       } else if (allPrimitive) {
-        // FAST PATH: All primitive args - direct call without processing
-        switch (argCount) {
-          case 1:
-            callMethod = function (a0) {
-              return ffiFunc.call(a0);
-            };
-            break;
-          case 2:
-            callMethod = function (a0, a1) {
-              return ffiFunc.call(a0, a1);
-            };
-            break;
-          case 3:
-            callMethod = function (a0, a1, a2) {
-              return ffiFunc.call(a0, a1, a2);
-            };
-            break;
-          case 4:
-            callMethod = function (a0, a1, a2, a3) {
-              return ffiFunc.call(a0, a1, a2, a3);
-            };
-            break;
-          default:
-            // Fallback for many args
-            callMethod = function (...args) {
-              return ffiFunc.call(...args);
-            };
-        }
+        // FAST PATH: All primitive args - use rest args to support variadic
+        callMethod = function (...args) {
+          return ffiFunc.call(...args);
+        };
       } else {
         // SLOW PATH: Has buffer/struct args - need to extract _buffer
         callMethod = function (...args) {
@@ -237,11 +226,54 @@ export function createLibraryClasses(Library, LRUCache, _toNativeType, _toNative
         };
       }
 
+      // =========================================================================
+      // ASYNC WRAPPER: same argument processing, but calls callAsync
+      // Returns a Promise instead of the result directly
+      // =========================================================================
+
+      let asyncCallMethod;
+
+      if (argCount === 0) {
+        asyncCallMethod = function (...args) {
+          if (args.length === 0) {
+            return ffiFunc.callAsync();
+          }
+          // Variadic: pass all args directly
+          return ffiFunc.callAsync(...args);
+        };
+      } else if (allPrimitive) {
+        asyncCallMethod = function (...args) {
+          return ffiFunc.callAsync(...args);
+        };
+      } else {
+        asyncCallMethod = function (...args) {
+          const processedArgs = [];
+
+          for (let i = 0; i < args.length; i++) {
+            const arg = args[i];
+            if (arg && typeof arg === "object") {
+              if (arg._buffer !== undefined && Buffer.isBuffer(arg._buffer)) {
+                processedArgs.push(arg._buffer);
+              } else if (Buffer.isBuffer(arg)) {
+                processedArgs.push(arg);
+              } else {
+                processedArgs.push(arg);
+              }
+            } else {
+              processedArgs.push(arg);
+            }
+          }
+
+          return ffiFunc.callAsync(...processedArgs);
+        };
+      }
+
       // Aggiungi metadata come proprietà non-enumerable per non interferire
       Object.defineProperties(callMethod, {
         funcName: { value: name },
         address: { value: ffiFunc.address },
         _ffi: { value: ffiFunc },
+        callAsync: { value: asyncCallMethod, writable: false, enumerable: false, configurable: false },
         // Esponi errcheck come setter/getter
         errcheck: {
           get() {

package/lib/index.d.ts

@@ -79,6 +79,8 @@ export type ErrcheckCallback = (result: any, func: CallableFunction, args: any[]
 /** FFI function wrapper */
 export interface FFIFunction {
   (...args: any[]): any;
+  /** Async version: executes the native call on a worker thread, returns a Promise */
+  callAsync(...args: any[]): Promise<any>;
   readonly funcName: string;
   readonly address: bigint;
   errcheck: ErrcheckCallback | null;
@@ -87,7 +89,7 @@ export interface FFIFunction {
 /** CDLL - C calling convention library */
 export class CDLL {
   constructor(path: string | null);
-  func(name: string, returnType: AnyType, argTypes?: AnyType[], options?: FunctionOptions): CallableFunction & { errcheck: ErrcheckCallback | null };
+  func(name: string, returnType: AnyType, argTypes?: AnyType[], options?: FunctionOptions): CallableFunction & { callAsync(...args: any[]): Promise<any>; errcheck: ErrcheckCallback | null };
   symbol(name: string): bigint;
   close(): void;
   readonly path: string;
@@ -99,6 +101,8 @@ export class CDLL {
 /** FunctionWrapper for Python-like argtypes/restype syntax */
 export interface FunctionWrapper {
   (...args: any[]): any;
+  /** Async version: executes the native call on a worker thread, returns a Promise */
+  callAsync(...args: any[]): Promise<any>;
   argtypes: AnyType[];
   restype: AnyType;
   errcheck: ErrcheckCallback | null;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "node-ctypes",
-  "version": "1.3.0",
+  "version": "1.4.0",
   "description": "Python ctypes-like FFI for Node.js using libffi",
   "author": "Damiano Mazzella",
   "license": "MIT",