bb-relay 0.0.1

package/src/load-virtual-editor/node/readDir.ts

@@ -0,0 +1,41 @@
+import formatPath from "./formatPath";
+import { getDescendantLevel } from "./getDescendantLevel";
+import { nodeStore } from "./store";
+
+export function readDir(
+  path: string,
+  callback: (
+    err: Error | null,
+    data: { path: string; type: "file" | "dir" }[]
+  ) => void
+) {
+  try {
+    const dirList = nodeStore
+      .getState()
+      .directories.filter(
+        (dir) =>
+          dir.startsWith(path) &&
+          formatPath(dir) !== formatPath(path) &&
+          getDescendantLevel(dir, path) === 1
+      );
+    const fileList = nodeStore
+      .getState()
+      .files.filter((file) => formatPath(file.directory) === formatPath(path));
+    const dir: { path: string; type: "file" | "dir" }[] = dirList.map(
+      (dir) => ({
+        path: dir,
+        type: "dir",
+      })
+    );
+    const files: { path: string; type: "file" | "dir" }[] = fileList.map(
+      (file) => ({
+        path: formatPath(`${file.directory}/${file.name}`),
+        type: "file",
+      })
+    );
+    const data: { path: string; type: "file" | "dir" }[] = [...dir, ...files];
+    callback(null, data);
+  } catch (err) {
+    callback(err as Error, []);
+  }
+}

package/src/load-virtual-editor/node/readFile.ts

@@ -0,0 +1,46 @@
+import { stringToBinary } from "./formatText";
+import { nodeStore } from "./store";
+
+export default function readFile(
+  arg: { path: string; type: "text" | "binary" },
+  callback: (
+    err: Error | null,
+    data:
+      | {
+          type: "text";
+          data: string | null;
+        }
+      | {
+          type: "binary";
+          data: Uint8Array | null;
+        }
+  ) => void
+) {
+  try {
+    const fullPath = arg.path.split("/");
+    const dir = fullPath.slice(0, -1);
+    const name = fullPath.slice(-1)[0];
+    const parentPath = dir.join("/");
+    const file = nodeStore
+      .getState()
+      .files.find(
+        (item) => item.directory === parentPath && item.name === name
+      );
+    if (!file) throw new Error(`File not found: ${arg.path}`);
+    if (arg.type === "text")
+      callback(null, {
+        type: "text",
+        data: file.content,
+      });
+    else
+      callback(null, {
+        type: "binary",
+        data: stringToBinary(file.content),
+      });
+  } catch (err) {
+    callback(err as Error, {
+      type: arg.type,
+      data: null,
+    });
+  }
+}

package/src/load-virtual-editor/node/store.ts

