electrobun 0.11.0-beta.3 → 0.13.0-beta.1

package/dist/api/bun/index.ts

@@ -14,12 +14,14 @@ import * as Socket from "./core/Socket";
 import type { ElectrobunConfig } from "./ElectrobunConfig";
 import { GlobalShortcut, Screen, Session } from "./proc/native";
 import type { Display, Rectangle, Point, Cookie, CookieFilter, StorageType } from "./proc/native";
+import { BuildConfig, type BuildConfigType } from "./core/BuildConfig";
 
 // Named Exports
 export {
   type RPCSchema,
   type ElectrobunEvent,
   type ElectrobunConfig,
+  type BuildConfigType,
   type MessageBoxOptions,
   type MessageBoxResponse,
   type Display,
@@ -41,6 +43,7 @@ export {
   GlobalShortcut,
   Screen,
   Session,
+  BuildConfig,
 };
 
 // Default Export
@@ -55,6 +58,7 @@ const Electrobun = {
   GlobalShortcut,
   Screen,
   Session,
+  BuildConfig,
   events: electobunEventEmmitter,
   PATHS,
   Socket,

package/dist/api/bun/proc/native.ts

@@ -1,4 +1,4 @@
-import { join, resolve } from "path";
+import { join } from "path";
 import { type RPCSchema, type RPCTransport, createRPC } from "rpc-anywhere";
 import { execSync } from "child_process";
 import * as fs from "fs";
@@ -62,7 +62,10 @@ import { BrowserWindow, BrowserWindowMap } from "../core/BrowserWindow";
 
 export const native = (() => {
   try {
-    return dlopen(`./libNativeWrapper.${suffix}`, {  
+    // Use absolute path to native wrapper DLL to avoid working directory issues
+    // On Windows shortcuts, the working directory may not be set correctly
+    const nativeWrapperPath = join(process.cwd(), `libNativeWrapper.${suffix}`);
+    return dlopen(nativeWrapperPath, {  
       // window
       createWindowWithFrameAndStyleFromWorker: {
         // Pass each parameter individually
@@ -72,6 +75,7 @@ export const native = (() => {
           FFIType.f64, FFIType.f64,    // width, height
           FFIType.u32,           // styleMask
           FFIType.cstring,       // titleBarStyle
+          FFIType.bool,          // transparent
           FFIType.function,      // closeHandler
           FFIType.function,      // moveHandler
           FFIType.function,      // resizeHandler
@@ -79,82 +83,99 @@ export const native = (() => {
         ],
         returns: FFIType.ptr
       },
-      setNSWindowTitle: {
+      setWindowTitle: {
         args: [
           FFIType.ptr, // window ptr
           FFIType.cstring, // title
         ],
         returns: FFIType.void,
       },
-      makeNSWindowKeyAndOrderFront: {
+      showWindow: {
         args: [
-          FFIType.ptr, // window ptr      
+          FFIType.ptr, // window ptr
         ],
         returns: FFIType.void,
       },
-      closeNSWindow: {
+      closeWindow: {
         args: [
           FFIType.ptr, // window ptr
         ],
         returns: FFIType.void,
       },
-      minimizeNSWindow: {
+      minimizeWindow: {
         args: [FFIType.ptr],
         returns: FFIType.void,
       },
-      unminimizeNSWindow: {
+      restoreWindow: {
         args: [FFIType.ptr],
         returns: FFIType.void,
       },
-      isNSWindowMinimized: {
+      isWindowMinimized: {
         args: [FFIType.ptr],
         returns: FFIType.bool,
       },
-      maximizeNSWindow: {
+      maximizeWindow: {
         args: [FFIType.ptr],
         returns: FFIType.void,
       },
-      unmaximizeNSWindow: {
+      unmaximizeWindow: {
         args: [FFIType.ptr],
         returns: FFIType.void,
       },
-      isNSWindowMaximized: {
+      isWindowMaximized: {
         args: [FFIType.ptr],
         returns: FFIType.bool,
       },
-      setNSWindowFullScreen: {
+      setWindowFullScreen: {
         args: [FFIType.ptr, FFIType.bool],
         returns: FFIType.void,
       },
-      isNSWindowFullScreen: {
+      isWindowFullScreen: {
         args: [FFIType.ptr],
         returns: FFIType.bool,
       },
-      setNSWindowAlwaysOnTop: {
+      setWindowAlwaysOnTop: {
         args: [FFIType.ptr, FFIType.bool],
         returns: FFIType.void,
       },
-      isNSWindowAlwaysOnTop: {
+      isWindowAlwaysOnTop: {
         args: [FFIType.ptr],
         returns: FFIType.bool,
       },
+      setWindowPosition: {
+        args: [FFIType.ptr, FFIType.f64, FFIType.f64],
+        returns: FFIType.void,
+      },
+      setWindowSize: {
+        args: [FFIType.ptr, FFIType.f64, FFIType.f64],
+        returns: FFIType.void,
+      },
+      setWindowFrame: {
+        args: [FFIType.ptr, FFIType.f64, FFIType.f64, FFIType.f64, FFIType.f64],
+        returns: FFIType.void,
+      },
+      getWindowFrame: {
+        args: [FFIType.ptr, FFIType.ptr, FFIType.ptr, FFIType.ptr, FFIType.ptr],
+        returns: FFIType.void,
+      },
       // webview
       initWebview: {
         args: [
           FFIType.u32, // webviewId
           FFIType.ptr, // windowPtr
-          FFIType.cstring, // renderer          
-          FFIType.cstring, // url                              
+          FFIType.cstring, // renderer
+          FFIType.cstring, // url
           FFIType.f64, FFIType.f64,    // x, y
-          FFIType.f64, FFIType.f64,    // width, height              
+          FFIType.f64, FFIType.f64,    // width, height
           FFIType.bool, // autoResize
-          FFIType.cstring, // partition                    
+          FFIType.cstring, // partition
           FFIType.function, // decideNavigation: *const fn (u32, [*:0]const u8) callconv(.C) bool,
           FFIType.function, // webviewEventHandler: *const fn (u32, [*:0]const u8, [*:0]const u8) callconv(.C) void,
           FFIType.function, //  bunBridgePostmessageHandler: *const fn (u32, [*:0]const u8) callconv(.C) void,
           FFIType.function, //  internalBridgeHandler: *const fn (u32, [*:0]const u8) callconv(.C) void,
           FFIType.cstring, // electrobunPreloadScript
           FFIType.cstring, // customPreloadScript
+          FFIType.bool, // transparent
         ],
         returns: FFIType.ptr
       },
@@ -440,8 +461,8 @@ export const native = (() => {
         returns: FFIType.void
       },
 
-      // MacOS specific native utils
-      getNSWindowStyleMask: {
+      // Window style utilities
+      getWindowStyle: {
         args: [
           FFIType.bool,
           FFIType.bool,
@@ -466,6 +487,13 @@ export const native = (() => {
         ],
         returns: FFIType.void
       },   
+      setWindowIcon: {
+        args: [
+          FFIType.ptr, // window pointer
+          FFIType.cstring, // icon path
+        ],
+        returns: FFIType.void
+      },
       killApp: {
         args: [],
         returns: FFIType.void
@@ -504,7 +532,7 @@ export const ffi = {
   request: {
     createWindow: (params: {
         id: number,
-        url: string | null,        
+        url: string | null,
         title: string,
         frame: {
           width: number,
@@ -527,6 +555,7 @@ export const ffi = {
           HUDWindow: boolean,
         },
         titleBarStyle: string,
+        transparent: boolean,
       }): FFIType.ptr => {
         const {id, url, title, frame: {x, y, width, height}, styleMask: {
             Borderless,
@@ -541,10 +570,11 @@ export const ffi = {
             DocModalWindow,
             NonactivatingPanel,
             HUDWindow
-          }, 
-          titleBarStyle} = params
-          
-          const styleMask = native.symbols.getNSWindowStyleMask(
+          },
+          titleBarStyle,
+          transparent} = params
+
+          const styleMask = native.symbols.getWindowStyle(
             Borderless,
             Titled,
             Closable,
@@ -557,8 +587,8 @@ export const ffi = {
             DocModalWindow,
             NonactivatingPanel,
             HUDWindow
-          )          
-     
+          )
+
         const windowPtr = native.symbols.createWindowWithFrameAndStyleFromWorker(
           id,
           // frame
@@ -566,6 +596,7 @@ export const ffi = {
           styleMask,
           // style
           toCString(titleBarStyle),
+          transparent,
           // callbacks
           windowCloseCallback,
           windowMoveCallback,
@@ -578,11 +609,8 @@ export const ffi = {
           throw "Failed to create window"
         }
         
-        native.symbols.setNSWindowTitle(windowPtr, toCString(title));        
-        // setTimeout(() => {
-          // console.log('calling makeNSWindowKeyAndOrderFront', windowPtr)
-        native.symbols.makeNSWindowKeyAndOrderFront(windowPtr);
-        // }, 1000)
+        native.symbols.setWindowTitle(windowPtr, toCString(title));
+        native.symbols.showWindow(windowPtr);
 
         return windowPtr;
       },
@@ -595,7 +623,7 @@ export const ffi = {
           throw `Can't add webview to window. window no longer exists`;
         }
         
-        native.symbols.setNSWindowTitle(windowPtr, toCString(title));        
+        native.symbols.setWindowTitle(windowPtr, toCString(title));        
       },
       
       closeWindow: (params: {winId: number}) => {
@@ -606,7 +634,7 @@ export const ffi = {
           throw `Can't close window. Window no longer exists`;
         }
         
-        native.symbols.closeNSWindow(windowPtr);
+        native.symbols.closeWindow(windowPtr);
         // Note: Cleanup of BrowserWindowMap happens in the windowCloseCallback
       },
 
@@ -618,7 +646,7 @@ export const ffi = {
           throw `Can't focus window. Window no longer exists`;
         }
 
-        native.symbols.makeNSWindowKeyAndOrderFront(windowPtr);
+        native.symbols.showWindow(windowPtr);
       },
 
       minimizeWindow: (params: {winId: number}) => {
@@ -629,18 +657,18 @@ export const ffi = {
           throw `Can't minimize window. Window no longer exists`;
         }
 
-        native.symbols.minimizeNSWindow(windowPtr);
+        native.symbols.minimizeWindow(windowPtr);
       },
 
-      unminimizeWindow: (params: {winId: number}) => {
+      restoreWindow: (params: {winId: number}) => {
         const {winId} = params;
         const windowPtr = BrowserWindow.getById(winId)?.ptr;
 
         if (!windowPtr) {
-          throw `Can't unminimize window. Window no longer exists`;
+          throw `Can't restore window. Window no longer exists`;
         }
 
-        native.symbols.unminimizeNSWindow(windowPtr);
+        native.symbols.restoreWindow(windowPtr);
       },
 
       isWindowMinimized: (params: {winId: number}): boolean => {
@@ -651,7 +679,7 @@ export const ffi = {
           return false;
         }
 
-        return native.symbols.isNSWindowMinimized(windowPtr);
+        return native.symbols.isWindowMinimized(windowPtr);
       },
 
       maximizeWindow: (params: {winId: number}) => {
@@ -662,7 +690,7 @@ export const ffi = {
           throw `Can't maximize window. Window no longer exists`;
         }
 
-        native.symbols.maximizeNSWindow(windowPtr);
+        native.symbols.maximizeWindow(windowPtr);
       },
 
       unmaximizeWindow: (params: {winId: number}) => {
@@ -673,7 +701,7 @@ export const ffi = {
           throw `Can't unmaximize window. Window no longer exists`;
         }
 
-        native.symbols.unmaximizeNSWindow(windowPtr);
+        native.symbols.unmaximizeWindow(windowPtr);
       },
 
       isWindowMaximized: (params: {winId: number}): boolean => {
@@ -684,7 +712,7 @@ export const ffi = {
           return false;
         }
 
-        return native.symbols.isNSWindowMaximized(windowPtr);
+        return native.symbols.isWindowMaximized(windowPtr);
       },
 
       setWindowFullScreen: (params: {winId: number; fullScreen: boolean}) => {
@@ -695,7 +723,7 @@ export const ffi = {
           throw `Can't set fullscreen. Window no longer exists`;
         }
 
-        native.symbols.setNSWindowFullScreen(windowPtr, fullScreen);
+        native.symbols.setWindowFullScreen(windowPtr, fullScreen);
       },
 
       isWindowFullScreen: (params: {winId: number}): boolean => {
@@ -706,7 +734,7 @@ export const ffi = {
           return false;
         }
 
-        return native.symbols.isNSWindowFullScreen(windowPtr);
+        return native.symbols.isWindowFullScreen(windowPtr);
       },
 
       setWindowAlwaysOnTop: (params: {winId: number; alwaysOnTop: boolean}) => {
@@ -717,7 +745,7 @@ export const ffi = {
           throw `Can't set always on top. Window no longer exists`;
         }
 
-        native.symbols.setNSWindowAlwaysOnTop(windowPtr, alwaysOnTop);
+        native.symbols.setWindowAlwaysOnTop(windowPtr, alwaysOnTop);
       },
 
       isWindowAlwaysOnTop: (params: {winId: number}): boolean => {
@@ -728,7 +756,70 @@ export const ffi = {
           return false;
         }
 
-        return native.symbols.isNSWindowAlwaysOnTop(windowPtr);
+        return native.symbols.isWindowAlwaysOnTop(windowPtr);
+      },
+
+      setWindowPosition: (params: {winId: number; x: number; y: number}) => {
+        const {winId, x, y} = params;
+        const windowPtr = BrowserWindow.getById(winId)?.ptr;
+
+        if (!windowPtr) {
+          throw `Can't set window position. Window no longer exists`;
+        }
+
+        native.symbols.setWindowPosition(windowPtr, x, y);
+      },
+
+      setWindowSize: (params: {winId: number; width: number; height: number}) => {
+        const {winId, width, height} = params;
+        const windowPtr = BrowserWindow.getById(winId)?.ptr;
+
+        if (!windowPtr) {
+          throw `Can't set window size. Window no longer exists`;
+        }
+
+        native.symbols.setWindowSize(windowPtr, width, height);
+      },
+
+      setWindowFrame: (params: {winId: number; x: number; y: number; width: number; height: number}) => {
+        const {winId, x, y, width, height} = params;
+        const windowPtr = BrowserWindow.getById(winId)?.ptr;
+
+        if (!windowPtr) {
+          throw `Can't set window frame. Window no longer exists`;
+        }
+
+        native.symbols.setWindowFrame(windowPtr, x, y, width, height);
+      },
+
+      getWindowFrame: (params: {winId: number}): {x: number; y: number; width: number; height: number} => {
+        const {winId} = params;
+        const windowPtr = BrowserWindow.getById(winId)?.ptr;
+
+        if (!windowPtr) {
+          return {x: 0, y: 0, width: 0, height: 0};
+        }
+
+        // Create buffers to receive the output values
+        const xBuf = new Float64Array(1);
+        const yBuf = new Float64Array(1);
+        const widthBuf = new Float64Array(1);
+        const heightBuf = new Float64Array(1);
+
+        native.symbols.getWindowFrame(
+          windowPtr,
+          ptr(xBuf),
+          ptr(yBuf),
+          ptr(widthBuf),
+          ptr(heightBuf)
+        );
+
+        return {
+          x: xBuf[0],
+          y: yBuf[0],
+          width: widthBuf[0],
+          height: heightBuf[0],
+        };
       },
 
       createWebview: (params: {
@@ -739,8 +830,8 @@ export const ffi = {
         secretKey: string;
         hostWebviewId: number | null;
         pipePrefix: string;
-        url: string | null;    
-        html: string | null;    
+        url: string | null;
+        html: string | null;
         partition: string | null;
         preload: string | null;
         frame: {
@@ -761,7 +852,7 @@ export const ffi = {
           // hostWebviewId: number | null;
           // pipePrefix: string;
           url,
-          // html: string | null;    
+          // html: string | null;
           partition,
           preload,
           frame: {
@@ -772,7 +863,10 @@ export const ffi = {
           },
           autoResize} = params
 
-          const windowPtr = BrowserWindow.getById(windowId)?.ptr;
+          const parentWindow = BrowserWindow.getById(windowId);
+          const windowPtr = parentWindow?.ptr;
+          // Get transparent flag from parent window
+          const transparent = parentWindow?.transparent ?? false;
           
 
         if (!windowPtr) {          
@@ -983,9 +1077,9 @@ export const ffi = {
           id,
           windowPtr,
           toCString(renderer),
-          toCString(url || ''),                          
-          x, y,  
-          width, height,             
+          toCString(url || ''),
+          x, y,
+          width, height,
           autoResize,
           toCString(partition || 'persist:default'),
           webviewDecideNavigation,
@@ -993,7 +1087,8 @@ export const ffi = {
           bunBridgePostmessageHandler,
           internalBridgeHandler,
           toCString(electrobunPreload),
-          toCString(customPreload || ''),        
+          toCString(customPreload || ''),
+          transparent,
         )        
 
         if (!webviewPtr) {
@@ -1785,6 +1880,9 @@ const webviewEventHandler = (id, eventName, detail) => {
       "download-progress": "downloadProgress",
       "download-completed": "downloadCompleted",
       "download-failed": "downloadFailed",
+      "load-started": "loadStarted",
+      "load-committed": "loadCommitted", 
+      "load-finished": "loadFinished",
     };
 
   // todo: the events map should use the same hyphenated names instead of camelCase

package/dist/main.js

@@ -12,6 +12,7 @@ var absoluteLibPath = resolve(libPath);
 function main() {
   let channel = "";
   let identifier = "";
+  let name = "";
   try {
     const pathToLauncherBin2 = process.argv0;
     const pathToBinDir2 = dirname(pathToLauncherBin2);
@@ -21,10 +22,13 @@ function main() {
       if (versionInfo.identifier) {
         identifier = versionInfo.identifier;
       }
+      if (versionInfo.name) {
+        name = versionInfo.name;
+      }
       if (versionInfo.channel) {
         channel = versionInfo.channel;
       }
-      console.log(`[LAUNCHER] Loaded identifier: ${identifier}, channel: ${channel}`);
+      console.log(`[LAUNCHER] Loaded identifier: ${identifier}, name: ${name}, channel: ${channel}`);
     }
   } catch (error) {
     console.error(`[LAUNCHER] Warning: Could not read version.json:`, error);
@@ -52,13 +56,13 @@ function main() {
       process.env.LD_LIBRARY_PATH = `.${process.env.LD_LIBRARY_PATH ? ":" + process.env.LD_LIBRARY_PATH : ""}`;
     }
     lib = dlopen(libPath, {
-      runNSApplication: { args: ["cstring", "cstring"], returns: "void" }
+      startEventLoop: { args: ["cstring", "cstring", "cstring"], returns: "void" }
     });
   } catch (error) {
     console.error(`[LAUNCHER] Failed to load library: ${error.message}`);
     try {
       lib = dlopen(absoluteLibPath, {
-        runNSApplication: { args: ["cstring", "cstring"], returns: "void" }
+        startEventLoop: { args: ["cstring", "cstring", "cstring"], returns: "void" }
       });
     } catch (absError) {
       console.error(`[LAUNCHER] Library loading failed. Try running: ldd ${libPath}`);
@@ -135,6 +139,6 @@ ${fileData.toString("utf8")}
     appEntrypointPath = join(appFolderPath, "bun", "index.js");
   }
   new Worker(appEntrypointPath, {});
-  lib.symbols.runNSApplication(ptr(Buffer.from(identifier + "\x00", "utf8")), ptr(Buffer.from(channel + "\x00", "utf8")));
+  lib.symbols.startEventLoop(ptr(Buffer.from(identifier + "\x00", "utf8")), ptr(Buffer.from(name + "\x00", "utf8")), ptr(Buffer.from(channel + "\x00", "utf8")));
 }
 main();

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "electrobun",
-  "version": "0.11.0-beta.3",
+  "version": "0.13.0-beta.1",
   "description": "Build ultra fast, tiny, and cross-platform desktop apps with Typescript.",
   "license": "MIT",
   "author": "Blackboard Technologies Inc.",
@@ -55,6 +55,8 @@
   "dependencies": {
     "@oneidentity/zstd-js": "^1.0.3",
     "archiver": "^7.0.1",
+    "png-to-ico": "^2.1.8",
+    "rcedit": "^4.0.1",
     "rpc-anywhere": "1.5.0",
     "tar": "^6.2.1"
   }