@next2d/builder 0.2.0 → 0.3.1

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@next2d/builder",
-  "version": "0.2.0",
+  "version": "0.3.1",
   "description": "Multi-platform builder for Next2d Framework, supporting export to various platforms such as macOS, Windows, iOS, Android and Web(HTML)",
   "author": "Toshiyuki Ienaga <ienaga@next2d.app>",
   "license": "MIT",
@@ -42,13 +42,13 @@
   "devDependencies": {
     "@eslint/eslintrc": "^3.3.7",
     "@eslint/js": "^10.0.1",
-    "@types/node": "^26.6.2",
-    "@typescript-eslint/eslint-plugin": "^8.70.1",
-    "@typescript-eslint/parser": "^8.70.1",
+    "@types/node": "^26.6.4",
+    "@typescript-eslint/eslint-plugin": "^8.71.0",
+    "@typescript-eslint/parser": "^8.71.0",
     "eslint": "^10.11.0",
     "eslint-plugin-unused-imports": "^4.4.1",
-    "globals": "^17.12.0",
+    "globals": "^17.13.0",
     "typescript": "^6.0.3",
-    "vite": "^8.3.0"
+    "vite": "^8.3.2"
   }
 }

package/templates/electron/index.js

@@ -1,12 +1,18 @@
-const { app, BrowserWindow, Menu, net, protocol, screen, session } = require("electron");
+const { app, BrowserWindow, Menu, net, protocol, screen, session, ipcMain } = require("electron");
 const path = require("node:path");
 const fs = require("node:fs");
 const { pathToFileURL } = require("node:url");
 const { resolveAssetPath, CSP } = require("./local-assets.cjs");
 const config = require("./runtime-config.json");
+const { NativeBridge, isTrustedSender } = require("./native-bridge.cjs");
+let nativeBridge;
+const closeNativeBridge = () => nativeBridge?.close();
+process.on("exit", closeNativeBridge);
+app.on("before-quit", closeNativeBridge);
 // Keep saves in a stable user directory even if the visible game name changes.
 app.setName(config.appName);
-app.setPath("userData", path.join(app.getPath("appData"), config.appId));
+const userDataOverride = app.commandLine.getSwitchValue("user-data-dir");
+app.setPath("userData", userDataOverride ? path.resolve(userDataOverride) : path.join(app.getPath("appData"), config.appId));
 const assetRoot = app.isPackaged
     ? path.join(process.resourcesPath, "resources")
     : path.join(__dirname, "resources");
@@ -31,7 +37,11 @@ const createWindow = async () => {
         backgroundColor: "#000000",
         autoHideMenuBar: true,
         show: false,
-        webPreferences: { nodeIntegration: false, contextIsolation: true, sandbox: true }
+        webPreferences: {
+            nodeIntegration: false, contextIsolation: true, sandbox: true,
+            ...(config.nativeBridge ? { preload: path.join(__dirname, "preload.cjs"),
+                backgroundThrottling: config.nativeBridge.backgroundThrottling ?? false } : {})
+        }
     });
     mainWindow.webContents.setWindowOpenHandler(() => ({ action: "deny" }));
     mainWindow.webContents.on("will-navigate", (event, url) => {
@@ -53,6 +63,7 @@ const createWindow = async () => {
     });
     mainWindow.webContents.on("render-process-gone", (_event, details) => {
         console.error("Renderer exited:", details.reason);
+        closeNativeBridge();
         app.exit(1);
     });
     mainWindow.once("ready-to-show", () => mainWindow.show());
@@ -85,6 +96,19 @@ app.whenReady().then(async () => {
             return new Response("Not found", { status: 404 });
         }
     });
