fullstacked 0.11.3-1148 → 0.11.3-1150

package/lib/bridge/index.ts

@@ -1,53 +1,53 @@
-import "../core_message";
-import platform, { Platform } from "../platform";
-import { BridgeAndroid } from "./platform/android";
-import { BridgeApple, initRespondApple } from "./platform/apple";
-import { BridgeLinuxGTK, initRespondLinuxGTK } from "./platform/linux-gtk";
-import { BridgeLinuxQT, initRespondLinuxQT } from "./platform/linux-qt";
-import { BridgeElectron } from "./platform/electron";
-import { BridgeNode, initCallbackNode } from "./platform/node";
-import { BridgeWasm } from "./platform/wasm";
-import { BridgeWindows, initRespondWindows } from "./platform/windows";
-
-export type Bridge = (
-    payload: Uint8Array,
-    transformer?: (args: any) => any
-) => Promise<any>;
-
-export let bridge: Bridge;
-switch (platform) {
-    case Platform.NODE:
-        bridge = BridgeNode;
-        initCallbackNode();
-        break;
-    case Platform.APPLE:
-        bridge = BridgeApple;
-        initRespondApple();
-        break;
-    case Platform.ANDROID:
-        bridge = BridgeAndroid;
-        break;
-    case Platform.WASM:
-        bridge = BridgeWasm;
-        break;
-    case Platform.WINDOWS:
-        bridge = BridgeWindows;
-        initRespondWindows();
-        break;
-    case Platform.LINUX_GTK:
-        bridge = BridgeLinuxGTK;
-        initRespondLinuxGTK();
-        break;
-    case Platform.LINUX_QT:
-        bridge = BridgeLinuxQT;
-        initRespondLinuxQT();
-        break;
-    case Platform.ELECTRON:
-        bridge = BridgeElectron;
-        break;
-    case Platform.DOCKER:
-        console.log("Bridge not yet implemented");
-}
-
-console.log("FullStacked");
-bridge(new Uint8Array([0]));
+import "../core_message";
+import platform, { Platform } from "../platform";
+import { BridgeAndroid } from "./platform/android";
+import { BridgeApple, initRespondApple } from "./platform/apple";
+import { BridgeLinuxGTK, initRespondLinuxGTK } from "./platform/linux-gtk";
+import { BridgeLinuxQT, initRespondLinuxQT } from "./platform/linux-qt";
+import { BridgeElectron } from "./platform/electron";
+import { BridgeNode, initCallbackNode } from "./platform/node";
+import { BridgeWasm } from "./platform/wasm";
+import { BridgeWindows, initRespondWindows } from "./platform/windows";
+
+export type Bridge = (
+    payload: Uint8Array,
+    transformer?: (args: any) => any
+) => Promise<any>;
+
+export let bridge: Bridge;
+switch (platform) {
+    case Platform.NODE:
+        bridge = BridgeNode;
+        initCallbackNode();
+        break;
+    case Platform.APPLE:
+        bridge = BridgeApple;
+        initRespondApple();
+        break;
+    case Platform.ANDROID:
+        bridge = BridgeAndroid;
+        break;
+    case Platform.WASM:
+        bridge = BridgeWasm;
+        break;
+    case Platform.WINDOWS:
+        bridge = BridgeWindows;
+        initRespondWindows();
+        break;
+    case Platform.LINUX_GTK:
+        bridge = BridgeLinuxGTK;
+        initRespondLinuxGTK();
+        break;
+    case Platform.LINUX_QT:
+        bridge = BridgeLinuxQT;
+        initRespondLinuxQT();
+        break;
+    case Platform.ELECTRON:
+        bridge = BridgeElectron;
+        break;
+    case Platform.DOCKER:
+        console.log("Bridge not yet implemented");
+}
+
+console.log("FullStacked");
+bridge(new Uint8Array([0]));

package/lib/bridge/platform/android.ts

@@ -1,18 +1,18 @@
-import { Bridge } from "..";
-import { fromByteArray, toByteArray } from "../../base64";
-import { deserializeArgs } from "../serialization";
-
-export const BridgeAndroid: Bridge = async (
-    payload: Uint8Array,
-    transformer?: (responseArgs: any[]) => any
-) => {
-    const base64 = fromByteArray(payload);
-    const response = toByteArray(globalThis.android.bridge(base64));
-    const args = deserializeArgs(response);
-
-    if (transformer) {
-        return transformer(args);
-    }
-
-    return args;
-};
+import { Bridge } from "..";
+import { fromByteArray, toByteArray } from "../../base64";
+import { deserializeArgs } from "../serialization";
+
+export const BridgeAndroid: Bridge = async (
+    payload: Uint8Array,
+    transformer?: (responseArgs: any[]) => any
+) => {
+    const base64 = fromByteArray(payload);
+    const response = toByteArray(globalThis.android.bridge(base64));
+    const args = deserializeArgs(response);
+
+    if (transformer) {
+        return transformer(args);
+    }
+
+    return args;
+};

