react-native-electron-platform 0.0.1

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2024 JESCON TECHNOLOGIES PVT LTD
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/README.md

@@ -0,0 +1,77 @@
+# react-native-electron-platform
+
+[![npm version](https://badge.fury.io/js/react-native-electron-platform.svg)](https://badge.fury.io/js/react-native-electron-platform)
+[![License: MIT](https://img.shields.io/badge/License-MIT-yellow.svg)](https://opensource.org/licenses/MIT)
+[![CI](https://github.com/dpraful/react-native-electron-platform/workflows/CI/badge.svg)](https://github.com/dpraful/react-native-electron-platform/actions)
+
+A boilerplate and utility library for running React Native applications in Electron, supporting both desktop and web platforms.
+
+## Features
+
+- Electron main process setup with auto-updater
+- Preload script for secure IPC communication
+- Webpack configuration helper for React Native web builds
+- Network service integration
+- PDF generation and preview
+- File selection dialogs
+- HTML preview functionality
+
+## Installation
+
+```bash
+npm install react-native-electron-platform
+```
+
+## Usage
+
+### As a Boilerplate
+
+1. Copy the `src/main.mjs` and `src/preload.js` to your Electron project.
+2. Use the `src/webpackConfigHelper.mjs` to configure your webpack build for React Native web.
+
+### As a Library
+
+```javascript
+import { categorizePackages, isWebSupported } from 'react-native-electron-platform';
+
+const packages = categorizePackages();
+// Use the categorized packages for your build configuration
+```
+
+### Running the Example
+
+```bash
+npm start
+```
+
+This will start the Electron app with the included example.
+
+## API
+
+### WebpackConfigHelper
+
+- `getAllPackages()`: Get all dependencies from package.json
+- `categorizePackages()`: Separate packages into web-supported and unsupported
+- `isWebSupported(packageName)`: Check if a package supports web platform
+
+## Building
+
+```bash
+npm run build
+```
+
+## Contributing
+
+Please read [CONTRIBUTING.md](CONTRIBUTING.md) for details on our code of conduct and the process for submitting pull requests.
+
+## Code of Conduct
+
+Please read our [Code of Conduct](CODE_OF_CONDUCT.md) to understand our community guidelines.
+
+## Changelog
+
+See [CHANGELOG.md](CHANGELOG.md) for a list of changes and version history.
+
+## License
+
+This project is licensed under the MIT License - see the [LICENSE](LICENSE) file for details.

package/index.mjs

@@ -0,0 +1 @@
+export * from './src/webpackConfigHelper.mjs';

package/package.json

@@ -0,0 +1,48 @@
+{
+  "name": "react-native-electron-platform",
+  "version": "0.0.1",
+  "description": "A boilerplate and utilities for running React Native applications in Electron",
+  "main": "index.mjs",
+  "scripts": {
+    "start": "electron src/main.mjs",
+    "build": "webpack --config webpack.config.mjs",
+    "test": "echo \"No tests specified\" && exit 0"
+  },
+  "keywords": [
+    "react-native",
+    "electron",
+    "desktop",
+    "web",
+    "boilerplate"
+  ],
+  "author": "JESCON TECHNOLOGIES PVT LTD",
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/dpraful/react-native-electron-platform.git"
+  },
+  "bugs": {
+    "url": "https://github.com/dpraful/react-native-electron-platform/issues"
+  },
+  "homepage": "https://github.com/dpraful/react-native-electron-platform#readme",
+  "dependencies": {
+    "electron": "^25.0.0",
+    "electron-updater": "^6.0.0"
+  },
+  "devDependencies": {
+    "webpack": "^5.0.0",
+    "html-webpack-plugin": "^5.0.0",
+    "webpack-cli": "^5.0.0"
+  },
+  "peerDependencies": {
+    "react-native": ">=0.60.0"
+  },
+  "engines": {
+    "node": ">=14.0.0"
+  },
+  "files": [
+    "src/",
+    "README.md",
+    "LICENSE"
+  ]
+}

package/src/index.html

@@ -0,0 +1,173 @@
+<!DOCTYPE html>
+<html>
+
+<head>
+  <meta charset="utf-8">
+  <meta name="viewport" content="width=device-width, initial-scale=1">
+  <title><%= title %></title>
+  <style>
+    html,
+    body {
+      width: 100%;
+      height: 100%;
+      margin: 0;
+      padding: 0;
+      overflow: hidden;
+    }
+
+    #root {
+      width: 100vw;
+      height: 100vh;
+      display: flex;
+      flex-direction: column;
+    }
+
+    #root>div {
+      flex: 1;
+      display: flex;
+      flex-direction: column;
+      min-height: 0;
+      min-width: 0;
+    }
+
+    @font-face {
+      font-family: 'MaterialCommunityIcons';
+      src: url('fonts/MaterialCommunityIcons.ttf') format('truetype');
+      font-weight: normal;
+      font-style: normal;
+    }
+
+    @font-face {
+      font-family: 'MaterialIcons';
+      src: url('fonts/MaterialIcons.ttf') format('truetype');
+      font-weight: normal;
+      font-style: normal;
+    }
+
+    @font-face {
+      font-family: 'SimpleLineIcons';
+      src: url('fonts/SimpleLineIcons.ttf') format('truetype');
+      font-weight: normal;
+      font-style: normal;
+    }
+
+    @font-face {
+      font-family: 'FontAwesome';
+      src: url('fonts/FontAwesome.ttf') format('truetype');
+      font-weight: normal;
+      font-style: normal;
+    }
+
+    @font-face {
+      font-family: 'Foundation';
+      src: url('fonts/Foundation.ttf') format('truetype');
+      font-weight: normal;
+      font-style: normal;
+    }
+
+    @font-face {
+      font-family: 'EvilIcons';
+      src: url('fonts/EvilIcons.ttf') format('truetype');
+      font-weight: normal;
+      font-style: normal;
+    }
+
+    @font-face {
+      font-family: 'Octicons';
+      src: url('fonts/Octicons.ttf') format('truetype');
+      font-weight: normal;
+      font-style: normal;
+    }
+
+    @font-face {
+      font-family: 'Ionicons';
+      src: url('fonts/Ionicons.ttf') format('truetype');
+      font-weight: normal;
+      font-style: normal;
+    }
+
+    @font-face {
+      font-family: 'Feather';
+      src: url('fonts/Feather.ttf') format('truetype');
+      font-weight: normal;
+      font-style: normal;
+    }
+
+    @font-face {
+      font-family: 'Entypo';
+      src: url('fonts/Entypo.ttf') format('truetype');
+      font-weight: normal;
+      font-style: normal;
+    }
+
+    @font-face {
+      font-family: 'Zocial';
+      src: url('fonts/Zocial.ttf') format('truetype');
+      font-weight: normal;
+      font-style: normal;
+    }
+
+    @font-face {
+      font-family: 'FontAwesome5_Regular';
+      src: url('fonts/FontAwesome5_Regular.ttf') format('truetype');
+      font-weight: normal;
+      font-style: normal;
+    }
+
+    @font-face {
+      font-family: 'FontAwesome5_Solid';
+      src: url('fonts/FontAwesome5_Solid.ttf') format('truetype');
+      font-weight: bold;
+      font-style: normal;
+    }
+
+    @font-face {
+      font-family: 'FontAwesome5_Brands';
+      src: url('fonts/FontAwesome5_Brands.ttf') format('truetype');
+      font-weight: normal;
+      font-style: normal;
+    }
+
+    @font-face {
+      font-family: 'AntDesign';
+      src: url('fonts/AntDesign.ttf') format('truetype');
+      font-weight: normal;
+      font-style: normal;
+    }
+
+    @font-face {
+      font-family: 'FontAwesome6_Brands';
+      src: url('fonts/FontAwesome6_Brands.ttf') format('truetype');
+      font-weight: normal;
+      font-style: normal;
+    }
+
+    @font-face {
+      font-family: 'FontAwesome6_Regular';
+      src: url('fonts/FontAwesome6_Regular.ttf') format('truetype');
+      font-weight: normal;
+      font-style: normal;
+    }
+
+    @font-face {
+      font-family: 'FontAwesome6_Solid';
+      src: url('fonts/FontAwesome6_Solid.ttf') format('truetype');
+      font-weight: bold;
+      font-style: normal;
+    }
+
+    @font-face {
+      font-family: 'Fontisto';
+      src: url('fonts/Fontisto.ttf') format('truetype');
+      font-weight: normal;
+      font-style: normal;
+    }
+  </style>
+</head>
+
+<body>
+  <div id="root"></div>
+  <script src="bundle.js"></script>
+</body>
+
+</html>

package/src/main.mjs

@@ -0,0 +1,552 @@
+import { app, BrowserWindow, session, screen, ipcMain, dialog } from "electron";
+import electronUpdater from "electron-updater";
+const { autoUpdater } = electronUpdater;
+import path from "path";
+import fs from "fs";
+import { Readable } from "stream";
+import os from "os";
+import { fileURLToPath } from 'url';
+import { dirname } from 'path';
+import packageJson from "../../../package.json" with { type: 'json' };
+
+const __dirname = dirname(fileURLToPath(import.meta.url));
+
+function isRunningFromNetwork() {
+  try {
+    const exePath = app.getPath("exe");
+    return exePath.startsWith("\\\\"); // UNC path
+  } catch {
+    return false;
+  }
+}
+
+function shouldUseSafeMode() {
+  const network = isRunningFromNetwork();
+
+  const hostname = os.hostname().toLowerCase();
+  const vmHint =
+    hostname.includes("vm") ||
+    hostname.includes("virtual") ||
+    hostname.includes("vbox") ||
+    hostname.includes("hyper");
+
+  return network || vmHint;
+}
+
+// Apply BEFORE Electron ready
+if (shouldUseSafeMode()) {
+  console.log("⚠ SAFE MODE ENABLED");
+
+  app.disableHardwareAcceleration();
+  app.commandLine.appendSwitch("disable-gpu");
+  app.commandLine.appendSwitch("disable-software-rasterizer");
+  app.commandLine.appendSwitch("no-sandbox");
+  app.commandLine.appendSwitch("disable-dev-shm-usage");
+} else {
+  console.log("✅ NORMAL MODE");
+}
+
+let mainWindow;
+
+function createWindow() {
+  const primaryDisplay = screen.getPrimaryDisplay();
+  const { x, y, width, height } = primaryDisplay.bounds;
+
+  const iconPath = path.join(__dirname, "icon.ico");
+  const preloadPath = path.join(__dirname, "preload.js");
+
+  mainWindow = new BrowserWindow({
+    x,
+    y,
+    width,
+    height,
+    show: false,
+    icon: iconPath,
+    frame: true,
+    webPreferences: {
+      preload: preloadPath,
+      nodeIntegration: false,
+      contextIsolation: true,
+      sandbox: false,
+      webSecurity: false,
+      disableBlinkFeatures: "AutoLoadIconsForPage",
+      nativeWindowOpen: true,
+      spellcheck: true,
+    },
+  });
+
+  mainWindow.removeMenu();
+  mainWindow.maximize();
+  mainWindow.show();
+
+  mainWindow.on("resize", () => {
+    const bounds = mainWindow.getBounds();
+    if (bounds?.width && bounds?.height) {
+      console.log(`Window resized: ${bounds.width}x${bounds.height}`);
+    }
+  });
+
+  session.defaultSession.webRequest.onHeadersReceived((details, callback) => {
+    const responseHeaders = { ...details.responseHeaders };
+
+    delete responseHeaders["access-control-allow-origin"];
+    delete responseHeaders["access-control-allow-headers"];
+    delete responseHeaders["access-control-allow-methods"];
+    delete responseHeaders["Access-Control-Allow-Origin"];
+    delete responseHeaders["Access-Control-Allow-Headers"];
+    delete responseHeaders["Access-Control-Allow-Methods"];
+
+    callback({
+      responseHeaders: {
+        ...responseHeaders,
+        "Access-Control-Allow-Origin": ["*"],
+        "Access-Control-Allow-Headers": ["*"],
+        "Access-Control-Allow-Methods": ["GET, POST, PUT, DELETE, OPTIONS"],
+      },
+    });
+  });
+
+  const isDev =
+    process.argv.includes("--enable-remote-module") ||
+    process.env.NODE_ENV === "development";
+
+  if (isDev) {
+    mainWindow.loadURL("http://localhost:5001");
+    console.log("DEV MODE: http://localhost:5001");
+
+    mainWindow.webContents.on("before-input-event", (event, input) => {
+      if (input.control && input.shift && input.key.toLowerCase() === "i") {
+        mainWindow.webContents.toggleDevTools();
+        event.preventDefault();
+      } else if (input.key === "F12") {
+        mainWindow.webContents.toggleDevTools();
+        event.preventDefault();
+      } else if (
+        input.key === "F5" ||
+        (input.control && input.key.toLowerCase() === "r")
+      ) {
+        mainWindow.webContents.reload();
+        event.preventDefault();
+      }
+    });
+  } else {
+    const possiblePaths = [
+      path.join(__dirname, "web-build/index.html"),
+      path.join(__dirname, "../web-build/index.html"),
+      path.join(__dirname, "../../web-build/index.html"),
+      path.join(app.getAppPath(), "web-build/index.html"),
+    ];
+
+    let indexPath = null;
+    for (const p of possiblePaths) {
+      if (fs.existsSync(p)) {
+        indexPath = p;
+        break;
+      }
+    }
+
+    console.log("Loading:", indexPath);
+
+    if (!indexPath) {
+      dialog.showErrorBox(
+        "Application Error",
+        `web-build/index.html not found. Tried: ${possiblePaths.join(", ")}`
+      );
+      app.quit();
+      return;
+    }
+
+    mainWindow.loadFile(indexPath);
+  }
+
+  mainWindow.webContents.on("did-finish-load", () => {
+    console.log("Page loaded successfully");
+  });
+}
+
+/**
+ * ----------------------------------------------------
+ * AUTO UPDATE (NSIS)
+ * ----------------------------------------------------
+ */
+function setupAutoUpdater() {
+  console.log("Current app version:", app.getVersion());
+  
+  if (!app.isPackaged) {
+    console.log("Auto-update disabled in development.");
+    return;
+  }
+  
+  autoUpdater.autoDownload = true;
+  autoUpdater.autoInstallOnAppQuit = true;
+
+  const sendStatus = (data) => {
+    if (mainWindow) {
+      mainWindow.webContents.send("update-status", data);
+    }
+  };
+
+  autoUpdater.on("checking-for-update", () => {
+    console.log("Checking for updates...");
+    sendStatus({ status: "checking" });
+  });
+
+  autoUpdater.on("update-available", (info) => {
+    console.log("Update available:", info.version);
+    sendStatus({ status: "available", version: info.version });
+  });
+
+  autoUpdater.on("update-not-available", () => {
+    console.log("No updates available");
+    sendStatus({ status: "not-available" });
+  });
+
+  autoUpdater.on("download-progress", (progress) => {
+    console.log(`Download progress: ${Math.round(progress.percent)}%`);
+    sendStatus({
+      status: "downloading",
+      percent: Math.round(progress.percent),
+    });
+  });
+
+  autoUpdater.on("update-downloaded", () => {
+    console.log("Update downloaded");
+    sendStatus({ status: "downloaded" });
+
+    dialog
+      .showMessageBox(mainWindow, {
+        type: "info",
+        title: "Update Ready",
+        message: "A new version has been downloaded. Restart now?",
+        buttons: ["Restart", "Later"],
+      })
+      .then((result) => {
+        if (result.response === 0) {
+          autoUpdater.quitAndInstall();
+        }
+      });
+  });
+
+  autoUpdater.on("error", (err) => {
+    console.error("Auto-updater error:", err);
+    sendStatus({ status: "error", message: err.message });
+  });
+
+  // Check for updates after a short delay to ensure window is ready
+  setTimeout(() => {
+    autoUpdater.checkForUpdates();
+  }, 3000);
+}
+
+/**
+ * ----------------------------------------------------
+ * IPC: MANUAL UPDATE CHECK
+ * ----------------------------------------------------
+ */
+ipcMain.handle("check-for-updates", async () => {
+  if (app.isPackaged) {
+    autoUpdater.checkForUpdates();
+    return { status: "checking" };
+  }
+  return { status: "disabled", message: "Auto-update disabled in development" };
+});
+
+//
+// ======================================================
+// NETWORK SERVICE
+// ======================================================
+//
+
+async function NetworkServiceCall(method, url, params = {}, headers = {}) {
+  try {
+    const upperMethod = method.toUpperCase();
+
+    const options = {
+      method: upperMethod,
+      headers: {
+        "Content-Type": "application/json",
+        ...headers,
+      },
+    };
+
+    if (upperMethod !== "GET") {
+      options.body = JSON.stringify(params);
+    } else if (params && Object.keys(params).length > 0) {
+      const query = new URLSearchParams(params).toString();
+      url += `?${query}`;
+    }
+
+    const response = await fetch(url, options);
+    const data = await response.json().catch(() => ({}));
+
+    if (response.ok || data?.httpstatus === 200) {
+      return { httpstatus: 200, data: data?.data || data };
+    }
+
+    return {
+      httpstatus: response.status,
+      data: { title: "ERROR", message: data?.message || "Network Error" },
+    };
+  } catch (err) {
+    return {
+      httpstatus: 404,
+      data: { title: "ERROR", message: err.message },
+    };
+  }
+}
+
+ipcMain.handle("network-call", async (event, payload) => {
+  try {
+    const { method, url, params, headers } = payload;
+    console.log("IPC network-call:", { method, url });
+    return NetworkServiceCall(method, url, params, headers);
+  } catch (err) {
+    console.error("IPC network-call error:", err);
+    return {
+      httpstatus: 500,
+      data: { title: "ERROR", message: err.message },
+    };
+  }
+});
+
+//
+// ======================================================
+// PDF / FILE IPC
+// ======================================================
+//
+
+ipcMain.handle("save-pdf", async (event, html) => {
+  try {
+    console.log("IPC save-pdf called");
+
+    const tempWin = new BrowserWindow({
+      show: false,
+      webPreferences: { offscreen: true },
+    });
+
+    await tempWin.loadURL(
+      `data:text/html;charset=utf-8,${encodeURIComponent(html)}`
+    );
+
+    const pdfBuffer = await tempWin.webContents.printToPDF({});
+    tempWin.destroy();
+
+    const { filePath } = await dialog.showSaveDialog({
+      title: "Save PDF",
+      defaultPath: "document.pdf",
+      filters: [{ name: "PDF", extensions: ["pdf"] }],
+    });
+
+    if (filePath) {
+      fs.writeFileSync(filePath, pdfBuffer);
+      console.log("PDF saved:", filePath);
+      return "saved";
+    }
+
+    return "cancelled";
+  } catch (err) {
+    console.error("IPC save-pdf error:", err);
+    throw err;
+  }
+});
+
+ipcMain.handle("post-pdf-preview", async (event, payload) => {
+  try {
+    const { url, data, headers = {} } = payload;
+    console.log("IPC post-pdf-preview:", { url });
+    
+    const res = await fetch(url, {
+      method: "POST",
+      headers: {
+        "Content-Type": "application/json",
+        Accept: "application/pdf",
+        ...headers,
+      },
+      body: data,
+    });
+
+    if (!res.ok) {
+      throw new Error(`HTTP ${res.status}`);
+    }
+
+    const fileName = `Report_${Date.now()}.pdf`;
+    const tempPath = path.join(app.getPath("temp"), fileName);
+
+    const nodeStream = Readable.fromWeb(res.body);
+    await new Promise((resolve, reject) => {
+      const fileStream = fs.createWriteStream(tempPath);
+      nodeStream.pipe(fileStream);
+      nodeStream.on("error", reject);
+      fileStream.on("finish", resolve);
+    });
+
+    return {
+      status: "ok",
+      path: `file://${tempPath}`,
+    };
+  } catch (err) {
+    console.error("post-pdf-preview error:", err);
+    return {
+      status: "error",
+      message: err.message,
+    };
+  }
+});
+
+ipcMain.handle("open-pdf-preview", async (_, pdfUrl) => {
+  try {
+    const res = await fetch(pdfUrl);
+    const buffer = Buffer.from(await res.arrayBuffer());
+
+    const tempPath = path.join(app.getPath("temp"), `preview_${Date.now()}.pdf`);
+    fs.writeFileSync(tempPath, buffer);
+
+    return `file://${tempPath}`;
+  } catch (err) {
+    console.error("open-pdf-preview error:", err);
+    throw err;
+  }
+});
+
+ipcMain.handle("select-file", async () => {
+  try {
+    const result = await dialog.showOpenDialog({
+      title: "Select a file",
+      properties: ["openFile"],
+      filters: [
+        { name: "All Files", extensions: ["*"] },
+      ],
+    });
+
+    if (result.canceled) {
+      return {
+        status: "cancelled",
+        filePath: null,
+      };
+    }
+
+    return {
+      status: "selected",
+      filePath: result.filePaths[0],
+    };
+  } catch (err) {
+    console.error("select-file error:", err);
+    return {
+      status: "error",
+      message: err.message,
+    };
+  }
+});
+
+ipcMain.handle("preview-html", async (event, htmlContent) => {
+  try {
+    // Create a new hidden BrowserWindow for preview
+    const previewWin = new BrowserWindow({
+      width: 800,
+      height: 600,
+      show: false, // hide until ready
+      webPreferences: {
+        contextIsolation: true,
+        sandbox: false,
+        nodeIntegration: false,
+      },
+    });
+
+    // Load the HTML content
+    await previewWin.loadURL(
+      `data:text/html;charset=utf-8,${encodeURIComponent(htmlContent)}`
+    );
+
+    // Show the window once loaded
+    previewWin.show();
+
+    return { status: "ok" };
+  } catch (err) {
+    console.error("preview-html error:", err);
+    return { status: "error", message: err.message };
+  }
+});
+
+async function convertHtmlToPdfPreview(htmlContent, options = {}) {
+  try {
+    // Step 1: Create a hidden BrowserWindow
+    const tempWin = new BrowserWindow({
+      show: false,
+      webPreferences: {
+        offscreen: true,
+        contextIsolation: true,
+        nodeIntegration: false,
+      },
+    });
+
+    // Step 2: Load HTML into the window
+    await tempWin.loadURL(`data:text/html;charset=utf-8,${encodeURIComponent(htmlContent)}`);
+
+    // Step 3: Generate PDF
+    const pdfBuffer = await tempWin.webContents.printToPDF({
+      printBackground: true,
+      ...options,
+    });
+
+    tempWin.destroy();
+
+    // Step 4: Save PDF to temp folder
+    const pdfFileName = `Preview_${Date.now()}.pdf`;
+    const pdfPath = path.join(app.getPath("temp"), pdfFileName);
+    fs.writeFileSync(pdfPath, pdfBuffer);
+
+    // Step 5: Open a new window to preview the PDF
+    const previewWin = new BrowserWindow({
+      width: 900,
+      height: 700,
+      show: true,
+      webPreferences: {
+        contextIsolation: true,
+        nodeIntegration: false,
+      },
+    });
+
+    await previewWin.loadURL(`file://${pdfPath}`);
+
+    return pdfPath;
+  } catch (err) {
+    console.error("convertHtmlToPdfPreview error:", err);
+    throw err;
+  }
+}
+
+ipcMain.handle("html-to-pdf-preview", async (event, htmlContent) => {
+  try {
+    const pdfPath = await convertHtmlToPdfPreview(htmlContent);
+    return { status: "ok", path: pdfPath };
+  } catch (err) {
+    console.error("html-to-pdf-preview error:", err);
+    return { status: "error", message: err.message };
+  }
+});
+
+//
+// ======================================================
+// APP READY
+// ======================================================
+//
+
+app.whenReady().then(() => {
+  if (process.platform === "win32") {
+    app.setAppUserModelId(`com.${packageJson.name}.desktop`);
+  }
+  createWindow();
+  setupAutoUpdater();
+});
+
+app.on("window-all-closed", () => {
+  if (process.platform !== "darwin") {
+    app.quit();
+  }
+});
+
+app.on("activate", () => {
+  if (BrowserWindow.getAllWindows().length === 0) {
+    createWindow();
+  }
+});

package/src/preload.mjs

@@ -0,0 +1,61 @@
+import { contextBridge, ipcRenderer } from "electron";
+
+contextBridge.exposeInMainWorld("electronAPI", {
+  // Network
+  networkCall: (method, url, params = {}, headers = {}) =>
+    ipcRenderer.invoke("network-call", { method, url, params, headers }),
+
+  // PDF Operations
+  savePDF: (html) =>
+    ipcRenderer.invoke("save-pdf", html),
+
+  postPdfPreview: (payload) =>
+    ipcRenderer.invoke("post-pdf-preview", payload),
+
+  openPdfPreview: (pdfUrl) =>
+    ipcRenderer.invoke("open-pdf-preview", pdfUrl),
+
+  // File Operations
+  selectFile: () => ipcRenderer.invoke("select-file"),
+
+  // HTML/PDF Preview
+  previewHTML: (htmlContent) =>
+    ipcRenderer.invoke("preview-html", htmlContent),
+
+  htmlToPdfPreview: (htmlContent) =>
+    ipcRenderer.invoke("html-to-pdf-preview", htmlContent),
+
+  // ======================================================
+  // AUTO-UPDATER APIs (NEW)
+  // ======================================================
+  
+  /**
+   * Listen for update status events from main process
+   * @param {Function} callback - Function to call when update status changes
+   * @returns {Function} - Cleanup function to remove listener
+   */
+  onUpdateStatus: (callback) => {
+    // Create the listener
+    const listener = (event, data) => callback(data);
+    
+    // Add the listener
+    ipcRenderer.on('update-status', listener);
+    
+    // Return cleanup function
+    return () => {
+      ipcRenderer.removeListener('update-status', listener);
+    };
+  },
+
+  /**
+   * Manually check for updates
+   * @returns {Promise<Object>} - Status of update check
+   */
+  checkForUpdates: () => ipcRenderer.invoke("check-for-updates"),
+
+  /**
+   * Get the current app version
+   * @returns {Promise<string>} - Current version
+   */
+  getAppVersion: () => ipcRenderer.invoke("get-app-version")
+});

package/src/webpackConfigHelper.mjs

@@ -0,0 +1,94 @@
+import path from 'path';
+import { fileURLToPath } from 'url';
+import { dirname } from 'path';
+import fs from 'fs';
+import { WEB_UNSUPPORTED_PACKAGES } from '../../../electron/nonmodules.mjs';
+
+const __dirname = dirname(fileURLToPath(import.meta.url));
+
+/**
+ * Get all dependencies from package.json
+ * @returns {Object} All dependencies and devDependencies
+ */
+export function getAllPackages() {
+  const packageJsonPath = path.join(__dirname, '../../../package.json');
+  const packageJson = JSON.parse(fs.readFileSync(packageJsonPath, 'utf8'));
+  return {
+    ...packageJson.dependencies,
+    ...packageJson.devDependencies,
+  };
+}
+
+/**
+ * Separate packages into web-supported and unsupported
+ * @returns {Object} { webSupported: [], webUnsupported: [] }
+ */
+export function categorizePackages() {
+  const allPackages = getAllPackages();
+  const webSupported = [];
+  const webUnsupported = [];
+
+  Object.keys(allPackages).forEach(pkg => {
+    if (WEB_UNSUPPORTED_PACKAGES.includes(pkg)) {
+      webUnsupported.push(pkg);
+    } else {
+      webSupported.push(pkg);
+    }
+  });
+
+  return { webSupported, webUnsupported };
+}
+
+/**
+ * Check if a specific package supports web
+ * @param {string} packageName - Package name to check
+ * @returns {boolean} True if package supports web, false otherwise
+ */
+export function isWebSupported(packageName) {
+  return !WEB_UNSUPPORTED_PACKAGES.includes(packageName);
+}
+
+/**
+ * Generate webpack alias configuration based on package.json dependencies
+ * @returns {Object} Alias configuration object
+ */
+export function generateAlias() {
+  const allDeps = getAllPackages();
+
+  const alias = {
+    'react-native$': 'react-native-web',
+  };
+
+  // Set packages to false if they don't support web
+  Object.keys(allDeps).forEach(pkg => {
+    if (!isWebSupported(pkg)) {
+      alias[pkg] = false;
+    }
+  });
+
+  return alias;
+}
+
+/**
+ * Generate webpack fallback configuration based on package.json dependencies
+ * @returns {Object} Fallback configuration object
+ */
+export function generateFallback() {
+  const { webUnsupported } = categorizePackages();
+
+  const fallback = {
+    fs: false,
+    path: false,
+    os: false,
+    AsyncStorage: false,
+    NativeModules: false,
+    Platform: false,
+  };
+
+  // Add all web-unsupported packages to fallback
+  webUnsupported.forEach(pkg => {
+    fallback[pkg] = false;
+  });
+
+  return fallback;
+}