koffi 2.7.0 → 2.7.2

package/CHANGELOG.md

@@ -4,6 +4,17 @@
 
 ### Koffi 2.7
 
+#### Koffi 2.7.2 (2024-01-15)
+
+- Add missing TypeScript declaration for `koffi.free()`
+- Fix TypeScript declaration of `koffi.encode()`
+- Try to improve compatibility with webpack
+
+#### Koffi 2.7.1 (2024-01-02)
+
+- Support C-like `int[3]` syntax for [fixed array types](input.md#fixed-size-c-arrays)
+- Refuse type specifiers with invalid tokens at the end (previously ignored)
+
 #### Koffi 2.7.0 (2023-12-21)
 
 - Support alternative [callback calling convention](callbacks.md#callback-types) in classic syntax

package/README.md

@@ -25,9 +25,9 @@ Go to the web site for more information: https://koffi.dev/
 
 # Project history
 
-You can consult the [changelog](https://koffi.dev/changes) on the official website.
+You can consult the [changelog](https://koffi.dev/changelog) on the official website.
 
-Major version increments can include breaking API changes, use the [migration guide](https://koffi.dev/changes#migration-guide) for more information.
+Major version increments can include breaking API changes, use the [migration guide](https://koffi.dev/changelog#migration-guide) for more information.
 
 # License
 

package/doc/functions.md

@@ -9,7 +9,7 @@ To declare functions, start by loading the shared library with `koffi.load(filen
 const koffi = require('koffi');
 
 const lib = koffi.load('/path/to/shared/library'); // File extension depends on platforms: .so, .dll, .dylib, etc.
-````
+```
 
 This library will be automatically unloaded once all references to it are gone (including all the functions that use it, as described below).
 

package/doc/input.md

@@ -336,6 +336,8 @@ try {
 
 ### Fixed-size C arrays
 
+*Changed in Koffi 2.7.1*
+
 Fixed-size arrays are declared with `koffi.array(type, length)`. Just like in C, they cannot be passed as functions parameters (they degenerate to pointers), or returned by value. You can however embed them in struct types.
 
 Koffi applies the following conversion rules when passing arrays to/from C:
@@ -350,13 +352,13 @@ See the example below:
 const koffi = require('koffi');
 
 // Those two structs are exactly the same, only the array conversion hint is different
-const Foo1 = koffi.struct('Foo', {
+const Foo1 = koffi.struct('Foo1', {
     i: 'int',
-    a16: koffi.array('int16_t', 8)
+    a16: koffi.array('int16_t', 2)
 });
-const Foo2 = koffi.struct('Foo', {
+const Foo2 = koffi.struct('Foo2', {
     i: 'int',
-    a16: koffi.array('int16_t', 8, 'Array')
+    a16: koffi.array('int16_t', 2, 'Array')
 });
 
 // Uses an hypothetical C function that just returns the struct passed as a parameter
@@ -367,6 +369,19 @@ console.log(ReturnFoo1({ i: 5, a16: [6, 8] })) // Prints { i: 5, a16: Int16Array
 console.log(ReturnFoo2({ i: 5, a16: [6, 8] })) // Prints { i: 5, a16: [6, 8] }
 ```
 
+You can also declare arrays with the C-like short syntax in type declarations, as shown below:
+
+```js
+const StructType = koffi.struct('StructType', {
+    f8: 'float [8]',
+    self4: 'StructType *[4]'
+});
+```
+
+```{note}
+The short C-like syntax was introduced in Koffi 2.7.1, use `koffi.array()` for older versions.
+```
+
 ### Fixed-size string buffers
 
 Koffi can also convert JS strings to fixed-sized arrays in the following cases:

package/doc/unions.md

@@ -49,8 +49,8 @@ const U = koffi.union('U', { i: 'int', str: 'char *' });
 
 const DoSomething = lib.func('void DoSomething(const char *type, U u)');
 
-DoSomething('int', { .i = 42 });
-DoSomething('string', { .str = 'Hello!' });
+DoSomething('int', { i: 42 });
+DoSomething('string', { str: 'Hello!' });
 ```
 
 ### Win32 example

package/index.d.ts

@@ -104,8 +104,8 @@ declare module 'koffi' {
     /** @deprecated */ export function handle(): IKoffiCType;
 
     export function pointer(ref: TypeSpec): IKoffiCType;
-    export function pointer(ref: TypeSpec, asteriskCount: number): IKoffiCType;
-    export function pointer(name: string, ref: TypeSpec, asteriskCount: number): IKoffiCType;
+    export function pointer(ref: TypeSpec, asteriskCount?: number): IKoffiCType;
+    export function pointer(name: string, ref: TypeSpec, asteriskCount?: number): IKoffiCType;
 
     export function out(type: TypeSpec): IKoffiCType;
     export function inout(type: TypeSpec): IKoffiCType;
@@ -131,7 +131,7 @@ declare module 'koffi' {
     export function decode(value: any, offset: number, type: TypeSpec): any;
     export function decode(value: any, offset: number, type: TypeSpec, len: number): any;
     export function address(value: any): bigint;
-    export function encode(ref: any, type: TypeSpec): void;
+    export function call(value: any, type: TypeSpec, ...args: any[]): any;
     export function encode(ref: any, type: TypeSpec, value: any): void;
     export function encode(ref: any, type: TypeSpec, value: any, len: number): void;
     export function encode(ref: any, offset: number, type: TypeSpec): void;
@@ -150,6 +150,8 @@ declare module 'koffi' {
     export function config(cfg: Record<string, unknown>): Record<string, unknown>;
     export function stats(): Record<string, unknown>;
 
+    export function free(value: any): void;
+
     export function errno(): number;
     export function errno(value: number): number;
 

package/index.js

@@ -69,17 +69,17 @@ var require_tools = __commonJS({
         try {
           crypto.randomFillSync(buf);
           let suffix = buf.toString("hex").padStart(8, "0");
-          let filename = `${prefix}.${suffix}`;
-          let file = fs2.createWriteStream(filename, { flags: "wx", mode: 420 });
-          return [filename, file];
+          let filename2 = `${prefix}.${suffix}`;
+          let file = fs2.createWriteStream(filename2, { flags: "wx", mode: 420 });
+          return [filename2, file];
         } catch (err) {
           if (err.code != "EEXIST")
             throw err;
         }
       }
     }
-    function extract_targz(filename, dest_dir, strip = 0) {
-      let reader = fs2.createReadStream(filename).pipe(zlib.createGunzip());
+    function extract_targz(filename2, dest_dir, strip = 0) {
+      let reader = fs2.createReadStream(filename2).pipe(zlib.createGunzip());
       return new Promise((resolve, reject) => {
         let header = null;
         let extended = {};
@@ -119,13 +119,13 @@ var require_tools = __commonJS({
               }
               data = data.subarray(0, header.size);
               if (header.type == "0" || header.type == "7") {
-                let filename2 = dest_dir + "/" + header.filename;
-                let dirname = path.dirname(filename2);
+                let filename3 = dest_dir + "/" + header.filename;
+                let dirname = path.dirname(filename3);
                 fs2.mkdirSync(dirname, { recursive: true, mode: 493 });
-                fs2.writeFileSync(filename2, data, { mode: header.mode });
+                fs2.writeFileSync(filename3, data, { mode: header.mode });
               } else if (header.type == "5") {
-                let filename2 = dest_dir + "/" + header.filename;
-                fs2.mkdirSync(filename2, { recursive: true, mode: header.mode });
+                let filename3 = dest_dir + "/" + header.filename;
+                fs2.mkdirSync(filename3, { recursive: true, mode: header.mode });
               } else if (header.type == "L") {
                 extended.filename = data.toString("utf-8").replace(/\0/g, "");
               } else if (header.type == "x") {
@@ -233,10 +233,10 @@ var require_tools = __commonJS({
       }
       return arch2;
     }
-    function read_file_header(filename, read) {
+    function read_file_header(filename2, read) {
       let fd = null;
       try {
-        let fd2 = fs2.openSync(filename);
+        let fd2 = fs2.openSync(filename2);
         let buf = Buffer.allocUnsafe(read);
         let len = fs2.readSync(fd2, buf);
         return buf.subarray(0, len);
@@ -378,8 +378,8 @@ var require_package = __commonJS({
   "build/dist/src/koffi/package.json"(exports2, module2) {
     module2.exports = {
       name: "koffi",
-      version: "2.7.0",
-      stable: "2.7.0",
+      version: "2.7.2",
+      stable: "2.7.2",
       description: "Fast and simple C FFI (foreign function interface) for Node.js",
       keywords: [
         "foreign",
@@ -527,24 +527,24 @@ try {
 } catch (err) {
 }
 if (native == null) {
+  let roots = [__dirname];
+  if (process.resourcesPath != null)
+    roots.push(process.resourcesPath);
   let names = [
     `/build/koffi/${process.platform}_${arch}/koffi.node`,
     `/koffi/${process.platform}_${arch}/koffi.node`,
     `/node_modules/koffi/build/koffi/${process.platform}_${arch}/koffi.node`
   ];
-  for (let name of names) {
-    if (fs.existsSync(__dirname + name)) {
-      native = require(__dirname + name);
-      break;
-    }
-  }
-  if (native == null && process.resourcesPath != null) {
+  for (let root of roots) {
     for (let name of names) {
-      if (fs.existsSync(process.resourcesPath + name)) {
-        native = require(process.resourcesPath + name);
+      let filename = root + name;
+      if (fs.existsSync(filename)) {
+        native = eval("require")(filename);
         break;
       }
     }
+    if (native != null)
+      break;
   }
 }
 if (native == null)

package/indirect.js

@@ -69,17 +69,17 @@ var require_tools = __commonJS({
         try {
           crypto.randomFillSync(buf);
           let suffix = buf.toString("hex").padStart(8, "0");
-          let filename = `${prefix}.${suffix}`;
-          let file = fs2.createWriteStream(filename, { flags: "wx", mode: 420 });
-          return [filename, file];
+          let filename2 = `${prefix}.${suffix}`;
+          let file = fs2.createWriteStream(filename2, { flags: "wx", mode: 420 });
+          return [filename2, file];
         } catch (err) {
           if (err.code != "EEXIST")
             throw err;
         }
       }
     }
-    function extract_targz(filename, dest_dir, strip = 0) {
-      let reader = fs2.createReadStream(filename).pipe(zlib.createGunzip());
+    function extract_targz(filename2, dest_dir, strip = 0) {
+      let reader = fs2.createReadStream(filename2).pipe(zlib.createGunzip());
       return new Promise((resolve, reject) => {
         let header = null;
         let extended = {};
@@ -119,13 +119,13 @@ var require_tools = __commonJS({
               }
               data = data.subarray(0, header.size);
               if (header.type == "0" || header.type == "7") {
-                let filename2 = dest_dir + "/" + header.filename;
-                let dirname = path.dirname(filename2);
+                let filename3 = dest_dir + "/" + header.filename;
+                let dirname = path.dirname(filename3);
                 fs2.mkdirSync(dirname, { recursive: true, mode: 493 });
-                fs2.writeFileSync(filename2, data, { mode: header.mode });
+                fs2.writeFileSync(filename3, data, { mode: header.mode });
               } else if (header.type == "5") {
-                let filename2 = dest_dir + "/" + header.filename;
-                fs2.mkdirSync(filename2, { recursive: true, mode: header.mode });
+                let filename3 = dest_dir + "/" + header.filename;
+                fs2.mkdirSync(filename3, { recursive: true, mode: header.mode });
               } else if (header.type == "L") {
                 extended.filename = data.toString("utf-8").replace(/\0/g, "");
               } else if (header.type == "x") {
@@ -233,10 +233,10 @@ var require_tools = __commonJS({
       }
       return arch2;
     }
-    function read_file_header(filename, read) {
+    function read_file_header(filename2, read) {
       let fd = null;
       try {
-        let fd2 = fs2.openSync(filename);
+        let fd2 = fs2.openSync(filename2);
         let buf = Buffer.allocUnsafe(read);
         let len = fs2.readSync(fd2, buf);
         return buf.subarray(0, len);
@@ -378,8 +378,8 @@ var require_package = __commonJS({
   "build/dist/src/koffi/package.json"(exports2, module2) {
     module2.exports = {
       name: "koffi",
-      version: "2.7.0",
-      stable: "2.7.0",
+      version: "2.7.2",
+      stable: "2.7.2",
       description: "Fast and simple C FFI (foreign function interface) for Node.js",
       keywords: [
         "foreign",
@@ -447,24 +447,24 @@ var arch = determine_arch();
 var triplet = `${process.platform}_${arch}`;
 var native = null;
 {
+  let roots = [__dirname];
+  if (process.resourcesPath != null)
+    roots.push(process.resourcesPath);
   let names = [
     `/build/koffi/${process.platform}_${arch}/koffi.node`,
     `/koffi/${process.platform}_${arch}/koffi.node`,
     `/node_modules/koffi/build/koffi/${process.platform}_${arch}/koffi.node`
   ];
-  for (let name of names) {
-    if (fs.existsSync(__dirname + name)) {
-      native = require(__dirname + name);
-      break;
-    }
-  }
-  if (native == null && process.resourcesPath != null) {
+  for (let root of roots) {
     for (let name of names) {
-      if (fs.existsSync(process.resourcesPath + name)) {
-        native = require(process.resourcesPath + name);
+      let filename = root + name;
+      if (fs.existsSync(filename)) {
+        native = eval("require")(filename);
         break;
       }
     }
+    if (native != null)
+      break;
   }
 }
 if (native == null)

package/package.json

@@ -1,7 +1,7 @@
 {
     "name": "koffi",
-    "version": "2.7.0",
-    "stable": "2.7.0",
+    "version": "2.7.2",
+    "stable": "2.7.2",
     "description": "Fast and simple C FFI (foreign function interface) for Node.js",
     "keywords": [
         "foreign",

package/src/core/libcc/brotli.cc

@@ -26,7 +26,7 @@
 
 namespace RG {
 
-class BrotliDecompressor: public StreamDecompressor {
+class BrotliDecompressor: public StreamDecoder {
     BrotliDecoderState *state = nullptr;
     bool done = false;
 
@@ -37,27 +37,23 @@ class BrotliDecompressor: public StreamDecompressor {
     Size out_len = 0;
 
 public:
-    BrotliDecompressor(StreamReader *reader) : StreamDecompressor(reader) {}
+    BrotliDecompressor(StreamReader *reader, CompressionType type);
     ~BrotliDecompressor();
 
-    bool Init(CompressionType type) override;
     Size Read(Size max_len, void *out_buf) override;
 };
 
-BrotliDecompressor::~BrotliDecompressor()
-{
-    if (state) {
-        BrotliDecoderDestroyInstance(state);
-    }
-}
-
-bool BrotliDecompressor::Init(CompressionType)
+BrotliDecompressor::BrotliDecompressor(StreamReader *reader, CompressionType)
+    : StreamDecoder(reader)
 {
     state = BrotliDecoderCreateInstance(nullptr, nullptr, nullptr);
     if (!state)
         throw std::bad_alloc();
+}
 
-    return true;
+BrotliDecompressor::~BrotliDecompressor()
+{
+    BrotliDecoderDestroyInstance(state);
 }
 
 Size BrotliDecompressor::Read(Size max_len, void *user_buf)
@@ -105,26 +101,19 @@ Size BrotliDecompressor::Read(Size max_len, void *user_buf)
     RG_UNREACHABLE();
 }
 
-class BrotliCompressor: public StreamCompressor {
+class BrotliCompressor: public StreamEncoder {
     BrotliEncoderStateStruct *state = nullptr;
 
 public:
-    BrotliCompressor(StreamWriter *writer) : StreamCompressor(writer) {}
+    BrotliCompressor(StreamWriter *writer, CompressionType type, CompressionSpeed speed);
     ~BrotliCompressor();
 
-    bool Init(CompressionType type, CompressionSpeed speed) override;
     bool Write(Span<const uint8_t> buf) override;
     bool Finalize() override;
 };
 
-BrotliCompressor::~BrotliCompressor()
-{
-    if (state) {
-        BrotliEncoderDestroyInstance(state);
-    }
-}
-
-bool BrotliCompressor::Init(CompressionType, CompressionSpeed speed)
+BrotliCompressor::BrotliCompressor(StreamWriter *writer, CompressionType, CompressionSpeed speed)
+    : StreamEncoder(writer)
 {
     state = BrotliEncoderCreateInstance(nullptr, nullptr, nullptr);
     if (!state)
@@ -137,8 +126,11 @@ bool BrotliCompressor::Init(CompressionType, CompressionSpeed speed)
         case CompressionSpeed::Slow: { BrotliEncoderSetParameter(state, BROTLI_PARAM_QUALITY, 11); } break;
         case CompressionSpeed::Fast: { BrotliEncoderSetParameter(state, BROTLI_PARAM_QUALITY, 0); } break;
     }
+}
 
-    return true;
+BrotliCompressor::~BrotliCompressor()
+{
+    BrotliEncoderDestroyInstance(state);
 }
 
 bool BrotliCompressor::Write(Span<const uint8_t> buf)