positron.js 1.0.0

package/ipc.js

@@ -0,0 +1,81 @@
+const { warn } = require("./logs");
+
+module.exports = class IpcRouter {
+  #handlers = new Map();
+
+  /**
+   * Registers a handler for a specific IPC channel. Returns a function to unregister the handler.
+   * @param {string} channel 
+   * @param {function} fn 
+   * @returns {function} A function to unregister the handler.
+   */
+  handle(channel, fn) {
+    if (!this.#handlers.has(channel)) {
+      this.#handlers.set(channel, new Set());
+    }
+
+    this.#handlers.get(channel).add(fn);
+
+    return () => {
+      this.#handlers.get(channel)?.delete(fn);
+
+      if (this.#handlers.get(channel)?.size === 0) {
+        this.#handlers.delete(channel);
+      }
+    };
+  }
+
+  /**
+   * @internal
+   */
+ dispatch(ws, msg) {
+    if (msg.event !== "ipcMessage") return false;
+
+    const { channel, payload } = msg.data;
+
+    const parsed =
+      typeof payload === "string"
+        ? JSON.parse(payload)
+        : payload;
+
+    const handlers = this.#handlers.get(channel);
+
+    if (!handlers || handlers.size === 0) {
+      warn(`[ipc] No handlers for channel "${channel}"`);
+      return false;
+    }
+
+    const reply = (data) =>
+      this.send(ws, msg.windowId, channel + "-reply", data);
+
+    const emit = (ch, data) =>
+      this.send(ws, msg.windowId, ch, data);
+
+    for (const handler of handlers) {
+      try {
+        handler(parsed, {
+          reply,
+          emit,
+          windowId: msg.windowId,
+        });
+      } catch (err) {
+        warn(`[ipc] Handler error on "${channel}": ${err.stack || err}`);
+      }
+    }
+
+    return true;
+  }
+
+  /** @internal */
+  send(ws, windowId, channel, data = null) {
+    if (ws && ws.readyState === WebSocket.OPEN) {
+      ws.send(JSON.stringify({
+        windowId,
+        command: "emitToRenderer",
+        args: [channel, JSON.stringify(data)],
+      }));
+    } else {
+      warn(`[ipc] Cannot emit to renderer: socket connection is not open.`);
+    }
+  }
+}

package/logs.js

@@ -0,0 +1,19 @@
+module.exports.success = (...msgs) => {
+    console.log(`\x1b[32m[SUCCESS] ${msgs.join(' ').trim()}\x1b[0m`.trim());
+}
+
+module.exports.error = (...msgs) => {
+    console.error(`\x1b[31m[ERROR] ${msgs.join(' ').trim()}\x1b[0m`.trim());
+}
+
+module.exports.info = (...msgs) => {
+    console.info(`\x1b[34m[INFO] ${msgs.join(' ').trim()}\x1b[0m`.trim());
+}
+
+module.exports.warn = (...msgs) => {
+  console.warn(`\x1b[33m[WARN] ${msgs.join(' ').trim()}\x1b[0m`.trim());
+}
+
+module.exports.special = (...msgs) => {
+    console.log(`\x1b[35m${msgs.join(' ').trim()}\x1b[0m`.trim());
+}

package/menu.js

