fullstacked 0.12.1-1371 → 0.12.2-1382

package/fullstacked_modules/@types/archive/index.d.ts

@@ -0,0 +1,33 @@
+declare module "archive" {
+    export type FileEntries<T extends string | Uint8Array> = {
+        [filePath: string]: {
+            isDir: boolean;
+            contents: T;
+        };
+    };
+    export declare function unzip(
+        entry: string | Uint8Array,
+    ): Promise<FileEntries<Uint8Array>>;
+    export declare function unzip(
+        entry: string | Uint8Array,
+        out: string,
+    ): Promise<boolean>;
+    export declare function zip(
+        entry: FileEntries<string | Uint8Array>,
+    ): Promise<Uint8Array>;
+    export declare function zip(
+        entry: string,
+        out?: null | undefined,
+        skip?: string[],
+    ): Promise<Uint8Array>;
+    export declare function zip(
+        entry: FileEntries<string | Uint8Array> | string,
+        out: string,
+        skip?: string[],
+    ): Promise<boolean>;
+    declare const archive: {
+        unzip: typeof unzip;
+        zip: typeof zip;
+    };
+    export default archive;
+}

package/fullstacked_modules/@types/connect/index.d.ts

@@ -0,0 +1,28 @@
+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 default function connect(
+        name: string,
+        port: number,
+        host?: string,
+        raw?: false,
+    ): Promise<DataChannel>;
+    export default function connect(
+        name: string,
+        port: number,
+        host: string,
+        raw: true,
+    ): Promise<DataChannelRaw>;
+    export {};
+}

package/fullstacked_modules/@types/fetch/index.d.ts

@@ -0,0 +1,38 @@
+declare module "fetch" {
+    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>;
+    };
+    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 declare function core_fetch2(request: Request): Promise<Response>;
+    export declare function core_fetch2(
+        url: string | URL,
+        options?: RequestInit,
+    ): Promise<Response>;
+    export {};
+}

package/fullstacked_modules/@types/fs/index.d.ts

@@ -0,0 +1,73 @@
+declare module "fs" {
+    export declare function readFile(path: string): Promise<Uint8Array>;
+    export declare function readFile(
+        path: string,
+        options: {
+            encoding: "utf8";
+        },
+    ): Promise<string>;
+    export declare function writeFile(
+        path: string,
+        data: string | Uint8Array,
+        origin?: string,
+    ): Promise<boolean>;
+    export declare function unlink(
+        path: string,
+        origin?: string,
+    ): Promise<boolean>;
+    export type FileInfo = {
+        name: string;
+        isDirectory: boolean;
+    };
+    export declare function readdir(
+        path: string,
+        options?: {
+            recursive?: boolean;
+            withFileTypes?: false;
+            filesOnly?: boolean;
+        },
+    ): Promise<string[]>;
+    export declare function readdir(
+        path: string,
+        options?: {
+            recursive?: boolean;
+            withFileTypes: true;
+            filesOnly?: boolean;
+        },
+    ): Promise<FileInfo[]>;
+    export declare function mkdir(
+        path: string,
+        origin?: string,
+    ): Promise<boolean>;
+    export declare function rmdir(
+        path: string,
+        origin?: string,
+    ): Promise<boolean>;
+    export declare function exists(path: string): Promise<{
+        isFile: boolean;
+    }>;
+    export declare function rename(
+        oldPath: string,
+        newPath: string,
+        origin?: string,
+    ): Promise<boolean>;
+    type FileStats = {
+        name: string;
+        size: number;
+        modTime: number;
+        isDirectory: boolean;
+    };
+    export declare function stat(path: string): Promise<FileStats>;
+    declare const fs: {
+        readFile: typeof readFile;
+        writeFile: typeof writeFile;
+        unlink: typeof unlink;
+        readdir: typeof readdir;
+        mkdir: typeof mkdir;
+        rmdir: typeof rmdir;
+        exists: typeof exists;
+        rename: typeof rename;
+        stat: typeof stat;
+    };
+    export default fs;
+}

package/fullstacked_modules/@types/platform/index.d.ts

@@ -0,0 +1,15 @@
+declare module "platform" {
+    export declare enum Platform {
+        NODE = "node",
+        APPLE = "apple",
+        ANDROID = "android",
+        DOCKER = "docker",
+        WINDOWS = "windows",
+        WASM = "wasm",
+        LINUX_GTK = "linux-gtk",
+        LINUX_QT = "linux-qt",
+        ELECTRON = "electron",
+    }
+    declare const platform: string;
+    export default platform;
+}

