node-ctypes 1.1.0 → 1.2.0

package/lib/core/Library.js

@@ -130,8 +130,8 @@ class CDLL {
   /**
    * Ottiene una funzione dalla libreria
    * @param {string} name - Nome della funzione
-   * @param {string|CType} returnType - Tipo di ritorno
-   * @param {Array<string|CType>} argTypes - Tipi degli argomenti
+   * @param {Function|number|CType} returnType - Tipo di ritorno (SimpleCData class, CType value, o CType)
+   * @param {Array<Function|number|CType>} argTypes - Tipi degli argomenti
    * @param {Object} [options] - Opzioni aggiuntive (es. { abi: 'stdcall' })
    * @returns {Function} Funzione callable
    */
@@ -156,14 +156,7 @@ class CDLL {
       if (typeof t === "function" && t._isSimpleCData) {
         // SimpleCData types that are NOT pointers are primitive
         const typeName = t._type;
-        return typeName !== "pointer" && typeName !== "char_p" && typeName !== "wchar_p";
-      }
-      if (typeof t === "string") {
-        return t !== "pointer" && t !== "char_p" && t !== "wchar_p" && t !== "void_p";
-      }
-      // CType objects from native - check if it's a pointer type
-      if (t && typeof t === "object" && t.name) {
-        return !t.name.includes("pointer") && !t.name.includes("char_p");
+        return typeName !== native.CType.POINTER && typeName !== native.CType.STRING && typeName !== native.CType.WSTRING;
       }
       return false;
     });
