fullstacked 0.12.0-1169 → 0.12.0-1175

package/lib/archive/archive.ts

@@ -0,0 +1,140 @@
+import { bridge } from "../bridge";
+import { serializeArgs } from "../bridge/serialization";
+
+type FileEntries<T extends string | Uint8Array> = {
+    [filePath: string]: {
+        isDir: boolean;
+        contents: T;
+    };
+};
+
+function unzipDataToFileEntries(data: any[]): FileEntries<Uint8Array> {
+    const entries: FileEntries<Uint8Array> = {};
+    for (let i = 0; i < data.length; i = i + 3) {
+        entries[data[i]] = {
+            isDir: data[i + 1],
+            contents: data[i + 2]
+        };
+    }
+    return entries;
+}
+
+export function unzip(
+    entry: string | Uint8Array
+): Promise<FileEntries<Uint8Array>>;
+export function unzip(
+    entry: string | Uint8Array,
+    out: string
+): Promise<boolean>;
+export function unzip(entry: string | Uint8Array, out?: string) {
+    let method: number;
+    let args: any[];
+    let transformer: (args: any) => any;
+
+    // BIN_TO
+    if (entry instanceof Uint8Array) {
+        // _FILE => 30
+        if (typeof out === "string") {
+            method = 30;
+            args = [entry, out];
+            transformer = ([success]) => success;
+        }
+        // _BIN => 31
+        else {
+            method = 31;
+            args = [entry];
+            transformer = (unzipData) => unzipDataToFileEntries(unzipData);
+        }
+    }
+    // FILE_TO
+    else {
+        // _FILE => 32
+        if (typeof out === "string") {
+            method = 32;
+            args = [entry, out];
+            transformer = ([success]) => success;
+        }
+        // _BIN => 33
+        else {
+            method = 33;
+            args = [entry];
+            transformer = (unzipData) => unzipDataToFileEntries(unzipData);
+        }
+    }
+
+    const payload = new Uint8Array([method, ...serializeArgs(args)]);
+    return bridge(payload, transformer);
+}
+
+const te = new TextEncoder();
+
+function fileEntriesToZipData(
+    entries: FileEntries<string | Uint8Array>
+): any[] {
+    return Object.entries(entries)
+        .map(([name, { isDir, contents }]) => [
+            name,
+            isDir,
+            contents instanceof Uint8Array ? contents : te.encode(contents)
+        ])
+        .flat();
+}
+
+export function zip(
+    entry: FileEntries<string | Uint8Array>
+): Promise<Uint8Array>;
+export function zip(
+    entry: string,
+    out?: null | undefined,
+    skip?: string[]
+): Promise<Uint8Array>;
+export function zip(
+    entry: FileEntries<string | Uint8Array> | string,
+    out: string,
+    skip?: string[]
+): Promise<boolean>;
+export function zip(
+    entry: FileEntries<string | Uint8Array> | string,
+    out?: string,
+    skip?: string[]
+) {
+    let method: number;
+    let args: any[];
+    let transformer: (args: any) => any;
+
+    // BIN_TO
+    if (typeof entry === "object") {
+        // _FILE => 34
+        if (typeof out === "string") {
+            method = 34;
+            args = fileEntriesToZipData(entry);
+            args.unshift(out);
+            transformer = ([success]) => success;
+        }
+        // _BIN => 35
+        else {
+            method = 35;
+            args = fileEntriesToZipData(entry);
+            transformer = ([zipData]) => zipData;
+        }
+    }
+    // FILE_TO
+    else {
+        // _FILE => 36
+        if (typeof out === "string") {
+            method = 36;
+            args = [entry, out, ...(skip || [])];
+            transformer = ([success]) => success;
+        }
+        // _BIN => 37
+        else {
+            method = 37;
+            args = [entry, ...(skip || [])];
+            transformer = ([zipData]) => zipData;
+        }
+    }
+
+    const payload = new Uint8Array([method, ...serializeArgs(args)]);
+
+    return bridge(payload, transformer);
+}

package/lib/archive/index.ts

@@ -0,0 +1,4 @@
+import * as archive from "./archive";
+
+export default archive;
+export * from "./archive";

package/lib/base64.ts

