positron.js 1.0.0 → 1.0.2

package/core/mac/main.swift

@@ -18,6 +18,7 @@ let AUTH_TOKEN: String = {
 }()
 
 var windowObservations: [Int: NSKeyValueObservation] = [:]
+var navigationDelegates: [Int: WebViewNavigationDelegate] = [:]
 
 
 import Foundation
@@ -225,6 +226,9 @@ func handleCommand(windowId: Int, command: String, args: [String]) {
         config.userContentController.addUserScript(preload)
 
         let webView = PositronWebView(frame: NSRect(origin: .zero, size: frame.size), configuration: config)
+        let navDelegate = WebViewNavigationDelegate(windowId: windowId)
+        webView.navigationDelegate = navDelegate
+        navigationDelegates[windowId] = navDelegate
         // Resize webview automatically when the window resizes
         webView.autoresizingMask = [.width, .height]
         newWindow.contentView = webView
@@ -242,6 +246,7 @@ func handleCommand(windowId: Int, command: String, args: [String]) {
         observation.invalidate()
         windowObservations.removeValue(forKey: windowId)
     }
+            navigationDelegates.removeValue(forKey: windowId)
 
 
             windows.removeValue(forKey: windowId)
@@ -305,7 +310,6 @@ case "forceCloseWindow":
         }
         (window.contentView as? WKWebView)?.load(URLRequest(url: url))
 
-
     case "hide":
         guard let window = windows[windowId] else { return }
         window.orderOut(nil)
@@ -344,7 +348,6 @@ case "forceCloseWindow":
         (window.contentView as? WKWebView)?
             .loadFileURL(fileURL, allowingReadAccessTo: fileURL.deletingLastPathComponent())
 
-
         case "setBounds":
             guard let window = windows[windowId] else { return }
             guard args.count >= 4,
@@ -682,6 +685,24 @@ case "resetMenu":
     }
 }
 
+// MARK: - WebView Navigation Delegate
+
+final class WebViewNavigationDelegate: NSObject, WKNavigationDelegate {
+    let windowId: Int
+
+    init(windowId: Int) {
+        self.windowId = windowId
+    }
+
+    func webView(_ webView: WKWebView, didFinish navigation: WKNavigation!) {
+        let isFile = webView.url?.isFileURL ?? false
+        let eventName = isFile ? "loadFile-reply-\(windowId)" : "loadURL-reply-\(windowId)"
+        AppDelegate.shared?.ipcClient.send(
+            IPCResponse(windowId: windowId, event: eventName, data: [:])
+        )
+    }
+}
+
 // MARK: - WebView → Swift IPC Handler
 
 /// Receives messages from renderer JS: window.webkit.messageHandlers.ipc.postMessage({...})

package/core/win/main.cs

@@ -102,11 +102,10 @@ namespace PositronWindows
 
         public static bool IsPackaged { get; private set; } = false;
 
-        private static IPCClient _ipcClient = null!;
+        public static IPCClient _ipcClient = null!;
         private static Process? _nodeProcess;
 
-        /// <summary>All window access must happen on the UI thread.</summary>
-        private static readonly Dictionary<int, Window> WindowsMap = new();
+        public static readonly Dictionary<int, Window> WindowsMap = new();
         private static readonly Dictionary<int, DockPanel> LayoutMap = new();
         private static readonly Dictionary<int, Menu> MenuMap = new();
         private static readonly HashSet<int> _forceClosing = new();
@@ -330,6 +329,17 @@ private void StartNodeProcess(string workingDirectory)
                         window.Title = webView.CoreWebView2.DocumentTitle;
                     };
 
+                    webView.CoreWebView2.NavigationCompleted += (s, e) =>
+                    {
+                        bool isFile = webView.Source != null && webView.Source.IsFile;
+                        string eventName = isFile ? $"loadFile-reply-{windowId}" : $"loadURL-reply-{windowId}";
+                        _ipcClient.Send(new IPCResponse
+                        {
+                            windowId = windowId,
+                            @event = eventName
+                        });
+                    };
+
             webView.CoreWebView2.ContextMenuRequested += (s, e) =>
 {
     if (LayoutMap.TryGetValue(windowId, out var l) && l.ContextMenu != null)
@@ -819,7 +829,7 @@ case "setBounds":
             }
         }
 
