fullstacked 0.12.0-1173 → 0.12.0-1184

package/{lib → fullstacked_modules}/connect/index.ts

@@ -1,125 +1,125 @@
-import { bridge } from "../bridge";
-import {
-    deserializeArgs,
-    numberTo4Bytes,
-    serializeArgs
-} from "../bridge/serialization";
-import core_message from "../core_message";
-import { toByteArray } from "../base64";
-
-export type Data = string | number | boolean | Uint8Array;
-
-type DataChannelCallback = (data: Data[]) => void;
-
-type DataChannel = {
-    send(...args: Data[]): void;
-    on(callback: DataChannelCallback): void;
-    off(callback: DataChannelCallback): void;
-};
-
-type DataChannelRawCallback = (data: Uint8Array) => void;
-
-type DataChannelRaw = {
-    send(buffer: Uint8Array): void;
-    on(callback: DataChannelRawCallback): void;
-    off(callback: DataChannelRawCallback): void;
-};
-
-type Channel = {
-    raw: false;
-    listeners: Set<DataChannelCallback>;
-};
-
-type ChannelRaw = {
-    raw: true;
-    listeners: Set<DataChannelRawCallback>;
-};
-
-const channels = new Map<string, Channel | ChannelRaw>();
-
-// 20
-export function connect(
-    name: string,
-    port: number,
-    host?: string,
-    raw?: false
-): Promise<DataChannel>;
-export function connect(
-    name: string,
-    port: number,
-    host: string,
-    raw: true
-): Promise<DataChannelRaw>;
-export function connect(
-    name: string,
-    port: number,
-    host = "localhost",
-    raw = false
-) {
-    const payload = new Uint8Array([
-        20,
-        ...serializeArgs([name, port, host, raw])
-    ]);
-
-    const transformer = ([channelId]) => {
-        if (raw) {
-            const listeners = new Set<DataChannelRawCallback>();
-
-            const channel: ChannelRaw = {
-                raw: true,
-                listeners
-            };
-
-            channels.set(channelId, channel);
-
-            core_message.addListener("channel-" + channelId, (dataStr) => {
-                const data = toByteArray(dataStr);
-                listeners.forEach((cb) => cb(data));
-            });
-
-            return {
-                send: (data) => send(channelId, data),
-                on: (cb) => listeners.add(cb),
-                off: (cb) => listeners.add(cb)
-            } as DataChannelRaw;
-        } else {
-            const listeners = new Set<DataChannelCallback>();
-
-            const channel: Channel = {
-                raw: false,
-                listeners
-            };
-
-            core_message.addListener("channel-" + channelId, (dataStr) => {
-                const data = toByteArray(dataStr);
-                listeners.forEach((cb) => cb(deserializeArgs(data)));
-            });
-
-            channels.set(channelId, channel);
-
-            return {
-                send: (...data) => {
-                    const body = serializeArgs(data);
-                    send(
-                        channelId,
-                        new Uint8Array([
-                            ...numberTo4Bytes(body.byteLength),
-                            ...body
-                        ])
-                    );
-                },
-                on: (cb) => listeners.add(cb),
-                off: (cb) => listeners.add(cb)
-            } as DataChannel;
-        }
-    };
-
-    return bridge(payload, transformer);
-}
-
-// 21
-function send(channelId: string, data: Uint8Array) {
-    const payload = new Uint8Array([21, ...serializeArgs([channelId, data])]);
-
-    return bridge(payload);
-}
+import { bridge } from "../bridge";
+import {
+    deserializeArgs,
+    numberTo4Bytes,
+    serializeArgs
+} from "../bridge/serialization";
+import core_message from "../core_message";
+import { toByteArray } from "../base64";
+
+export type Data = string | number | boolean | Uint8Array;
+
+type DataChannelCallback = (data: Data[]) => void;
+
+type DataChannel = {
+    send(...args: Data[]): void;
+    on(callback: DataChannelCallback): void;
+    off(callback: DataChannelCallback): void;
+};
+
+type DataChannelRawCallback = (data: Uint8Array) => void;
+
+type DataChannelRaw = {
+    send(buffer: Uint8Array): void;
+    on(callback: DataChannelRawCallback): void;
+    off(callback: DataChannelRawCallback): void;
+};
+
+type Channel = {
+    raw: false;
+    listeners: Set<DataChannelCallback>;
+};
+
+type ChannelRaw = {
+    raw: true;
+    listeners: Set<DataChannelRawCallback>;
+};
+
+const channels = new Map<string, Channel | ChannelRaw>();
+
+// 20
+export function connect(
+    name: string,
+    port: number,
+    host?: string,
+    raw?: false
+): Promise<DataChannel>;
+export function connect(
+    name: string,
+    port: number,
+    host: string,
+    raw: true
+): Promise<DataChannelRaw>;
+export function connect(
+    name: string,
+    port: number,
+    host = "localhost",
+    raw = false
+) {
+    const payload = new Uint8Array([
+        20,
+        ...serializeArgs([name, port, host, raw])
+    ]);
+
+    const transformer = ([channelId]) => {
+        if (raw) {
+            const listeners = new Set<DataChannelRawCallback>();
+
+            const channel: ChannelRaw = {
+                raw: true,
+                listeners
+            };
+
+            channels.set(channelId, channel);
+
+            core_message.addListener("channel-" + channelId, (dataStr) => {
+                const data = toByteArray(dataStr);
+                listeners.forEach((cb) => cb(data));
+            });
+
+            return {
+                send: (data) => send(channelId, data),
+                on: (cb) => listeners.add(cb),
+                off: (cb) => listeners.add(cb)
+            } as DataChannelRaw;
+        } else {
+            const listeners = new Set<DataChannelCallback>();
+
+            const channel: Channel = {
+                raw: false,
+                listeners
+            };
+
+            core_message.addListener("channel-" + channelId, (dataStr) => {
+                const data = toByteArray(dataStr);
+                listeners.forEach((cb) => cb(deserializeArgs(data)));
+            });
+
+            channels.set(channelId, channel);
+
+            return {
+                send: (...data) => {
+                    const body = serializeArgs(data);
+                    send(
+                        channelId,
+                        new Uint8Array([
+                            ...numberTo4Bytes(body.byteLength),
+                            ...body
+                        ])
+                    );
+                },
+                on: (cb) => listeners.add(cb),
+                off: (cb) => listeners.add(cb)
+            } as DataChannel;
+        }
+    };
+
+    return bridge(payload, transformer);
+}
+
+// 21
+function send(channelId: string, data: Uint8Array) {
+    const payload = new Uint8Array([21, ...serializeArgs([channelId, data])]);
+
+    return bridge(payload);
+}

