fullstacked 0.12.0-1169 → 0.12.0-1173

package/lib/fetch/index.ts

@@ -0,0 +1,318 @@
+import { toByteArray } from "../base64";
+import { bridge } from "../bridge";
+import {
+    deserializeArgs,
+    getLowestKeyIdAvailable,
+    serializeArgs
+} from "../bridge/serialization";
+import core_message from "../core_message";
+
+const te = new TextEncoder();
+
+type ResponseSimplified = {
+    statusCode: number;
+    statusMessage: string;
+    headers: Record<string, string>;
+    body: string | Uint8Array | AsyncIterableIterator<string | Uint8Array>;
+};
+
+const activeFetchRequests = new Map<
+    number,
+    {
+        resolve: (response: ResponseSimplified) => void;
+        reject: (error: string) => void;
+    }
+>();
+
+let addedListener = false;
+function receivedResponse(base64Data: string) {
+    const data = toByteArray(base64Data);
+    const args = deserializeArgs(data);
+
+    const id = args.at(0);
+    const fetchRequest = activeFetchRequests.get(id);
+
+    const [statusCode, statusMessage, headersStr, body] = args.slice(1);
+
+    const response: ResponseSimplified = {
+        statusCode,
+        statusMessage,
+        headers: headersStr ? JSON.parse(headersStr) : {},
+        body
+    };
+
+    if (statusCode >= 400) {
+        fetchRequest.reject(JSON.stringify(response));
+    } else {
+        fetchRequest.resolve(response);
+    }
+
+    activeFetchRequests.delete(id);
+}
+
+// 15
+export default function core_fetch(
+    url: string,
+    options?: Partial<FetchOptions>
+): Promise<FetchResponse & { body: Uint8Array }>;
+export default function core_fetch(
+    url: string,
+    options?: Partial<FetchOptions> & { encoding: "utf8" }
+): Promise<FetchResponse & { body: string }>;
+export default function core_fetch(
+    url: string,
+    options?: Partial<FetchOptions> & { stream?: boolean; encoding?: "utf8" }
+) {
+    const method = options?.method || "GET";
+
+    const headers = options?.headers ? JSON.stringify(options.headers) : "";
+
+    const body = options?.body
+        ? typeof options.body === "string"
+            ? te.encode(options.body)
+            : options.body
+        : new Uint8Array();
+
+    const timeout = options?.timeout || 10;
+
+    const requestId = getLowestKeyIdAvailable(activeFetchRequests);
+
+    const payload = new Uint8Array([
+        15,
+
+        ...serializeArgs([
+            requestId,
+            method,
+            url,
+            headers,
+            body,
+            timeout,
+            options?.encoding === "utf8"
+        ])
+    ]);
+
+    if (!addedListener) {
+        core_message.addListener("fetch-response", receivedResponse);
+        addedListener = true;
+    }
+
+    return new Promise<ResponseSimplified>((resolve, reject) => {
+        activeFetchRequests.set(requestId, {
+            resolve,
+            reject
+        });
+        bridge(payload);
+    });
+}
+
+const activeFetch2Requests = new Map<
+    number,
+    {
+        url: string;
+        resolveResponse(response: Response): void;
+        resolveStream?(param: { done: boolean; chunk: Uint8Array }): void;
+    }
+>();
+
+let addedListener2 = false;
+function receivedResponse2(base64Data: string) {
+    const data = toByteArray(base64Data);
+    const args = deserializeArgs(data);
+
+    const id = args.at(0);
+    const request = activeFetch2Requests.get(id);
+
+    if (request.resolveStream) {
+        const [done, chunk] = args.slice(1);
+        request.resolveStream({ done, chunk });
+        if (done) {
+            activeFetch2Requests.delete(id);
+        }
+        return;
+    }
+
+    const [status, statusText, headersStr] = args.slice(1);
+
+    const ok = status <= 299;
+
+    let finished = false;
+    const read = async () => {
+        if (finished) {
+            return { done: true };
+        }
+
+        const { done, chunk } = await new Promise<{
+            done: boolean;
+            chunk: Uint8Array;
+        }>((resolve) => {
+            request.resolveStream = resolve;
+        });
+        finished = done;
+
+        return { done: false, value: chunk };
+    };
+
+    const it = {
+        next: read
+    } as AsyncIterator<Uint8Array>;
+
+    const responseIterator = {
+        [Symbol.asyncIterator]() {
+            return it;
+        }
+    };
+
+    const readBody = async () => {
+        if (!ok) {
+            return te.encode(statusText);
+        }
+        let body = new Uint8Array();
+        for await (const chunk of responseIterator) {
+            const buffer = new Uint8Array(body.byteLength + chunk.byteLength);
+            buffer.set(body, 0);
+            buffer.set(chunk, body.length);
+            body = buffer;
+        }
+        return body;
+    };
+
+    const response: Response = {
+        url: request.url,
+        redirected: false,
+        type: "default",
+        bodyUsed: false,
+        ok,
+        status,
+        statusText,
+        headers: objectToHeaders(JSON.parse(headersStr || "{}")),
+
+        body: iteratorToStream(it),
+
+        bytes: readBody,
+        arrayBuffer: async () => {
+            const data = await readBody();
+            return data.buffer;
+        },
+        blob: async () => {
+            const body = await readBody();
+            return new Blob([body]);
+        },
+        text: async () => {
+            const body = await readBody();
+            return new TextDecoder().decode(body);
+        },
+        json: async () => {
+            const body = await readBody();
+            return JSON.parse(new TextDecoder().decode(body));
+        },
+
+        // not implemented
+        clone: () => null,
+        formData: async () => null
+    };
+
+    request.resolveResponse(response);
+}
+
+export function core_fetch2(request: Request): Promise<Response>;
+export function core_fetch2(
+    url: string | URL,
+    options?: RequestInit
+): Promise<Response>;
+export async function core_fetch2(
+    urlOrRequest: string | URL | Request,
+    options?: RequestInit
+): Promise<Response> {
+    if (!addedListener2) {
+        core_message.addListener("fetch2-response", receivedResponse2);
+        addedListener2 = true;
+    }
+
+    if (urlOrRequest instanceof Request) {
+        const bodyReader = urlOrRequest.body?.getReader();
+        const body = bodyReader ? (await bodyReader.read()).value : "";
+
+        options = {
+            method: urlOrRequest.method,
+            headers: urlOrRequest.headers,
+            signal: urlOrRequest.signal,
+            body
+        };
+
+        return fetch2(urlOrRequest.url, options);
+    }
+
+    const url =
+        urlOrRequest instanceof URL ? urlOrRequest.toString() : urlOrRequest;
+
+    return fetch2(url, options);
+}
+
+// 16
+function fetch2(url: string, options?: RequestInit): Promise<Response> {
+    const id = getLowestKeyIdAvailable(activeFetch2Requests);
+
+    const headers = options?.headers
+        ? options.headers instanceof Headers
+            ? JSON.stringify(headersToObject(options.headers))
+            : JSON.stringify(options.headers)
+        : "";
+    const body = options?.body
+        ? typeof options.body === "string"
+            ? te.encode(options.body)
+            : options.body
+        : new Uint8Array();
+
+    if (options?.signal) {
+        options.signal.onabort = () => {
+            console.log("ABORT REQUEST");
+            // cancel
+        };
+    }
+
+    const payload = new Uint8Array([
+        16,
+
+        ...serializeArgs([id, options?.method || "GET", url, headers, body])
+    ]);
+
+    return new Promise<Response>((resolve) => {
+        activeFetch2Requests.set(id, {
+            url,
+            resolveResponse: resolve
+        });
+        bridge(payload);
+    });
+}
+
+function objectToHeaders(o: Record<string, string>) {
+    const headers = new Headers();
+    Object.entries(o).forEach(([n, v]) => {
+        headers.set(n, v);
+    });
+    return headers;
+}
+
+const headersToObject = (h: Headers) => {
+    const obj = {};
+    for (const [n, v] of h.entries()) {
+        obj[n] = v;
+    }
+    return obj;
+};
+
+// https://developer.mozilla.org/en-US/docs/Web/API/ReadableStream#convert_an_iterator_or_async_iterator_to_a_stream
+function iteratorToStream(iterator: AsyncIterator<Uint8Array>) {
+    return new ReadableStream({
+        async pull(controller) {
+            const { value, done } = await iterator.next();
+
+            if (value) {
+                controller.enqueue(value);
+            }
+            if (done) {
+                controller.close();
+            }
+        }
+    });
+}

