electrobun 0.1.7 → 0.1.9

package/dist/api/bun/core/BrowserView.ts

@@ -122,6 +122,18 @@ export class BrowserView<T> {
 
     BrowserViewMap[this.id] = this;
     this.ptr = this.init();
+    
+    // If HTML content was provided, load it after webview creation
+    if (this.html) {
+      console.log(`DEBUG: BrowserView constructor triggering loadHTML for webview ${this.id}`);
+      // Small delay to ensure webview is ready
+      setTimeout(() => {
+        console.log(`DEBUG: BrowserView delayed loadHTML for webview ${this.id}`);
+        this.loadHTML(this.html!);
+      }, 100);  // Back to 100ms since we fixed the race condition
+    } else {
+      console.log(`DEBUG: BrowserView constructor - no HTML provided for webview ${this.id}`);
+    }
   }
 
   init() {    
@@ -138,7 +150,8 @@ export class BrowserView<T> {
       hostWebviewId: this.hostWebviewId || null,
       pipePrefix: this.pipePrefix,
       partition: this.partition,      
-      url: this.url,      
+      // Only pass URL if no HTML content is provided to avoid conflicts
+      url: this.html ? null : this.url,      
       html: this.html,
       preload: this.preload,
       frame: {
@@ -194,16 +207,23 @@ export class BrowserView<T> {
   }
 
   loadURL(url: string) {
+    console.log(`DEBUG: loadURL called for webview ${this.id}: ${url}`);
     this.url = url;    
     native.symbols.loadURLInWebView(this.ptr, toCString(this.url))      
   }
 
   loadHTML(html: string) {
-    // Note: CEF doesn't natively support "setting html" so we just return
-    // this BrowserView's html when a special views:// url is hit.
-    // So we can update that content and ask the webview to load that url
     this.html = html;
-    this.loadURL('views://internal/index.html');
+    console.log(`DEBUG: Setting HTML content for webview ${this.id}:`, html.substring(0, 50) + '...');
+    
+    if (this.renderer === 'cef') {
+      // For CEF, store HTML content in native map and use scheme handler
+      native.symbols.setWebviewHTMLContent(this.id, toCString(html));
+      this.loadURL('views://internal/index.html');
+    } else {
+      // For WKWebView, load HTML content directly
+      native.symbols.loadHTMLInWebView(this.ptr, toCString(html));
+    }
   }
 
 

package/dist/api/bun/events/webviewEvents.ts

@@ -12,5 +12,13 @@ export default {
   domReady: (data) =>
     new ElectrobunEvent<{ detail: string }, {}>("dom-ready", data),
   newWindowOpen: (data) =>
-    new ElectrobunEvent<{ detail: string }, {}>("new-window-open", data),
+    new ElectrobunEvent<{ 
+      detail: string | {
+        url: string;
+        isCmdClick: boolean;
+        modifierFlags?: number;
+        targetDisposition?: number;
+        userGesture?: boolean;
+      }
+    }, {}>("new-window-open", data),
 };

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

@@ -110,6 +110,10 @@ export const native = (() => {
         args: [FFIType.ptr, FFIType.cstring],
         returns: FFIType.void
       },
+      loadHTMLInWebView: {
+        args: [FFIType.ptr, FFIType.cstring],
+        returns: FFIType.void
+      },
      
       updatePreloadScriptToWebView: {
         args: [
@@ -136,6 +140,10 @@ export const native = (() => {
         args: [FFIType.ptr],
         returns: FFIType.void
       },
+      setWebviewHTMLContent: {
+        args: [FFIType.u32, FFIType.cstring],
+        returns: FFIType.void
+      },
       startWindowMove: {
         args: [FFIType.ptr],
         returns: FFIType.void
@@ -885,7 +893,7 @@ const getHTMLForWebviewSync = new JSCallback((webviewId) => {
   
   return toCString(webview?.html || '');
 }, {
-  args: [FFIType.cstring],  
+  args: [FFIType.u32],  
   returns: FFIType.cstring,
   // threadsafe: true
 });
@@ -907,14 +915,32 @@ const webviewDecideNavigation = new JSCallback((webviewId, url) => {
 });
 
 
-const webviewEventHandler = (id, eventName, detail) => {
+const webviewEventHandler = (id, eventName, detail) => {    
   const webview = BrowserView.getById(id);
+  if (!webview) {
+    console.error('[webviewEventHandler] No webview found for id:', id);
+    return;
+  }
+  
   if (webview.hostWebviewId) {
+    const hostWebview = BrowserView.getById(webview.hostWebviewId);
+
+    if (!hostWebview) {
+      console.error('[webviewEventHandler] No webview found for id:', id);
+      return;
+    }
+
     // This is a webviewtag so we should send the event into the parent as well
     // TODO XX: escape event name and detail to remove `
-    const js = `document.querySelector('#electrobun-webview-${id}').emit(\`${eventName}\`, \`${detail}\`);`
+    // NOTE: for new-window-open the detail is a json string that needs to be parsed
+    let js;
+    if (eventName === 'new-window-open') {
+      js = `document.querySelector('#electrobun-webview-${id}').emit(\`${eventName}\`, ${detail});`    
+    } else {
+      js = `document.querySelector('#electrobun-webview-${id}').emit(\`${eventName}\`, \`${detail}\`);`
+    }
     
-    native.symbols.evaluateJavaScriptWithNoCompletion(webview.ptr, toCString(js))        
+    native.symbols.evaluateJavaScriptWithNoCompletion(hostWebview.ptr, toCString(js))        
   }
     
   const eventMap = {
@@ -931,28 +957,50 @@ const webviewEventHandler = (id, eventName, detail) => {
     electrobunEventEmitter.events.webview[eventMap[eventName]];
 
   if (!handler) {
-    
+    console.error('[webviewEventHandler] No handler found for event:', eventName, '(mapped to:', eventMap[eventName], ')');
     return { success: false };
   }
 
+  // Parse JSON data for new-window-open events
+  let parsedDetail = detail;
+  if (eventName === "new-window-open") {    
+    try {
+      parsedDetail = JSON.parse(detail);      
+    } catch (e) {
+      console.error('[webviewEventHandler] Failed to parse JSON:', e);
+      // Fallback to string if parsing fails (backward compatibility)
+      parsedDetail = detail;
+    }
+  }
+
   const event = handler({
     id,
-    detail,
-  });
+    detail: parsedDetail,
+  });  
 
   let result;
-  // global event
-  result = electrobunEventEmitter.emitEvent(event);      
-  result = electrobunEventEmitter.emitEvent(event, id);
+  // global event  
+  result = electrobunEventEmitter.emitEvent(event);        
+  result = electrobunEventEmitter.emitEvent(event, id);  
 }
 
-const webviewEventJSCallback = new JSCallback((id, _eventName, _detail) => {  
-  const eventName = new CString(_eventName);
-  const detail = new CString(_detail);
-
+const webviewEventJSCallback = new JSCallback((id, _eventName, _detail) => {    
+  let eventName = "";
+  let detail = "";
+  
+  try {
+    // Convert cstring pointers to actual strings
+    eventName = new CString(_eventName).toString();
+    detail = new CString(_detail).toString();
+  } catch (err) {
+    console.error('[webviewEventJSCallback] Error converting strings:', err);
+    console.error('[webviewEventJSCallback] Raw values:', { _eventName, _detail });
+    return;
+  }
+  
   webviewEventHandler(id, eventName, detail);    
 }, {
-  args: [FFIType.u32, FFIType.cstring],
+  args: [FFIType.u32, FFIType.cstring, FFIType.cstring],
   returns: FFIType.void,
   threadsafe: true
 });
@@ -1200,6 +1248,10 @@ export const internalRpcHandlers = {
         console.error(`webviewTagUpdateHtml: BrowserView not found or has no ptr for id ${params.id}`);
         return;
       }   
+      
+      // Store HTML content in native map for scheme handlers
+      native.symbols.setWebviewHTMLContent(webview.id, toCString(params.html));
+      
       webview.loadHTML(params.html);
       webview.html = params.html;
     },

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "electrobun",
-  "version": "0.1.7",
+  "version": "0.1.9",
   "description": "Build ultra fast, tiny, and cross-platform desktop apps with Typescript.",
   "license": "MIT",
   "author": "Blackboard Technologies Inc.",

package/src/cli/index.ts

@@ -261,7 +261,7 @@ async function ensureCoreDependencies(targetOS?: 'macos' | 'win' | 'linux', targ
     if (existsSync(extractedMainJs) && !existsSync(sharedMainJs)) {
       console.log('Development fallback: copying main.js from platform-specific download to shared dist/');
       mkdirSync(sharedDistPath, { recursive: true });
-      cpSync(extractedMainJs, sharedMainJs);
+      cpSync(extractedMainJs, sharedMainJs, { dereference: true });
     }
     
     console.log(`Core dependencies for ${platformOS}-${platformArch} downloaded and cached successfully`);
@@ -1122,7 +1122,7 @@ if (commandArg === "init") {
     dereference: true,
   });
 
-  cpSync(targetPaths.MAIN_JS, join(appBundleFolderResourcesPath, 'main.js'));
+  cpSync(targetPaths.MAIN_JS, join(appBundleFolderResourcesPath, 'main.js'), { dereference: true });
 
   // Bun runtime binary
   // todo (yoav): this only works for the current architecture
@@ -1163,7 +1163,7 @@ if (commandArg === "init") {
     "WebView2Loader.dll"
   );  ;
   // copy webview2 system webview library
-  cpSync(webview2LibSource, webview2LibDestination);
+  cpSync(webview2LibSource, webview2LibDestination, { dereference: true });
   
 } else if (targetOS === 'linux') {
   // Choose the appropriate native wrapper based on bundleCEF setting
@@ -1250,7 +1250,7 @@ if (commandArg === "init") {
         const sourcePath = join(cefSourcePath, dllFile);
         const destPath = join(appBundleMacOSPath, dllFile);
         if (existsSync(sourcePath)) {
-          cpSync(sourcePath, destPath);
+          cpSync(sourcePath, destPath, { dereference: true });
         }
       });
       
@@ -1258,7 +1258,7 @@ if (commandArg === "init") {
       const icuDataSource = join(cefSourcePath, 'icudtl.dat');
       const icuDataDest = join(appBundleMacOSPath, 'icudtl.dat');
       if (existsSync(icuDataSource)) {
-        cpSync(icuDataSource, icuDataDest);
+        cpSync(icuDataSource, icuDataDest, { dereference: true });
       }
       
       // Copy essential CEF pak files to MacOS root (same folder as libcef.dll) - required for CEF resources
@@ -1268,7 +1268,7 @@ if (commandArg === "init") {
         const destPath = join(appBundleMacOSPath, pakFile);
 
         if (existsSync(sourcePath)) {
-          cpSync(sourcePath, destPath);
+          cpSync(sourcePath, destPath, { dereference: true });
         } else {
           console.log(`WARNING: Missing CEF file: ${sourcePath}`);
         }
@@ -1298,7 +1298,7 @@ if (commandArg === "init") {
       if (existsSync(helperSourcePath)) {
         cefHelperNames.forEach((helperName) => {
           const destinationPath = join(appBundleMacOSPath, `${helperName}.exe`);
-          cpSync(helperSourcePath, destinationPath);
+          cpSync(helperSourcePath, destinationPath, { dereference: true });
           
         });
       } else {
@@ -1331,7 +1331,7 @@ if (commandArg === "init") {
         const icuDataSource = join(cefSourcePath, 'icudtl.dat');
         const icuDataDest = join(appBundleMacOSPath, 'icudtl.dat');
         if (existsSync(icuDataSource)) {
-          cpSync(icuDataSource, icuDataDest);
+          cpSync(icuDataSource, icuDataDest, { dereference: true });
         }
         
         // Copy .pak files and other CEF resources to the main executable directory
@@ -1350,7 +1350,7 @@ if (commandArg === "init") {
           const sourcePath = join(cefSourcePath, pakFile);
           const destPath = join(appBundleMacOSPath, pakFile);
           if (existsSync(sourcePath)) {
-            cpSync(sourcePath, destPath, { recursive: true });
+            cpSync(sourcePath, destPath, { recursive: true, dereference: true });
           }
         });
         
@@ -1365,7 +1365,7 @@ if (commandArg === "init") {
           const sourcePath = join(cefSourcePath, soFile);
           const destPath = join(cefResourcesDestination, soFile);
           if (existsSync(sourcePath)) {
-            cpSync(sourcePath, destPath);
+            cpSync(sourcePath, destPath, { dereference: true });
             console.log(`Copied CEF library to cef subdirectory: ${soFile}`);
           } else {
             console.log(`WARNING: Missing CEF library: ${sourcePath}`);
@@ -1378,7 +1378,7 @@ if (commandArg === "init") {
           const sourcePath = join(cefSourcePath, cefFile);
           const destPath = join(cefResourcesDestination, cefFile);
           if (existsSync(sourcePath)) {
-            cpSync(sourcePath, destPath);
+            cpSync(sourcePath, destPath, { dereference: true });
             console.log(`Copied CEF essential file to cef subdirectory: ${cefFile}`);
           } else {
             console.log(`WARNING: Missing CEF essential file: ${sourcePath}`);
@@ -1403,7 +1403,7 @@ if (commandArg === "init") {
             } catch (error) {
               console.log(`WARNING: Failed to create symlink for ${soFile}: ${error}`);
               // Fallback to copying the file
-              cpSync(cefFilePath, mainDirPath);
+              cpSync(cefFilePath, mainDirPath, { dereference: true });
               console.log(`Fallback: Copied CEF library to main directory: ${soFile}`);
             }
           }
@@ -1422,7 +1422,7 @@ if (commandArg === "init") {
         if (existsSync(helperSourcePath)) {
           cefHelperNames.forEach((helperName) => {
             const destinationPath = join(appBundleMacOSPath, helperName);
-            cpSync(helperSourcePath, destinationPath);
+            cpSync(helperSourcePath, destinationPath, { dereference: true });
             // console.log(`Copied CEF helper: ${helperName}`);
           });
         } else {
@@ -1706,7 +1706,7 @@ if (commandArg === "init") {
     );
 
     // copy the zstd tarball to the self-extracting app bundle
-    cpSync(compressedTarPath, compressedTarballInExtractingBundlePath);
+    cpSync(compressedTarPath, compressedTarballInExtractingBundlePath, { dereference: true });
 
     const selfExtractorBinSourcePath = targetPaths.EXTRACTOR;
     const selfExtractorBinDestinationPath = join(
@@ -1973,7 +1973,7 @@ exec "\$LAUNCHER_BINARY" "\$@"
 
     artifactsToUpload.forEach((filePath) => {
       const filename = basename(filePath);
-      cpSync(filePath, join(artifactFolder, filename));
+      cpSync(filePath, join(artifactFolder, filename), { dereference: true });
     });
 
     // todo: now just upload the artifacts to your bucket replacing the ones that exist
@@ -2409,7 +2409,7 @@ async function createAppImage(buildFolder: string, appBundlePath: string, appFil
     
     // Copy app bundle contents to AppDir
     const appDirAppPath = join(appDirPath, "app");
-    cpSync(appBundlePath, appDirAppPath, { recursive: true });
+    cpSync(appBundlePath, appDirAppPath, { recursive: true, dereference: true });
     
     // Create AppRun script (main executable for AppImage)
     const appRunContent = `#!/bin/bash
@@ -2443,7 +2443,7 @@ Categories=Application;
     const iconPath = config.build.linux?.appImageIcon;
     if (iconPath && existsSync(iconPath)) {
       const iconDestPath = join(appDirPath, `${appFileName}.png`);
-      cpSync(iconPath, iconDestPath);
+      cpSync(iconPath, iconDestPath, { dereference: true });
     }
     
     // Try to create AppImage using available tools