react-native-electron-platform 0.0.10 → 0.0.12

package/electron-builder.json

@@ -55,13 +55,14 @@
     "!**/node_modules/react-native-*/*",
     "!**/node_modules/rn-fetch-blob/**",
     "!**/locales/**",
-    "node_modules/react-native-electron-platform/src/**/*"
+    "node_modules/react-native-electron-platform/src/**/*",
+    "node_modules/react-native-electron-platform/index.mjs"
   ],
   "asarUnpack": [
     "**/*.node"
   ],
   "extraMetadata": {
-    "main": "node_modules/react-native-electron-platform/src/main.mjs"
+    "main": "node_modules/react-native-electron-platform/index.mjs"
   },
   "win": {
     "target": [

package/index.mjs

@@ -1 +1,84 @@
+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 './src/modules/safeMode.js';
+import { registerDeepLinkingHandlers, sendOpenURL } from './src/modules/deepLinking.js';
+import { registerAllIpcHandlers } from './src/modules/ipcHandlers/index.js';
+import { setupAutoUpdater } from './src/modules/autoUpdater.js';
+import { createMainWindow } from './src/modules/windowManager.js';
+
+const __dirname = dirname(fileURLToPath(import.meta.url));
+
+// ======================================================
+// SAFE MODE DETECTION (applies before ready)
+// ======================================================
+if (shouldUseSafeMode()) {
+  applySafeMode();
+}
+
+let mainWindow;
+
+// ======================================================
+// REGISTER IPC HANDLERS
+// ======================================================
+registerAllIpcHandlers();
+registerDeepLinkingHandlers(sendOpenURL);
+
+// ======================================================
+// APP LIFECYCLE
+// ======================================================
+
+// Single instance lock
+const gotTheLock = app.requestSingleInstanceLock();
+
+if (!gotTheLock) {
+  app.quit();
+} else {
+  app.on('second-instance', (event, commandLine) => {
+    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);
+      }
+    }
+  });
+}
+
+app.whenReady().then(() => {
+  if (process.platform === "win32") {
+    app.setAppUserModelId(`com.${packageJson.name}.desktop`);
+  }
+  
+  mainWindow = createMainWindow(__dirname);
+  setupAutoUpdater(mainWindow);
+  
+  // Log registered handlers
+  console.log("📊 IPC Handlers registered:", 
+    ipcMain.eventNames().filter(name => 
+      typeof name === 'string' && 
+      !name.startsWith('ELECTRON_')
+    )
+  );
+});
+
+app.on("window-all-closed", () => {
+  if (process.platform !== "darwin") {
+    app.quit();
+  }
+});
+
+app.on("activate", () => {
+  if (BrowserWindow.getAllWindows().length === 0) {
+    mainWindow = createMainWindow(__dirname);
+  }
+});
+
+// Export webpack helper utilities
 export * from './src/webpackConfigHelper.mjs';

package/package.json

@@ -1,10 +1,10 @@
 {
   "name": "react-native-electron-platform",
-  "version": "0.0.10",
+  "version": "0.0.12",
   "description": "A boilerplate and utilities for running React Native applications in Electron",
   "main": "index.mjs",
   "scripts": {
-    "start": "electron src/main.mjs",
+    "start": "electron index.mjs",
     "build": "webpack --config webpack.config.mjs"
   },
   "keywords": [

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");
+}