package/{lib → fullstacked_modules}/core_message/core_message.ts

@@ -1,76 +1,57 @@
-import { bridge } from "../bridge";
-import { serializeArgs } from "../bridge/serialization";
-import { SnackBar } from "../components/snackbar";
-
-const coreMessageListeners = new Map<string, Set<(message: string) => void>>();
-export const addListener = (
-    messageType: string,
-    cb: (message: string) => void
-) => {
-    let listeners = coreMessageListeners.get(messageType);
-    if (!listeners) {
-        listeners = new Set<typeof cb>();
-        coreMessageListeners.set(messageType, listeners);
-    }
-    listeners.add(cb);
-
-    const pending = pendingMessages.get(messageType);
-    if (pending?.length) {
-        for (const m of pending) {
-            cb(m);
-        }
-    }
-};
-export const removeListener = (
-    messageType: string,
-    cb: (message: string) => void
-) => {
-    let listeners = coreMessageListeners.get(messageType);
-    listeners?.delete(cb);
-    if (listeners?.size === 0) {
-        coreMessageListeners.delete(messageType);
-    }
-};
-
-const pendingMessages = new Map<string, string[]>();
-setInterval(() => pendingMessages.clear(), 10 * 1000); // 10s
-
-globalThis.oncoremessage = (messageType: string, message: string) => {
-    const listeners = coreMessageListeners.get(messageType);
-    if (!listeners?.size) {
-        let pending = pendingMessages.get(messageType);
-        if (!pending) {
-            pending = [];
-            pendingMessages.set(messageType, pending);
-        }
-        pending.push(message);
-    } else {
-        listeners?.forEach((cb) => cb(message));
-    }
-};
-
-addListener("hello", console.log);
-addListener("log", console.log);
-addListener("alert", (message) => {
-    SnackBar({
-        message,
-        autoDismissTimeout: 4000
-    });
-});
-
-// 40
-function setTitle(title: string) {
-    const payload = new Uint8Array([
-        40,
-        ...serializeArgs([title])
-    ]);
-    bridge(payload);
-}
-
-let lastTitleSeen = null;
-setInterval(() => {
-    if(lastTitleSeen !== document.title) {
-        setTitle(document.title);
-    }
-    lastTitleSeen = document.title;
-}, 500)
+import { SnackBar } from "../components/snackbar";
+
+const coreMessageListeners = new Map<string, Set<(message: string) => void>>();
+export const addListener = (
+    messageType: string,
+    cb: (message: string) => void
+) => {
+    let listeners = coreMessageListeners.get(messageType);
+    if (!listeners) {
+        listeners = new Set<typeof cb>();
+        coreMessageListeners.set(messageType, listeners);
+    }
+    listeners.add(cb);
+
+    const pending = pendingMessages.get(messageType);
+    if (pending?.length) {
+        for (const m of pending) {
+            cb(m);
+        }
+    }
+};
+export const removeListener = (
+    messageType: string,
+    cb: (message: string) => void
+) => {
+    let listeners = coreMessageListeners.get(messageType);
+    listeners?.delete(cb);
+    if (listeners?.size === 0) {
+        coreMessageListeners.delete(messageType);
+    }
+};
+
+const pendingMessages = new Map<string, string[]>();
+setInterval(() => pendingMessages.clear(), 10 * 1000); // 10s
+
+globalThis.oncoremessage = (messageType: string, message: string) => {
+    const listeners = coreMessageListeners.get(messageType);
+    if (!listeners?.size) {
+        let pending = pendingMessages.get(messageType);
+        if (!pending) {
+            pending = [];
+            pendingMessages.set(messageType, pending);
+        }
+        pending.push(message);
+    } else {
+        listeners?.forEach((cb) => cb(message));
+    }
+};
+
+addListener("hello", console.log);
+addListener("log", console.log);
+addListener("alert", (message) => {
+    SnackBar({
+        message,
+        autoDismissTimeout: 4000
+    });
+});

