react-native-electron-platform 0.0.9 → 0.0.11

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "react-native-electron-platform",
-  "version": "0.0.9",
+  "version": "0.0.11",
   "description": "A boilerplate and utilities for running React Native applications in Electron",
   "main": "index.mjs",
   "scripts": {

package/src/main.mjs

@@ -1,625 +1,65 @@
-import { 
-  app, 
-  BrowserWindow, 
-  session, 
-  screen, 
-  ipcMain, 
-  dialog,
-  clipboard,
-  shell 
-} 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 { app, BrowserWindow, ipcMain } from "electron";
 import { fileURLToPath } from 'url';
 import { dirname } from 'path';
 import packageJson from "../../../package.json" with { type: 'json' };
 
+// Import modules
+import { shouldUseSafeMode, applySafeMode } from './modules/safeMode.js';
+import { registerDeepLinkingHandlers, sendOpenURL } from './modules/deepLinking.js';
+import { registerAllIpcHandlers } from './modules/ipcHandlers/index.js';
+import { setupAutoUpdater } from './modules/autoUpdater.js';
+import { createMainWindow } from './modules/windowManager.js';
+
 const __dirname = dirname(fileURLToPath(import.meta.url));
 
 // ======================================================
-// AUTO SAFE MODE DETECTION
+// SAFE MODE DETECTION (applies before ready)
 // ======================================================
-
-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");
+  applySafeMode();
 }
 
 let mainWindow;
 
 // ======================================================
-// DEEP LINKING / URL HANDLING
-// ======================================================
-
-const appOpenURLTargets = new WeakSet();
-
-function sendOpenURL(url) {
-  for (const window of BrowserWindow.getAllWindows()) {
-    if (appOpenURLTargets.has(window.webContents)) {
-      window.webContents.send('react-native-app-open-url', url);
-    }
-  }
-}
-
-// ======================================================
-// REGISTER ALL IPC HANDLERS
-// ======================================================
-
-function registerIpcHandlers() {
-  console.log("📝 Registering IPC handlers...");
-
-  // Deep Linking Handlers
-  ipcMain.handle('react-native-add-app-open-url', (event) => {
-    appOpenURLTargets.add(event.sender);
-  });
-
-  ipcMain.handle('react-native-get-initial-url', () => {
-    return Promise.resolve(process.argv[1]);
-  });
-
-  ipcMain.handle('react-native-open-url', async (_event, url) => {
-    await shell.openExternal(url);
-  });
-
-  // Clipboard Handlers
-  ipcMain.handle('react-native-get-clipboard-text', async () => {
-    return await clipboard.readText();
-  });
-
-  ipcMain.handle('react-native-set-clipboard-text', async (_event, text) => {
-    await clipboard.writeText(text);
-  });
-
-  // Dialog Handlers
-  ipcMain.handle('react-native-show-alert', async (event, options) => {
-    const window = BrowserWindow.fromWebContents(event.sender);
-    if (window != null) {
-      const { response } = await dialog.showMessageBox(window, options);
-      return response;
-    }
-  });
-
-  // Internal support check
-  ipcMain.on('react-native-supported', (event) => {
-    event.returnValue = true;
-  });
-
-  // Auto-updater Handlers
-  ipcMain.handle("check-for-updates", async () => {
-    if (app.isPackaged) {
-      autoUpdater.checkForUpdates();
-      return { status: "checking" };
-    }
-    return { status: "disabled", message: "Auto-update disabled in development" };
-  });
-
-  ipcMain.handle("get-app-version", () => {
-    return app.getVersion();
-  });
-
-  // Network Service Handlers
-  ipcMain.handle("network-call", async (event, payload) => {
-    try {
-      const { method, url, params, headers } = payload;
-      console.log("IPC network-call:", { method, url });
-      return await NetworkServiceCall(method, url, params, headers);
-    } catch (err) {
-      console.error("IPC network-call error:", err);
-      return {
-        httpstatus: 500,
-        data: { title: "ERROR", message: err.message },
-      };
-    }
-  });
-
-  // PDF Operations Handlers
-  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 { status: "saved", path: filePath };
-      }
-
-      return { status: "cancelled" };
-    } catch (err) {
-      console.error("IPC save-pdf error:", err);
-      return { status: "error", message: err.message };
-    }
-  });
-
-  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;
-    }
-  });
-
-  // File Operations Handlers
-  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,
-      };
-    }
-  });
-
-  // HTML Preview Handlers
-  ipcMain.handle("preview-html", async (event, htmlContent) => {
-    try {
-      const previewWin = new BrowserWindow({
-        width: 800,
-        height: 600,
-        show: false,
-        webPreferences: {
-          contextIsolation: true,
-          sandbox: false,
-          nodeIntegration: false,
-        },
-      });
-
-      await previewWin.loadURL(
-        `data:text/html;charset=utf-8,${encodeURIComponent(htmlContent)}`
-      );
-
-      previewWin.show();
-      return { status: "ok" };
-    } catch (err) {
-      console.error("preview-html error:", err);
-      return { status: "error", message: err.message };
-    }
-  });
-
-  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 };
-    }
-  });
-
-  // Utility Handlers
-  ipcMain.handle("get-platform", () => {
-    return process.platform;
-  });
-
-  ipcMain.handle("get-app-path", () => {
-    return app.getAppPath();
-  });
-
-  ipcMain.handle("get-user-data-path", () => {
-    return app.getPath("userData");
-  });
-
-  console.log("✅ All IPC handlers registered");
-}
-
-// ======================================================
-// 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 },
-    };
-  }
-}
-
-// ======================================================
-// PDF CONVERSION HELPER
+// REGISTER IPC HANDLERS
 // ======================================================
