react-native-electron-platform 0.0.26 → 0.0.27

package/electron-builder.json

@@ -1,6 +1,6 @@
 {
-  "appId": "com.app.desktop",
-  "productName": "app",
+  "appId": "com.inv.desktop",
+  "productName": "inv",
   "asar": {
     "smartUnpack": true
   },
@@ -79,7 +79,7 @@
     "allowToChangeInstallationDirectory": true,
     "createDesktopShortcut": true,
     "createStartMenuShortcut": true,
-    "shortcutName": "app",
+    "shortcutName": "inv",
     "artifactName": "${productName} Setup ${version}.${ext}"
   },
 

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "react-native-electron-platform",
-  "version": "0.0.26",
-  "description": "A boilerplate and utilities for running React Native applications in Electron",
+  "version": "0.0.27",
+  "description": "A boilerplate and utilities for running React Native applications in desktop environments using Electron.",
   "main": "index.mjs",
   "scripts": {
     "start": "electron index.mjs",

package/src/modules/ipcHandlers/pdf.js

@@ -1,4 +1,4 @@
-import { ipcMain, dialog, BrowserWindow } from "electron";
+import { ipcMain, dialog, BrowserWindow, net } from "electron";
 import fs from "fs";
 import path from "path";
 import { Readable } from "stream";
@@ -45,29 +45,38 @@ export function registerPdfHandlers() {
       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);
+        const req = net.request({
+          method: "POST",
+          url: url,
+        });
+
+        // Set headers
+        req.setHeader("Content-Type", "application/json");
+        req.setHeader("Accept", "application/pdf");
+        Object.entries(headers).forEach(([key, value]) => {
+          req.setHeader(key, value);
+        });
+
+        req.on('response', (res) => {
+          if (res.statusCode < 200 || res.statusCode >= 300) {
+            reject(new Error(`HTTP ${res.statusCode}`));
+            return;
+          }
+
+          const fileStream = fs.createWriteStream(tempPath);
+          res.pipe(fileStream);
+          res.on('error', reject);
+          fileStream.on('finish', resolve);
+          fileStream.on('error', reject);
+        });
+
+        req.on('error', reject);
+        req.write(data);
+        req.end();
       });
 
       return {
@@ -85,8 +94,21 @@ export function registerPdfHandlers() {
 
   ipcMain.handle("open-pdf-preview", async (_, pdfUrl) => {
     try {
-      const res = await fetch(pdfUrl);
-      const buffer = Buffer.from(await res.arrayBuffer());
+      // Check if it's already a file:// URL
+      if (pdfUrl.startsWith('file://')) {
+        // It's already a local file, just return it
+        return pdfUrl;
+      }
+
+      // It's an HTTP(S) URL, fetch it
+      const buffer = await new Promise((resolve, reject) => {
+        net.request(pdfUrl).on('response', (res) => {
+          const chunks = [];
+          res.on('data', (chunk) => chunks.push(chunk));
+          res.on('end', () => resolve(Buffer.concat(chunks)));
+          res.on('error', reject);
+        }).on('error', reject).end();
+      });
 
       const tempPath = path.join(app.getPath("temp"), `preview_${Date.now()}.pdf`);
       fs.writeFileSync(tempPath, buffer);

package/src/modules/networkService.js

@@ -1,25 +1,67 @@
+import { net } from "electron";
+
 export async function networkServiceCall(method, url, params = {}, headers = {}) {
   try {
     const upperMethod = method.toUpperCase();
-    const options = {
-      method: upperMethod,
-      headers: {
-        "Content-Type": "application/json",
-        ...headers,
-      },
-    };
+    
+    let body = undefined;
+    let finalUrl = url;
 
     if (upperMethod !== "GET") {
-      options.body = JSON.stringify(params);
+      body = JSON.stringify(params);
     } else if (params && Object.keys(params).length > 0) {
       const query = new URLSearchParams(params).toString();
-      url += `?${query}`;
+      finalUrl += `?${query}`;
     }
 
-    const response = await fetch(url, options);
-    const data = await response.json().catch(() => ({}));
+    const response = await new Promise((resolve, reject) => {
+      const req = net.request({
+        method: upperMethod,
+        url: finalUrl,
+      });
+
+      // Set headers
+      req.setHeader("Content-Type", "application/json");
+      Object.entries(headers).forEach(([key, value]) => {
+        req.setHeader(key, value);
+      });
+
+      let responseBody = '';
+
+      req.on('response', (res) => {
+        res.on('data', (chunk) => {
+          responseBody += chunk.toString();
+        });
+
+        res.on('end', () => {
+          resolve({
+            status: res.statusCode,
+            headers: res.headers,
+            body: responseBody,
+          });
+        });
+
+        res.on('error', reject);
+      });
+
+      req.on('error', reject);
+      
+      if (body) {
+        req.write(body);
+      }
+      
+      req.end();
+    });
+
+    let data = {};
+    try {
+      data = JSON.parse(response.body);
+    } catch (e) {
+      // If not JSON, use raw body
+      data = response.body;
+    }
 
-    if (response.ok || data?.httpstatus === 200) {
+    if ((response.status >= 200 && response.status < 300) || data?.httpstatus === 200) {
       return { httpstatus: 200, data: data?.data || data };
     }