fetch api & apply fix current https

preload/src/api/fetch.js

@@ -0,0 +1,88 @@
+import * as https from "https";
+import * as http from "http";
+
+const redirectCodes = new Set([301, 302, 307, 308]);
+
+export function nativeFetch(url, options) {
+    let state = "PENDING";
+    const data = {content: [], headers: null, statusCode: null, url: url, statusText: "", redirected: false};
+    const listeners = new Set();
+    const errors = new Set();
+
+    /** * @param {URL} url */
+    const execute = (url, options, redirect = false) => {
+        const Module = url.protocol === "http" ? http : https;
+        
+        const req = Module.request(url.href, {
+            headers: options.headers ?? {},
+            method: options.method ?? "GET"
+        }, res => {
+            if (redirectCodes.has(res.statusCode) && res.headers.location && options.redirect !== "manual") {
+                const final = new URL(res.headers.location);
+
+                for (const [key, value] of new URL(url).searchParams.entries()) {
+                    final.searchParams.set(key, value);
+                }
+
+                return execute(final, options, true);
+            }
+
+            res.on("data", chunk => data.content.push(chunk));
+            res.on("end", () => {
+                data.content = Buffer.concat(data.content);
+                data.headers = res.headers;
+                data.statusCode = res.statusCode;
+                data.url = url.toString();
+                data.statusText = res.statusMessage;
+                data.redirected = redirect;
+                state = "DONE";
+
+                listeners.forEach(listener => listener());
+            });
+            res.on("error", error => {
+                state = "ABORTED";
+                errors.forEach(e => e(error));
+            });
+        });
+
+        if (options.body) {
+            try {req.write(options.body)}
+            catch (error) {
+                state = "ABORTED";
+                errors.forEach(e => e(error));
+            } finally {
+                req.end();
+            }
+        } else {
+            req.end();
+        }
+
+        if (options.signal) {
+            options.signal.addEventListener("abort", () => {
+                req.end();
+                state = "ABORTED";
+            });
+        }
+    };
+
+    execute(new URL(url), options);
+
+    return {
+        onComplete(listener) {
+            listeners.add(listener);
+        },
+        onError(listener) {
+            errors.add(listener);
+        },
+        readData() {
+            switch (state) {
+                case "PENDING":
+                    throw new Error("Cannot read data before request is done!");
+                case "ABORTED":
+                    throw new Error("Request was aborted.");
+                case "DONE":
+                    return data;
+            }
+        }
+    };
+}

preload/src/api/https.js

@@ -34,7 +34,15 @@ const makeRequest = (url, options, callback, setReq) => {
             req.end();
         });
     });
-    req.end();
+
+    if (options.formData) {
+        // Make sure to close the socket.
+        try {req.write(options.formData);}
+        finally {req.end();}
+    } else {
+        req.end();
+    }
+
 };
 
 const request = function (url, options, callback) {

preload/src/api/index.js

@@ -3,6 +3,7 @@ export {default as https} from "./https";
 export * as electron from "./electron";
 export * as crypto from "./crypto";
 export * as vm from "./vm";
+export * from "./fetch";
 
 // We can expose that without any issues.
 export * as path from "path";