-        private static WebView2? GetWebView(int windowId)
+        public static WebView2? GetWebView(int windowId)
         {
             if (LayoutMap.TryGetValue(windowId, out var layout))
             {

package/index.js

@@ -226,6 +226,8 @@ let _windowCounter = 0;
 
 class Window extends Events.EventEmitter {
 
+  id = 0;
+
   /** Creates a new window instance. */
   constructor(options = {
 
@@ -292,16 +294,6 @@ class Window extends Events.EventEmitter {
     this.emit("title-updated", title); 
   }
 
-  /**
-   * Loads a remote URL in the window. Emits "url-loaded" and "navigated" events with the URL as data.
-   * @param {string} url The URL to load.
-   */
-  loadURL(url) { 
-    this.sendCommand("loadURL", [url]); 
-    this.emit("url-loaded", url); 
-    this.emit("navigated", url); 
-  }
-
   /**
    * Triggers the print dialog for the window. Emits a "print" event. Note that the actual print functionality and dialog is handled by the native layer, so behavior may vary across platforms.
    */
@@ -320,13 +312,25 @@ class Window extends Events.EventEmitter {
   }
 
   /**
-   * Loads a local file in the window. Emits "file-loaded" and "navigated" events with the file path as data.
+   * Loads a file into the window. The path can be an absolute file path or a relative path from the application's root directory. Emits a "file-loaded" event with the path as data, and a "navigated" event with the path as data.
    * @param {string} path The path to the file to load.
    */
-  loadFile(path) { 
-    this.sendCommand("loadFile", [path]); 
-    this.emit("file-loaded", path); 
-    this.emit("navigated", path); 
+  async loadFile(path) {
+    const res = await this.request("loadFile", `loadFile-reply-${this.id}`, path);
+    this.emit("file-loaded", path);
+    this.emit("navigated", path);
+    return res;
+  }
+
+  /**
+   * Loads a URL into the window. Emits a "url-loaded" event with the URL as data, and a "navigated" event with the URL as data.
+   * @param {string} url The URL to load.
+   */
+  async loadURL(url) {
+    const res = await this.request("loadURL", `loadURL-reply-${this.id}`, url);
+    this.emit("url-loaded", url);
+    this.emit("navigated", url);
+    return res;
   }
 
   /**
@@ -592,6 +596,15 @@ async request(command, replyChannel, ...args) {
   return new Promise((resolve, reject) => {
     let settled = false;
 
+    if(!command) {
+      reject(new Error("Command is required for request"));
+      return;
+    }
+
+    if(!replyChannel) {
+      replyChannel = `${command}-reply-${this.id}`;
+    }
+
     const unsubscribe = ipc.handle(replyChannel, (data) => {
       if (!settled) {
         settled = true;
@@ -601,15 +614,34 @@ async request(command, replyChannel, ...args) {
       }
     });
 
-    const timeout = setTimeout(() => {
+    let timeout;
+
+    if(!args.includes("NO_TIMEOUT")) {
+      let timeoutDuration = 7000;
+     
+      const timeoutArg = args.find(
+  arg => typeof arg === "string" && arg.startsWith("TIMEOUT=")
+);
+
+if (timeoutArg) {
+
+  args = args.filter(arg => arg !== timeoutArg);
+
+  timeoutDuration = parseInt(timeoutArg.split("=")[1], 10);
+}
+      
+    timeout = setTimeout(() => {
       if (!settled) {
         settled = true;
         unsubscribe();
         reject(new Error(`Request timed out waiting for reply on channel "${replyChannel}"`));
       }
-    }, 5000);
+    }, timeoutDuration);
+  } else {
+    args = args.filter(arg => arg !== "NO_TIMEOUT");
+  }
 
-    this.sendCommand(command, args);
+    this.sendCommand(command, [...args, replyChannel]);
   });
 }
 
@@ -772,6 +804,135 @@ const res = await this.request("evaluateJS", `evaluateJS-reply-${this.id}`, scri
 return res;
 }
 
+/**
+ * Gets the user agent string of the window. Returns a Promise that resolves to the user agent as a string.
+ * @returns {Promise<string>} The user agent string of the window.
+ */
+async getUserAgent() {
+  const res = await this.evaluateJavaScript("navigator.userAgent");
+  return res;
+}
+
+/**
+ * Sets the style of elements matching a CSS selector. Returns a Promise that resolves when the style has been applied.
+ * @param {string} selector The CSS selector for the elements to style.
+ * @param {Object} style The style properties to apply.
+ * @returns {Promise<void>} A Promise that resolves when the style has been applied.
+ */
+async setStyleOf(selector, style) {
+  const styleString = Object.entries(style).map(([key, value]) => `${key}: ${value};`).join(" ");
+  const script = `
+    const elements = document.querySelectorAll(${JSON.stringify(selector)});
+    elements.forEach(el => {
+      el.style.cssText += ${JSON.stringify(styleString)};
+    });
+  `;
+  await this.evaluateJavaScript(script);
+  this.emit("style-updated", { selector, style });
+}
+
+/**
+ * Sets an attribute of elements matching a CSS selector. Returns a Promise that resolves when the attribute has been set.
+ * @param {string} selector The CSS selector for the elements to update.
+ * @param {string} attribute The name of the attribute to set.
+ * @param {string} value The value to set for the attribute.
+ * @returns {Promise<void>} A Promise that resolves when the attribute has been set.
+ */
+async setAttributeOf(selector, attribute, value) {
+  const script = `
+    const elements = document.querySelectorAll(${JSON.stringify(selector)});
+    elements.forEach(el => {
+      el.setAttribute(${JSON.stringify(attribute)}, ${JSON.stringify(value)});
+    });
+  `;
+  await this.evaluateJavaScript(script);
+  this.emit("attribute-updated", { selector, attribute, value });
+}
+
+/**
+ * Removes an attribute from elements matching a CSS selector. Returns a Promise that resolves when the attribute has been removed.
+ * @param {string} selector The CSS selector for the elements to update.
+ * @param {string} attribute The name of the attribute to remove.
+ * @returns {Promise<void>} A Promise that resolves when the attribute has been removed.
+ */
+async removeAttributeOf(selector, attribute) {
+  const script = `
+    const elements = document.querySelectorAll(${JSON.stringify(selector)});
+    elements.forEach(el => {
+      el.removeAttribute(${JSON.stringify(attribute)});
+    });
+  `;
+  await this.evaluateJavaScript(script);
+  this.emit("attribute-removed", { selector, attribute });
+}
+
+/**
+ * Removes specific style properties from elements matching a CSS selector. Returns a Promise that resolves when the styles have been removed.
+ * @param {string} selector The CSS selector for the elements to update.
+ * @param {string[]} styleProperties The style properties to remove.
+ * @returns {Promise<void>} A Promise that resolves when the styles have been removed.
+ */
+async removeStyleOf(selector, styleProperties) {
+  const propertiesString = styleProperties.map(prop => `${prop}:`).join("|");
+  const script = `
+    const elements = document.querySelectorAll(${JSON.stringify(selector)});
+    elements.forEach(el => {
+      el.style.cssText = el.style.cssText.split(";").filter(rule => {
+        return !${JSON.stringify(propertiesString)}.includes(rule.trim().split(":")[0] + ":");
+      }).join(";");
+    });
+  `;
+  await this.evaluateJavaScript(script);
+  this.emit("style-removed", { selector, styleProperties });
+}
+
+/**
+ * Adds or replaces click handlers that emit IPC events.
+ *
+ * @param {string} selector - The CSS selector for the elements to attach the click handlers to.
+ * @param {string} channel - The IPC channel to emit events on when the elements are clicked.
+ * @param {{ replace?: boolean }} [options] - Optional settings for the click handlers. If `replace` is true, any existing IPC click handlers on the elements will be removed before adding the new handler. If false or omitted, the new handler will be added alongside existing handlers without removing them.
+ * @returns {Promise<void>} A Promise that resolves when the click handlers have been added.
+ */
+async onClick(selector, channel, { replace = true } = {}) {
+  const script = `
+      const selector = ${JSON.stringify(selector)};
+      const channel = ${JSON.stringify(channel)};
+      const replace = ${replace};
+
+      const elements = document.querySelectorAll(selector);
+
+      elements.forEach(el => {
+        if (replace) {
+          el.onclick = () => {
+            window.ipc.send(channel, { selector });
+          }
+        } else {
+        el.addEventListener("click", () => {
+          window.ipc.send(channel, { selector });
+        });  
+        }
+            })
+  `;
+
+  await this.evaluateJavaScript(script);
+}
+
+/**
+ * Removes click handlers that emit IPC events from elements matching the specified CSS selector. This will remove all click handlers that were added via the onClick method for the given selector, regardless of the channel or whether they were set to replace existing handlers.
+ * @param {string} selector The CSS selector for the elements to remove click handlers from.
+ * @returns {Promise<void>} A Promise that resolves when the click handlers have been removed.
+ */
+async removeOnClick(selector) {
+  const script = `
+    const elements = document.querySelectorAll(${JSON.stringify(selector)});
+    elements.forEach(el => {
+      el.onclick = null;
+    });
+  `;
+  await this.evaluateJavaScript(script);
+}
+
 }
 
 const app = {

package/package.json

@@ -2,10 +2,10 @@
   "name": "positron.js",
   "description": "A lightweight cross-platform hybrid application framework designed to build desktop applications using a native compiled runtime driven by a Node.js main process.",
   "repository": {
-    "url": "https://github.com/systemsoftware/positron-app"
+    "url": "https://github.com/systemsoftware/positron.js"
   },
   "homepage": "https://positronjs.gitbook.io",
-  "version": "1.0.0",
+  "version": "1.0.2",
   "main": "index.js",
   "scripts": {
     "test": "node --test"
@@ -21,7 +21,6 @@
   "dependencies": {
     "@yao-pkg/pkg": "^6.20.0",
     "esbuild": "^0.28.0",
-    "resedit": "^3.0.2",
     "ws": "^8.20.1"
   },
   "bin": {