@@ -0,0 +1,206 @@
+import { create } from "zustand";
+import { createJSONStorage, persist } from "zustand/middleware";
+import formatPath from "./formatPath";
+import { getParent } from "./getParent";
+import { NodeState } from "./NodeState";
+import { generateDirs } from "./generateDirs";
+import { indexedStorage } from "@/load-virtual-editor/lib/indexedStorage";
+
+export const nodeStore = create<NodeState>()(
+  persist(
+    (set) => ({
+      directories: [],
+      files: [],
+      addDir: (path: string) => {
+        const allDirs = generateDirs(path, nodeStore.getState().directories);
+        set({
+          directories: allDirs,
+          record: {
+            file: null,
+            dir: getParent(path),
+          },
+        });
+      },
+      addFile: (arg: { path: string; content?: string }) => {
+        const allFiles = nodeStore.getState().files;
+
+        const file = allFiles.find(
+          (item) =>
+            formatPath(`${item.directory}/${item.name}`) ===
+            formatPath(arg.path)
+        );
+        if (file) throw new Error(`File already exist: ${arg.path}`);
+        const fullPath = arg.path.split("/").filter((item) => item);
+        const dir = fullPath.slice(0, -1);
+        const name = formatPath(fullPath.slice(-1)[0]);
+        const parentPath = formatPath(dir.join("/"));
+
+        const dirs = generateDirs(
+          parentPath || "",
+          nodeStore.getState().directories
+        );
+        set({
+          files: [
+            ...allFiles,
+            {
+              directory: parentPath,
+              name,
+              content: arg.content ?? "",
+              createdAt: new Date().toISOString(),
+              modifiedAt: new Date().toISOString(),
+            },
+          ],
+          directories: dirs,
+          record: {
+            file: formatPath(arg.path),
+            dir: getParent(arg.path),
+          },
+        });
+      },
+      removeDir: (path: string) => {
+        const dirs = nodeStore.getState().directories;
+        const newDirs = dirs.filter((dir) => !dir.startsWith(path));
+        if (newDirs.length === dirs.length)
+          throw new Error(`Path not found: ${path}`);
+        const files = nodeStore.getState().files;
+        set({
+          directories: newDirs,
+          files: files.filter((file) => !file.directory.startsWith(path)),
+          record: {
+            file: null,
+            dir: getParent(path),
+          },
+        });
+      },
+      removeFile: (path) => {
+        const files = nodeStore.getState().files;
+        const file = files.find(
+          (item) =>
+            formatPath(`${item.directory}/${item.name}`) === formatPath(path)
+        );
+        if (!file) throw new Error(`File not found: ${path}`);
+        set({
+          files: files.filter(
+            (file) =>
+              formatPath(`${file.directory}/${file.name}`) !== formatPath(path)
+          ),
+          record: {
+            file: null,
+            dir: getParent(path),
+          },
+        });
+      },
+      copyDir: (source: string, destination: string) => {
+        const files = nodeStore.getState().files;
+        const directories = nodeStore.getState().directories;
+        const matchingSource = directories.find((path) => path === source);
+        if (!matchingSource) throw new Error(`Dir does not exist: ${source}`);
+        const matchingDestination = directories.find(
+          (path) => path === destination
+        );
+        if (matchingDestination)
+          throw new Error(`Destination already exist: ${destination}`);
+        const nestedFiles = files.filter((item) =>
+          nestedDirectories.includes(item.directory)
+        );
+        const nestedDirectories = directories.filter((dir) =>
+          dir.startsWith(source)
+        );
+        const newContent = nestedFiles.map((item) => ({
+          ...item,
+          directory: item.directory.replace(source, destination),
+        }));
+        const newDirectories = nestedDirectories.map((item) =>
+          item.replace(source, destination)
+        );
+        set({
+          files: [...files, ...newContent],
+          directories: [...directories, ...newDirectories],
+          record: {
+            file: null,
+            dir: getParent(destination),
+          },
+        });
+      },
+      copyFile: (source: string, destination: string) => {
+        const files = nodeStore.getState().files;
+        const matchingFile = files.find(
+          (item) =>
+            formatPath(`${item.directory}/${item.name}`) === formatPath(source)
+        );
+        if (!matchingFile) throw new Error(`Source not found: ${source}`);
+        const matchingDestination = files.find(
+          (item) =>
+            formatPath(`${item.directory}/${item.name}`) ===
+            formatPath(destination)
+        );
+        if (matchingDestination)
+          throw new Error(`Destination already exist: ${destination}`);
+        const addFile = nodeStore.getState().addFile;
+        addFile({
+          path: destination,
+          content: matchingFile.content,
+        });
+      },
+      writeFile: (arg: { path: string; content: string }) => {
+        const allFiles = nodeStore.getState().files;
+
+        const file = allFiles.find(
+          (item) =>
+            formatPath(`${item.directory}/${item.name}`) ===
+            formatPath(arg.path)
+        );
+        if (!file) throw new Error(`File does not exist: ${arg.path}`);
+        const fullPath = arg.path.split("/");
+        const dir = fullPath.slice(0, -1);
+        const name = fullPath.slice(-1)[0];
+        const parentPath = dir.join("/");
+
+        set({
+          files: [
+            ...allFiles.filter(
+              (item) => item.directory !== parentPath || item.name !== name
+            ),
+            {
+              directory: parentPath,
+              name,
+              content: arg.content,
+              modifiedAt: new Date().toISOString(),
+              createdAt: file.createdAt,
+            },
+          ],
+          record: {
+            file: arg.path,
+            dir: null,
+          },
+        });
+      },
+      record: {
+        file: null,
+        dir: null,
+      },
+      addFiles: (files: { path: string; content?: string }[]) => {
+        files.forEach(({ path, content }) => {
+          const allFiles = nodeStore.getState().files;
+          const existingFile = allFiles.find(
+            (item) =>
+              formatPath(`${item.directory}/${item.name}`) === formatPath(path)
+          );
+
+          if (!existingFile) {
+            const addFile = nodeStore.getState().addFile;
+            addFile({ path, content });
+          }
+        });
+      },
+      reset: () =>
+        set({ files: [], directories: [], record: { file: null, dir: null } }),
+    }),
+    {
+      name: "node-storage",
+      storage: createJSONStorage(() => indexedStorage),
+    }
+  )
+);
+
+export default nodeStore;