-
-async function convertHtmlToPdfPreview(htmlContent, options = {}) {
-  try {
-    const tempWin = new BrowserWindow({
-      show: false,
-      webPreferences: {
-        offscreen: true,
-        contextIsolation: true,
-        nodeIntegration: false,
-      },
-    });
-
-    await tempWin.loadURL(`data:text/html;charset=utf-8,${encodeURIComponent(htmlContent)}`);
-
-    const pdfBuffer = await tempWin.webContents.printToPDF({
-      printBackground: true,
-      ...options,
-    });
-
-    tempWin.destroy();
-
-    const pdfFileName = `Preview_${Date.now()}.pdf`;
-    const pdfPath = path.join(app.getPath("temp"), pdfFileName);
-    fs.writeFileSync(pdfPath, pdfBuffer);
-
-    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;
-  }
-}
+registerAllIpcHandlers();
+registerDeepLinkingHandlers(sendOpenURL);
 
 // ======================================================
-// AUTO UPDATER SETUP
+// APP LIFECYCLE
 // ======================================================
 
-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;
+// Single instance lock
+const gotTheLock = app.requestSingleInstanceLock();
 
-  const sendStatus = (data) => {
+if (!gotTheLock) {
+  app.quit();
+} else {
+  app.on('second-instance', (event, commandLine) => {
     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);
-}
-
-// ======================================================
-// WINDOW CREATION
-// ======================================================
-
-function createWindow() {
-  const primaryDisplay = screen.getPrimaryDisplay();
-  const { x, y, width, height } = primaryDisplay.bounds;
-
-  const iconPath = path.join(app.getAppPath(), "electron/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}`);
-    }
-  });
-
-  // CORS handling
-  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");
-
-    // Dev tools shortcuts
-    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;
+      if (mainWindow.isMinimized()) mainWindow.restore();
+      mainWindow.focus();
+      
+      // Handle deep link from second instance
+      const url = commandLine.pop();
+      if (url && (url.startsWith('myapp://') || url.startsWith('http'))) {
+        sendOpenURL(url);
       }
     }
-
-    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");
   });
 }
 
