fullstacked 0.12.0-1173 → 0.12.0-1184

package/fullstacked_modules/bridge/index.ts

@@ -0,0 +1,120 @@
+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";
+import git from "../git";
+import esbuild from "../esbuild";
+import { SnackBar } from "../components/snackbar";
+import { Button } from "@fullstacked/ui";
+import { serializeArgs } from "./serialization";
+import { buildSASS } from "../esbuild/sass";
+import fs from "../fs";
+
+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]));
+
+let lastUpdateCheck = 0;
+const updateCheckDelay = 1000 * 10 // 10sec;
+async function checkForUpdates() {
+    window.requestAnimationFrame(checkForUpdates)
+
+    const now = Date.now();
+    if (now - lastUpdateCheck < updateCheckDelay) {
+        return;
+    }
+
+    lastUpdateCheck = now;
+
+    if (await git.pull() !== git.PullResponse.DID_PULL) {
+        return;
+    }
+
+    let preventReload = false;
+    const preventReloadButton = Button({
+        text: "Stop"
+    });
+    preventReloadButton.onclick = () => {
+        preventReload = true;
+        snackbar.dismiss();
+    }
+
+    const snackbar = SnackBar({
+        message: "Project has updated. Rebuilding...",
+        button: preventReloadButton
+    });
+
+    buildSASS(fs)
+        .then(() => {
+            esbuild.build().then(() => {
+                snackbar.dismiss();
+                if (preventReload) return;
+                window.location.reload();
+            });
+        });
+
+}
+if (await git.hasGit()) {
+    checkForUpdates();
+}
+
+// 40
+function setTitle(title: string) {
+    const payload = new Uint8Array([40, ...serializeArgs([title])]);
+    bridge(payload);
+}
+
+let lastTitleSeen = null;
+setInterval(() => {
+    if (!document.title) return;
+
+    if (lastTitleSeen !== document.title) {
+        setTitle(document.title);
+    }
+    lastTitleSeen = document.title;
+}, 500);

package/{lib → fullstacked_modules}/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 → fullstacked_modules}/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 → fullstacked_modules}/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 → fullstacked_modules}/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 → fullstacked_modules}/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 → fullstacked_modules}/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<ArrayBuffer>,
+    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 → fullstacked_modules}/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;
+};