@@ -271,8 +264,8 @@ class CDLL {
   /**
    * Crea un callback JS chiamabile da C
    * @param {Function} fn - Funzione JavaScript
-   * @param {string|CType} returnType - Tipo di ritorno
-   * @param {Array<string|CType>} argTypes - Tipi degli argomenti
+   * @param {Function|number|CType} returnType - Tipo di ritorno (SimpleCData class, CType value, o CType)
+   * @param {Array<Function|number|CType>} argTypes - Tipi degli argomenti
    * @returns {Object} Oggetto callback con proprietà pointer e metodi
    */
   callback(fn, returnType, argTypes = []) {

package/lib/core/callback.js

@@ -87,8 +87,8 @@ import { _toNativeType, _toNativeTypes } from "./types.js";
  *
  * @param {Function} fn - JavaScript function to wrap
  *   The function will receive converted arguments based on argTypes
- * @param {Function|Object} returnType - Return type (SimpleCData class or CType)
- * @param {Array<Function|Object>} argTypes - Argument types array
+ * @param {Function|Object|number} returnType - Return type (SimpleCData class, CType, or CType value)
+ * @param {Array<Function|Object|number>} argTypes - Argument types array
  * @param {Object} native - Native module reference (internal use)
  * @returns {Object} Callback wrapper with properties:
  *   - `pointer` (BigInt): Function pointer to pass to C
@@ -197,8 +197,8 @@ export function callback(fn, returnType, argTypes = [], native) {
  * @param {Function} fn - JavaScript function to wrap
  *   The function will be executed on Node.js's main thread regardless of
  *   which thread invokes the callback
- * @param {Function|Object} returnType - Return type (SimpleCData class or CType)
- * @param {Array<Function|Object>} argTypes - Argument types array
+ * @param {Function|Object|number} returnType - Return type (SimpleCData class, CType, or CType value)
+ * @param {Array<Function|Object|number>} argTypes - Argument types array
  * @param {Object} native - Native module reference (internal use)
  * @returns {Object} Callback wrapper with properties:
  *   - `pointer` (BigInt): Function pointer to pass to C

package/lib/core/types.js

@@ -11,14 +11,14 @@
  * @example
  * ```javascript
  * import { _toNativeType, _toNativeTypes } from './core/types.js';
- * import { c_int32, c_char_p } from './types/integers.js';
+ * import { c_int32, c_char_p, CType } from 'node-ctypes';
  *
- * // Convert single type
- * const nativeType = _toNativeType(c_int32); // Returns "int32"
+ * // Convert single type - returns numeric CType value
+ * const nativeType = _toNativeType(c_int32); // Returns CType.INT32 (5)
  *
  * // Convert array of types
  * const nativeTypes = _toNativeTypes([c_int32, c_char_p]);
- * // Returns ["int32", <native CType for c_char_p>]
+ * // Returns [CType.INT32, CType.STRING]
  * ```
  */
 
@@ -28,34 +28,36 @@
  *
  * **Type Conversion Rules**:
  * 1. **SimpleCData classes** (e.g., `c_int32`, `c_uint64`):
- *    - Most types → Convert to string type name (e.g., `"int32"`, `"uint64"`)
- *    - `c_char_p` and `c_wchar_p` → Convert to native CType for automatic string marshalling
+ *    - Returns the numeric CType value (e.g., `CType.INT32`, `CType.STRING`)
  *
  * 2. **Structure/Union classes**: Pass through unchanged for struct/union handling
  *
- * 3. **Native CType objects**: Pass through unchanged (already in native format)
+ * 3. **Numbers (CType values)**: Pass through unchanged (already in native format)
+ *
+ * 4. **Native CType objects**: Pass through unchanged (already in native format)
  *
  * **Python ctypes Compatibility**:
  * This function mimics Python's ctypes internal type normalization, ensuring that
  * type specifications work consistently whether passed as class constructors or
  * type objects.
  *
- * @param {Function|Object} type - Type specification to normalize
+ * @param {Function|Object|number} type - Type specification to normalize
  *   - SimpleCData class (e.g., `c_int32`)
  *   - Structure or Union class
+ *   - CType numeric value
  *   - Native CType object
- * @returns {string|Object} Normalized type for native FFI:
- *   - String type name for most SimpleCData types
- *   - Native CType object for string pointer types (c_char_p, c_wchar_p)
+ * @param {Object} native - Native module reference (unused but kept for API compatibility)
+ * @returns {number|Object} Normalized type for native FFI:
+ *   - Numeric CType value for SimpleCData types
  *   - Original value for Structure/Union/CType objects
  *
  * @example Basic type conversion
  * ```javascript
- * import { c_int32, c_float, c_char_p } from 'node-ctypes';
+ * import { c_int32, c_float, c_char_p, CType } from 'node-ctypes';
  *
- * _toNativeType(c_int32);  // Returns "int32"
- * _toNativeType(c_float);  // Returns "float"
- * _toNativeType(c_char_p); // Returns native.types.c_char_p (CType object)
+ * _toNativeType(c_int32);  // Returns CType.INT32 (5)
+ * _toNativeType(c_float);  // Returns CType.FLOAT (9)
+ * _toNativeType(c_char_p); // Returns CType.STRING (12)
  * ```
  *
  * @example Structure type pass-through
@@ -69,18 +71,20 @@
  * _toNativeType(Point); // Returns Point class unchanged
  * ```
  *
+ * @example Direct CType usage
+ * ```javascript
+ * import { CType } from 'node-ctypes';
+ *
+ * _toNativeType(CType.INT32); // Returns 5 (pass-through)
+ * ```
+ *
  * @private
  * @internal
  */
 export function _toNativeType(type, native) {
-  // SimpleCData classes: convert to string type names or native CTypes
+  // SimpleCData classes: return the numeric CType value directly
   if (typeof type === "function" && type._isSimpleCData) {
-    // String pointer types need native CType for automatic conversion
-    // This enables automatic marshalling between C strings and JS strings
-    if (type._type === "char_p") return native.types.c_char_p;
-    if (type._type === "wchar_p") return native.types.c_wchar_p;
-
-    // All other SimpleCData types: use string type name
+    // _type is now a numeric CType value from native.CType
     return type._type;
   }
 
@@ -92,6 +96,11 @@ export function _toNativeType(type, native) {
     return type;
   }
 
+  // Numbers (direct CType values): pass through unchanged
+  if (typeof type === "number") {
+    return type;
+  }
+
   // Native CType objects: pass through unchanged (already in correct format)
   return type;
 }
@@ -108,16 +117,16 @@ export function _toNativeType(type, native) {
  *
  * @param {Array|*} types - Array of type specifications, or non-array value
  * @param {Object} native - Native module reference for CType lookups
- * @returns {Array|*} Array of normalized types, or original value if not an array
+ * @returns {Array|*} Array of normalized types (CType values), or original value if not an array
  *
  * @example Function signature normalization
  * ```javascript
- * import { c_int32, c_char_p, c_void_p } from 'node-ctypes';
+ * import { c_int32, c_char_p, c_void_p, CType } from 'node-ctypes';
  *
  * // Normalize function argument types
  * const argTypes = [c_int32, c_char_p, c_void_p];
  * const normalized = _toNativeTypes(argTypes);
- * // Returns ["int32", <native c_char_p CType>, "void_p"]
+ * // Returns [CType.INT32, CType.STRING, CType.POINTER]
  * ```
  *
  * @example Non-array pass-through

package/lib/index.d.ts

@@ -9,14 +9,42 @@
 // Basic Types
 // =============================================================================
 
-/** Native CType object (internal C++ type representation) */
-export interface CType {
-  readonly size: number;
-  readonly name: string;
+/**
+ * CType - Object containing numeric type identifiers
+ * Single source of truth for type values
+ */
+export interface CTypeValues {
+  readonly VOID: number;
+  readonly INT8: number;
+  readonly UINT8: number;
+  readonly INT16: number;
+  readonly UINT16: number;
+  readonly INT32: number;
+  readonly UINT32: number;
+  readonly INT64: number;
+  readonly UINT64: number;
+  readonly FLOAT: number;
+  readonly DOUBLE: number;
+  readonly POINTER: number;
+  readonly STRING: number;
+  readonly WSTRING: number;
+  readonly WCHAR: number;
+  readonly BOOL: number;
+  readonly SIZE_T: number;
+  readonly SSIZE_T: number;
+  readonly LONG: number;
+  readonly ULONG: number;
+  readonly STRUCT: number;
+  readonly UNION: number;
+  readonly ARRAY: number;
+  readonly COUNT: number;
 }
 
-/** Any accepted type specification (CType object or SimpleCData class) */
-export type AnyType = CType | SimpleCDataConstructor;
+/** CType object with numeric type identifiers */
+export const CType: CTypeValues;
+
+/** Any accepted type specification (SimpleCData class, CType value, or struct/union) */
+export type AnyType = SimpleCDataConstructor | number | StructDef | UnionDef;
 
 // =============================================================================
 // Library & Function
@@ -315,7 +343,7 @@ export function WinError(code?: number): Error & { winerror: number };
 export interface SimpleCDataConstructor {
   new (value?: any): SimpleCDataInstance;
   readonly _size: number;
-  readonly _type: string;
+  readonly _type: number;  // CType numeric value from native module
   readonly _isSimpleCData: true;
   _reader(buf: Buffer, offset: number): any;
   _writer(buf: Buffer, offset: number, value: any): void;

package/lib/index.js

@@ -140,7 +140,7 @@ const native = require(nativeModulePath);
 _initConstants(native);
 
 // Re-esporta le classi native
-const { Version, Library, FFIFunction, Callback, ThreadSafeCallback, CType, StructType, ArrayType } = native;
+const { Version, Library, FFIFunction, Callback, ThreadSafeCallback, StructType, ArrayType, CType } = native;
 
 // ============================================================================
 // Type Normalization Helpers

package/lib/memory/pointer.js

@@ -56,8 +56,7 @@ export function addressOf(ptr, alloc, native) {
   if (Buffer.isBuffer(ptr)) {
     // Get the buffer's memory address
     const tempBuf = alloc(native.POINTER_SIZE);
-    // Use native.writeValue with string 'pointer' to avoid JS-level recursion
-    native.writeValue(tempBuf, "pointer", ptr, 0);
+    native.writeValue(tempBuf, native.CType.POINTER, ptr, 0);
     if (native.POINTER_SIZE === 8) return tempBuf.readBigUInt64LE(0);
     return BigInt(tempBuf.readUInt32LE(0));
   }

package/lib/types/SimpleCData.js

@@ -13,11 +13,11 @@
  *
  * @example Creating custom type
  * ```javascript
- * import { SimpleCData } from 'node-ctypes';
+ * import { SimpleCData, CType } from 'node-ctypes';
  *
  * class c_int32 extends SimpleCData {
  *   static _size = 4;
- *   static _type = 'int32';
+ *   static _type = CType.INT32;  // Numeric enum value from native module
  *   static _reader = (buf, off) => buf.readInt32LE(off);
  *   static _writer = (buf, off, val) => buf.writeInt32LE(val, off);
  * }
@@ -59,7 +59,7 @@ export function createSimpleCDataClass(alloc) {
    *
    * Subclasses must define:
    * - `static _size`: Size in bytes
-   * - `static _type`: Type name string
+   * - `static _type`: CType numeric value (from native.CType)
    * - `static _reader(buffer, offset)`: Function to read value from buffer
    * - `static _writer(buffer, offset, value)`: Function to write value to buffer
    *
@@ -76,7 +76,7 @@ export function createSimpleCDataClass(alloc) {
    * ```javascript
    * class c_uint8 extends SimpleCData {
    *   static _size = 1;
-   *   static _type = 'uint8';
+   *   static _type = CType.UINT8;  // Numeric enum from native module
    *   static _reader = (buf, off) => buf.readUInt8(off);
    *   static _writer = (buf, off, val) => buf.writeUInt8(val, off);
    * }
@@ -91,7 +91,7 @@ export function createSimpleCDataClass(alloc) {
    * ```javascript
    * class c_float extends SimpleCData {
    *   static _size = 4;
-   *   static _type = 'float';
+   *   static _type = CType.FLOAT;
    *   static _reader = (buf, off) => buf.readFloatLE(off);
    *   static _writer = (buf, off, val) => buf.writeFloatLE(val, off);
    * }

package/lib/types/primitives.js

@@ -4,7 +4,12 @@
  * @description Primitive C type definitions (integers, floats, chars, pointers).
  *
  * This module provides all primitive C types that extend SimpleCData. Each type
- * defines its size, type name, and read/write functions for buffer operations.
+ * defines its size, CType value, and read/write functions for buffer operations.
+ *
+ * **Type System**:
+ * All types use numeric CType values from the native module as their `_type`
+ * property. This enables efficient type passing to the native FFI layer without
+ * string lookups.
  *
  * **Python ctypes Compatibility**:
  * All types are compatible with Python's ctypes module equivalents.
@@ -58,8 +63,14 @@
 /**
  * Creates all primitive type classes with required dependencies injected.
  *
+ * Each type class has:
+ * - `_size`: Size in bytes
+ * - `_type`: CType numeric value (from native.CType)
+ * - `_reader`: Function to read value from buffer
+ * - `_writer`: Function to write value to buffer
+ *
  * @param {Class} SimpleCData - SimpleCData base class
- * @param {Object} native - Native module with POINTER_SIZE
+ * @param {Object} native - Native module with POINTER_SIZE and CType
  * @param {Function} addressOf - addressOf function for pointers
  * @param {Function} cstring - cstring function for c_char_p
  * @param {Function} wstring - wstring function for c_wchar_p
@@ -69,13 +80,16 @@
  * @private
  */
 export function createPrimitiveTypes(SimpleCData, native, addressOf, cstring, wstring, readCString, readWString) {
+  // Get CType from native module - single source of truth
+  const CType = native.CType;
+
   // ============================================================================
   // Void type
   // ============================================================================
 
   class c_void extends SimpleCData {
     static _size = 0;
-    static _type = "void";
+    static _type = CType.VOID;
     static _reader = (buf, off) => undefined;
     static _writer = (buf, off, val) => {};
   }
@@ -86,21 +100,21 @@ export function createPrimitiveTypes(SimpleCData, native, addressOf, cstring, ws
 
   class c_int8 extends SimpleCData {
     static _size = 1;
-    static _type = "int8";
+    static _type = CType.INT8;
     static _reader = (buf, off) => buf.readInt8(off);
     static _writer = (buf, off, val) => buf.writeInt8(val, off);
   }
 
   class c_int16 extends SimpleCData {
     static _size = 2;
-    static _type = "int16";
+    static _type = CType.INT16;
     static _reader = (buf, off) => buf.readInt16LE(off);
     static _writer = (buf, off, val) => buf.writeInt16LE(val, off);
   }
 
   class c_int32 extends SimpleCData {
     static _size = 4;
-    static _type = "int32";
+    static _type = CType.INT32;
     static _reader = (buf, off) => buf.readInt32LE(off);
     static _writer = (buf, off, val) => {
       const v = Number(val) | 0; // coerce to signed 32-bit
@@ -110,7 +124,7 @@ export function createPrimitiveTypes(SimpleCData, native, addressOf, cstring, ws
 
   class c_int64 extends SimpleCData {
     static _size = 8;
-    static _type = "int64";
+    static _type = CType.INT64;
     static _reader = (buf, off) => buf.readBigInt64LE(off);
     static _writer = (buf, off, val) => buf.writeBigInt64LE(BigInt(val), off);
   }
@@ -121,21 +135,21 @@ export function createPrimitiveTypes(SimpleCData, native, addressOf, cstring, ws
 
   class c_uint8 extends SimpleCData {
     static _size = 1;
-    static _type = "uint8";
+    static _type = CType.UINT8;
     static _reader = (buf, off) => buf.readUInt8(off);
     static _writer = (buf, off, val) => buf.writeUInt8(val, off);
   }
 
   class c_uint16 extends SimpleCData {
     static _size = 2;
-    static _type = "uint16";
+    static _type = CType.UINT16;
     static _reader = (buf, off) => buf.readUInt16LE(off);
     static _writer = (buf, off, val) => buf.writeUInt16LE(val, off);
   }
 
   class c_uint32 extends SimpleCData {
     static _size = 4;
-    static _type = "uint32";
+    static _type = CType.UINT32;
     static _reader = (buf, off) => buf.readUInt32LE(off);
     static _writer = (buf, off, val) => {
       const v = Number(val) >>> 0; // coerce to unsigned 32-bit
@@ -145,7 +159,7 @@ export function createPrimitiveTypes(SimpleCData, native, addressOf, cstring, ws
 
   class c_uint64 extends SimpleCData {
     static _size = 8;
-    static _type = "uint64";
+    static _type = CType.UINT64;
     static _reader = (buf, off) => buf.readBigUInt64LE(off);
     static _writer = (buf, off, val) => buf.writeBigUInt64LE(BigInt(val), off);
   }
@@ -156,14 +170,14 @@ export function createPrimitiveTypes(SimpleCData, native, addressOf, cstring, ws
 
   class c_float extends SimpleCData {
     static _size = 4;
-    static _type = "float";
+    static _type = CType.FLOAT;
     static _reader = (buf, off) => buf.readFloatLE(off);
     static _writer = (buf, off, val) => buf.writeFloatLE(val, off);
   }
 
   class c_double extends SimpleCData {
     static _size = 8;
-    static _type = "double";
+    static _type = CType.DOUBLE;
     static _reader = (buf, off) => buf.readDoubleLE(off);
     static _writer = (buf, off, val) => buf.writeDoubleLE(val, off);
   }
@@ -174,7 +188,7 @@ export function createPrimitiveTypes(SimpleCData, native, addressOf, cstring, ws
 
   class c_bool extends SimpleCData {
     static _size = 1;
-    static _type = "bool";
+    static _type = CType.BOOL;
     static _reader = (buf, off) => buf.readUInt8(off) !== 0;
     static _writer = (buf, off, val) => buf.writeUInt8(val ? 1 : 0, off);
   }
@@ -185,7 +199,7 @@ export function createPrimitiveTypes(SimpleCData, native, addressOf, cstring, ws
 
   class c_char extends SimpleCData {
     static _size = 1;
-    static _type = "char";
+    static _type = CType.INT8;  // char is int8 in C
     static _reader = (buf, off) => buf.readInt8(off);
     static _writer = (buf, off, val) => {
       if (typeof val === "string") val = val.charCodeAt(0);
@@ -195,7 +209,7 @@ export function createPrimitiveTypes(SimpleCData, native, addressOf, cstring, ws
 
   class c_wchar extends SimpleCData {
     static _size = native.WCHAR_SIZE;
-    static _type = "wchar";
+    static _type = CType.WCHAR;
     static _reader = (buf, off) => {
       if (native.WCHAR_SIZE === 2) {
         return String.fromCharCode(buf.readUInt16LE(off));
@@ -218,7 +232,7 @@ export function createPrimitiveTypes(SimpleCData, native, addressOf, cstring, ws
 
   class c_void_p extends SimpleCData {
     static _size = native.POINTER_SIZE;
-    static _type = "pointer";
+    static _type = CType.POINTER;
     static _reader = (buf, off) => {
       const ptr = native.POINTER_SIZE === 8 ? buf.readBigUInt64LE(off) : BigInt(buf.readUInt32LE(off));
       if (!ptr) return null;
@@ -257,7 +271,7 @@ export function createPrimitiveTypes(SimpleCData, native, addressOf, cstring, ws
 
   class c_size_t extends SimpleCData {
     static _size = native.POINTER_SIZE;
-    static _type = "size_t";
+    static _type = CType.SIZE_T;
     static _reader = (buf, off) => {
       return native.POINTER_SIZE === 8 ? buf.readBigUInt64LE(off) : buf.readUInt32LE(off);
     };
@@ -271,18 +285,18 @@ export function createPrimitiveTypes(SimpleCData, native, addressOf, cstring, ws
   }
 
   // Get actual long size from native module (4 on Windows, 4 or 8 on Unix depending on arch)
-  const _longSize = native.sizeof ? native.sizeof("long") : 4;
+  const _longSize = native.sizeof ? native.sizeof(CType.LONG) : 4;
 
   class c_long extends SimpleCData {
     static _size = _longSize;
-    static _type = "long";
+    static _type = CType.LONG;
     static _reader = _longSize === 8 ? (buf, off) => buf.readBigInt64LE(off) : (buf, off) => buf.readInt32LE(off);
     static _writer = _longSize === 8 ? (buf, off, val) => buf.writeBigInt64LE(BigInt(val), off) : (buf, off, val) => buf.writeInt32LE(val, off);
   }
 
   class c_ulong extends SimpleCData {
     static _size = _longSize;
-    static _type = "ulong";
+    static _type = CType.ULONG;
     static _reader = _longSize === 8 ? (buf, off) => buf.readBigUInt64LE(off) : (buf, off) => buf.readUInt32LE(off);
     static _writer = _longSize === 8 ? (buf, off, val) => buf.writeBigUInt64LE(BigInt(val), off) : (buf, off, val) => buf.writeUInt32LE(val, off);
   }
@@ -293,7 +307,7 @@ export function createPrimitiveTypes(SimpleCData, native, addressOf, cstring, ws
 
   class c_char_p extends SimpleCData {
     static _size = native.POINTER_SIZE;
-    static _type = "char_p";
+    static _type = CType.STRING;
     static _reader = (buf, off) => {
       const ptr = native.POINTER_SIZE === 8 ? buf.readBigUInt64LE(off) : BigInt(buf.readUInt32LE(off));
       if (!ptr) return null;
@@ -324,7 +338,7 @@ export function createPrimitiveTypes(SimpleCData, native, addressOf, cstring, ws
 
   class c_wchar_p extends SimpleCData {
     static _size = native.POINTER_SIZE;
-    static _type = "wchar_p";
+    static _type = CType.WSTRING;
     static _reader = (buf, off) => {
       const ptr = native.POINTER_SIZE === 8 ? buf.readBigUInt64LE(off) : BigInt(buf.readUInt32LE(off));
       if (!ptr) return null;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "node-ctypes",
-  "version": "1.1.0",
+  "version": "1.2.0",
   "description": "Python ctypes-like FFI for Node.js using libffi",
   "author": "Damiano Mazzella",
   "license": "MIT",
@@ -32,7 +32,7 @@
     "generate-ffi-headers": "node third-party/libffi_cmake/generate-headers.js"
   },
   "devDependencies": {
-    "cmake-js": "^7.4.0",
+    "cmake-js": "^8.0.0",
     "node-addon-api": "^8.5.0"
   },
   "engines": {