package/lib/fs/fs.ts

@@ -0,0 +1,157 @@
+import { bridge } from "../bridge";
+import { serializeArgs } from "../bridge/serialization";
+
+const te = new TextEncoder();
+
+// 2
+export function readFile(path: string): Promise<Uint8Array>;
+export function readFile(
+    path: string,
+    options: { encoding: "utf8" }
+): Promise<string>;
+export function readFile(path: string, options?: { encoding: "utf8" }) {
+    const payload = new Uint8Array([
+        2,
+        ...serializeArgs([path, options?.encoding === "utf8"])
+    ]);
+
+    const transformer = ([stringOrBuffer]) => stringOrBuffer;
+
+    return bridge(payload, transformer);
+}
+
+// 3
+export function writeFile(
+    path: string,
+    data: string | Uint8Array,
+    origin = ""
+): Promise<boolean> {
+    if (typeof data === "string") {
+        data = te.encode(data);
+    }
+
+    const payload = new Uint8Array([3, ...serializeArgs([path, data, origin])]);
+
+    return bridge(payload, ([success]) => success);
+}
+
+// 4
+export function unlink(path: string, origin = ""): Promise<boolean> {
+    const payload = new Uint8Array([4, ...serializeArgs([path, origin])]);
+
+    return bridge(payload, ([success]) => success);
+}
+
+export type FileInfo = {
+    name: string;
+    isDirectory: boolean;
+};
+
+// 5
+export function readdir(
+    path: string,
+    options?: { recursive?: boolean; withFileTypes?: false }
+): Promise<string[]>;
+export function readdir(
+    path: string,
+    options?: { recursive?: boolean; withFileTypes: true }
+): Promise<FileInfo[]>;
+export function readdir(
+    path: string,
+    options?: { recursive?: boolean; withFileTypes?: boolean }
+) {
+    const payload = new Uint8Array([
+        5,
+        ...serializeArgs([path, !!options?.recursive, !!options?.withFileTypes])
+    ]);
+
+    const transformer = (items: string[] | (string | boolean)[]) => {
+        if (options?.withFileTypes) {
+            const dirents: FileInfo[] = [];
+            for (let i = 0; i < items.length; i = i + 2) {
+                dirents.push({
+                    name: items[i] as string,
+                    isDirectory: items[i + 1] as boolean
+                });
+            }
+            return dirents;
+        }
+
+        return items;
+    };
+
+    return bridge(payload, transformer);
+}
+
+// 6
+export function mkdir(path: string, origin = ""): Promise<boolean> {
+    const payload = new Uint8Array([6, ...serializeArgs([path, origin])]);
+
+    return bridge(payload, ([success]) => success);
+}
+
+// 7
+export function rmdir(path: string, origin = ""): Promise<boolean> {
+    const payload = new Uint8Array([7, ...serializeArgs([path, origin])]);
+
+    return bridge(payload, ([success]) => success);
+}
+
+// 8
+export function exists(path: string): Promise<{ isFile: boolean }> {
+    const payload = new Uint8Array([8, ...serializeArgs([path])]);
+
+    const transformer = ([exists, isFile]: [boolean, boolean]) => {
+        if (!exists) return undefined;
+        return { isFile };
+    };
+
+    return bridge(payload, transformer);
+}
+
+// 9
+export function rename(
+    oldPath: string,
+    newPath: string,
+    origin = ""
+): Promise<boolean> {
+    const payload = new Uint8Array([
+        9,
+        ...serializeArgs([oldPath, newPath, origin])
+    ]);
+
+    return bridge(payload, ([success]) => success);
+}
+
+type FileStats = {
+    name: string;
+    size: number;
+    modTime: number;
+    isDirectory: boolean;
+};
+
+// 10
+export function stat(path: string): Promise<FileStats> {
+    const payload = new Uint8Array([10, ...serializeArgs([path])]);
+
+    const transformer = (responseArgs: any[]) => {
+        if (!responseArgs.length) return null;
+
+        const [name, size, atimeMs, mtimeMs, ctimeMs, isDirectory] =
+            responseArgs;
+
+        return {
+            name,
+            size,
+            atimeMs,
+            mtimeMs,
+            ctimeMs,
+            atime: new Date(atimeMs),
+            mtime: new Date(mtimeMs),
+            ctime: new Date(ctimeMs),
+            isDirectory
+        };
+    };
+
+    return bridge(payload, transformer);
+}