package/lib/bridge/platform/apple.ts

@@ -1,46 +1,46 @@
-import { Bridge } from "..";
-import { fromByteArray, toByteArray } from "../../base64";
-import {
-    bytesToNumber,
-    deserializeArgs,
-    getLowestKeyIdAvailable,
-    numberTo4Bytes
-} from "../serialization";
-
-const requests = new Map<number, (data: Uint8Array) => void>();
-
-export const BridgeApple: Bridge = (
-    payload: Uint8Array,
-    transformer?: (responseArgs: any[]) => any
-) => {
-    const requestId = getLowestKeyIdAvailable(requests);
-
-    const base64 = fromByteArray(
-        new Uint8Array([...numberTo4Bytes(requestId), ...payload])
-    );
-
-    return new Promise((resolve, reject) => {
-        requests.set(requestId, (data) => {
-            try {
-                const args = deserializeArgs(data);
-                if (transformer) {
-                    return resolve(transformer(args));
-                }
-                resolve(args);
-            } catch (e) {
-                reject(e);
-            }
-        });
-        globalThis.webkit.messageHandlers.bridge.postMessage(base64);
-    });
-};
-
-export function initRespondApple() {
-    globalThis.respond = (base64: string) => {
-        const data = toByteArray(base64);
-        const id = bytesToNumber(data.slice(0, 4));
-        const resolver = requests.get(id);
-        resolver(data.slice(4));
-        requests.delete(id);
-    };
-}
+import { Bridge } from "..";
+import { fromByteArray, toByteArray } from "../../base64";
+import {
+    bytesToNumber,
+    deserializeArgs,
+    getLowestKeyIdAvailable,
+    numberTo4Bytes
+} from "../serialization";
+
+const requests = new Map<number, (data: Uint8Array) => void>();
+
+export const BridgeApple: Bridge = (
+    payload: Uint8Array,
+    transformer?: (responseArgs: any[]) => any
+) => {
+    const requestId = getLowestKeyIdAvailable(requests);
+
+    const base64 = fromByteArray(
+        new Uint8Array([...numberTo4Bytes(requestId), ...payload])
+    );
+
+    return new Promise((resolve, reject) => {
+        requests.set(requestId, (data) => {
+            try {
+                const args = deserializeArgs(data);
+                if (transformer) {
+                    return resolve(transformer(args));
+                }
+                resolve(args);
+            } catch (e) {
+                reject(e);
+            }
+        });
+        globalThis.webkit.messageHandlers.bridge.postMessage(base64);
+    });
+};
+
+export function initRespondApple() {
+    globalThis.respond = (base64: string) => {
+        const data = toByteArray(base64);
+        const id = bytesToNumber(data.slice(0, 4));
+        const resolver = requests.get(id);
+        resolver(data.slice(4));
+        requests.delete(id);
+    };
+}

package/lib/bridge/platform/electron.ts

@@ -1,14 +1,14 @@
-import { Bridge } from "..";
-import { deserializeArgs } from "../serialization";
-
-export const BridgeElectron: Bridge = async (
-    payload: Uint8Array,
-    transformer?: (responseArgs: any[]) => any
-) => {
-    const response = await (window as any).electronAPI.bridge(payload);
-    const args = deserializeArgs(response);
-    if (transformer) {
-        return transformer(args);
-    }
-    return args;
-};
+import { Bridge } from "..";
+import { deserializeArgs } from "../serialization";
+
+export const BridgeElectron: Bridge = async (
+    payload: Uint8Array,
+    transformer?: (responseArgs: any[]) => any
+) => {
+    const response = await (window as any).electronAPI.bridge(payload);
+    const args = deserializeArgs(response);
+    if (transformer) {
+        return transformer(args);
+    }
+    return args;
+};

package/lib/bridge/platform/linux-gtk.ts

