@atom-js-org/runtime 0.5.3-alpha.0 → 0.5.3-alpha.1

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@atom-js-org/runtime",
-  "version": "0.5.3-alpha.0",
+  "version": "0.5.3-alpha.1",
   "description": "Electron-like desktop runtime powered by the operating system WebView.",
   "main": "src/index.cjs",
   "types": "index.d.ts",
@@ -19,10 +19,11 @@
     "LICENSE"
   ],
   "engines": {
-    "node": ">=20.12"
+    "node": ">=24"
   },
   "dependencies": {
-    "ws": "^8.21.1"
+    "ws": "^8.21.1",
+    "@webviewjs/webview": "0.4.0"
   },
   "repository": {
     "type": "git",

package/src/app.cjs

@@ -7,6 +7,7 @@ const fs = require('node:fs');
 const state = require('./state.cjs');
 const { BridgeServer } = require('./bridge-server.cjs');
 const { stopNativeHost } = require('./native-host.cjs');
+const { stopWindowsNativeHost } = require('./windows-native-host.cjs');
 
 class App extends EventEmitter {
   constructor() {
@@ -43,6 +44,7 @@ class App extends EventEmitter {
 
     for (const win of [...state.windows.values()]) win.destroy();
     await stopNativeHost();
+    await stopWindowsNativeHost();
     if (state.bridgeServer) await state.bridgeServer.stop();
     this.emit('will-quit');
     this.emit('quit', {}, 0);

package/src/browser-window.cjs

@@ -10,6 +10,7 @@ const app = require('./app.cjs');
 const { WebContents } = require('./web-contents.cjs');
 const { generateBridgeScript } = require('./bridge-script.cjs');
 const { getNativeHost } = require('./native-host.cjs');
+const { getWindowsNativeHost } = require('./windows-native-host.cjs');
 
 class BrowserWindow extends EventEmitter {
   constructor(options = {}) {
@@ -136,6 +137,10 @@ class BrowserWindow extends EventEmitter {
       this._nativeHost = getNativeHost(app.getName());
       this._hostAttached = true;
       await this._nativeHost.createWindow(this, config);
+    } else if (process.platform === 'win32') {
+      this._nativeHost = getWindowsNativeHost();
+      this._hostAttached = true;
+      await this._nativeHost.createWindow(this, config);
     } else {
       await this._startLegacyHost(config);
     }
@@ -213,8 +218,7 @@ class BrowserWindow extends EventEmitter {
 
   _sendHostCommand(command) {
     if (this._nativeHost) {
-      this._nativeHost.send({ ...command, windowId: this.id });
-      return true;
+      return this._nativeHost.send({ ...command, windowId: this.id }) !== false;
     }
     return false;
   }

package/src/runtime/window-host.mjs

@@ -29,7 +29,7 @@ try {
   ({ Webview, SizeHint } = await import('webview-nodejs'));
 } catch (error) {
   console.error('\nAtomJS could not load the system WebView binding.');
-  console.error('Windows and Linux currently require the webview-nodejs package.');
+  console.error('Linux currently requires the webview-nodejs package.');
   console.error('Run `atom doctor`, install the platform prerequisites, then install dependencies again.');
   console.error(error && error.stack ? error.stack : error);
   process.exit(1);

package/src/windows-native-host.cjs

@@ -0,0 +1,209 @@
+'use strict';
+
+let singleton = null;
+
+class WindowsNativeHost {
+  constructor() {
+    this.binding = null;
+    this.application = null;
+    this.startPromise = null;
+    this.windows = new Map();
+    this.stopping = false;
+  }
+
+  async ensureStarted() {
+    if (process.platform !== 'win32') {
+      throw new Error('The in-process Windows native host can only run on Windows.');
+    }
+    if (!this.startPromise) {
+      this.startPromise = this._start().catch((error) => {
+        this.startPromise = null;
+        throw error;
+      });
+    }
+    await this.startPromise;
+  }
+
+  async _start() {
+    let binding;
+    try {
+      binding = require('@webviewjs/webview');
+    } catch (error) {
+      const wrapped = new Error([
+        'AtomJS could not load the prebuilt Windows WebView binding.',
+        'Delete node_modules and package-lock.json, then run npm install again.',
+        'CMake and Visual Studio Build Tools are not required.',
+        error && error.message ? error.message : String(error)
+      ].join('\n'));
+      wrapped.cause = error;
+      throw wrapped;
+    }
+
+    this.binding = binding;
+    this.application = new binding.Application();
+    await this.application.whenReady({ interval: 16, ref: true });
+  }
+
+  async createWindow(atomWindow, config) {
+    await this.ensureStarted();
+
+    const parent = config.parentWindowId ? this.windows.get(Number(config.parentWindowId)) : null;
+    const nativeOptions = {
+      title: String(config.title || 'AtomJS App'),
+      width: positive(config.width, 800),
+      height: positive(config.height, 600),
+      resizable: config.resizable !== false,
+      visible: false,
+      decorations: config.frame !== false,
+      alwaysOnTop: Boolean(config.alwaysOnTop),
+      maximizable: config.maximizable !== false,
+      minimizable: config.minimizable !== false,
+      focused: config.focusable !== false,
+      transparent: Boolean(config.transparent),
+      windowsSkipTaskbar: Boolean(config.skipTaskbar),
+      windowsClassName: sanitizeWindowsClass(process.env.ATOM_APP_ID || process.env.ATOM_APP_NAME || config.title)
+    };
+    if (Number.isFinite(Number(config.x))) nativeOptions.x = Math.round(Number(config.x));
+    if (Number.isFinite(Number(config.y))) nativeOptions.y = Math.round(Number(config.y));
+    if (parent && parent.nativeWindow && typeof parent.nativeWindow.getNativeHandle === 'function') {
+      nativeOptions.windowsOwnerWindow = parent.nativeWindow.getNativeHandle();
+    }
+
+    const nativeWindow = this.application.createBrowserWindow(nativeOptions);
+    nativeWindow.setClosable(config.closable !== false);
+    if (Number(config.minWidth) > 0 || Number(config.minHeight) > 0) {
+      nativeWindow.setMinSize(positive(config.minWidth, 1), positive(config.minHeight, 1), true);
+    }
+    if (Number(config.maxWidth) > 0 || Number(config.maxHeight) > 0) {
+      nativeWindow.setMaxSize(positive(config.maxWidth, 100000), positive(config.maxHeight, 100000), true);
+    }
+    if (config.center !== false && !Number.isFinite(Number(config.x)) && !Number.isFinite(Number(config.y))) {
+      nativeWindow.center();
+    }
+
+    const webview = nativeWindow.createWebview({
+      url: String(config.url),
+      preload: String(config.bridgeScript || ''),
+      enableDevtools: Boolean(config.debug),
+      transparent: Boolean(config.transparent)
+    });
+
+    const record = { atomWindow, nativeWindow, webview };
+    this.windows.set(Number(config.windowId), record);
+    this._attachEvents(Number(config.windowId), record);
+
+    if (config.show === false) nativeWindow.hide();
+    else nativeWindow.show();
+  }
+
+  _attachEvents(windowId, record) {
+    const emit = (event) => {
+      if (!this.windows.has(windowId)) return;
+      try { record.atomWindow._handleHostEvent({ ...event, windowId }); } catch {}
+    };
+
+    record.nativeWindow.on('close', () => {
+      try { record.atomWindow._handleHostEvent({ type: 'closed', windowId }); } catch {}
+      this.windows.delete(windowId);
+    });
+    record.nativeWindow.on('focus', () => emit({ type: 'focus' }));
+    record.nativeWindow.on('blur', () => emit({ type: 'blur' }));
+    record.nativeWindow.on('move', (event) => emit({
+      type: 'bounds-changed',
+      reason: 'move',
+      bounds: { x: Number(event.x), y: Number(event.y) }
+    }));
+    record.nativeWindow.on('resize', (event) => emit({
+      type: 'bounds-changed',
+      reason: 'resize',
+      bounds: { width: Number(event.width), height: Number(event.height) }
+    }));
+    record.webview.on('page-load-started', (event) => emit({ type: 'did-start-loading', url: event.url || '' }));
+    record.webview.on('page-load-finished', (event) => emit({ type: 'did-finish-load', url: event.url || '' }));
+    record.webview.on('title-changed', (event) => emit({ type: 'page-title-updated', title: event.title || '' }));
+  }
+
+  send(message) {
+    const record = this.windows.get(Number(message.windowId));
+    if (!record) return false;
+    const win = record.nativeWindow;
+    const view = record.webview;
+
+    switch (message.command) {
+      case 'navigate': view.loadUrl(String(message.url)); return true;
+      case 'show': win.show(); return true;
+      case 'hide': win.hide(); return true;
+      case 'focus': win.focus(); return true;
+      case 'close': win.close(); return true;
+      case 'destroy':
+        this.windows.delete(Number(message.windowId));
+        try { view.dispose(); } catch {}
+        try { win.dispose(); } catch {}
+        return true;
+      case 'set-title': win.setTitle(String(message.title || '')); return true;
+      case 'set-always-on-top': win.setAlwaysOnTop(Boolean(message.value)); return true;
+      case 'set-resizable': win.setResizable(Boolean(message.value)); return true;
+      case 'fullscreen':
+        win.setFullscreen(message.value ? this.binding.FullscreenType.Borderless : null);
+        return true;
+      case 'maximize': win.setMaximized(true); return true;
+      case 'unmaximize': win.setMaximized(false); return true;
+      case 'minimize': win.setMinimized(true); return true;
+      case 'restore':
+        win.setMinimized(false);
+        win.setMaximized(false);
+        win.show();
+        return true;
+      case 'set-bounds': {
+        const bounds = message.bounds || {};
+        if (Number.isFinite(Number(bounds.width)) && Number.isFinite(Number(bounds.height))) {
+          win.setSize(Math.round(Number(bounds.width)), Math.round(Number(bounds.height)), true);
+        }
+        if (Number.isFinite(Number(bounds.x)) && Number.isFinite(Number(bounds.y))) {
+          win.setPosition(Math.round(Number(bounds.x)), Math.round(Number(bounds.y)), true);
+        }
+        return true;
+      }
+      default: return false;
+    }
+  }
+
+  async stop() {
+    if (this.stopping) return;
+    this.stopping = true;
+    for (const record of this.windows.values()) {
+      try { record.webview.dispose(); } catch {}
+      try { record.nativeWindow.dispose(); } catch {}
+    }
+    this.windows.clear();
+    if (this.application) {
+      try { this.application.exit(); } catch {}
+    }
+    this.application = null;
+    this.startPromise = null;
+    this.stopping = false;
+  }
+}
+
+function positive(value, fallback) {
+  const number = Number(value);
+  return Number.isFinite(number) && number > 0 ? Math.round(number) : fallback;
+}
+
+function sanitizeWindowsClass(value) {
+  return String(value || 'AtomJS.App').replace(/[^A-Za-z0-9._-]+/g, '.').slice(0, 120) || 'AtomJS.App';
+}
+
+function getWindowsNativeHost() {
+  if (!singleton) singleton = new WindowsNativeHost();
+  return singleton;
+}
+
+async function stopWindowsNativeHost() {
+  if (!singleton) return;
+  const current = singleton;
+  singleton = null;
+  await current.stop();
+}
+
+module.exports = { WindowsNativeHost, getWindowsNativeHost, stopWindowsNativeHost };