package/fullstacked_modules/{archive/archive.ts → archive.ts}

@@ -1,7 +1,7 @@
-import { bridge } from "../bridge";
-import { serializeArgs } from "../bridge/serialization";
+import { bridge } from "./bridge";
+import { serializeArgs } from "./bridge/serialization";
 
-type FileEntries<T extends string | Uint8Array> = {
+export type FileEntries<T extends string | Uint8Array> = {
     [filePath: string]: {
         isDir: boolean;
         contents: T;
@@ -138,3 +138,10 @@ export function zip(
 
     return bridge(payload, transformer);
 }
+
+const archive = {
+    unzip,
+    zip
+};
+
+export default archive;

package/fullstacked_modules/{auto_update/index.ts → auto_update.ts}

@@ -1,8 +1,8 @@
-import git from "../git";
+import git from "./git";
 import { Button } from "@fullstacked/ui";
-import { SnackBar } from "../components/snackbar";
-import packages from "../packages";
-import build from "../build";
+import { SnackBar } from "./components/snackbar";
+import packages from "./packages";
+import build from "./build";
 
 let lastUpdateCheck = 0;
 const updateCheckDelay = 1000 * 10; // 10sec;
@@ -43,7 +43,6 @@ async function checkForUpdates() {
         message: "Project has updated. Rebuilding...",
         button: preventReloadButton
     });
-    console.log("ICICI2");
 
     updating = true;
     update().then(() => {
@@ -59,8 +58,6 @@ if (await git.hasGit()) {
 }
 
 async function update() {
-    console.log("ICICI1");
     await packages.installQuick();
-    console.log("ICICI");
     return build.buildProject();
 }

package/fullstacked_modules/build/index.ts

@@ -1,3 +1,109 @@
-import * as build from "./build";
+import { Project } from "../../editor/types";
+import { bridge } from "../bridge";
+import {
+    getLowestKeyIdAvailable,
+    serializeArgs
+} from "../bridge/serialization";
+import type { Message } from "esbuild";
+import core_message from "../core_message";
+import { buildSASS } from "./sass";
+import fs from "../fs";
+
+core_message.addListener("build-style", async (messageStr) => {
+    const { id, entryPoint, projectId } = JSON.parse(messageStr);
+    const result = await buildSASS(entryPoint, {
+        projectId,
+        canonicalize: (filePath) => new URL(filePath, "file://"),
+        load: (url) =>
+            fs.readFile(projectId + url.pathname, { encoding: "utf8" })
+    });
+    bridge(
+        new Uint8Array([58, ...serializeArgs([id, JSON.stringify(result)])])
+    );
+});
+
+const activeBuilds = new Map<
+    number,
+    { project: Project; resolve: (buildErrors: Message[]) => void }
+>();
+
+function buildResponse(buildResult: string) {
+    const { id, errors } = JSON.parse(buildResult);
+    const activeBuild = activeBuilds.get(id);
+
+    if (!errors) {
+        activeBuild.resolve([]);
+    } else {
+        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);
+}
+core_message.addListener("build", buildResponse);
+
+// 55
+export function esbuildVersion(): Promise<string> {
+    const payload = new Uint8Array([55]);
+    return bridge(payload, ([str]) => str);
+}
+
+// 56
+export function buildProject(project?: Project): Promise<Message[]> {
+    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;
+}
+
+const build = {
+    esbuildVersion,
+    buildProject,
+    shouldBuild
+};
+
 export default build;
-export * from "./build";

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

@@ -1,11 +1,11 @@
-import { bridge } from "../bridge";
+import { bridge } from "./bridge";
 import {
     deserializeArgs,
     numberTo4Bytes,
     serializeArgs
-} from "../bridge/serialization";
-import core_message from "../core_message";
-import { toByteArray } from "../base64";
+} from "./bridge/serialization";
+import core_message from "./core_message";
+import { toByteArray } from "./base64";
 
 export type Data = string | number | boolean | Uint8Array;
 
@@ -38,19 +38,19 @@ type ChannelRaw = {
 const channels = new Map<string, Channel | ChannelRaw>();
 
 // 20
-export function connect(
+export default function connect(
     name: string,
     port: number,
     host?: string,
     raw?: false
 ): Promise<DataChannel>;
-export function connect(
+export default function connect(
     name: string,
     port: number,
     host: string,
     raw: true
 ): Promise<DataChannelRaw>;
-export function connect(
+export default function connect(
     name: string,
     port: number,
     host = "localhost",

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

@@ -1,4 +1,4 @@
-import { SnackBar } from "../components/snackbar";
+import { SnackBar } from "./components/snackbar";
 
 const coreMessageListeners = new Map<string, Set<(message: string) => void>>();
 export const addListener = (
@@ -55,3 +55,9 @@ addListener("alert", (message) => {
         autoDismissTimeout: 4000
     });
 });
+
+const core_message = {
+    addListener,
+    removeListener
+};
+export default core_message;

package/fullstacked_modules/{fetch/index.ts → fetch.ts}

@@ -1,13 +1,12 @@
-import { toByteArray } from "../base64";
-import { bridge } from "../bridge";
+import { toByteArray } from "./base64";
+import { bridge } from "./bridge";
 import {
     deserializeArgs,
     getLowestKeyIdAvailable,
     serializeArgs
-} from "../bridge/serialization";
-import core_message from "../core_message";
-import { ar } from "zod/v4/locales";
-import platform, { Platform } from "../platform";
+} from "./bridge/serialization";
+import core_message from "./core_message";
+import platform, { Platform } from "./platform";
 
 const te = new TextEncoder();
 

package/fullstacked_modules/{fs/fs.ts → fs.ts}

@@ -1,5 +1,5 @@
-import { bridge } from "../bridge";
-import { serializeArgs } from "../bridge/serialization";
+import { bridge } from "./bridge";
+import { serializeArgs } from "./bridge/serialization";
 
 const te = new TextEncoder();
 
@@ -168,3 +168,16 @@ export function stat(path: string): Promise<FileStats> {
 
     return bridge(payload, transformer);
 }
+
+const fs = {
+    readFile,
+    writeFile,
+    unlink,
+    readdir,
+    mkdir,
+    rmdir,
+    exists,
+    rename,
+    stat
+};
+export default fs;

package/fullstacked_modules/{git/git.ts → git.ts}

@@ -1,7 +1,7 @@
-import { bridge } from "../bridge";
-import { serializeArgs } from "../bridge/serialization";
-import core_message from "../core_message";
-import { Project } from "../../editor/types";
+import { bridge } from "./bridge";
+import { serializeArgs } from "./bridge/serialization";
+import core_message from "./core_message";
+import { Project } from "./../editor/types";
 
 const pullPromises = new Map<
     string,
@@ -221,3 +221,23 @@ export function remoteUrl(project?: Project) {
 
     return bridge(payload, ([url]) => url);
 }
+
+const git = {
+    PullResponse,
+    gitAuthResponse,
+    clone,
+    head,
+    status,
+    pull,
+    restore,
+    checkout,
+    fetch,
+    commit,
+    branches,
+    push,
+    branchDelete,
+    hasGit,
+    remoteUrl
+};
+
+export default git;

package/fullstacked_modules/{packages/packages.ts → packages.ts}

@@ -1,10 +1,7 @@
-import { Project } from "../../editor/types";
-import { bridge } from "../bridge";
-import {
-    getLowestKeyIdAvailable,
-    serializeArgs
-} from "../bridge/serialization";
-import core_message from "../core_message";
+import { Project } from "./../editor/types";
+import { bridge } from "./bridge";
+import { getLowestKeyIdAvailable, serializeArgs } from "./bridge/serialization";
+import core_message from "./core_message";
 
 const activeInstallations = new Map<
     number,
@@ -140,3 +137,9 @@ export function installQuick(
         bridge(payload);
     });
 }
+
+const packages = {
+    install,
+    installQuick
+};
+export default packages;

package/index.js

@@ -569,20 +569,14 @@ var compilerOptions = {
   allowJs: true,
   lib: ["dom", "dom.iterable", "es2023"],
   jsx: "react",
-  paths: {
-    "*": ["../.fullstacked_modules/*"]
-  },
-  typeRoots: ["../.fullstacked_modules", "./node_modules/@types"]
+  typeRoots: ["../.fullstacked_modules/@types", "./node_modules/@types"]
 };
 
 // src/dev-files.ts
 var tsConfig = {
   compilerOptions: {
     ...compilerOptions,
-    paths: {
-      "*": ["./.fullstacked_modules/*"]
-    },
-    typeRoots: ["./.fullstacked_modules", "./node_modules/@types"]
+    typeRoots: ["./.fullstacked_modules/@types", "./node_modules/@types"]
   }
 };
 var defaultGitignore = `node_modules

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "fullstacked",
-    "version": "0.12.1-1371",
+    "version": "0.12.2-1382",
     "scripts": {
         "build": "node build.js",
         "postbuild": "node build.js --binding",

package/fullstacked_modules/@fullstacked/ai-agent/README.md

@@ -1 +0,0 @@
-# ai-agent