@@ -0,0 +1,100 @@
+class MenuItem {
+
+    /**
+     * Creates a new MenuItem instance with the specified properties. The label is the text displayed for the menu item, the channel is the IPC channel to send when the item is clicked, and the payload is the data to send along with the click event. The key is an optional identifier for the menu item, and items can be used to create submenus. The separator property indicates whether this item is a separator, and click is a callback function that will be called when the item is clicked. The enabled property determines whether the menu item is enabled or disabled.
+     * @param {Object} options - The options for creating the MenuItem.
+     * @param {string} options.label - The text displayed for the menu item.
+     * @param {string} options.channel - The IPC channel to send when the item is clicked.
+     * @param {Object} options.payload - The data to send along with the click event.
+     * @param {string} [options.key] - An optional identifier for the menu item.
+     * @param {MenuItem[]} [options.items] - An array of MenuItem instances to create a submenu.
+     * @param {boolean} [options.separator=false] - Whether this item is a separator.
+     * @param {function} [options.click=()=>{}] - A callback function that will be called when the item is clicked.
+     * @param {boolean} [options.enabled=true] - Whether the menu item is enabled or disabled.
+     */
+
+    constructor({ label="", channel="", payload={}, key="", items=[], separator=false, click=()=>{}, enabled=true }) {
+        this.label = label;
+        this.channel = channel;
+        this.payload = JSON.stringify(payload);
+        this.key = key;
+        this.items = items ? items.map(i => new MenuItem(i)) : null;
+        this.enabled = enabled;
+        this.click = click;
+        this.separator = separator || false;
+    }
+
+    /**
+     * Converts the MenuItem instance into a JSON object that can be used to create a menu
+     * @internal
+     */
+    json() {
+        return {
+            label: this.label,
+            channel: this.channel,
+            payload: this.payload,
+            key: this.key,
+            items: this.items ? this.items.map(i => i.json()) : null,
+            separator: this.separator,
+            enabled: this.enabled,
+            click: this.click
+        }
+    }
+}
+
+class Separator extends MenuItem {
+    /**
+     * Creates a new Separator instance, which is a type of MenuItem that represents a separator in a menu. 
+     */
+    constructor() {
+        super({ separator: true });
+    }
+}
+
+
+ class Menu {
+
+    #template = []
+
+    /**
+     * Creates a new Menu instance with an optional template. The template is an array of MenuItem instances that define the structure of the menu. If no template is provided, an empty menu will be created.
+     * @param {MenuItem[]} template - An array of MenuItem instances that define the structure of the menu.
+     */
+    constructor(template = []) {
+        this.#template = template;
+    }
+
+/**
+ * Gets the current template of the menu, which is an array of MenuItem instances that define the structure of the menu.
+ */
+get template() {
+  return this.#template;
+}
+
+/**
+ * Adds an item to the menu.
+ * @param {MenuItem} item - The MenuItem instance to add.
+ * @returns {Menu} The menu instance for chaining.
+ */
+addItem(item) {
+this.#template.push(item.json());
+return this;
+}
+
+/**
+ * Adds multiple items to the menu.
+ * @param {MenuItem[]} items - An array of MenuItem instances to add.
+ * @returns {Menu} The menu instance for chaining.
+ */
+addItems(items) {
+items.forEach(item => this.addItem(item));
+return this;
+}
+
+}
+
+module.exports = {
+    Menu,
+    MenuItem,
+    Separator
+}

package/package.json

@@ -0,0 +1,30 @@
+{
+  "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"
+  },
+  "homepage": "https://positronjs.gitbook.io",
+  "version": "1.0.0",
+  "main": "index.js",
+  "scripts": {
+    "test": "node --test"
+  },
+  "keywords": [
+    "app",
+    "framework",
+    "desktop"
+  ],
+  "author": "Bryce",
+  "license": "MIT",
+  "type": "commonjs",
+  "dependencies": {
+    "@yao-pkg/pkg": "^6.20.0",
+    "esbuild": "^0.28.0",
+    "resedit": "^3.0.2",
+    "ws": "^8.20.1"
+  },
+  "bin": {
+    "positron": "./bin/positron.js"
+  }
+}

package/packager.js