-// ======================================================
-// REGISTER IPC HANDLERS BEFORE APP READY
-// ======================================================
-
-registerIpcHandlers();
-
-// ======================================================
-// APP LIFECYCLE
-// ======================================================
-
 app.whenReady().then(() => {
   if (process.platform === "win32") {
     app.setAppUserModelId(`com.${packageJson.name}.desktop`);
   }
-  createWindow();
-  setupAutoUpdater();
   
-  // Log all registered IPC handlers for debugging
+  mainWindow = createMainWindow(__dirname);
+  setupAutoUpdater(mainWindow);
+  
+  // Log registered handlers
   console.log("📊 IPC Handlers registered:", 
     ipcMain.eventNames().filter(name => 
       typeof name === 'string' && 
@@ -636,27 +76,6 @@ app.on("window-all-closed", () => {
 
 app.on("activate", () => {
   if (BrowserWindow.getAllWindows().length === 0) {
-    createWindow();
+    mainWindow = createMainWindow(__dirname);
   }
-});
-
-// Handle second instance (for single instance apps)
-const gotTheLock = app.requestSingleInstanceLock();
-
-if (!gotTheLock) {
-  app.quit();
-} else {
-  app.on('second-instance', (event, commandLine, workingDirectory) => {
-    // Someone tried to run a second instance, focus our window instead
-    if (mainWindow) {
-      if (mainWindow.isMinimized()) mainWindow.restore();
-      mainWindow.focus();
-      
-      // Handle deep link from second instance
-      const url = commandLine.pop();
-      if (url && (url.startsWith('myapp://') || url.startsWith('http'))) {
-        sendOpenURL(url);
-      }
-    }
-  });
-}
+});

package/src/modules/autoUpdater.js

@@ -0,0 +1,72 @@
+import { app, dialog } from "electron";
+import electronUpdater from "electron-updater";
+const { autoUpdater } = electronUpdater;
+
+export function setupAutoUpdater(mainWindow) {
+  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
+  setTimeout(() => {
+    autoUpdater.checkForUpdates();
+  }, 3000);
+}

package/src/modules/deepLinking.js

@@ -0,0 +1,21 @@
+import { BrowserWindow, ipcMain } from "electron";
+
+const appOpenURLTargets = new WeakSet();
+
+export function sendOpenURL(url) {
+  for (const window of BrowserWindow.getAllWindows()) {
+    if (appOpenURLTargets.has(window.webContents)) {
+      window.webContents.send('react-native-app-open-url', url);
+    }
+  }
+}
+
+export function registerDeepLinkingHandlers(sendOpenURLCallback) {
+  ipcMain.handle('react-native-add-app-open-url', (event) => {
+    appOpenURLTargets.add(event.sender);
+  });
+
+  ipcMain.handle('react-native-get-initial-url', () => {
+    return Promise.resolve(process.argv[1]);
+  });
+}

package/src/modules/ipcHandlers/clipboard.js

@@ -0,0 +1,11 @@
+import { ipcMain, clipboard } from "electron";
+
+export function registerClipboardHandlers() {
+  ipcMain.handle('react-native-get-clipboard-text', async () => {
+    return await clipboard.readText();
+  });
+
+  ipcMain.handle('react-native-set-clipboard-text', async (_event, text) => {
+    await clipboard.writeText(text);
+  });
+}

package/src/modules/ipcHandlers/dialog.js

@@ -0,0 +1,11 @@
+import { ipcMain, dialog, BrowserWindow } from "electron";
+
+export function registerDialogHandlers() {
+  ipcMain.handle('react-native-show-alert', async (event, options) => {
+    const window = BrowserWindow.fromWebContents(event.sender);
+    if (window != null) {
+      const { response } = await dialog.showMessageBox(window, options);
+      return response;
+    }
+  });
+}

package/src/modules/ipcHandlers/fileOps.js

@@ -0,0 +1,33 @@
+import { ipcMain, dialog } from "electron";
+
+export function registerFileHandlers() {
+  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,
+      };
+    }
+  });
+}