package/src/load-virtual-editor/node/watch.ts

@@ -0,0 +1,9 @@
+import { nodeStore } from "./store";
+
+export function watch(
+  callback: (data: { file: string | null; dir: string | null }) => void
+) {
+  nodeStore.subscribe((curr) => {
+    callback(curr.record);
+  });
+}

package/src/load-virtual-editor/node/writeFile.ts

@@ -0,0 +1,21 @@
+import { TextFile, BinaryFile } from "@/types/BBRequest";
+import { nodeStore } from "./store";
+
+export function writeFile(
+  arg: TextFile | BinaryFile,
+  callback: (err: Error | null) => void
+) {
+  try {
+    if (arg.type === "text") nodeStore.getState().writeFile(arg);
+    else {
+      const text = new TextDecoder().decode(arg.content);
+      nodeStore.getState().writeFile({
+        path: arg.path,
+        content: text,
+      });
+    }
+    callback(null);
+  } catch (err) {
+    callback(err as Error);
+  }
+}

package/src/load-virtual-editor/postResponse.ts

@@ -0,0 +1,21 @@
+import BBEvent from "@/types/BBEvent";
+import EventReturn from "@/types/EventReturn";
+import BBRequest from "@/types/BBRequest";
+import RequestReturn from "@/types/RequestReturn";
+
+function postResponse<K extends keyof BBRequest>(
+  iframe: HTMLIFrameElement | null,
+  response: RequestReturn<K>
+): void;
+function postResponse<K extends keyof BBEvent>(
+  iframe: HTMLIFrameElement | null,
+  response: EventReturn<K>
+): void;
+function postResponse<K extends keyof (BBRequest | BBEvent)>(
+  iframe: HTMLIFrameElement | null,
+  response: RequestReturn<K> | EventReturn<K>
+) {
+  iframe?.contentWindow?.postMessage(response, "*");
+}
+
+export default postResponse;

package/src/load-virtual-editor/request/requestFS.ts

