koffi 2.5.9 → 2.5.10

package/CHANGELOG.md

@@ -4,6 +4,10 @@
 
 ### Koffi 2.5
 
+#### Koffi 2.5.10
+
+- Fix CMake regression when client has to build Koffi
+
 #### Koffi 2.5.9
 
 **Main changes:**

package/doc/packaging.md

@@ -6,42 +6,43 @@
 
 Koffi uses native modules to work. The NPM package contains binaries for various platforms and architectures, and the appropriate module is selected at runtime.
 
-In theory, the bundlers should be able to find recorgnize all native modules because they are explictly listed in the Javascript file, as static strings.
+In theory, the **packagers/bundlers should be able to find all native modules** because they are explictly listed in the Javascript file (as static strings) and package them somehow.
 
 If that is not the case, you can manually arrange to copy the `node_modules/koffi/build/koffi` directory next to your bundled script.
 
 Here is an example that would work:
 
 ```
-    koffi/
-        win32_x64/
-            koffi.node
-        linux_x64/
-            koffi.node
-        ...
-    MyBundle.js
+koffi/
+    win32_x64/
+        koffi.node
+    linux_x64/
+        koffi.node
+    ...
+MyBundle.js
 ```
 
 When running in Electron, Koffi will also try to find the native module in `process.resourcesPath`. For an Electron app you could do something like this
 
 ```
-    locales/
-    resources/
-        koffi/
-            darwin_arm64/
-                koffi.node
-            darwin_x64/
-                koffi.node
-    MyApp.exe
+locales/
+resources/
+    koffi/
+        win32_ia32/
+            koffi.node
+        win32_x64/
+            koffi.node
+        ...
+MyApp.exe
 ```
 
 ## Packaging examples
 
 ### Electron with electron-builder
 
-Packaging with electron-builder should work as-is:
+Packaging with electron-builder should work as-is.
 
-You can also go take a look at the full [working example in the repository](https://github.com/Koromix/rygel/tree/master/src/koffi/examples/electron-builder).
+Take a look at the full [working example in the repository](https://github.com/Koromix/rygel/tree/master/src/koffi/examples/electron-builder).
 
 ### Electron Forge
 
@@ -51,10 +52,20 @@ Packaging with Electron Force should work as-is, even when using webpack as conf
 npm init electron-app@latest my-app -- --template=webpack
 ```
 
-You can also go take a look at the full [working example in the repository](https://github.com/Koromix/rygel/tree/master/src/koffi/examples/electron-forge).
+Take a look at the full [working example in the repository](https://github.com/Koromix/rygel/tree/master/src/koffi/examples/electron-forge).
 
 ### NW.js
 
 Packagers such as nw-builder should work as-is.
 
 You can find a full [working example in the repository](https://github.com/Koromix/rygel/tree/master/src/koffi/examples/nwjs).
+
+### Node.js and esbuild
+
+You can easily tell esbuild to copy the native files with the copy loader and things should just work. Use something like:
+
+```sh
+esbuild index.js --platform=node --bundle --loader:.node=copy --outdir=dist/
+```
+
+You can find a full [working example in the repository](https://github.com/Koromix/rygel/tree/master/src/koffi/examples/node-esbuild).

package/package.json

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

package/src/core/libcc/libcc.cc

@@ -4832,7 +4832,8 @@ const char *GetTemporaryDirectory()
 
 #endif
 
-const char *FindConfigFile(const char *name, Allocator *alloc, LocalArray<const char *, 4> *out_possibilities)
+const char *FindConfigFile(Span<const char *const> names, Allocator *alloc,
+                           LocalArray<const char *, 4> *out_possibilities)
 {
     decltype(GetUserConfigPath) *funcs[] = {
         [](const char *name, Allocator *alloc) {
@@ -4850,16 +4851,19 @@ const char *FindConfigFile(const char *name, Allocator *alloc, LocalArray<const
     const char *filename = nullptr;
 
     for (const auto &func: funcs) {
-        const char *path = func(name, alloc);
+        for (const char *name: names) {
+            const char *path = func(name, alloc);
 
-        if (!path)
-            continue;
+            if (!path)
+                continue;
 
-        if (TestFile(path, FileType::File)) {
-            filename = path;
-        }
-        if (out_possibilities) {
-            out_possibilities->Append(path);
+            if (TestFile(path, FileType::File)) {
+                filename = path;
+            }
+            if (out_possibilities) {
+                out_possibilities->Append(path);
+                break;
+            }
         }
     }
 

package/src/core/libcc/libcc.hh

@@ -4114,7 +4114,8 @@ const char *GetUserCachePath(const char *name, Allocator *alloc); // Can return
 const char *GetSystemConfigPath(const char *name, Allocator *alloc);
 const char *GetTemporaryDirectory();
 
-const char *FindConfigFile(const char *name, Allocator *alloc, LocalArray<const char *, 4> *out_possibilities = nullptr);
+const char *FindConfigFile(Span<const char *const> names, Allocator *alloc,
+                           LocalArray<const char *, 4> *out_possibilities = nullptr);
 
 const char *CreateUniqueFile(Span<const char> directory, const char *prefix, const char *extension,
                              Allocator *alloc, FILE **out_fp = nullptr);

package/src/index.js

@@ -21,14 +21,14 @@
 
 'use strict';
 
-const cnoke = require('./cnoke/src/index.js');
 const util = require('util');
 const fs = require('fs');
+const { get_napi_version, determine_arch } = require('./cnoke/src/tools.js');
 const pkg = require('../package.json');
 
 if (process.versions.napi == null || process.versions.napi < pkg.cnoke.napi) {
     let major = parseInt(process.versions.node, 10);
-    let required = cnoke.get_napi_version(pkg.cnoke.napi, major);
+    let required = get_napi_version(pkg.cnoke.napi, major);
 
     if (required != null) {
         throw new Error(`Project ${pkg.name} requires Node >= ${required} in the Node ${major}.x branch (N-API >= ${pkg.cnoke.napi})`);
@@ -37,7 +37,7 @@ if (process.versions.napi == null || process.versions.napi < pkg.cnoke.napi) {
     }
 }
 
-let arch = cnoke.determine_arch();
+let arch = determine_arch();
 let triplet = `${process.platform}_${arch}`;
 
 let native = null;

package/src/koffi/CMakeLists.txt

@@ -47,7 +47,11 @@ endif()
 
 # ---- Koffi ----
 
-file(READ ${CMAKE_CURRENT_SOURCE_DIR}/package.json PKG)
+if(EXISTS ${CMAKE_CURRENT_SOURCE_DIR}/package.json)
+    file(READ ${CMAKE_CURRENT_SOURCE_DIR}/package.json PKG)
+else()
+    file(READ ${CMAKE_CURRENT_SOURCE_DIR}/../../package.json PKG)
+endif()
 string(REGEX MATCH "\"version\": \"([^\"]+)\"" XX "${PKG}")
 set(KOFFI_VERSION ${CMAKE_MATCH_1})
 

package/src/koffi/examples/electron-builder/README.md

@@ -3,18 +3,6 @@ This is a simple example shows:
 - How to communicate with Koffi from a renderer window
 - How to use electron-builder with an application that uses Koffi
 
-One of the important piece for the packaging is in `package.json`, specifically this part:
-
-```json
-  "build": {
-    "extraResources": [
-      { "from": "node_modules/koffi/build", "to": "koffi" }
-    ]
-  }
-```
-
-This instructs electron-builder to copy the native koffi modules to a place where your application will find them.
-
 Use the following commands to package the app for your system:
 
 ```sh

package/src/koffi/examples/electron-builder/package.json

@@ -1,5 +1,5 @@
 {
-  "name": "Koffi Config",
+  "name": "KoffiConfig",
   "version": "1.0.0",
   "description": "Koffi Electron Example",
   "main": "src/app.js",
@@ -16,6 +16,6 @@
     "esbuild": "^0.18.17"
   },
   "dependencies": {
-    "koffi": "^2.5.8"
+    "koffi": "^2.5.9"
   }
 }

package/src/koffi/examples/electron-forge/package.json

@@ -1,5 +1,5 @@
 {
-  "name": "Koffi Config",
+  "name": "KoffiConfig",
   "version": "1.0.0",
   "description": "Koffi Electron Example",
   "main": ".webpack/main",
@@ -32,6 +32,6 @@
   },
   "dependencies": {
     "electron-squirrel-startup": "^1.0.0",
-    "koffi": "^2.5.8"
+    "koffi": "^2.5.9"
   }
 }

