node-ctypes 1.1.0 → 1.3.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.3.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": {