package/{lib → fullstacked_modules}/core_message/index.ts

@@ -1,3 +1,3 @@
-import * as core_message from "./core_message";
-export default core_message;
-export * from "./core_message";
+import * as core_message from "./core_message";
+export default core_message;
+export * from "./core_message";

package/fullstacked_modules/core_open.ts

@@ -0,0 +1,9 @@
+import { bridge } from "./bridge";
+import { serializeArgs } from "./bridge/serialization";
+
+// 100
+export default function core_open(projectId: string) {
+    const payload = new Uint8Array([100, ...serializeArgs([projectId])]);
+
+    return bridge(payload);
+}

package/fullstacked_modules/esbuild/esbuild.ts

@@ -0,0 +1,101 @@
+import { Project } from "../../editor/types";
+import { toByteArray } from "../base64";
+import { bridge } from "../bridge";
+import {
+    deserializeArgs,
+    getLowestKeyIdAvailable,
+    serializeArgs
+} from "../bridge/serialization";
+import type { Message } from "esbuild";
+import core_message from "../core_message";
+
+// 55
+export function version(): Promise<string> {
+    const payload = new Uint8Array([55]);
+    return bridge(payload, ([str]) => str);
+}
+
+let addedListener = false;
+const activeBuilds = new Map<
+    number,
+    { project: Project; resolve: (buildErrors: Message[]) => void }
+>();
+
+function buildResponse(buildResult: string) {
+    const responseData = toByteArray(buildResult);
+    const [id, errorsStr] = deserializeArgs(responseData);
+    const activeBuild = activeBuilds.get(id);
+
+    if (!errorsStr) {
+        activeBuild.resolve([]);
+    } else {
+        const errors = JSON.parse(errorsStr);
+        const messages = errors?.map(uncapitalizeKeys).map((error) => ({
+            ...error,
+            location: error.location
+                ? {
+                      ...error.location,
+                      file: error.location.file.includes(activeBuild.project.id)
+                          ? activeBuild.project.id +
+                            error.location.file
+                                .split(activeBuild.project.id)
+                                .pop()
+                          : error.location.file
+                  }
+                : null
+        }));
+        activeBuild.resolve(messages);
+    }
+
+    activeBuilds.delete(id);
+}
+
+// 56
+export function build(project?: Project): Promise<Message[]> {
+    if (!addedListener) {
+        core_message.addListener("build", buildResponse);
+        addedListener = true;
+    }
+
+
+    const args: any[] = project
+        ? [project.id]
+        : []
+
+    const buildId = getLowestKeyIdAvailable(activeBuilds);
+    args.push(buildId)
+
+    const payload = new Uint8Array([
+        56,
+        ...serializeArgs(args)
+    ]);
+
+    return new Promise((resolve) => {
+        activeBuilds.set(buildId, {
+            project,
+            resolve
+        });
+        bridge(payload);
+    });
+}
+
+// 57
+export function shouldBuild(project: Project): Promise<boolean> {
+    const payload = new Uint8Array([57, ...serializeArgs([project.id])]);
+
+    return bridge(payload, ([should]) => should);
+}
+
+function isPlainObject(input: any) {
+    return input && !Array.isArray(input) && typeof input === "object";
+}
+
+function uncapitalizeKeys<T>(obj: T) {
+    const final = {};
+    for (const [key, value] of Object.entries(obj)) {
+        final[key.at(0).toLowerCase() + key.slice(1)] = isPlainObject(value)
+            ? uncapitalizeKeys(value)
+            : value;
+    }
+    return final as T;
+}