@@ -1,48 +1,48 @@
-import { Bridge } from "..";
-import { fromByteArray, toByteArray } from "../../base64";
-import {
-    bytesToNumber,
-    deserializeArgs,
-    getLowestKeyIdAvailable,
-    numberTo4Bytes
-} from "../serialization";
-
-const requests = new Map<number, (data: Uint8Array) => void>();
-
-export const BridgeLinuxGTK: Bridge = (
-    payload: Uint8Array,
-    transformer?: (responseArgs: any[]) => any
-) => {
-    const requestId = getLowestKeyIdAvailable(requests);
-
-    const base64 = fromByteArray(
-        new Uint8Array([...numberTo4Bytes(requestId), ...payload])
-    );
-
-    return new Promise((resolve, reject) => {
-        requests.set(requestId, (data) => {
-            try {
-                const args = deserializeArgs(data);
-                if (transformer) {
-                    return resolve(transformer(args));
-                }
-                resolve(args);
-            } catch (e) {
-                reject(e);
-            }
-        });
-        globalThis.webkit.messageHandlers.bridge.postMessage(base64);
-    });
-};
-
-export function initRespondLinuxGTK() {
-    globalThis.respond = (base64: string) => {
-        console.log(base64);
-        const data = toByteArray(base64);
-        const id = bytesToNumber(data.slice(0, 4));
-        console.log(id);
-        const resolver = requests.get(id);
-        resolver(data.slice(4));
-        requests.delete(id);
-    };
-}
+import { Bridge } from "..";
+import { fromByteArray, toByteArray } from "../../base64";
+import {
+    bytesToNumber,
+    deserializeArgs,
+    getLowestKeyIdAvailable,
+    numberTo4Bytes
+} from "../serialization";
+
+const requests = new Map<number, (data: Uint8Array) => void>();
+
+export const BridgeLinuxGTK: Bridge = (
+    payload: Uint8Array,
+    transformer?: (responseArgs: any[]) => any
+) => {
+    const requestId = getLowestKeyIdAvailable(requests);
+
+    const base64 = fromByteArray(
+        new Uint8Array([...numberTo4Bytes(requestId), ...payload])
+    );
+
+    return new Promise((resolve, reject) => {
+        requests.set(requestId, (data) => {
+            try {
+                const args = deserializeArgs(data);
+                if (transformer) {
+                    return resolve(transformer(args));
+                }
+                resolve(args);
+            } catch (e) {
+                reject(e);
+            }
+        });
+        globalThis.webkit.messageHandlers.bridge.postMessage(base64);
+    });
+};
+
+export function initRespondLinuxGTK() {
+    globalThis.respond = (base64: string) => {
+        console.log(base64);
+        const data = toByteArray(base64);
+        const id = bytesToNumber(data.slice(0, 4));
+        console.log(id);
+        const resolver = requests.get(id);
+        resolver(data.slice(4));
+        requests.delete(id);
+    };
+}

package/lib/bridge/platform/linux-qt.ts

@@ -1,68 +1,68 @@
-import { Bridge } from "..";
-import { fromByteArray, toByteArray } from "../../base64";
-import {
-    bytesToNumber,
-    deserializeArgs,
-    getLowestKeyIdAvailable,
-    numberTo4Bytes
-} from "../serialization";
-
-const pendingRequests: {
-    payload: Uint8Array;
-    transformer: (responseArgs: any[]) => any;
-    resolve: (args: any) => void;
-}[] = [];
-let channel: any;
-
-async function respond(
-    payload: Uint8Array,
-    transformer?: (responseArgs: any[]) => any
-) {
-    const payloadStr = fromByteArray(new Uint8Array([0, 0, 0, 0, ...payload]));
-
-    const response = await channel.objects.bridge.call(payloadStr);
-    const data = toByteArray(response);
-    const args = deserializeArgs(data.slice(4));
-
-    if (transformer) {
-        return transformer(args);
-    }
-
-    return args;
-}
-
-export const BridgeLinuxQT: Bridge = (
-    payload: Uint8Array,
-    transformer?: (responseArgs: any[]) => any
-) => {
-    if (!channel) {
-        return new Promise((resolve) => {
-            pendingRequests.push({
-                payload,
-                transformer,
-                resolve
-            });
-        });
-    }
-
-    return respond(payload, transformer);
-};
-
-export async function initRespondLinuxQT() {
-    const script = document.createElement("script");
-    script.src = "qrc:///qtwebchannel/qwebchannel.js";
-    script.onload = () => {
-        new globalThis.QWebChannel(globalThis.qt.webChannelTransport, (c) => {
-            channel = c;
-            pendingRequests.forEach(({ payload, transformer, resolve }) => {
-                respond(payload, transformer).then(resolve);
-            });
-            channel.objects.bridge.core_message.connect(
-                function (type, message) {
-                    globalThis.oncoremessage(type, message);
-                }
-            );
-        });
-    };
-    document.body.append(script);
-}
+import { Bridge } from "..";
+import { fromByteArray, toByteArray } from "../../base64";
+import {
+    bytesToNumber,
+    deserializeArgs,
+    getLowestKeyIdAvailable,
+    numberTo4Bytes
+} from "../serialization";
+
+const pendingRequests: {
+    payload: Uint8Array;
+    transformer: (responseArgs: any[]) => any;
+    resolve: (args: any) => void;
+}[] = [];
+let channel: any;
+
+async function respond(
+    payload: Uint8Array,
+    transformer?: (responseArgs: any[]) => any
+) {
+    const payloadStr = fromByteArray(new Uint8Array([0, 0, 0, 0, ...payload]));
+
+    const response = await channel.objects.bridge.call(payloadStr);
+    const data = toByteArray(response);
+    const args = deserializeArgs(data.slice(4));
+
+    if (transformer) {
+        return transformer(args);
+    }
+
+    return args;
+}
+
+export const BridgeLinuxQT: Bridge = (
+    payload: Uint8Array,
+    transformer?: (responseArgs: any[]) => any
+) => {
+    if (!channel) {
+        return new Promise((resolve) => {
+            pendingRequests.push({
+                payload,
+                transformer,
+                resolve
+            });
+        });
+    }
+
+    return respond(payload, transformer);
+};
+
+export async function initRespondLinuxQT() {
+    const script = document.createElement("script");
+    script.src = "qrc:///qtwebchannel/qwebchannel.js";
+    script.onload = () => {
+        new globalThis.QWebChannel(globalThis.qt.webChannelTransport, (c) => {
+            channel = c;
+            pendingRequests.forEach(({ payload, transformer, resolve }) => {
+                respond(payload, transformer).then(resolve);
+            });
+            channel.objects.bridge.core_message.connect(
+                function (type, message) {
+                    globalThis.oncoremessage(type, message);
+                }
+            );
+        });
+    };
+    document.body.append(script);
+}