package/lib/fs/index.ts

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

package/lib/fullstacked.d.ts

@@ -0,0 +1,208 @@
+declare module "fs" {
+    export type FileInfo = {
+        name: string;
+        isDirectory: boolean;
+    };
+    export type FileStats = {
+        name: string;
+        size: number;
+        modTime: number;
+        isDirectory: boolean;
+    };
+
+    export function readFile(path: string): Promise<Uint8Array>;
+    export function readFile(
+        path: string,
+        options: {
+            encoding: "utf8";
+        }
+    ): Promise<string>;
+    export function writeFile(
+        path: string,
+        data: string | Uint8Array
+    ): Promise<boolean>;
+    export function unlink(path: string): Promise<boolean>;
+    export function readdir(
+        path: string,
+        options?: {
+            recursive?: boolean;
+            withFileTypes?: false;
+        }
+    ): Promise<string[]>;
+    export function readdir(
+        path: string,
+        options?: {
+            recursive?: boolean;
+            withFileTypes: true;
+        }
+    ): Promise<FileInfo[]>;
+    export function mkdir(path: string): Promise<boolean>;
+    export function rmdir(path: string): Promise<boolean>;
+    export function exists(path: string): Promise<{
+        isFile: boolean;
+    }>;
+    export function rename(oldPath: string, newPath: string): Promise<boolean>;
+    export function stat(path: string): Promise<FileStats>;
+
+    var fs: {
+        readFile(path: string): Promise<Uint8Array>;
+        readFile(
+            path: string,
+            options: {
+                encoding: "utf8";
+            }
+        ): Promise<string>;
+        writeFile(path: string, data: string | Uint8Array): Promise<boolean>;
+        unlink(path: string): Promise<boolean>;
+        readdir(
+            path: string,
+            options?: {
+                recursive?: boolean;
+                withFileTypes?: false;
+            }
+        ): Promise<string[]>;
+        readdir(
+            path: string,
+            options?: {
+                recursive?: boolean;
+                withFileTypes: true;
+            }
+        ): Promise<FileInfo[]>;
+        mkdir(path: string): Promise<boolean>;
+        rmdir(path: string): Promise<boolean>;
+        exists(path: string): Promise<{
+            isFile: boolean;
+        }>;
+        rename(oldPath: string, newPath: string): Promise<boolean>;
+        stat(path: string): Promise<FileStats>;
+    };
+    export default fs;
+}
+
+type FetchOptions = {
+    method: "GET" | "POST" | "PUT" | "DELETE";
+    headers: Record<string, string>;
+    body: string | Uint8Array;
+    timeout: number;
+    stream: boolean;
+};
+
+type FetchResponse = {
+    statusCode: number;
+    statusMessage: string;
+    headers: Record<string, string>;
+};
+
+declare module "fetch" {
+    export default function core_fetch(
+        url: string,
+        options?: Partial<FetchOptions>
+    ): Promise<FetchResponse & { body: Uint8Array }>;
+    export default function core_fetch(
+        url: string,
+        options?: Partial<FetchOptions> & { encoding: "utf8" }
+    ): Promise<FetchResponse & { body: string }>;
+
+    export function core_fetch2(request: Request): Promise<Response>;
+    export function core_fetch2(
+        url: string | URL,
+        options?: RequestInit
+    ): Promise<Response>;
+}
+
+declare module "platform" {
+    export enum Platform {
+        NODE = "node",
+        APPLE = "apple",
+        ANDROID = "android",
+        DOCKER = "docker",
+        WINDOWS = "windows",
+        WASM = "wasm"
+    }
+
+    const platform: Platform;
+    export default platform;
+}
+
+declare module "archive" {
+    type FileEntries<T extends string | Uint8Array> = {
+        [filePath: string]: {
+            isDir: boolean;
+            contents: T;
+        };
+    };
+
+    export function unzip(
+        entry: string | Uint8Array
+    ): Promise<FileEntries<Uint8Array>>;
+    export function unzip(
+        entry: string | Uint8Array,
+        out: string
+    ): Promise<boolean>;
+
+    export function zip(
+        entry: FileEntries<string | Uint8Array>
+    ): Promise<Uint8Array>;
+    export function zip(entry: string): 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>;
+
+    var archive: {
+        unzip(entry: string | Uint8Array): Promise<FileEntries<Uint8Array>>;
+        unzip(entry: string | Uint8Array, out: string): Promise<boolean>;
+        zip(entry: FileEntries<string | Uint8Array>): Promise<Uint8Array>;
+        zip(entry: string): Promise<Uint8Array>;
+        zip(
+            entry: string,
+            out: null | undefined,
+            skip: string[]
+        ): Promise<Uint8Array>;
+        zip(
+            entry: FileEntries<string | Uint8Array> | string,
+            out: string,
+            skip?: string[]
+        ): Promise<boolean>;
+    };
+    export default archive;
+}
+
+declare module "connect" {
+    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;
+    };
+
+    export function connect(
+        name: string,
+        port: number,
+        host: string,
+        stream: true
+    ): Promise<DataChannelRaw>;
+    export function connect(
+        name: string,
+        port: number,
+        host?: string,
+        stream?: boolean
+    ): Promise<DataChannel>;
+}

package/lib/platform/index.ts

@@ -0,0 +1,14 @@
+export enum Platform {
+    NODE = "node",
+    APPLE = "apple",
+    ANDROID = "android",
+    DOCKER = "docker",
+    WINDOWS = "windows",
+    WASM = "wasm",
+    LINUX_GTK = "linux-gtk",
+    LINUX_QT = "linux-qt",
+    ELECTRON = "electron"
+}
+
+const platform = await (await fetch("/platform")).text();
+export default platform;

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "fullstacked",
-    "version": "0.12.0-1169",
+    "version": "0.12.0-1173",
     "scripts": {
         "build": "node build.js",
         "start": "npm run build && node index.js --lib ../../core/bin --root ~/FullStacked --config ~/.config/fullstacked --editor ../../out/editor",