@@ -0,0 +1,260 @@
+const fs = require("fs");
+const path = require("path");
+const { execSync } = require("child_process");
+const { info, error, success } = require("./logs");
+const https = require("https");
+const esbuild = require("esbuild");
+const findPackageJson = require("./findpackage");
+
+const MAJOR_NODE_V = 24;
+
+const ob = process.argv.includes("--obfuscate");
+
+const arch = process.argv.includes("--x64") ? "x64" : process.argv.includes("--arm64") ? "arm64" : process.arch;
+
+function performPackager() {
+  const appRoot = process.cwd();
+  const rootPackage = findPackageJson(appRoot)?.packageJson;
+  
+  const appName = process.env.POSITRON_APP_NAME || rootPackage.productName || rootPackage.name || "PositronApp";
+  const distDir = path.join(appRoot, "dist");
+  
+  if (fs.existsSync(distDir)) fs.rmSync(distDir, { recursive: true, force: true });
+  fs.mkdirSync(distDir, { recursive: true });
+
+  if (process.argv.includes("--mac") || process.argv.includes("--m")) {
+    packageMacOS(appRoot, distDir, appName);
+  } else if (process.argv.includes("--windows") || process.argv.includes("--w")) {
+    packageWindows(appRoot, distDir, appName);
+  } else {
+    process.platform === "win32" ? packageWindows(appRoot, distDir, appName) : packageMacOS(appRoot, distDir, appName);
+  }
+}
+
+function handleJavaScriptPipeline(appRoot, resourcesPath) {
+  const targetOutputFile = path.join(resourcesPath, "index.js");
+
+    info(`[Packager] Bundling JavaScript code with esbuild...`);
+    try {
+      esbuild.buildSync({
+        entryPoints: [path.join(appRoot, "index.js")],
+        bundle: true,
+        platform: "node",
+        target: `node${MAJOR_NODE_V}`,
+        outfile: targetOutputFile,
+        minify: ob,
+        sourcemap: false,
+      });
+    } catch (err) {
+      error("Fatal: esbuild bundling failed.");
+      process.exit(1);
+    }
+
+    copyAppAssets(appRoot, resourcesPath);
+
+}
+
+async function packageMacOS(appRoot, distDir, appName) {
+  const appBundlePath = path.join(distDir, `${appName}.app`);
+  const contentsPath = path.join(appBundlePath, "Contents");
+  const macosPath = path.join(contentsPath, "MacOS");
+  const resourcesPath = path.join(contentsPath, "Resources"); 
+
+  fs.mkdirSync(macosPath, { recursive: true });
+  fs.mkdirSync(resourcesPath, { recursive: true });
+
+  info(`[Packager] Creating macOS App Bundle structure...`);
+
+  const compiledBinary = path.join(appRoot, "bin", "positron-runtime");
+  if (!fs.existsSync(compiledBinary)) {
+    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 packageJsonPath = path.join(appRoot, "package.json");
+  const package = JSON.parse(fs.readFileSync(packageJsonPath, "utf8"));
+
+  const plistContent = `<?xml version="1.0" encoding="UTF-8"?>
+<!DOCTYPE plist PUBLIC "-//Apple//DTD PLIST 1.0//EN" "http://www.apple.com/DTDs/PropertyList-1.0.dtd">
+<plist version="1.0">
+<dict>
+    <key>CFBundleExecutable</key>
+    <string>${appName}</string>
+    <key>CFBundleIdentifier</key>
+    <string>com.${package.author || "positron"}.${appName.toLowerCase()}</string>
+    <key>CFBundleName</key>
+    <string>${appName}</string>
+    <key>CFBundlePackageType</key>
+    <string>APPL</string>
+    <key>CFBundleShortVersionString</key>
+    <string>${package.version || "1.0.0"}</string>
+    <key>CFBundleIconFile</key>
+    <string>icon</string>
+    <key>NSHighResolutionCapable</key>
+    <true/>
+    <key>NSHumanReadableCopyright</key>
+    <string>${package.author || "Positron"}</string>
+    <key>LSApplicationCategoryType</key>
+    <string>${package.macCategory || "public.app-category.developer-tools"}</string>
+</dict>
+</plist>`;
+  fs.writeFileSync(path.join(contentsPath, "Info.plist"), plistContent);
+
+  handleJavaScriptPipeline(appRoot, resourcesPath);
+
+  const bundledJs = path.join(resourcesPath, "index.js");
+  if (fs.existsSync(bundledJs)) {
+    await compileWithPkg(bundledJs, "darwin", resourcesPath, "positron-backend");
+    
+  //  fs.renameSync(targetNodePath, path.join(resourcesPath, "positron-backend"));
+  }
+
+  fs.rmSync(path.join(resourcesPath, "icon.ico"), { force: true });
+
+
+  success(`Successfully packaged macOS app at: ${appBundlePath}`);
+}
+
+async function packageWindows(appRoot, distDir, appName) {
+  const outputFolder = path.join(distDir, appName);
+  fs.mkdirSync(outputFolder, { recursive: true });
+
+  info(`[Packager] Creating Windows App structure...`);
+
+  const binFolder = path.join(appRoot, "bin");
+  
+  function copyDirRecursive(src, dest) {
+    fs.readdirSync(src, { withFileTypes: true }).forEach(entry => {
+      const srcPath = path.join(src, entry.name);
+      const destPath = path.join(dest, entry.name);
+      if (entry.isDirectory()) {
+        fs.mkdirSync(destPath, { recursive: true });
+        copyDirRecursive(srcPath, destPath);
+      } else {
+        fs.copyFileSync(srcPath, destPath);
+      }
+    });
+  }
+
+  // Ensure binary source folder exists
+  if (!fs.existsSync(binFolder)) {
+    error("Fatal: bin/ directory missing. Run build first.");
+    process.exit(1);
+  }
+
+  copyDirRecursive(binFolder, outputFolder);
+
+  const resourcesPath = path.join(outputFolder, "resources");
+  fs.mkdirSync(resourcesPath, { recursive: true });
+
+  handleJavaScriptPipeline(appRoot, resourcesPath);
+
+  const oldBinaryPath = path.join(outputFolder, "positron-runtime.exe");
+  const newBinaryPath = path.join(outputFolder, `${appName}.exe`);
+  
+  if (fs.existsSync(oldBinaryPath)) {
+    fs.renameSync(oldBinaryPath, newBinaryPath);
+  } else if (!fs.existsSync(newBinaryPath)) {
+    error(`Fatal: Could not find base Windows executable template at ${oldBinaryPath}`);
+    process.exit(1);
+  }
+
+  const bundledJs = path.join(resourcesPath, "index.js");
+  
+  if (fs.existsSync(bundledJs)) {
+        await compileWithPkg(bundledJs, "win32", resourcesPath, "positron-backend");
+  } else {
+    error(`[Packager] Fatal: Bundled JavaScript entry point missing at ${bundledJs}`);
+    process.exit(1);
+  }
+
+  fs.rmSync(path.join(resourcesPath, "icon.icns"), { force: true });
+  fs.rmSync(path.join(resourcesPath, "icon.ico"), { force: true });
+
+  const macBinaryPath = path.join(outputFolder, "positron-runtime");
+  if (fs.existsSync(macBinaryPath)) {
+    fs.rmSync(macBinaryPath);
+  }
+
+  // Clean out empty extraction shell folders if they exist
+  fs.readdirSync(resourcesPath).forEach(file => {
+    const fullPath = path.join(resourcesPath, file);
+    if (fs.statSync(fullPath).isDirectory() && file.startsWith("node-v") && file !== "node") {
+      fs.rmSync(fullPath, { recursive: true, force: true });
+    }
+  });
+
+  success(`Successfully packaged Windows app directory at: ${outputFolder}`);
+}
+
+function copyAppAssets(src, dest) {
+  const ignoreList = ["node_modules", "dist", "bin", ".git"];
+  
+  function copyRecursive(currentSrc, currentDest) {
+    const items = fs.readdirSync(currentSrc);
+    for (const item of items) {
+      if (ignoreList.includes(item)) continue;
+
+      const srcPath = path.join(currentSrc, item);
+      const destPath = path.join(currentDest, item);
+      const stat = fs.statSync(srcPath);
+
+      if (stat.isFile() && (item === "package-lock.json" || item.endsWith(".log"))) {
+        continue;
+      }
+
+      if (stat.isDirectory()) {
+        fs.mkdirSync(destPath, { recursive: true });
+        copyRecursive(srcPath, destPath);
+      } else {
+        if (item.endsWith(".js")) continue;
+        fs.copyFileSync(srcPath, destPath);
+      }
+    }
+  }
+  copyRecursive(src, dest);
+}
+
+
+const { exec } = require("@yao-pkg/pkg");
+
+async function compileWithPkg(bundledJsPath, targetPlatform, outputFolder, appName) {
+  info(`[Packager] Packaging application into a standalone binary...`);
+
+  let pkgTarget = "";
+  let finalBinaryName = appName;
+
+  info(`[Packager] Detected target platform: ${targetPlatform}, architecture: ${arch}`);
+
+  if (targetPlatform === "win32") {
+    pkgTarget = `node${MAJOR_NODE_V}-win-${arch}`;
+    finalBinaryName = `${appName}.exe`;
+  } else if (targetPlatform === "darwin") {
+    pkgTarget = `node${MAJOR_NODE_V}-macos-${arch}`;
+  }
+
+  const outputPath = path.join(outputFolder, finalBinaryName);
+
+  const pkgArgs = [
+    bundledJsPath,
+    "--target", pkgTarget,
+    "--output", outputPath
+  ];
+
+  try {
+    await exec(pkgArgs);
+
+    if (fs.existsSync(bundledJsPath)) {
+      fs.rmSync(bundledJsPath);
+    }
+
+    success(`[Packager] pkg compilation complete: ${outputPath}`);
+  } catch (err) {
+    error(`[Packager] pkg compilation failed: ${err.message}`);
+    process.exit(1);
+  }
+}
+
+module.exports = performPackager;

package/screen.js

@@ -0,0 +1,35 @@
+const { execSync } = require('child_process');
+
+/**
+ * Gets the screen size of the primary display. The implementation varies based on the operating system:
+ * - On Windows, it uses PowerShell to query the current horizontal and vertical resolution of the video controller.
+ * - On macOS, it uses the system_profiler command to extract the resolution information from the display data.
+ * If the platform is not supported or if there is an error during execution, it returns a default size of { width: 0, height: 0 }.
+ */
+function getScreenSize() {
+  const platform = process.platform;
+
+  try {
+    if (platform === 'win32') {
+      const cmd = "powershell -command \"Get-CimInstance Win32_VideoController | Select-Object CurrentHorizontalResolution, CurrentVerticalResolution | Format-List\"";
+      const output = execSync(cmd).toString();
+      const width = output.match(/CurrentHorizontalResolution\s*:\s*(\d+)/)?.[1];
+      const height = output.match(/CurrentVerticalResolution\s*:\s*(\d+)/)?.[1];
+      return { width: parseInt(width), height: parseInt(height) };
+    } 
+    
+    if (platform === 'darwin') {
+      const cmd = "system_profiler SPDisplaysDataType | grep Resolution";
+      const output = execSync(cmd).toString();
+      const match = output.match(/(\d+) x (\d+)/);
+      return { width: parseInt(match[1]), height: parseInt(match[2]) };
+    } 
+
+  } catch (error) {
+    console.error("Failed to fetch screen size:", error.message);
+  }
+  
+  return { width: 0, height: 0 };
+}
+
+module.exports = { getScreenSize };

package/store.js

@@ -0,0 +1,104 @@
+const { app } = require("./index")
+const fs = require("fs")
+const path = require("path")
+ 
+module.exports = class DataStore {
+
+    id = ""
+
+    /**
+     * Creates a new store instance with the given id. The store will be in the user's data directory under the "stores" folder.
+     * @param {string} id
+     */
+    constructor(id) {
+
+        if(!id) throw new Error("Store id is required")
+        if (id.includes("/") || id.includes("\\") || id === ".." || id === ".") {
+            throw new Error("Invalid store id: cannot contain path traversals")
+        }
+
+        this.id = id
+
+        this.path = path.join(app.userData.getPath(), "stores", `${id}.json`)
+
+        if(!fs.existsSync(path.join(app.userData.getPath(), "stores"))) {
+            fs.mkdirSync(path.join(app.userData.getPath(), "stores"), { recursive: true })
+        }
+
+        if (!fs.existsSync(this.path)) {
+            fs.writeFileSync(this.path, JSON.stringify({}))
+        }
+
+    }
+
+    /**
+     * Gets the value of the given key from the store. If the key does not exist, it will return undefined.
+     * @param {string} key 
+     * @returns {any} Value of the key
+     */
+    get(key) {
+        const data = JSON.parse(fs.readFileSync(this.path))
+        return data[key]
+    }
+
+    /**
+     * Sets the value of the given key in the store.
+     * @param {string} key 
+     * @param {any} value 
+     */
+    set(key, value) {
+        const data = JSON.parse(fs.readFileSync(this.path))
+        data[key] = value
+        fs.writeFileSync(this.path, JSON.stringify(data))
+    }
+
+    /**
+     * Deletes the given key from the store.
+     * @param {string} key The key to delete 
+     */
+    delete(key) {
+        const data = JSON.parse(fs.readFileSync(this.path))
+        delete data[key]
+        fs.writeFileSync(this.path, JSON.stringify(data))
+    }
+
+    /**
+     * Clears all keys from the store.
+     */
+    clear() {
+        fs.writeFileSync(this.path, JSON.stringify({}))
+    }
+
+    /**
+     * Deletes the store file from the user's data directory.
+     */
+    rm() {
+        fs.rmSync(this.path)
+    }
+
+    /**
+     * Creates the store file if it does not exist. If the file already exists, it does nothing.
+     */
+    create() {
+        if (!fs.existsSync(this.path)) {
+            fs.writeFileSync(this.path, JSON.stringify({}))
+        }
+    }
+
+    /**
+     * Checks if the store file exists in the user's data directory.
+     * @returns {boolean} True if the store file exists, false otherwise.
+     */
+    exists() {
+        return fs.existsSync(this.path)
+    }
+
+    /**
+     * Gets all keys and values from the store as an object.
+     * @returns {object} An object containing all keys and values from the store.
+     */
+    all() {
+        return JSON.parse(fs.readFileSync(this.path))
+    }
+
+}