native-recorder-nodejs 1.0.8 → 1.1.2

package/README.md

@@ -41,6 +41,20 @@ npm install native-recorder-nodejs
 
 Prebuilt binaries are available for most platforms. If a prebuild is not available, the package will compile from source (requires CMake and a C++ compiler).
 
+### Electron Support
+
+This package includes prebuilt binaries for Electron 29-40. In most cases, it will work out of the box. If you encounter issues:
+
+```bash
+# Option 1: Use electron-rebuild (recommended)
+npx electron-rebuild
+
+# Option 2: Rebuild using cmake-js with Electron runtime
+npx cmake-js compile --runtime=electron --runtime-version=YOUR_ELECTRON_VERSION --arch=x64
+```
+
+**Note**: Make sure to rebuild native modules after updating Electron version.
+
 ## Quick Start
 
 ```typescript

package/dist/bindings.js

@@ -2,30 +2,155 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 const path_1 = require("path");
 const fs_1 = require("fs");
+/**
+ * Detect if running in Electron environment
+ */
+function isElectron() {
+    // Check for Electron-specific process properties
+    if (typeof process !== "undefined") {
+        // @ts-ignore
+        if (process.versions && process.versions.electron) {
+            return true;
+        }
+        // Check for Electron renderer process
+        if (typeof globalThis !== "undefined" &&
+            // @ts-ignore
+            globalThis.window &&
+            // @ts-ignore
+            globalThis.window.process &&
+            // @ts-ignore
+            globalThis.window.process.type === "renderer") {
+            return true;
+        }
+    }
+    return false;
+}
+/**
+ * Get Electron major version number
+ */
+function getElectronMajorVersion() {
+    try {
+        // @ts-ignore
+        const electronVersion = process.versions.electron;
+        if (!electronVersion)
+            return null;
+        return parseInt(electronVersion.split(".")[0], 10);
+    }
+    catch {
+        return null;
+    }
+}
+/**
+ * Find available Electron prebuild versions in the prebuilds directory
+ */
+function findAvailableElectronVersions(platformDir) {
+    try {
+        if (!(0, fs_1.existsSync)(platformDir))
+            return [];
+        const dirs = (0, fs_1.readdirSync)(platformDir, { withFileTypes: true });
+        const versions = [];
+        for (const dir of dirs) {
+            if (dir.isDirectory() && dir.name.startsWith("electron-v")) {
+                const version = parseInt(dir.name.replace("electron-v", ""), 10);
+                if (!isNaN(version)) {
+                    versions.push(version);
+                }
+            }
+        }
+        return versions.sort((a, b) => b - a); // Sort descending (newest first)
+    }
+    catch {
+        return [];
+    }
+}
+/**
+ * Find the closest available Electron prebuild version
+ * Prefers newer versions that are closest to the target
+ */
+function findClosestElectronVersion(targetVersion, availableVersions) {
+    if (availableVersions.length === 0)
+        return null;
+    // First, try to find an exact match
+    if (availableVersions.includes(targetVersion)) {
+        return targetVersion;
+    }
+    // Find the closest version (prefer slightly older over much newer for stability)
+    let closest = null;
+    let minDiff = Infinity;
+    for (const version of availableVersions) {
+        const diff = Math.abs(version - targetVersion);
+        // Prefer older versions when diff is the same (more stable)
+        if (diff < minDiff || (diff === minDiff && version < targetVersion)) {
+            minDiff = diff;
+            closest = version;
+        }
+    }
+    return closest;
+}
 function getBinding() {
     const moduleName = "NativeAudioSDK.node";
     // Try prebuild first (installed via npm)
     const prebuildsDir = (0, path_1.join)(__dirname, "..", "prebuilds");
     const platform = process.platform;
     const arch = process.arch;
+    const platformDir = (0, path_1.join)(prebuildsDir, `${platform}-${arch}`);
+    const paths = [];
+    // For Electron, try Electron-specific prebuild first
+    if (isElectron()) {
+        const electronMajor = getElectronMajorVersion();
+        if (electronMajor) {
+            // Try exact version match first
+            const exactPath = (0, path_1.join)(platformDir, `electron-v${electronMajor}`, moduleName);
+            paths.push(exactPath);
+            if ((0, fs_1.existsSync)(exactPath)) {
+                return require(exactPath);
+            }
+            // Fallback: find closest available Electron version
+            const availableVersions = findAvailableElectronVersions(platformDir);
+            const closestVersion = findClosestElectronVersion(electronMajor, availableVersions);
+            if (closestVersion && closestVersion !== electronMajor) {
+                const fallbackPath = (0, path_1.join)(platformDir, `electron-v${closestVersion}`, moduleName);
+                paths.push(fallbackPath);
+                if ((0, fs_1.existsSync)(fallbackPath)) {
+                    console.warn(`[native-recorder-nodejs] No prebuild for Electron ${electronMajor}, ` +
+                        `using Electron ${closestVersion} prebuild as fallback. ` +
+                        `Consider running 'npx electron-rebuild' for best compatibility.`);
+                    return require(fallbackPath);
+                }
+            }
+        }
+    }
+    // Try N-API prebuild (works for both Node.js and Electron with N-API support)
+    // Since this module uses N-API, the Node.js prebuild should work in Electron too
     // prebuild-install stores binaries in: prebuilds/{platform}-{arch}/
-    const prebuildPath = (0, path_1.join)(prebuildsDir, `${platform}-${arch}`, moduleName);
+    const prebuildPath = (0, path_1.join)(platformDir, moduleName);
+    paths.push(prebuildPath);
     if ((0, fs_1.existsSync)(prebuildPath)) {
         return require(prebuildPath);
     }
+    // Also try napi-v8 subfolder format
+    const napiPrebuildPath = (0, path_1.join)(platformDir, "napi-v8", moduleName);
+    paths.push(napiPrebuildPath);
+    if ((0, fs_1.existsSync)(napiPrebuildPath)) {
+        return require(napiPrebuildPath);
+    }
     // Fallback to local build (development)
     const localPath = (0, path_1.join)(__dirname, "..", "build", "Release", moduleName);
+    paths.push(localPath);
     if ((0, fs_1.existsSync)(localPath)) {
         return require(localPath);
     }
     // Final fallback for different build configurations
     const debugPath = (0, path_1.join)(__dirname, "..", "build", "Debug", moduleName);
+    paths.push(debugPath);
     if ((0, fs_1.existsSync)(debugPath)) {
         return require(debugPath);
     }
-    throw new Error(`Could not find native module ${moduleName}. ` +
-        `Tried:\n  - ${prebuildPath}\n  - ${localPath}\n  - ${debugPath}\n` +
-        `Please run 'npm run build:native' or reinstall the package.`);
+    const runtime = isElectron() ? "Electron" : "Node.js";
+    throw new Error(`Could not find native module ${moduleName} for ${runtime}. ` +
+        `Tried:\n  - ${paths.join("\n  - ")}\n` +
+        `Please run 'npm run build:native' or reinstall the package.\n` +
+        `For Electron users: try running 'npx electron-rebuild' in your project.`);
 }
 const bindings = getBinding();
 exports.default = bindings;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "native-recorder-nodejs",
-  "version": "1.0.8",
+  "version": "1.1.2",
   "description": "Cross-platform (Win/Mac) Native Audio SDK for Node.js",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
@@ -11,11 +11,14 @@
     "build:native:debug": "cmake-js compile --debug",
     "build:tests": "cmake -S . -B build -DBUILD_TESTS=ON && cmake --build build --config Release --target NativeTests",
     "prebuild": "prebuild --backend cmake-js -r napi --strip",
+    "prebuild:electron": "prebuild --backend cmake-js -r electron -t 29.0.0 -t 30.0.0 -t 31.0.0 -t 32.0.0 -t 33.0.0 -t 34.0.0 -t 35.0.0 -t 36.0.0 -t 37.0.0 -t 38.0.0 -t 39.0.0 -t 40.0.0 --strip",
+    "prebuild:all": "npm run prebuild && npm run prebuild:electron",
     "prebuild:upload": "prebuild --upload-all ${GITHUB_TOKEN}",
     "test": "jest",
     "test:native": "npm run build:tests && cd build && ctest -C Release --output-on-failure",
     "test:cli": "node ./test/cli_test.js",
     "clean": "rimraf dist build prebuilds",
+    "install": "prebuild-install || npm run build:native",
     "prepublishOnly": "npm run build:ts",
     "release": "npm version patch && git push && git push --tags",
     "release:minor": "npm version minor && git push && git push --tags",
@@ -57,7 +60,8 @@
     ]
   },
   "dependencies": {
-    "node-addon-api": "^7.0.0"
+    "node-addon-api": "^7.0.0",
+    "prebuild-install": "^7.1.2"
   },
   "devDependencies": {
     "@types/jest": "^29.5.0",

package/src/bindings.ts

@@ -1,5 +1,102 @@
 import { join, dirname } from "path";
-import { existsSync } from "fs";
+import { existsSync, readdirSync } from "fs";
+
+/**
+ * Detect if running in Electron environment
+ */
+function isElectron(): boolean {
+  // Check for Electron-specific process properties
+  if (typeof process !== "undefined") {
+    // @ts-ignore
+    if (process.versions && process.versions.electron) {
+      return true;
+    }
+    // Check for Electron renderer process
+    if (
+      typeof globalThis !== "undefined" &&
+      // @ts-ignore
+      globalThis.window &&
+      // @ts-ignore
+      globalThis.window.process &&
+      // @ts-ignore
+      globalThis.window.process.type === "renderer"
+    ) {
+      return true;
+    }
+  }
+  return false;
+}
+
+/**
+ * Get Electron major version number
+ */
+function getElectronMajorVersion(): number | null {
+  try {
+    // @ts-ignore
+    const electronVersion = process.versions.electron;
+    if (!electronVersion) return null;
+
+    return parseInt(electronVersion.split(".")[0], 10);
+  } catch {
+    return null;
+  }
+}
+
+/**
+ * Find available Electron prebuild versions in the prebuilds directory
+ */
+function findAvailableElectronVersions(platformDir: string): number[] {
+  try {
+    if (!existsSync(platformDir)) return [];
+
+    const dirs = readdirSync(platformDir, { withFileTypes: true });
+    const versions: number[] = [];
+
+    for (const dir of dirs) {
+      if (dir.isDirectory() && dir.name.startsWith("electron-v")) {
+        const version = parseInt(dir.name.replace("electron-v", ""), 10);
+        if (!isNaN(version)) {
+          versions.push(version);
+        }
+      }
+    }
+
+    return versions.sort((a, b) => b - a); // Sort descending (newest first)
+  } catch {
+    return [];
+  }
+}
+
+/**
+ * Find the closest available Electron prebuild version
+ * Prefers newer versions that are closest to the target
+ */
+function findClosestElectronVersion(
+  targetVersion: number,
+  availableVersions: number[],
+): number | null {
+  if (availableVersions.length === 0) return null;
+
+  // First, try to find an exact match
+  if (availableVersions.includes(targetVersion)) {
+    return targetVersion;
+  }
+
+  // Find the closest version (prefer slightly older over much newer for stability)
+  let closest: number | null = null;
+  let minDiff = Infinity;
+
+  for (const version of availableVersions) {
+    const diff = Math.abs(version - targetVersion);
+    // Prefer older versions when diff is the same (more stable)
+    if (diff < minDiff || (diff === minDiff && version < targetVersion)) {
+      minDiff = diff;
+      closest = version;
+    }
+  }
+
+  return closest;
+}
 
 function getBinding() {
   const moduleName = "NativeAudioSDK.node";
@@ -8,30 +105,89 @@ function getBinding() {
   const prebuildsDir = join(__dirname, "..", "prebuilds");
   const platform = process.platform;
   const arch = process.arch;
+  const platformDir = join(prebuildsDir, `${platform}-${arch}`);
+
+  const paths: string[] = [];
 
+  // For Electron, try Electron-specific prebuild first
+  if (isElectron()) {
+    const electronMajor = getElectronMajorVersion();
+    if (electronMajor) {
+      // Try exact version match first
+      const exactPath = join(
+        platformDir,
+        `electron-v${electronMajor}`,
+        moduleName,
+      );
+      paths.push(exactPath);
+      if (existsSync(exactPath)) {
+        return require(exactPath);
+      }
+
+      // Fallback: find closest available Electron version
+      const availableVersions = findAvailableElectronVersions(platformDir);
+      const closestVersion = findClosestElectronVersion(
+        electronMajor,
+        availableVersions,
+      );
+
+      if (closestVersion && closestVersion !== electronMajor) {
+        const fallbackPath = join(
+          platformDir,
+          `electron-v${closestVersion}`,
+          moduleName,
+        );
+        paths.push(fallbackPath);
+        if (existsSync(fallbackPath)) {
+          console.warn(
+            `[native-recorder-nodejs] No prebuild for Electron ${electronMajor}, ` +
+              `using Electron ${closestVersion} prebuild as fallback. ` +
+              `Consider running 'npx electron-rebuild' for best compatibility.`,
+          );
+          return require(fallbackPath);
+        }
+      }
+    }
+  }
+
+  // Try N-API prebuild (works for both Node.js and Electron with N-API support)
+  // Since this module uses N-API, the Node.js prebuild should work in Electron too
   // prebuild-install stores binaries in: prebuilds/{platform}-{arch}/
-  const prebuildPath = join(prebuildsDir, `${platform}-${arch}`, moduleName);
+  const prebuildPath = join(platformDir, moduleName);
+  paths.push(prebuildPath);
 
   if (existsSync(prebuildPath)) {
     return require(prebuildPath);
   }
 
+  // Also try napi-v8 subfolder format
+  const napiPrebuildPath = join(platformDir, "napi-v8", moduleName);
+  paths.push(napiPrebuildPath);
+
+  if (existsSync(napiPrebuildPath)) {
+    return require(napiPrebuildPath);
+  }
+
   // Fallback to local build (development)
   const localPath = join(__dirname, "..", "build", "Release", moduleName);
+  paths.push(localPath);
   if (existsSync(localPath)) {
     return require(localPath);
   }
 
   // Final fallback for different build configurations
   const debugPath = join(__dirname, "..", "build", "Debug", moduleName);
+  paths.push(debugPath);
   if (existsSync(debugPath)) {
     return require(debugPath);
   }
 
+  const runtime = isElectron() ? "Electron" : "Node.js";
   throw new Error(
-    `Could not find native module ${moduleName}. ` +
-      `Tried:\n  - ${prebuildPath}\n  - ${localPath}\n  - ${debugPath}\n` +
-      `Please run 'npm run build:native' or reinstall the package.`
+    `Could not find native module ${moduleName} for ${runtime}. ` +
+      `Tried:\n  - ${paths.join("\n  - ")}\n` +
+      `Please run 'npm run build:native' or reinstall the package.\n` +
+      `For Electron users: try running 'npx electron-rebuild' in your project.`,
   );
 }