positron.js 1.0.3 → 1.0.5

package/index.js

@@ -267,7 +267,8 @@ class Window extends Events.EventEmitter {
    * @param {string} command 
    * @param {string[]} args 
    */
-  sendCommand(command, args = []) {
+  sendCommand(command, ...args) {
+    if(args[0] instanceof Array) args = args[0].concat(args.slice(1));
     const normalizedArgs = Array.isArray(args) ? args.map(String) : [String(args)];
     
     const payload = JSON.stringify({ 
@@ -316,7 +317,7 @@ class Window extends Events.EventEmitter {
    * @param {string} path The path to the file to load.
    */
   async loadFile(path) {
-    const res = await this.request("loadFile", `loadFile-reply-${this.id}`, path);
+    const res = await this.request("loadFile", { replyChannel: `loadFile-reply-${this.id}` }, path);
     this.emit("file-loaded", path);
     this.emit("navigated", path);
     return res;
@@ -327,7 +328,7 @@ class Window extends Events.EventEmitter {
    * @param {string} url The URL to load.
    */
   async loadURL(url) {
-    const res = await this.request("loadURL", `loadURL-reply-${this.id}`, url);
+    const res = await this.request("loadURL", { replyChannel: `loadURL-reply-${this.id}` }, url);
     this.emit("url-loaded", url);
     this.emit("navigated", url);
     return res;
@@ -338,7 +339,7 @@ class Window extends Events.EventEmitter {
    * @param {string} channel The IPC channel to send the message on.
    * @param {string[]} args The arguments to send with the message.
    */
-sendIpc(channel, args = []) {
+emitToRenderer(channel, args = []) {
   if (activeSocket && activeSocket.readyState === WebSocket.OPEN) {
     const payload = JSON.stringify({
       windowId: this.id,
@@ -348,10 +349,19 @@ sendIpc(channel, args = []) {
     activeSocket.send(payload);
     this.emit("ipc-sent", { channel, args });
   } else {
-    warn(`Cannot send IPC message, socket not ready. Channel: ${channel}`);
+    warn(`Cannot send IPC message on ${channel}, socket not ready.`);
   }
 }
 
+
+/**
+ * @deprecated Use emitToRenderer instead.
+ */
+sendIpc = (channel, args = []) => {
+  warn("sendIpc is deprecated. Use emitToRenderer instead.");
+  this.emitToRenderer(channel, args);
+}
+
  #created = false;
 
  /**
@@ -405,6 +415,10 @@ create(width, height, darwinOptions = {
     this.sendCommand("forceCloseWindow");
   }
 
+  isClosed() {
+    return !activeWindows.has(this);
+  }
+
 
   /**
    * Sets the application menu for this window.
@@ -488,10 +502,6 @@ resize(width, height) {
  * Opens the developer tools for the window. Emits a "devtools-opened" event when done. Does not work on macOS. For macOS, right-click the window and select "Inspect Element" to open dev tools for that window.
  */
 openDevTools() {
-  if(process.platform === "darwin") {
-    warn("The openDevTools command is not supported on macOS due to OS limitations. Please right-click the window and select 'Inspect Element' to access developer tools.");
-    return;
-  }
   this.sendCommand("openDevTools");
   this.emit("devtools-opened");
 }
@@ -560,6 +570,26 @@ focus() {
   this.emit("focused");
 }
 
+/**
+ * Checks if the window is currently visible. Returns a Promise that resolves to true if the window is visible, or false if it is hidden. Emits an "is-visible-checked" event with the result as data when done.
+ * @returns {Promise<boolean>} True if the window is visible, false otherwise.
+ */
+async isVisible() {
+  const res = await this.request("isVisible");
+  return res?.isVisible === "true";
+}
+
+/**
+ * Checks if the window is currently in fullscreen mode.
+ * @returns {Promise<boolean>} True if the window is fullscreen, false otherwise.
+ */
+async isFullscreen() {
+  const res = await this.request("isFullscreen");
+  return res?.isFullscreen === "true";
+}
+
+
+
 /**
  * Reloads the window. Emits a "reloaded" event when done.
  */
@@ -573,7 +603,7 @@ reload() {
  * @returns {Promise<Buffer|null>} The captured screenshot as a Buffer, or null if the capture failed.
  */
 async capturePage() {
- const response = await this.request("capturePage", `capture-page-result-${this.id}`);
+ const response = await this.request("capturePage", { replyChannel: `capture-page-result-${this.id}` });
  return response.image ? Buffer.from(response.image, "base64") : null;
 }
 
@@ -582,52 +612,94 @@ async capturePage() {
  * @returns {Promise<boolean>} True if the window can navigate back, false otherwise.
  */
 async canGoBack() {
- const response = await this.request("canGoBack", `canGoBack-reply-${this.id}`);
+ const response = await this.request("canGoBack");
  return response === "true";
 }
 
+// @ts-check
+
+/**
+ * @typedef {Object} RequestOptions
+ * @property {number} [timeout]
+ * @property {boolean} [noTimeout]
+ * @property {string} [replyChannel]
+ */
+
 /**
- * Sends a request/response command to the native layer. The command will be sent, and the method will wait for a response on the specified reply channel. Once a response is received, the promise will resolve with the reply data.
- * @param {string} command The command to send.
- * @param {string} replyChannel The channel to listen for the reply on.
- * @returns {Promise<*>} A promise that resolves to the reply data.
+ * @overload
+ * @param {string} command
+ * @param {...any} args
+ * @returns {Promise<any>}
  */
-async request(command, replyChannel, ...args) {
+
+/**
+ * @overload
+ * @param {string} command
+ * @param {RequestOptions} options
+ * @param {...any} args
+ * @returns {Promise<any>}
+ */
+
+/**
+ * Send an IPC request.
+ * @param {string} command
+ * @param {...any} args
+ */
+async request(command, ...args) {
   return new Promise((resolve, reject) => {
     let settled = false;
 
+    let options = {};
+
+    if(typeof args[0] === "object" && args[0].constructor === Object) {
+      options = args[0];
+      args = args.slice(1);
+    }
+
     if(!command) {
       reject(new Error("Command is required for request"));
       return;
     }
 
-    if(!replyChannel) {
-      replyChannel = `${command}-reply-${this.id}`;
-    }
+    const reqId = crypto.randomUUID();
+
+    let replyChannel = `${command}-reply-${reqId}`;
+
+  if (options.replyChannel) {
+  replyChannel = options.replyChannel;
+} else if(args[0] && (args[0].includes("-reply-") || args[0].includes("-result-"))) {
+  // TEMP TRANSITIONAL LOGIC TO SUPPORT LEGACY REQUESTS THAT PASS REPLY CHANNEL AS FIRST ARGUMENT. WILL BE REMOVED IN A FUTURE RELEASE.
+  replyChannel = args[0];
+}
 
     const unsubscribe = ipc.handle(replyChannel, (data) => {
       if (!settled) {
         settled = true;
         clearTimeout(timeout);
         unsubscribe();
+
+        for (const key in data) {
+          if (data[key] === "true") {
+            data[key] = true;
+          } else if (data[key] === "false") {
+            data[key] = false;
+          } else if (!isNaN(data[key])) {
+            data[key] = Number(data[key]);
+          }
+        } 
+
         resolve(data);
       }
     });
 
     let timeout;
 
-    if(!args.includes("NO_TIMEOUT")) {
+    if(!options.noTimeout) {
       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]);
+if (options.timeout) {
+  timeoutDuration = options.timeout;
 }
       
     timeout = setTimeout(() => {
@@ -650,7 +722,7 @@ if (timeoutArg) {
  * @returns {Promise<boolean>} True if the window can navigate forward, false otherwise.
  */
 async canGoForward() {
-  const response = await this.request("canGoForward", `canGoForward-reply-${this.id}`);
+  const response = await this.request("canGoForward");
   return response === "true";
 }
 
@@ -715,7 +787,7 @@ setBounds(x, y, width, height) {
  * @returns {Promise<string|null>} The user's input as a string, or null if the user cancelled the prompt.
  */
 async prompt(message, defaultValue = "") {
-  const res = await this.request("prompt", `prompt-reply-${this.id}`, message, defaultValue);
+  const res = await this.request("prompt", message, defaultValue);
   this.emit("prompt", { message, defaultValue });
   return res?.input;
 }
@@ -747,8 +819,12 @@ setContextMenu(menuTemplate) {
   this.emit("context-menu-updated", menuTemplate);
 }
 
+/**
+ * Checks if the window is currently focused.
+ * @returns {Promise<boolean>} True if the window is focused, false otherwise.
+ */
 async isFocused() {
-  const res = await this.request("isFocused", `isFocused-reply-${this.id}`);
+  const res = await this.request("isFocused");
   return res?.isFocused === "true";
 }
 
@@ -757,7 +833,7 @@ async isFocused() {
  * @returns {Promise<{x: number, y: number, width: number, height: number}>} An object containing the window's bounds.
  */
 async getBounds() {
-  return await this.request("getBounds", `getBounds-reply-${this.id}`);
+  return await this.request("getBounds");
 }
 
 /**
@@ -765,7 +841,7 @@ async getBounds() {
  * @returns {Promise<string>} The current URL loaded in the window.
  */
 async getURL() {
-  return (await this.request("getURL", `getURL-reply-${this.id}`))?.url || "";
+  return (await this.request("getURL"))?.url || "";
 }
 
 /**
@@ -773,7 +849,7 @@ async getURL() {
  * @returns {Promise<string>} The current title of the window.
  */
 async getTitle() {
-  return (await this.request("getTitle", `getTitle-reply-${this.id}`)).title || "";
+  return (await this.request("getTitle"))?.title || "";
 }
 
 /**
@@ -800,7 +876,7 @@ setTitlebarTransparent(isTransparent) {
  * @returns {Promise<*>} A Promise that resolves to the result of the evaluation.
  */
 async evaluateJavaScript(script) {
-const res = await this.request("evaluateJS", `evaluateJS-reply-${this.id}`, script);
+const res = await this.request("evaluateJS", script);
 return res.result;
 }
 
@@ -950,7 +1026,7 @@ async removeOnClick(selector) {
  * @returns {Promise<boolean>} True if the user confirmed, false if the user cancelled.
  */
 async confirm(message) {
-  const res = await this.request("confirm", `confirm-reply-${this.id}`, message);
+  const res = await this.request("confirm", message);
   this.emit("confirm", message);
   return res?.confirmed === "true";
 }
@@ -961,10 +1037,70 @@ async confirm(message) {
  * @returns {Promise<void>} A Promise that resolves when the swipe navigation setting has been updated.
  */
 async setSwipeNavigation(enabled) {
-const res = await this.request("setSwipeNav", `setSwipeNav-reply-${this.id}`, String(enabled));
+const res = await this.request("setSwipeNav", String(enabled));
 this.emit("swipe-navigation-updated", enabled);
 }
 
+/**
+ * Checks if swipe navigation is enabled for the window. Returns a Promise that resolves to true if swipe navigation is enabled, or false if it is disabled. Emits an "is-swipe-navigation-enabled-checked" event with the result as data when done.
+ * @returns {Promise<boolean>} True if swipe navigation is enabled, false otherwise.
+ */
+async isSwipeNavigationEnabled() {
+  const res = await this.request("isSwipeNavEnabled");
+  return res?.enabled === "true";
+}
+
+/**
+ * Adds content blocker rules to the window. The rules can be provided as a JSON object, loaded from a URL that returns JSON, or loaded from a local file. 
+ * Once the rules are added, the window will block content according to the specified rules. Emits a "content-blocker-updated" event with the new rules as data when done.
+ * @param {Object} config The configuration for adding content blocker rules.
+ * @param {Object[]} [config.json] An array of content blocker rules as JSON objects. Each rule should follow the format specified by the native layer's content blocking implementation.
+ * @param {string} [config.url] A URL that returns a JSON array of content blocker rules. If provided, the rules will be loaded from this URL instead of using the `json` property.
+ * @param {string} [config.file] A local file path containing the content blocker rules in JSON format. If provided, the rules will be loaded from this file instead of using the `json` or `url` properties.
+ * @param {boolean} [config.reload] Whether to reload the window after adding the content blocker rules. Reloading may be necessary for the new rules to take effect immediately, but it can also be set to false if you want to add rules without interrupting the user's current session.
+ * @param {boolean} [config.clearExisting] Whether to clear existing content blocker rules before adding the new ones. If false, the new rules will be added alongside any existing rules. If true, all existing rules will be removed before adding the new ones.
+ * @platform macOS only
+ * @see https://webkit.org/blog/3476/content-blockers-first-look/
+ */
+async addToContentBlocker(config={ json:[], url:"", file:"", reload:true, clearExisting: false }) {
+
+  if(process.platform !== "darwin") return;
+
+  let json = config.json || [];
+
+  if(config.file) {
+    json = config.file
+  } else {
+  if(config.url) {
+    let req = (await fetch(config.url));
+    let _json = await req.json();
+
+    if(json.length) {
+      json = json.concat(_json);
+    } else {
+      json = _json;
+    }
+  }
+
+  json = JSON.stringify(json);
+}
+
+
+  const res = await this.request("addToContentBlocker", json, config.reload, config.clearExisting);
+  this.emit("content-blocker-updated", json);
+}
+
+/**
+ * Displays a file open dialog and returns a Promise that resolves to an array of selected file paths, or null if the user cancelled the dialog.
+ * @param {*} options The options for the file open dialog.
+ * @returns 
+ */
+async showFileOpenDialog(options = {}) {
+  this.emit("show-file-open-dialog", options);
+  return this.request("showFileOpenDialog", options);
+}
+
+
 }
 
 const app = {
@@ -1047,9 +1183,10 @@ const app = {
 userData: {
   /**
    * Gets the path to the user data directory for the application. The path is determined based on the operating system and the application name. If the directory does not exist, it will be created. Emits a "user-data-path-retrieved" event with the path as data when done.
+   * @param {string} [append] An optional string to append to the user data path. This can be used to create subdirectories within the user data directory for organizing different types of data. If provided, the appended path will also be created if it does not exist.
    * @returns {string} The path to the user data directory.
    */
-  getPath() {
+  getPath(append) {
     let userPath = null;
 
     if (process.platform === "win32") {
@@ -1074,7 +1211,7 @@ userData: {
       fs.mkdirSync(userPath, { recursive: true });
   }
 
-    return userPath;
+    return append ? path.join(userPath, append) : userPath;
   },
 
   /**
@@ -1108,11 +1245,71 @@ userData: {
   /**
    * Full access to the underlying event emitter for application-level events, allowing for advanced event handling patterns if needed.
    */
-  events: appEvents
+  events: appEvents,
+
+  /**
+   * Sends a command to the native layer. This is a low-level method that can be used to send arbitrary commands, but for most use cases you will want to use the higher-level methods provided by the Window class instead. Emits an "ipc-sent" event with the command and arguments as data when done.
+   * @param {string} command The command to send to the native layer.
+   * @param {any[]} args The arguments to send with the command.
+   */
+  sendToNative(command, args) {
+   const firstWin = activeWindows.values().next().value;
+    if (firstWin) {
+      firstWin.sendCommand(command, args);
+    } else {
+      error("No active windows to send command to native layer");
+    }
+  },
+  
+  /**
+   * Sends a request to the native layer and returns a Promise that resolves to the response. This is a low-level method that can be used to send arbitrary requests, but for most use cases you will want to use the higher-level methods provided by the Window class instead. Emits an "ipc-request-sent" event with the command and arguments as data when done.
+   * @param {string} command The command to send to the native layer.
+   * @param {any[]} args The arguments to send with the command.
+   * @returns {Promise<any>} A Promise that resolves to the response from the native layer.
+   */
+  async requestFromNative(command, ...args) {
+    const firstWin = activeWindows.values().next().value;
+    if (firstWin) {
+      return await firstWin.request(command, ...args);
+    } else {
+      error("No active windows to send request to native layer");
+      return null;
+    }
+  },
+
+  async isDarkMode() {
+    const res = await this.requestFromNative("isDarkMode");
+    return res?.isDarkMode;
+  }
+
+}
+
+const clipboard = {
+
+  async writeText(text) {
+    app.sendToNative("writeToClipboard", [text]);
+  },
+
+  async readText() {
+    const res = await app.requestFromNative("readFromClipboard");
+    return res.text || "";
+  }
+
+}
+
+const blockPowerSave = {
   
+  start() {
+    app.sendToNative("blockPowerSave");
+  },
+
+  stop() {
+    app.sendToNative("unblockPowerSave");
+  }
+
 }
 
-module.exports = { Window, ipc, isPackaged, app, PORT };
+module.exports = { Window, ipc, isPackaged, app, PORT, clipboard, blockPowerSave };
 
 const findNearestPackageJson = require("./findpackage");
 

package/package.json

@@ -5,7 +5,7 @@
     "url": "https://github.com/systemsoftware/positron.js"
   },
   "homepage": "https://positronjs.gitbook.io",
-  "version": "1.0.3",
+  "version": "1.0.5",
   "main": "index.js",
   "scripts": {
     "test": "node --test"
@@ -13,7 +13,13 @@
   "keywords": [
     "app",
     "framework",
-    "desktop"
+    "desktop",
+    "cross-platform",
+    "native",
+    "javascript",
+    "node",
+    "macos",
+    "windows"
   ],
   "author": "Bryce",
   "license": "MIT",
@@ -21,6 +27,7 @@
   "dependencies": {
     "@yao-pkg/pkg": "^6.20.0",
     "esbuild": "^0.28.0",
+    "semver": "^7.8.1",
     "ws": "^8.20.1"
   },
   "bin": {

package/packager.js

@@ -1,6 +1,6 @@
 const fs = require("fs");
 const path = require("path");
-const { execSync } = require("child_process");
+const { execSync, execFileSync } = require("child_process");
 const { info, error, success } = require("./logs");
 const https = require("https");
 const esbuild = require("esbuild");
@@ -70,9 +70,12 @@ async function packageMacOS(appRoot, distDir, appName) {
     error("Fatal: Native compiled binary missing from bin/. Run build first.");
     process.exit(1);
   }
-  fs.copyFileSync(compiledBinary, path.join(macosPath, appName));
-  fs.chmodSync(path.join(macosPath, appName), "755"); 
-  
+  const binaryPath = path.join(macosPath, appName);
+  fs.copyFileSync(compiledBinary, binaryPath);
+  fs.chmodSync(binaryPath, "755"); 
+
+
+
   const packageJsonPath = path.join(appRoot, "package.json");
   const package = JSON.parse(fs.readFileSync(packageJsonPath, "utf8"));
 
@@ -105,14 +108,29 @@ async function packageMacOS(appRoot, distDir, appName) {
   handleJavaScriptPipeline(appRoot, resourcesPath);
 
   const bundledJs = path.join(resourcesPath, "index.js");
+  const backendName = appName.replace(/([a-z0-9])([A-Z])/g, '$1-$2').replace(/[\s_]+/g, '-').toLowerCase() + '-backend';
   if (fs.existsSync(bundledJs)) {
-    await compileWithPkg(bundledJs, "darwin", resourcesPath, "positron-backend");
+    await compileWithPkg(bundledJs, "darwin", resourcesPath, backendName);
+    const binPathEscaped = path.join(resourcesPath, backendName).replace(/"/g, '\\"');
+   
+          try {
+        let swiftScript = "";
+     if(fs.existsSync(path.join(__dirname, ['positronicon', 'png'].join('.')))) {
+        const iconPathEscaped = path.join(__dirname, ['positronicon', 'png'].join('.')).replace(/"/g, '\\"');
+        swiftScript = `import Cocoa; NSWorkspace.shared.setIcon(NSImage(contentsOfFile: "${iconPathEscaped}"), forFile: "${binPathEscaped}", options: []);`;
+        }
+         execFileSync("swift", ["-e", swiftScript], { stdio: "ignore" });
+      } catch (err) {
+        error("Failed to set custom icon on native binary:", err);
+      }
     
-  //  fs.renameSync(targetNodePath, path.join(resourcesPath, "positron-backend"));
   }
 
   fs.rmSync(path.join(resourcesPath, "icon.ico"), { force: true });
 
+  if(!process.argv.includes('--keep-package-json') || !process.argv.includes('--kpj')) {
+    fs.rmSync(path.join(resourcesPath, "package.json"), { force: true });
+  }
 
   success(`Successfully packaged macOS app at: ${appBundlePath}`);
 }
@@ -162,9 +180,10 @@ async function packageWindows(appRoot, distDir, appName) {
   }
 
   const bundledJs = path.join(resourcesPath, "index.js");
+  const backendName = appName.replace(/([a-z0-9])([A-Z])/g, '$1-$2').replace(/[\s_]+/g, '-').toLowerCase() + '-backend';
   
   if (fs.existsSync(bundledJs)) {
-        await compileWithPkg(bundledJs, "win32", resourcesPath, "positron-backend");
+        await compileWithPkg(bundledJs, "win32", resourcesPath, backendName);
   } else {
     error(`[Packager] Fatal: Bundled JavaScript entry point missing at ${bundledJs}`);
     process.exit(1);
@@ -173,6 +192,10 @@ async function packageWindows(appRoot, distDir, appName) {
   fs.rmSync(path.join(resourcesPath, "icon.icns"), { force: true });
   fs.rmSync(path.join(resourcesPath, "icon.ico"), { force: true });
 
+    if(!process.argv.includes('--keep-package-json') || !process.argv.includes('--kpj')) {
+    fs.rmSync(path.join(resourcesPath, "package.json"), { force: true });
+  }
+
   const macBinaryPath = path.join(outputFolder, "positron-runtime");
   if (fs.existsSync(macBinaryPath)) {
     fs.rmSync(macBinaryPath);