package/src/modules/ipcHandlers/index.js

@@ -0,0 +1,33 @@
+import { ipcMain, shell } from "electron";
+import { registerClipboardHandlers } from './clipboard.js';
+import { registerDialogHandlers } from './dialog.js';
+import { registerUpdaterHandlers } from './updater.js';
+import { registerNetworkHandlers } from './network.js';
+import { registerPdfHandlers } from './pdf.js';
+import { registerFileHandlers } from './fileOps.js';
+import { registerUtilsHandlers } from './utils.js';
+
+export function registerAllIpcHandlers() {
+  console.log("📝 Registering IPC handlers...");
+
+  // Deep Linking (basic)
+  ipcMain.handle('react-native-open-url', async (_event, url) => {
+    await shell.openExternal(url);
+  });
+
+  // Register all category handlers
+  registerClipboardHandlers();
+  registerDialogHandlers();
+  registerUpdaterHandlers();
+  registerNetworkHandlers();
+  registerPdfHandlers();
+  registerFileHandlers();
+  registerUtilsHandlers();
+
+  // Internal support check
+  ipcMain.on('react-native-supported', (event) => {
+    event.returnValue = true;
+  });
+
+  console.log("✅ All IPC handlers registered");
+}

package/src/modules/ipcHandlers/network.js

@@ -0,0 +1,18 @@
+import { ipcMain } from "electron";
+import { networkServiceCall } from '../networkService.js';
+
+export function registerNetworkHandlers() {
+  ipcMain.handle("network-call", async (event, payload) => {
+    try {
+      const { method, url, params, headers } = payload;
+      console.log("IPC network-call:", { method, url });
+      return await networkServiceCall(method, url, params, headers);
+    } catch (err) {
+      console.error("IPC network-call error:", err);
+      return {
+        httpstatus: 500,
+        data: { title: "ERROR", message: err.message },
+      };
+    }
+  });
+}

package/src/modules/ipcHandlers/pdf.js

@@ -0,0 +1,135 @@
+import { ipcMain, dialog, BrowserWindow } from "electron";
+import fs from "fs";
+import path from "path";
+import { Readable } from "stream";
+import { app } from "electron";
+import { convertHtmlToPdfPreview } from '../pdfHelper.js';
+
+export function registerPdfHandlers() {
+  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 { status: "saved", path: filePath };
+      }
+
+      return { status: "cancelled" };
+    } catch (err) {
+      console.error("IPC save-pdf error:", err);
+      return { status: "error", message: err.message };
+    }
+  });
+
+  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("preview-html", async (event, htmlContent) => {
+    try {
+      const previewWin = new BrowserWindow({
+        width: 800,
+        height: 600,
+        show: false,
+        webPreferences: {
+          contextIsolation: true,
+          sandbox: false,
+          nodeIntegration: false,
+        },
+      });
+
+      await previewWin.loadURL(
+        `data:text/html;charset=utf-8,${encodeURIComponent(htmlContent)}`
+      );
+
+      previewWin.show();
+      return { status: "ok" };
+    } catch (err) {
+      console.error("preview-html error:", err);
+      return { status: "error", message: err.message };
+    }
+  });
+
+  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 };
+    }
+  });
+}

package/src/modules/ipcHandlers/updater.js

@@ -0,0 +1,17 @@
+import { ipcMain, app } from "electron";
+import electronUpdater from "electron-updater";
+const { autoUpdater } = electronUpdater;
+
+export function registerUpdaterHandlers() {
+  ipcMain.handle("check-for-updates", async () => {
+    if (app.isPackaged) {
+      autoUpdater.checkForUpdates();
+      return { status: "checking" };
+    }
+    return { status: "disabled", message: "Auto-update disabled in development" };
+  });
+
+  ipcMain.handle("get-app-version", () => {
+    return app.getVersion();
+  });
+}