package/src/koffi/examples/electron-forge/src/main.js

@@ -21,7 +21,7 @@ const createWindow = () => {
   mainWindow.loadURL(MAIN_WINDOW_WEBPACK_ENTRY);
 
   // Open the DevTools.
-  mainWindow.webContents.openDevTools();
+  // mainWindow.webContents.openDevTools();
 };
 
 // This method will be called when Electron has finished

package/src/koffi/examples/node-esbuild/README.md

@@ -0,0 +1,19 @@
+This is a simple example to bundle a CLI node.js app that uses Koffi, using esbuild.
+
+To run the app, execute the following:
+
+```sh
+cd examples/node-esbuild
+npm install
+npm start
+```
+
+You can bundle the script and the native modules with the following command
+
+```sh
+cd examples/node-esbuild
+npm install
+npm run bundle
+```
+
+Internally, this uses the esbuild copy loader to handle the native `.node` modules.

package/src/koffi/examples/node-esbuild/index.js

@@ -0,0 +1,2 @@
+const koffi = require('koffi');
+console.log(koffi.config());

package/src/koffi/examples/node-esbuild/package.json

@@ -0,0 +1,16 @@
+{
+  "name": "KoffiConfig",
+  "version": "1.0.0",
+  "description": "",
+  "main": "index.js",
+  "scripts": {
+    "start": "node index.js",
+    "bundle": "esbuild index.js --platform=node --bundle --loader:.node=copy --outdir=dist/"
+  },
+  "author": "",
+  "license": "ISC",
+  "dependencies": {
+    "esbuild": "^0.18.17",
+    "koffi": "^2.5.9"
+  }
+}

package/src/koffi/examples/nwjs/src/package.json

@@ -1,9 +1,10 @@
 {
-  "name": "Koffi Config",
+  "name": "KoffiConfig",
+  "version": "1.0.0",
   "main": "index.html",
   "author": "Niels Martignène <niels.martignene@protonmail.com>",
   "license": "MIT",
   "dependencies": {
-    "koffi": "^2.5.8"
+    "koffi": "^2.5.9"
   }
 }