package/fullstacked_modules/esbuild/index.ts

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

package/fullstacked_modules/esbuild/sass.ts

@@ -0,0 +1,103 @@
+import * as sass from "sass";
+import type { Message } from "esbuild";
+import { Project } from "../../editor/types";
+
+export async function buildSASS(
+    fs: {
+        mkdir(dir: string): Promise<boolean>;
+        writeFile(path: string, data: string): Promise<boolean>;
+        readdir(dir: string): Promise<string[]>;
+        readFile(path: string, options: any): Promise<string>;
+    },
+    project?: Project
+): Promise<Partial<Message>> {
+    const baseDirectory = project?.id || "";
+
+    const writeOutputCSS = async (css: string) => {
+        const buildDirectory = baseDirectory
+            ? `${baseDirectory}/.build`
+            : ".build";
+        await fs.mkdir(buildDirectory);
+        console.log(buildDirectory + "/index.css", css)
+        await fs.writeFile(buildDirectory + "/index.css", css);
+    };
+
+    const contents = await fs.readdir(baseDirectory);
+    const entryPointSASS = contents.find(
+        (item) => item === "index.sass" || item === "index.scss"
+    );
+
+    console.log(entryPointSASS)
+
+    // check for css file and write to output
+    // esbuild will pick it up and merge with css in js
+    if (!entryPointSASS) {
+        const entryPointCSS = contents.find((item) => item === "index.css");
+        if (entryPointCSS) {
+            const filePath = baseDirectory
+                ? `${baseDirectory}/${entryPointCSS}`
+                : entryPointCSS;
+            // TODO: fs.copyFile
+            await writeOutputCSS(
+                await fs.readFile(filePath, {
+                    encoding: "utf8"
+                })
+            );
+        } else {
+            await writeOutputCSS("");
+        }
+
+        return;
+    }
+
+    const filePath = baseDirectory
+        ? `${baseDirectory}/${entryPointSASS}`
+        : entryPointSASS;
+    const entryData = await fs.readFile(filePath, {
+        encoding: "utf8"
+    });
+    let result: sass.CompileResult;
+    try {
+        result = await sass.compileStringAsync(entryData, {
+            importer: {
+                load: async (url) => {
+                    const filePath = `${baseDirectory}${url.pathname}`;
+                    const contents = await fs.readFile(filePath, {
+                        encoding: "utf8"
+                    });
+                    return {
+                        syntax: filePath.endsWith(".sass")
+                            ? "indented"
+                            : filePath.endsWith(".scss")
+                                ? "scss"
+                                : "css",
+                        contents
+                    };
+                },
+                canonicalize: (path) => new URL(path, window.location.href)
+            }
+        });
+    } catch (e) {
+        const error = e as unknown as sass.Exception;
+        const file =
+            baseDirectory + (error.span.url?.pathname || "/" + entryPointSASS);
+        const line = error.span.start.line + 1;
+        const column = error.span.start.column;
+        const length = error.span.text.length;
+        return {
+            text: error.message,
+            location: {
+                file,
+                line,
+                column,
+                length,
+                namespace: "SASS",
+                lineText: error.message,
+                suggestion: ""
+            }
+        };
+    }
+
+    await writeOutputCSS(result.css);
+    return null;
+}

package/fullstacked_modules/fetch/index.d.ts

@@ -0,0 +1,2 @@
+import ".";
+declare module "fetch" {}