@@ -0,0 +1,199 @@
+import BBRequest from "@/types/BBRequest";
+import { getFiles } from "../node/getFiles";
+import { writeFile } from "../node/writeFile";
+import { copyFile } from "../node/copyFile";
+import { copyDir } from "../node/copyDir";
+import { deleteFile } from "../node/deleteFile";
+import { deleteDir } from "../node/deleteDir";
+import { createFile } from "../node/createFile";
+import { createDir } from "../node/createDir";
+import { readDir } from "../node/readDir";
+import readFile from "../node/readFile";
+import RequestParam from "@/types/RequestParam";
+import postResponse from "../postResponse";
+import RequestReturn from "@/types/RequestReturn";
+import { getDirInfo } from "../node/getDirInfo";
+import { getFileInfo } from "../node/getFileInfo";
+
+export default function requestFS<K extends keyof BBRequest>({
+  sidebar,
+  main,
+  request,
+}: {
+  sidebar: HTMLIFrameElement | null;
+  main: HTMLIFrameElement | null;
+  request: RequestParam<K>;
+}) {
+  if (request.type === "create-dir") {
+    const req = request as RequestParam<"create-dir">;
+    createDir(req.arg.path, (err) => {
+      const res: RequestReturn<"create-dir"> = {
+        id: req.id,
+        type: "create-dir",
+        response: null,
+        error: err?.message || null,
+        responseId: crypto.randomUUID(),
+      };
+      postResponse(sidebar, res);
+      postResponse(main, res);
+    });
+  }
+  if (request.type === "delete-dir") {
+    const req = request as RequestParam<"delete-dir">;
+    deleteDir(req.arg.path, (err) => {
+      const res: RequestReturn<"delete-dir"> = {
+        id: req.id,
+        type: "delete-dir",
+        response: null,
+        error: err?.message || null,
+        responseId: crypto.randomUUID(),
+      };
+      postResponse(sidebar, res);
+      postResponse(main, res);
+    });
+  }
+  if (request.type === "delete-file") {
+    const req = request as RequestParam<"delete-file">;
+    deleteFile(req.arg.path, (err) => {
+      const res: RequestReturn<"delete-file"> = {
+        id: req.id,
+        type: "delete-file",
+        response: null,
+        error: err?.message || null,
+        responseId: crypto.randomUUID(),
+      };
+      postResponse(sidebar, res);
+      postResponse(main, res);
+    });
+  }
+  if (request.type === "copy-dir") {
+    const req = request as RequestParam<"copy-dir">;
+    copyDir(req.arg.source, req.arg.destination, (err) => {
+      const res: RequestReturn<"copy-dir"> = {
+        id: req.id,
+        type: "copy-dir",
+        response: null,
+        error: err?.message || null,
+        responseId: crypto.randomUUID(),
+      };
+      postResponse(sidebar, res);
+      postResponse(main, res);
+    });
+  }
+  if (request.type === "copy-file") {
+    const req = request as RequestParam<"copy-file">;
+    copyFile(req.arg.source, req.arg.destination, (err) => {
+      const res: RequestReturn<"copy-file"> = {
+        id: req.id,
+        type: "copy-file",
+        response: null,
+        error: err?.message || null,
+        responseId: crypto.randomUUID(),
+      };
+      postResponse(sidebar, res);
+      postResponse(main, res);
+    });
+  }
+  if (request.type === "read-dir") {
+    const req = request as RequestParam<"read-dir">;
+    readDir(req.arg.path, (err, data) => {
+      const res: RequestReturn<"read-dir"> = {
+        id: req.id,
+        type: "read-dir",
+        response: data,
+        error: err?.message || null,
+        responseId: crypto.randomUUID(),
+      };
+      postResponse(sidebar, res);
+      postResponse(main, res);
+    });
+  }
+  if (request.type === "create-file") {
+    const req = request as RequestParam<"create-file">;
+    createFile(req.arg, (err) => {
+      const res: RequestReturn<"create-file"> = {
+        id: req.id,
+        type: "create-file",
+        response: null,
+        error: err?.message || null,
+        responseId: crypto.randomUUID(),
+      };
+      postResponse(sidebar, res);
+      postResponse(main, res);
+    });
+  }
+  if (request.type === "read-file") {
+    const req = request as RequestParam<"read-file">;
+    readFile(req.arg, (err, data) => {
+      const res: RequestReturn<"read-file"> = {
+        id: req.id,
+        type: "read-file",
+        response: {
+          path: req.arg.path,
+          type: data.type as "text",
+          content: data.data as string,
+        },
+        error: err?.message || null,
+        responseId: crypto.randomUUID(),
+      };
+      postResponse(sidebar, res);
+      postResponse(main, res);
+    });
+  }
+  if (request.type === "get-dir-info") {
+    const req = request as RequestParam<"get-dir-info">;
+    getDirInfo(req.arg.path, (err, data) => {
+      const res: RequestReturn<"get-dir-info"> = {
+        id: req.id,
+        type: "get-dir-info",
+        response: data,
+        error: err?.message || null,
+        responseId: crypto.randomUUID(),
+      };
+      postResponse(sidebar, res);
+      postResponse(main, res);
+    });
+  }
+  if (request.type === "write-file") {
+    const req = request as RequestParam<"write-file">;
+    writeFile(req.arg, (err) => {
+      const res: RequestReturn<"write-file"> = {
+        id: req.id,
+        type: "write-file",
+        response: null,
+        error: err?.message || null,
+        responseId: crypto.randomUUID(),
+      };
+      postResponse(sidebar, res);
+      postResponse(main, res);
+    });
+  }
+  if (request.type === "get-files") {
+    const req = request as RequestParam<"get-files">;
+    getFiles(req.arg.path, (err, data) => {
+      const res: RequestReturn<"get-files"> = {
+        id: req.id,
+        type: "get-files",
+        response: data,
+        error: err?.message || null,
+        responseId: crypto.randomUUID(),
+      };
+      postResponse(sidebar, res);
+      postResponse(main, res);
+    });
+  }
+  if (request.type === "get-file-info") {
+    const req = request as RequestParam<"get-file-info">;
+    getFileInfo(req.arg.path, (err, data) => {
+      const res: RequestReturn<"get-file-info"> = {
+        id: req.id,
+        type: "get-file-info",
+        response: data,
+        error: err?.message || null,
+        responseId: crypto.randomUUID(),
+      };
+      postResponse(sidebar, res);
+      postResponse(main, res);
+    });
+  }
+}