package/src/modules/ipcHandlers/utils.js

@@ -0,0 +1,15 @@
+import { ipcMain, app } from "electron";
+
+export function registerUtilsHandlers() {
+  ipcMain.handle("get-platform", () => {
+    return process.platform;
+  });
+
+  ipcMain.handle("get-app-path", () => {
+    return app.getAppPath();
+  });
+
+  ipcMain.handle("get-user-data-path", () => {
+    return app.getPath("userData");
+  });
+}

package/src/modules/networkService.js

@@ -0,0 +1,36 @@
+export 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 },
+    };
+  }
+}

package/src/modules/pdfHelper.js

@@ -0,0 +1,46 @@
+import { BrowserWindow } from "electron";
+import fs from "fs";
+import path from "path";
+import { app } from "electron";
+
+export async function convertHtmlToPdfPreview(htmlContent, options = {}) {
+  try {
+    const tempWin = new BrowserWindow({
+      show: false,
+      webPreferences: {
+        offscreen: true,
+        contextIsolation: true,
+        nodeIntegration: false,
+      },
+    });
+
+    await tempWin.loadURL(`data:text/html;charset=utf-8,${encodeURIComponent(htmlContent)}`);
+
+    const pdfBuffer = await tempWin.webContents.printToPDF({
+      printBackground: true,
+      ...options,
+    });
+
+    tempWin.destroy();
+
+    const pdfFileName = `Preview_${Date.now()}.pdf`;
+    const pdfPath = path.join(app.getPath("temp"), pdfFileName);
+    fs.writeFileSync(pdfPath, pdfBuffer);
+
+    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;
+  }
+}

package/src/modules/safeMode.js

@@ -0,0 +1,32 @@
+import os from "os";
+import { app } from "electron";
+
+function isRunningFromNetwork() {
+  try {
+    const exePath = app.getPath("exe");
+    return exePath.startsWith("\\\\"); // UNC path
+  } catch {
+    return false;
+  }
+}
+
+export 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;
+}
+
+export function applySafeMode() {
+  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");
+}

package/src/modules/windowManager.js

@@ -0,0 +1,142 @@
+import { BrowserWindow, screen, session } from "electron";
+import path from "path";
+import fs from "fs";
+import { app, dialog } from "electron";
+
+export function createMainWindow(__dirname) {
+  const primaryDisplay = screen.getPrimaryDisplay();
+  const { x, y, width, height } = primaryDisplay.bounds;
+
+  const iconPath = path.join(app.getAppPath(), "electron/icon.ico");
+  const preloadPath = path.join(__dirname, "preload.mjs");
+
+  const 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}`);
+    }
+  });
+
+  // CORS handling
+  setupCorsHandling();
+
+  // Load the app
+  loadAppContent(mainWindow, __dirname);
+
+  // Setup dev tools shortcuts in development
+  if (isDevMode()) {
+    setupDevToolsShortcuts(mainWindow);
+  }
+
+  mainWindow.webContents.on("did-finish-load", () => {
+    console.log("Page loaded successfully");
+  });
+
+  return mainWindow;
+}
+
+function setupCorsHandling() {
+  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"],
+      },
+    });
+  });
+}
+
+function isDevMode() {
+  return process.argv.includes("--enable-remote-module") ||
+    process.env.NODE_ENV === "development";
+}
+
+function loadAppContent(mainWindow, __dirname) {
+  const isDev = isDevMode();
+
+  if (isDev) {
+    mainWindow.loadURL("http://localhost:5001");
+    console.log("DEV MODE: http://localhost:5001");
+  } 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);
+  }
+}
+
+function setupDevToolsShortcuts(mainWindow) {
+  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();
+    }
+  });
+}

package/src/preload.mjs

@@ -1,4 +1,4 @@
-const { contextBridge, ipcRenderer } = require("electron");
+import { contextBridge, ipcRenderer } from "electron";
 
 /**
  * Enhanced Electron API with comprehensive features