@@ -0,0 +1,144 @@
+// source : https://github.com/beatgammit/base64-js/tree/master
+const lookup = [];
+const revLookup = [];
+
+var code = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
+for (let i = 0, len = code.length; i < len; ++i) {
+    lookup[i] = code[i];
+    revLookup[code.charCodeAt(i)] = i;
+}
+
+// Support decoding URL-safe base64 strings, as Node.js does.
+// See: https://en.wikipedia.org/wiki/Base64#URL_applications
+revLookup["-".charCodeAt(0)] = 62;
+revLookup["_".charCodeAt(0)] = 63;
+
+function getLens(b64) {
+    var len = b64.length;
+
+    // if (len % 4 > 0) {
+    //     throw new Error("Invalid string. Length must be a multiple of 4");
+    // }
+
+    // Trim off extra bytes after placeholder bytes are found
+    // See: https://github.com/beatgammit/base64-js/issues/42
+    var validLen = b64.indexOf("=");
+    if (validLen === -1) validLen = len;
+
+    var placeHoldersLen = validLen === len ? 0 : 4 - (validLen % 4);
+
+    return [validLen, placeHoldersLen];
+}
+
+// base64 is 4/3 + up to two characters of the original data
+function byteLength(b64) {
+    var lens = getLens(b64);
+    var validLen = lens[0];
+    var placeHoldersLen = lens[1];
+    return ((validLen + placeHoldersLen) * 3) / 4 - placeHoldersLen;
+}
+
+function _byteLength(b64, validLen, placeHoldersLen) {
+    return ((validLen + placeHoldersLen) * 3) / 4 - placeHoldersLen;
+}
+
+export function toByteArray(b64: string) {
+    let tmp: any;
+    const lens = getLens(b64);
+    const validLen = lens[0];
+    const placeHoldersLen = lens[1];
+
+    const arr = new Uint8Array(_byteLength(b64, validLen, placeHoldersLen));
+
+    let curByte = 0;
+
+    // if there are placeholders, only get up to the last complete 4 chars
+    const len = placeHoldersLen > 0 ? validLen - 4 : validLen;
+
+    let i: number;
+    for (i = 0; i < len; i += 4) {
+        tmp =
+            (revLookup[b64.charCodeAt(i)] << 18) |
+            (revLookup[b64.charCodeAt(i + 1)] << 12) |
+            (revLookup[b64.charCodeAt(i + 2)] << 6) |
+            revLookup[b64.charCodeAt(i + 3)];
+        arr[curByte++] = (tmp >> 16) & 0xff;
+        arr[curByte++] = (tmp >> 8) & 0xff;
+        arr[curByte++] = tmp & 0xff;
+    }
+
+    if (placeHoldersLen === 2) {
+        tmp =
+            (revLookup[b64.charCodeAt(i)] << 2) |
+            (revLookup[b64.charCodeAt(i + 1)] >> 4);
+        arr[curByte++] = tmp & 0xff;
+    }
+
+    if (placeHoldersLen === 1) {
+        tmp =
+            (revLookup[b64.charCodeAt(i)] << 10) |
+            (revLookup[b64.charCodeAt(i + 1)] << 4) |
+            (revLookup[b64.charCodeAt(i + 2)] >> 2);
+        arr[curByte++] = (tmp >> 8) & 0xff;
+        arr[curByte++] = tmp & 0xff;
+    }
+
+    return arr;
+}
+
+function tripletToBase64(num) {
+    return (
+        lookup[(num >> 18) & 0x3f] +
+        lookup[(num >> 12) & 0x3f] +
+        lookup[(num >> 6) & 0x3f] +
+        lookup[num & 0x3f]
+    );
+}
+
+function encodeChunk(uint8, start, end) {
+    var tmp;
+    var output = [];
+    for (var i = start; i < end; i += 3) {
+        tmp =
+            ((uint8[i] << 16) & 0xff0000) +
+            ((uint8[i + 1] << 8) & 0xff00) +
+            (uint8[i + 2] & 0xff);
+        output.push(tripletToBase64(tmp));
+    }
+    return output.join("");
+}
+
+export function fromByteArray(uint8: Uint8Array) {
+    let tmp;
+    const len = uint8.length;
+    const extraBytes = len % 3; // if we have 1 byte left, pad 2 bytes
+    const parts = [];
+    const maxChunkLength = 16383; // must be multiple of 3
+
+    // go through the array every three bytes, we'll deal with trailing stuff later
+    for (let i = 0, len2 = len - extraBytes; i < len2; i += maxChunkLength) {
+        parts.push(
+            encodeChunk(
+                uint8,
+                i,
+                i + maxChunkLength > len2 ? len2 : i + maxChunkLength
+            )
+        );
+    }
+
+    // pad the end with zeros, but make sure to not forget the extra bytes
+    if (extraBytes === 1) {
+        tmp = uint8[len - 1];
+        parts.push(lookup[tmp >> 2] + lookup[(tmp << 4) & 0x3f] + "==");
+    } else if (extraBytes === 2) {
+        tmp = (uint8[len - 2] << 8) + uint8[len - 1];
+        parts.push(
+            lookup[tmp >> 10] +
+                lookup[(tmp >> 4) & 0x3f] +
+                lookup[(tmp << 2) & 0x3f] +
+                "="
+        );
+    }
+
+    return parts.join("");
+}

package/lib/bridge/index.ts

@@ -0,0 +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]));

package/lib/bridge/platform/android.ts

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

package/lib/bridge/platform/apple.ts

@@ -0,0 +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);
+    };
+}

package/lib/bridge/platform/electron.ts

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

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

@@ -0,0 +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);
+    };
+}

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

@@ -0,0 +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);
+}

package/lib/bridge/platform/node.ts

@@ -0,0 +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);
+    };
+}

package/lib/bridge/platform/wasm.ts

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

package/lib/bridge/platform/windows.ts

@@ -0,0 +1,49 @@
+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 BridgeWindows: Bridge = (
+    payload: Uint8Array,
+    transformer?: (responseArgs: any[]) => any
+) => {
+    const requestId = getLowestKeyIdAvailable(requests);
+
+    requests.set(requestId, null);
+
+    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.chrome.webview.postMessage(base64);
+    });
+};
+
+export function initRespondWindows() {
+    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);
+    };
+}