package/src/load-virtual-editor/request/requestSelected.ts

@@ -0,0 +1,45 @@
+import BBRequest from "@/types/BBRequest";
+import RequestParam from "@/types/RequestParam";
+import postResponse from "../postResponse";
+import RequestReturn from "@/types/RequestReturn";
+import selectFile from "../selected/selectFile";
+import selectDir from "../selected/selectDir";
+
+export default function requestSelected<K extends keyof BBRequest>({
+  sidebar,
+  main,
+  request,
+}: {
+  sidebar: HTMLIFrameElement | null;
+  main: HTMLIFrameElement | null;
+  request: RequestParam<K>;
+}) {
+  if (request.type === "select-file") {
+    const req = request as RequestParam<"select-file">;
+    selectFile(req.arg.path, (err) => {
+      const res: RequestReturn<"select-file"> = {
+        id: req.id,
+        type: "select-file",
+        response: null,
+        error: err?.message || null,
+        responseId: crypto.randomUUID(),
+      };
+      postResponse(sidebar, res);
+      postResponse(main, res);
+    });
+  }
+  if (request.type === "select-dir") {
+    const req = request as RequestParam<"select-dir">;
+    selectDir(req.arg.path, (err) => {
+      const res: RequestReturn<"select-dir"> = {
+        id: req.id,
+        type: "select-dir",
+        response: null,
+        error: err?.message || null,
+        responseId: crypto.randomUUID(),
+      };
+      postResponse(sidebar, res);
+      postResponse(main, res);
+    });
+  }
+}

package/src/load-virtual-editor/selected/SelectedState.ts

@@ -0,0 +1,7 @@
+export type SelectedState = {
+  selectedPath: {
+    path: string;
+    type: "file" | "dir";
+  };
+  selectPath: (path: string, type: "file" | "dir") => void;
+};

package/src/load-virtual-editor/selected/selectDir.ts

@@ -0,0 +1,13 @@
+import { selectedStore } from "./store";
+
+export default function selectDir(
+  path: string,
+  callback: (err: Error | null) => void
+) {
+  try {
+    selectedStore.getState().selectPath(path, "dir");
+    callback(null);
+  } catch (err) {
+    callback(err as Error);
+  }
+}

package/src/load-virtual-editor/selected/selectFile.ts

@@ -0,0 +1,13 @@
+import { selectedStore } from "./store";
+
+export default function selectFile(
+  path: string,
+  callback: (err: Error | null) => void
+) {
+  try {
+    selectedStore.getState().selectPath(path, "file");
+    callback(null);
+  } catch (err) {
+    callback(err as Error);
+  }
+}

package/src/load-virtual-editor/selected/store.ts

@@ -0,0 +1,27 @@
+import { create } from "zustand";
+import { persist } from "zustand/middleware";
+import { SelectedState } from "./SelectedState";
+
+export const selectedStore = create<SelectedState>()(
+  persist(
+    (set) => ({
+      selectedPath: {
+        path: "",
+        type: "file",
+      },
+      selectPath: (path: string, type: "file" | "dir") => {
+        set({
+          selectedPath: {
+            path,
+            type,
+          },
+        });
+      },
+    }),
+    {
+      name: "selected-storage",
+    }
+  )
+);
+
+export default selectedStore;

package/src/load-virtual-editor/selected/watch.ts

@@ -0,0 +1,9 @@
+import { selectedStore } from "./store";
+
+export default function watch(
+  callback: (data: { path: string; type: "file" | "dir" }) => void
+) {
+  selectedStore.subscribe((curr) => {
+    callback(curr.selectedPath);
+  });
+}