package/lib/bridge/platform/node.ts

@@ -1,32 +1,32 @@
-import { Bridge } from "..";
-import { deserializeArgs } from "../serialization";
-
-const bridge = globalThis.fetch;
-
-export const BridgeNode: Bridge = async (
-    payload: Uint8Array,
-    transformer?: (responseArgs: any[]) => any
-) => {
-    const response = await bridge("/call", {
-        method: "POST",
-        body: payload
-    });
-    const data = new Uint8Array(await response.arrayBuffer());
-    const args = deserializeArgs(data);
-
-    if (transformer) {
-        return transformer(args);
-    }
-
-    return args;
-};
-
-export function initCallbackNode() {
-    const url = new URL(globalThis.location.href);
-    url.protocol = "ws:";
-    const ws = new WebSocket(url.toString());
-    ws.onmessage = (e) => {
-        const [type, message] = JSON.parse(e.data);
-        globalThis.oncoremessage(type, message);
-    };
-}
+import { Bridge } from "..";
+import { deserializeArgs } from "../serialization";
+
+const bridge = globalThis.fetch;
+
+export const BridgeNode: Bridge = async (
+    payload: Uint8Array,
+    transformer?: (responseArgs: any[]) => any
+) => {
+    const response = await bridge("/call", {
+        method: "POST",
+        body: payload
+    });
+    const data = new Uint8Array(await response.arrayBuffer());
+    const args = deserializeArgs(data);
+
+    if (transformer) {
+        return transformer(args);
+    }
+
+    return args;
+};
+
+export function initCallbackNode() {
+    const url = new URL(globalThis.location.href);
+    url.protocol = "ws:";
+    const ws = new WebSocket(url.toString());
+    ws.onmessage = (e) => {
+        const [type, message] = JSON.parse(e.data);
+        globalThis.oncoremessage(type, message);
+    };
+}

package/lib/bridge/platform/wasm.ts

@@ -1,17 +1,17 @@
-import { Bridge } from "..";
-import { toByteArray } from "../../base64";
-import { deserializeArgs } from "../serialization";
-
-export const BridgeWasm: Bridge = async (
-    payload: Uint8Array,
-    transformer?: (responseArgs: any[]) => any
-) => {
-    const response = await globalThis.lib.call(payload);
-    const args = deserializeArgs(toByteArray(response));
-
-    if (transformer) {
-        return transformer(args);
-    }
-
-    return args;
-};
+import { Bridge } from "..";
+import { toByteArray } from "../../base64";
+import { deserializeArgs } from "../serialization";
+
+export const BridgeWasm: Bridge = async (
+    payload: Uint8Array,
+    transformer?: (responseArgs: any[]) => any
+) => {
+    const response = await globalThis.lib.call(payload);
+    const args = deserializeArgs(toByteArray(response));
+
+    if (transformer) {
+        return transformer(args);
+    }
+
+    return args;
+};