reorganize types

Author: xan105

README.md

@@ -19,7 +19,7 @@ import { dlopen } from "@xan105/ffi/napi";
 import { dlopen } from "@xan105/ffi/koffi";
 
 const lib = dlopen("libm", {
-  "ceil": { 
+  ceil: { 
     result: "double", 
     parameters: [ "double" ] 
   }
@@ -41,6 +41,37 @@ const MB_ICONINFORMATION = 0x40;
 MessageBoxA(null, "Hello World!", "Message", MB_ICONINFORMATION);
 ```
 
+Callback with Deno like syntax
+
+```
+import { dlopen, Callback} from "@xan105/ffi/koffi";
+
+const library = dlopen(
+  "./callback.so",
+  {
+    set_status_callback: {
+      parameters: ["function"],
+      result: "void"
+    },
+    start_long_operation: {
+      parameters: [],
+      result: "void"
+    }
+  }
+);
+
+const callback = new Callback(
+  {
+    parameters: ["u8"],
+    result: "void",
+  },
+  (success) => {}
+);
+
+library.set_status_callback(callback.pointer);
+library.start_long_operation();
+```
+
 Install
 =======
 
@@ -168,22 +199,50 @@ await lib.XInputEnable(1);
 
 #### `const types: object`
 
-The FFI Library's primitive types as well as corresponding alias such as Windows specific types (DWORD,...) are exposed for convenience.
+The FFI Library's primitive types as well as corresponding alias are exposed for convenience.
+Such as Deno types (rust) and Windows specific types (DWORD,...).
+
+💡 Windows specific types are grouped together under `win32`.
 
 ```js
-import { types } from "@xan105/ffi/napi";
-//or
-import { types } from "@xan105/ffi/koffi";
+import { types } from "@xan105/ffi/[ napi | koffi ]";
+const { DWORD, LPCSTR } = types.win32;
 ```
 
-When using `koffi` alias are also set with `koffi.alias()`.
+💡 When using `koffi` alias are also set with `koffi.alias()` so you can use them as string.
 
 ```js
 import { load } from "@xan105/ffi/koffi";
 const call = load("user32.dll", { abi: "stdcall" });
 const MessageBoxA = call("MessageBoxA", "int", ["void *", "LPCSTR", "LPCSTR", "uint"]);
 ```
 
+⚠️ Types are not exposed under their own namespace because some words are illegal or already in use in JavaScript.
+You can still use destructuring if needed as long as the name is "allowed".
+
+❌ No
+
+```
+import { i32 } from "@xan105/ffi/koffi/types"
+```
+
+✔️ Yes
+```
+import { types } from "@xan105/ffi/koffi"
+const { i32 } = types;
+```
+
+🚫 Forbidden
+
+```
+import { function } from "@xan105/ffi/napi/types"
+```
+
+```
+import { types } from "@xan105/ffi/napi"
+const { function } = types;
+```
+
 #### `class Callback`
 
 Create a callback to be called at a later time (registered callback).
@@ -200,6 +259,10 @@ This is a class wrapper to the FFI library's callback function(s) inspired by De
 
   The pointer to the callback.
 
+  - `address: number | BigInt | null`
+  
+  The memory address of the pointer.
+  
   - `type: unknown`
 
   The type of the callback.
@@ -217,14 +280,11 @@ This is a class wrapper to the FFI library's callback function(s) inspired by De
 ##### Example
 
 ```js
-const callback = new Callback(
-  { parameters: [], result: "void" },
-  () => {},
-);
+import { dlopen, types, Callback } from "@xan105/ffi/...";
 
 const library = dlopen("./callback.so", {
     setCallback: {
-      parameters: [callback.type],
+      parameters: [types.function],
       result: "void",
     },
     doSomething(): {
@@ -233,6 +293,11 @@ const library = dlopen("./callback.so", {
     },
 });
 
+const callback = new Callback(
+  { parameters: [], result: "void" },
+  () => {},
+);
+
 library.setCallback(callback.pointer);
 library.doSomething();
 
@@ -243,6 +308,8 @@ callback.close();
 You can also register the callback at a later time:
 
 ```js
+import { dlopen, Callback } from "@xan105/ffi/...";
+
 const callback = new Callback(
   { parameters: [], result: "void" }
 );

lib/ffi-napi/index.js

@@ -5,13 +5,14 @@ found in the LICENSE file in the root directory of this source tree.
 */
 
 import ref from "ref-napi";
-import * as windows from "./types/windows.js";
-import * as rust from "./types/rust.js";
+import * as win32 from "./types/windows.js";
+import * as deno from "./types/deno.js";
 
 export * from "./open.js";
 export * from "./helper.js";
-export const types = {
+export const types = Object.assign(Object.create(null), {
+  pointer: ref.refType(ref.types.void),
   ...ref.types,
-  ...windows,
-  ...rust
-};
+  ...deno.types,
+  win32
+});

lib/ffi-napi/types/deno.js

@@ -0,0 +1,22 @@
+/*
+Copyright (c) Anthony Beaumont
+This source code is licensed under the MIT License
+found in the LICENSE file in the root directory of this source tree.
+*/
+
+import ref from "ref-napi";
+
+export const types = Object.assign(Object.create(null), {
+  i8 : ref.types.int8,
+  u8 : ref.types.uint8,
+  i16 : ref.types.int16,
+  u16 : ref.types.uint16,
+  i32 : ref.types.int32,
+  u32 : ref.types.uint32,
+  i64 : ref.types.int64,	
+  u64 : ref.types.uint64,	
+  usize : ref.types.size_t,	
+  f32 : ref.types.float,
+  f64 : ref.types.double,
+  "function" : ref.refType(ref.types.void)
+});

lib/ffi-napi/types/rust.js

@@ -33,7 +33,7 @@ export const ULONG_PTR = _WIN64 ? ref.refType(ref.types.uint64) : ref.refType(re
 
 export const BOOL = ref.types.int;
 export const BOOLEAN = ref.types.bool;
-export const CALLBACK = ref.types.pointer;
+export const CALLBACK = ref.refType(ref.types.void);
 export const CCHAR = ref.types.uint8;
 export const CHAR = ref.types.uint8;
 export const COLORREF = DWORD;
@@ -107,8 +107,8 @@ export const LPDWORD = ref.refType(ref.types.uint16);
 export const LPHANDLE = _WIN64 ? ref.refType(ref.types.int64) : ref.refType(ref.types.int32);
 export const LPINT = ref.refType(ref.types.int);
 export const LPLONG = ref.refType(ref.types.int32);
-export const LPMSG = ref.types.pointer;
-export const LPPOINT = ref.types.pointer;
+export const LPMSG = ref.refType(ref.types.void);
+export const LPPOINT = ref.refType(ref.types.void);
 export const LPSTR = ref.refType(ref.types.char);
 export const LPWSTR = ref.refType(ref.types.uint16);
 export const LPTSTR = ref.refType(ref.types.uint16);
@@ -127,7 +127,7 @@ export const PDWORD_PTR = DWORD_PTR;
 export const PDWORD32 = ref.refType(ref.types.uint32);
 export const PDWORD64 = ref.refType(ref.types.uint64);
 export const PFLOAT = ref.refType(ref.types.float);
-export const PHALF_PTR = ref.types.pointer;
+export const PHALF_PTR = ref.refType(ref.types.void);
 export const PHANDLE = _WIN64 ? ref.refType(ref.refType(ref.types.uint64)) : ref.refType(ref.refType(ref.types.uint32));
 export const PHKEY = _WIN64 ? ref.refType(ref.refType(ref.types.uint64)) : ref.refType(ref.refType(ref.types.uint32));
 export const PINT = ref.refType(ref.types.int);
@@ -139,22 +139,22 @@ export const PINT64 = ref.refType(ref.types.int64);
 export const PLCID = ref.refType(ref.types.uint32);
 export const PLONG = ref.refType(ref.types.long);
 export const PLONGLONG = ref.refType(ref.types.int64);
-export const PLONG_PTR = ref.types.pointer;
+export const PLONG_PTR = ref.refType(ref.types.void);
 export const PLONG32 = ref.refType(ref.types.int32);
 export const PLONG64 = ref.refType(ref.types.int64);
 export const POINTER_32 = ref.refType(ref.types.int32);
 export const POINTER_64 = _WIN64 ? ref.refType(ref.types.int64) : ref.refType(ref.types.int32);
-export const POINTER_SIGNED = ref.types.pointer;
-export const POINTER_UNSIGNED = ref.types.pointer;
+export const POINTER_SIGNED = ref.refType(ref.types.void);
+export const POINTER_UNSIGNED = ref.refType(ref.types.void);
 export const PSHORT = ref.refType(ref.types.int16);
 export const PSIZE_T = ULONG_PTR;
-export const PSSIZE_T = ref.types.pointer;
+export const PSSIZE_T = ref.refType(ref.types.void);
 export const PSTR = ref.refType(ref.types.char);
 export const PTBYTE = ref.refType(ref.types.int16);
 export const PTCHAR = ref.refType(ref.types.uint16);
 export const PTSTR = ref.refType(ref.types.uint16);
-export const PUCHAR = ref.types.pointer;
-export const PUHALF_PTR = ref.types.pointer;
+export const PUCHAR = ref.refType(ref.types.void);
+export const PUHALF_PTR = ref.refType(ref.types.void);
 export const PUINT = ref.refType(ref.types.uint);
 export const PUINT_PTR = ref.refType(ref.refType(ref.types.uint));
 export const PUINT8 = ref.refType(ref.types.uint8);

lib/ffi-napi/types/windows.js

@@ -5,25 +5,29 @@ found in the LICENSE file in the root directory of this source tree.
 */
 
 import koffi from "koffi";
-import * as windows from "./types/windows.js";
-import * as rust from "./types/rust.js";
+import * as win32 from "./types/windows.js";
+import * as deno from "./types/deno.js";
 import { isWindows } from "@xan105/is";
 import { shouldObj } from "@xan105/is/assert";
 
-function setAlias(list){
-  shouldObj(list);
-  for (const [name, type] of Object.entries(list))
+const setAlias = function(types){  
+  shouldObj(types);
+  for (const [name, type] of Object.entries(types))
     if (koffi.types[name] === undefined) 
       koffi.alias(name, type);
-}
+};
 
-if (isWindows()) setAlias(windows);
-setAlias(rust);
+if (isWindows()) setAlias(win32);
+setAlias({
+  pointer: koffi.pointer(koffi.types.void),
+  ...deno.types
+});
 
 export * from "./open.js";
 export * from "./helper.js";
-export const types = {
+export const types = Object.assign(Object.create(null), {
+  pointer: koffi.pointer(koffi.types.void),
   ...koffi.types,
-  ...windows,
-  ...rust
-};
+  ...deno.types,
+  win32
+});

lib/koffi/index.js

@@ -0,0 +1,22 @@
+/*
+Copyright (c) Anthony Beaumont
+This source code is licensed under the MIT License
+found in the LICENSE file in the root directory of this source tree.
+*/
+
+import koffi from "koffi";
+
+export const types = Object.assign(Object.create(null), {
+  i8 : koffi.types.int8,
+  u8 : koffi.types.uint8, 
+  i16 : koffi.types.int16,
+  u16 : koffi.types.uint16,
+  i32 : koffi.types.int32,
+  u32 : koffi.types.uint32,
+  i64 : koffi.types.int64,
+  u64 : koffi.types.uint64,	
+  usize : koffi.types.size_t,	
+  f32 : koffi.types.float,
+  f64 : koffi.types.double,
+  "function" : koffi.pointer(koffi.types.void)
+});