fullstacked 0.12.0-1173 → 0.12.0-1184

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

@@ -1,157 +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);
-}
+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/fullstacked_modules/fs/index.d.ts

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

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

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

package/fullstacked_modules/git/git.ts

@@ -0,0 +1,238 @@
+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, ((pullResponse: PullResponse) => void)[]>();
+let addedListener = false;
+function setListenerOnce() {
+    if (addedListener) return;
+
+    core_message.addListener("git-pull", (message) => {
+        console.log(message);
+        const { url, data, finished } = JSON.parse(message);
+        if (!finished) return;
+        const promises = pullPromises.get(url);
+        promises?.forEach((resolve) => resolve(data));
+        pullPromises.delete(url);
+    });
+
+    core_message.addListener("git-push", console.log);
+
+    addedListener = true;
+}
+
+// 81
+export function gitAuthResponse(id: number, success: boolean) {
+    console.log(id, success);
+    const payload = new Uint8Array([81, ...serializeArgs([id, success])]);
+    bridge(payload);
+}
+
+// 70
+export function clone(url: string, into: string) {
+    const payload = new Uint8Array([70, ...serializeArgs([into, url])]);
+    return bridge(payload);
+}
+
+// 71
+export function head(projectId: string): Promise<{ name: string; hash: string }> {
+    const payload = new Uint8Array([71,
+        ...serializeArgs([projectId])
+    ]);
+
+    const transformer = ([name, hash]) => {
+        return { name, hash };
+    };
+
+    return bridge(payload, transformer);
+}
+
+export type Status = {
+    added: string[];
+    deleted: string[];
+    modified: string[];
+};
+
+// 72
+export function status(projectId: string): Promise<Status> {
+    const payload = new Uint8Array([72, ...serializeArgs([projectId])]);
+
+    // added: 0, deleted: 1, modified: 2
+    const transformer = (s: (string | number)[]) => {
+        const status: Status = {
+            added: [],
+            deleted: [],
+            modified: []
+        };
+
+        for (let i = 0; i < s.length; i = i + 2) {
+            const file = s[i] as string;
+            const type = s[i + 1] as number;
+
+            switch (type) {
+                case 0:
+                    status.added.push(file);
+                    break;
+                case 1:
+                    status.deleted.push(file);
+                    break;
+                case 2:
+                    status.modified.push(file);
+                    break;
+            }
+        }
+
+        return status;
+    };
+
+    return bridge(payload, transformer);
+}
+
+// 73
+export enum PullResponse {
+    DID_PULL = "",
+    UP_TO_DATE = "already up-to-date",
+    REF_NOT_FOUND = "reference not found",
+    UNAUTHORIZED = "authentication required",
+    UNREACHABLE = "unreacheable"
+}
+export async function pull(project?: Project): Promise<PullResponse> {
+    setListenerOnce();
+
+    const args = project
+        ? serializeArgs([project.id])
+        : [];
+
+    const payload = new Uint8Array([73, ...args]);
+
+    const url = await remoteUrl(project);
+    let p = pullPromises.get(url);
+    if (!p) {
+        p = [];
+        pullPromises.set(url, p);
+    }
+
+    return new Promise((resolve) => {
+        p.push(resolve);
+        bridge(payload);
+    });
+}
+
+// 74
+export function restore(projectId: string, files: string[]): Promise<void> {
+    const payload = new Uint8Array([
+        74,
+        ...serializeArgs([projectId, ...files])
+    ]);
+
+    return bridge(payload);
+}
+
+// 75
+export function checkout(
+    project: Project,
+    branch: string,
+    create: boolean = false
+) {
+    const payload = new Uint8Array([
+        75,
+        ...serializeArgs([project.id, branch, create])
+    ]);
+
+    return bridge(payload);
+}
+
+// 76
+export function fetch(project: Project): Promise<void> {
+    const payload = new Uint8Array([76, ...serializeArgs([project.id])]);
+    return bridge(payload);
+}
+
+// 77
+export function commit(project: Project, commitMessage: string): Promise<void> {
+    const payload = new Uint8Array([
+        77,
+        ...serializeArgs([
+            project.id,
+            commitMessage,
+            project.gitRepository.name || "",
+            project.gitRepository.email || ""
+        ])
+    ]);
+
+    return bridge(payload);
+}
+
+type Branch = {
+    name: string;
+    remote: boolean;
+    local: boolean;
+};
+
+// 78
+export async function branches(project: Project): Promise<Branch[]> {
+    const payload = new Uint8Array([78, ...serializeArgs([project.id])]);
+
+    // [name, isLocal, isRemote, name, isLocal, isRemote, ...]
+    const transformer = (branchesArgs: (string | boolean)[]) => {
+        const branches: Branch[] = [];
+
+        for (let i = 0; i < branchesArgs.length; i = i + 3) {
+            branches.push({
+                name: branchesArgs[i] as string,
+                remote: branchesArgs[i + 1] as boolean,
+                local: branchesArgs[i + 2] as boolean
+            });
+        }
+
+        return branches;
+    };
+
+    return bridge(payload, transformer);
+}
+
+// 79
+export function push(project: Project) {
+    const payload = new Uint8Array([79, ...serializeArgs([project.id])]);
+    return bridge(payload);
+}
+
+// 80
+export function branchDelete(project: Project, branch: string) {
+    const payload = new Uint8Array([
+        80,
+        ...serializeArgs([project.id, branch])
+    ]);
+
+    return bridge(payload);
+}
+
+
+// 82
+export function hasGit(project?: Project) {
+    const args = project
+        ? [project.id]
+        : [];
+
+    const payload = new Uint8Array([
+        82,
+        ...serializeArgs(args)
+    ]);
+
+    return bridge(payload, ([hasGit]) => hasGit);
+}
+
+// 83
+export function remoteUrl(project?: Project) {
+    const args = project
+        ? [project.id]
+        : [];
+
+    const payload = new Uint8Array([
+        83,
+        ...serializeArgs(args)
+    ]);
+
+    return bridge(payload, ([url]) => url);
+}

package/fullstacked_modules/git/index.ts

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

package/fullstacked_modules/packages/index.ts

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