+    if (config.nativeBridge) {
+        ipcMain.handle("next2d:native:request", (event, method, params) => {
+            if (!isTrustedSender(event, mainWindow)) throw new Error("Native bridge access denied");
+            if (!config.nativeBridge.methods.includes(method)) throw new Error("Native method not allowed");
+            if (!nativeBridge) {
+                const nativeRoot = path.join(app.isPackaged ? process.resourcesPath : __dirname, "native");
+                nativeBridge = new NativeBridge(path.join(nativeRoot, config.nativeBridge.executable), config.nativeBridge.methods, (message) => {
+                    if (mainWindow && !mainWindow.isDestroyed()) mainWindow.webContents.send("next2d:native:event", message);
+                }, { cwd: nativeRoot });
+            }
+            return nativeBridge.request(method, params);
+        });
+    }
     await createWindow();
 }).catch((error) => {
     console.error(error);

package/templates/electron/native-bridge.cjs

@@ -0,0 +1,98 @@
+const { spawn } = require("node:child_process");
+const { StringDecoder } = require("node:string_decoder");
+const MAX_BYTES = 256 * 1024;
+
+class NativeBridge {
+    constructor(executable, methods, onEvent, options = {}) {
+        this.methods = new Set(methods);
+        this.pending = new Map();
+        this.sequence = 0;
+        this.failure = null;
+        this.timeout = options.timeout ?? 15000;
+        this.onEvent = onEvent;
+        this.child = spawn(executable, options.args ?? [], {
+            cwd: options.cwd, shell: false, windowsHide: true, stdio: ["pipe", "pipe", "pipe"]
+        });
+        const decoder = new StringDecoder("utf8");
+        let buffer = "";
+        this.child.stdout.on("data", (chunk) => {
+            if (this.failure) return;
+            buffer += decoder.write(chunk);
+            let end;
+            while ((end = buffer.indexOf("\n")) >= 0) {
+                const line = buffer.slice(0, end);
+                buffer = buffer.slice(end + 1);
+                if (Buffer.byteLength(line) > MAX_BYTES) return this.fail("Native message too large");
+                try {
+                    const message = JSON.parse(line);
+                    if (!message || typeof message !== "object") throw new Error("Invalid message");
+                    if (typeof message.event === "string" && message.event.length <= 64 && message.event !== "bridge.closed") {
+                        this.onEvent({ event: message.event, data: message.data ?? null });
+                    } else if (Number.isSafeInteger(message.id)) {
+                        const pending = this.pending.get(message.id);
+                        if (!pending) continue;
+                        clearTimeout(pending.timer);
+                        this.pending.delete(message.id);
+                        if (typeof message.error === "string") pending.reject(new Error(message.error));
+                        else pending.resolve(message.result ?? null);
+                    } else throw new Error("Invalid message");
+                } catch {
+                    return this.fail("Invalid native protocol");
+                }
+            }
+            if (Buffer.byteLength(buffer) > MAX_BYTES) this.fail("Native message too large");
+        });
+        // Drain diagnostics without sending credentials or SDK logs to the renderer.
+        this.child.stderr.resume();
+        this.child.stdin.on("error", () => this.fail("Native input closed"));
+        this.child.once("error", () => this.fail("Native process could not start"));
+        this.child.once("exit", () => this.fail("Native process exited"));
+    }
+
+    async request(method, params) {
+        if (this.failure) throw new Error(this.failure);
+        if (!this.methods.has(method)) throw new Error("Native method not allowed");
+        if (this.pending.size >= 128 || this.child.stdin.writableLength > MAX_BYTES) throw new Error("Native bridge busy");
+        const id = ++this.sequence;
+        const line = JSON.stringify({ id, method, params: params ?? null }) + "\n";
+        if (Buffer.byteLength(line) > MAX_BYTES) throw new Error("Native request too large");
+        return new Promise((resolve, reject) => {
+            const timer = setTimeout(() => {
+                this.pending.delete(id);
+                reject(new Error("Native request timed out"));
+            }, this.timeout);
+            this.pending.set(id, { resolve, reject, timer });
+            this.child.stdin.write(line);
+        });
+    }
+
+    fail(reason, graceful = false) {
+        if (this.failure) return;
+        this.failure = reason;
+        for (const pending of this.pending.values()) {
+            clearTimeout(pending.timer);
+            pending.reject(new Error(reason));
+        }
+        this.pending.clear();
+        if (graceful) {
+            this.child.stdin.end();
+            const timer = setTimeout(() => this.child.kill("SIGKILL"), 4000);
+            timer.unref();
+            this.child.once("exit", () => clearTimeout(timer));
+        } else this.child.kill("SIGKILL");
+        this.onEvent({ event: "bridge.closed", data: { reason } });
+    }
+
+    close() { this.fail("Native bridge closed", true); }
+}
+
+const isTrustedSender = (event, window) => {
+    if (!window || window.isDestroyed() || event.sender !== window.webContents
+        || event.senderFrame !== window.webContents.mainFrame) return false;
+    try {
+        const url = new URL(event.senderFrame.url);
+        return url.protocol === "next2d:" && url.host === "game" && !url.username && !url.password;
+    } catch { return false; }
+};
+
+module.exports = { NativeBridge, isTrustedSender };

package/templates/electron/preload.cjs

@@ -0,0 +1,11 @@
+const { contextBridge, ipcRenderer } = require("electron");
+
+contextBridge.exposeInMainWorld("next2dNative", {
+    request: (method, params) => ipcRenderer.invoke("next2d:native:request", method, params),
+    onEvent: (listener) => {
+        if (typeof listener !== "function") throw new TypeError("Expected event listener");
+        const handler = (_event, message) => listener(message);
+        ipcRenderer.on("next2d:native:event", handler);
+        return () => ipcRenderer.removeListener("next2d:native:event", handler);
+    }
+});