vvvfs 0.0.1 → 0.0.3

package/index.ts

@@ -2,6 +2,20 @@ import { Dexie, Table } from "dexie";
 import packageJson from "./package.json" with { type: "json" };
 import mime from "mime";
 
+/**
+ * 虚拟文件系统
+ * @author IFTC
+ * @description 虚拟文件系统
+ */
+
+/**
+ * 文件记录
+ * @param id 文件id
+ * @param name 文件名
+ * @param path 文件路径
+ * @param type 文件类型(file或dir)
+ * @param file 文件对象
+ */
 export interface FileRecord {
     id?: number;
     name: string;
@@ -10,14 +24,40 @@ export interface FileRecord {
     file: File | null;
 }
 
+/**
+ * 虚拟文件系统数据库
+ * @param files 文件存储数据表
+ */
 export interface VVVFSDatabase extends Dexie {
     files: Table<FileRecord, number>;
 }
 
+/**
+ * 虚拟文件系统配置项
+ * @param throwError 是否抛出错误
+ */
+export interface VVVFSOptions {
+    throwError: boolean;
+}
+
+/**
+ * 虚拟文件系统错误类
+ */
+class VVVFSError extends Error {
+    /**
+     * @param type 错误类型
+     * @param message 错误信息
+     */
+    constructor(type: string, message: string) {
+        super(message);
+        this.name = "VVVFS" + type + "Error";
+    }
+}
+
 const version = packageJson.version;
 class VVVFS {
     private db: VVVFSDatabase;
-    options: Record<string, any>;
+    options: VVVFSOptions;
     /**
      * 虚拟文件系统版本
      */
@@ -27,22 +67,173 @@ class VVVFS {
      * @param name 虚拟文件系统名称
      * @param options 配置项
      */
-    constructor(name = "vvvfs", options = {}) {
+    constructor(
+        name = "vvvfs",
+        options = {
+            throwError: false,
+        },
+    ) {
         this.options = options;
-        this.db = new Dexie(name) as VVVFSDatabase;
-        this.db.version(1).stores({
-            files: "++id, name, path, type, file",
-        });
+        try {
+            this.db = new Dexie(name) as VVVFSDatabase;
+            this.db.version(1).stores({
+                files: "++id, name, path, type, file",
+            });
+        } catch (error) {
+            console.error("创建数据库失败", error);
+            throw new VVVFSError("CreateDatabase", "创建数据库失败");
+        }
+    }
+    /**
+     * 初始化虚拟文件系统
+     * @description 将Linux的系统初始文件初始化到数据库中
+     */
+    async init(user?: string) {
+        const linuxInitFiles = [
+            {
+                name: "root",
+                path: "/",
+                type: "dir",
+                file: new File([], "root"),
+            },
+            {
+                name: "boot",
+                path: "/",
+                type: "dir",
+                file: new File([], "boot"),
+            },
+            {
+                name: "bin",
+                path: "/",
+                type: "dir",
+                file: new File([], "bin"),
+            },
+            {
+                name: "dev",
+                path: "/",
+                type: "dir",
+                file: new File([], "dev"),
+            },
+            {
+                name: "etc",
+                path: "/",
+                type: "dir",
+                file: new File([], "etc"),
+            },
+            {
+                name: "home",
+                path: "/",
+                type: "dir",
+                file: new File([], "home"),
+            },
+            {
+                name: user || "root",
+                path: "/home",
+                type: "dir",
+                file: new File([], "home"),
+            },
+            {
+                name: "lib",
+                path: "/",
+                type: "dir",
+                file: new File([], "lib"),
+            },
+            {
+                name: "lib64",
+                path: "/",
+                type: "dir",
+                file: new File([], "lib64"),
+            },
+            {
+                name: "media",
+                path: "/",
+                type: "dir",
+                file: new File([], "media"),
+            },
+            {
+                name: "mnt",
+                path: "/",
+                type: "dir",
+                file: new File([], "mnt"),
+            },
+            {
+                name: "opt",
+                path: "/",
+                type: "dir",
+                file: new File([], "opt"),
+            },
+            {
+                name: "proc",
+                path: "/",
+                type: "dir",
+                file: new File([], "proc"),
+            },
+            {
+                name: "run",
+                path: "/",
+                type: "dir",
+                file: new File([], "run"),
+            },
+            {
+                name: "sbin",
+                path: "/",
+                type: "dir",
+                file: new File([], "sbin"),
+            },
+            {
+                name: "srv",
+                path: "/",
+                type: "dir",
+                file: new File([], "srv"),
+            },
+            {
+                name: "sys",
+                path: "/",
+                type: "dir",
+                file: new File([], "sys"),
+            },
+            {
+                name: "tmp",
+                path: "/",
+                type: "dir",
+                file: new File([], "tmp"),
+            },
+            {
+                name: "usr",
+                path: "/",
+                type: "dir",
+                file: new File([], "usr"),
+            },
+            {
+                name: "var",
+                path: "/",
+                type: "dir",
+                file: new File([], "var"),
+            },
+        ];
+        try {
+            for (const file of linuxInitFiles) {
+                await this.db.files.put(file);
+            }
+        } catch (error) {
+            console.error("初始化文件失败", error);
+            throw new VVVFSError("InitFiles", "初始化文件失败" + error);
+        }
     }
     /**
      * 重置虚拟文件系统
      */
     async reset() {
-        await this.db.delete();
-        this.db = new Dexie(this.db.name) as VVVFSDatabase;
-        this.db.version(1).stores({
-            files: "++id, name, path, type, file",
-        });
+        try {
+            await this.db.delete();
+            this.db = new Dexie(this.db.name) as VVVFSDatabase;
+            this.db.version(1).stores({
+                files: "++id, name, path, type, file",
+            });
+        } catch (error) {
+            console.error("重置数据库失败", error);
+            throw new VVVFSError("ResetDatabase", "重置数据库失败" + error);
+        }
     }
     /**
      * 创建文件
@@ -58,7 +249,7 @@ class VVVFS {
             if (!(await this.exists(parent))) {
                 await this.createDir(parent);
             }
-            console.log(name, parent);
+            // console.log(name, parent);
             await this.db.files.add({
                 name: name,
                 path: parent,
@@ -70,6 +261,9 @@ class VVVFS {
             return true;
         } catch (error) {
             console.error("创建文件失败", error);
+            if (this.options.throwError) {
+                throw new VVVFSError("CreateFile", "创建文件失败" + error);
+            }
             return false;
         }
     }
@@ -107,6 +301,9 @@ class VVVFS {
             return true;
         } catch (error) {
             console.error("创建目录失败", error);
+            if (this.options.throwError) {
+                throw new VVVFSError("CreateDir", "创建目录失败" + error);
+            }
             return false;
         }
     }
@@ -115,33 +312,47 @@ class VVVFS {
      * @param path 文件路径
      */
     async exists(path: string) {
-        const { name, parent } = parsePath(path);
-        return (
-            (await this.db.files
-                .where({
-                    name: name,
-                    path: parent,
-                })
-                .count()) > 0
-        );
+        try {
+            const { name, parent } = parsePath(path);
+            return (
+                (await this.db.files
+                    .where({
+                        name: name,
+                        path: parent,
+                    })
+                    .count()) > 0
+            );
+        } catch (error) {
+            console.error("判断文件是否存在失败", error);
+            if (this.options.throwError) {
+                throw new VVVFSError("Exists", "判断文件是否存在失败" + error);
+            }
+            return false;
+        }
     }
     /**
      * 读取文件内容
      * @param path 文件路径
      */
     async write(path: string, content: Blob) {
-        if (!(await this.exists(path))) {
-            const success = await this.createFile(path);
-            if (!success) {
-                console.warn("创建文件失败");
-                return false;
-            }
-        }
         try {
+            if (!(await this.exists(path))) {
+                const success = await this.createFile(path);
+                if (!success) {
+                    console.warn("创建文件失败");
+                    if (this.options.throwError) {
+                        throw new VVVFSError("Write", "创建文件失败");
+                    }
+                    return false;
+                }
+            }
             const { name, parent } = parsePath(path);
             console.log(name, parent);
             if (await this.isDir(parent + "/" + name)) {
                 console.warn("路径已存在");
+                if (this.options.throwError) {
+                    throw new VVVFSError("Write", "路径已存在");
+                }
                 return false;
             }
             const file = new File([content], name, {
@@ -157,10 +368,16 @@ class VVVFS {
                 return true;
             } else {
                 console.warn("文件记录未找到，无法写入内容");
+                if (this.options.throwError) {
+                    throw new VVVFSError("Write", "文件记录未找到，无法写入内容");
+                }
                 return false;
             }
         } catch (error) {
             console.error("写入文件失败", error);
+            if (this.options.throwError) {
+                throw new VVVFSError("Write", "写入文件失败" + error);
+            }
             return false;
         }
     }
@@ -170,8 +387,16 @@ class VVVFS {
      * @param content 文本内容
      */
     async writeText(path: string, content: string) {
-        const blob = new Blob([content], { type: "text/plain" });
-        return await this.write(path, blob);
+        try {
+            const blob = new Blob([content], { type: "text/plain" });
+            return await this.write(path, blob);
+        } catch (error) {
+            console.error("写入文件失败", error);
+            if (this.options.throwError) {
+                throw new VVVFSError("Write", "写入文件失败" + error);
+            }
+            return false;
+        }
     }
     /**
      * 写入JSON内容
@@ -180,22 +405,39 @@ class VVVFS {
      * @param format 是否格式化
      */
     async writeJson(path: string, content: Record<string, any>, format?: boolean) {
-        return await this.writeText(path, JSON.stringify(content, null, format ? 4 : undefined));
+        try {
+            return await this.writeText(
+                path,
+                JSON.stringify(content, null, format ? 4 : undefined),
+            );
+        } catch (error) {
+            console.error("写入文件失败", error);
+            if (this.options.throwError) {
+                throw new VVVFSError("Write", "写入文件失败" + error);
+            }
+            return false;
+        }
     }
     /**
      * 读取文件内容
      * @param path 文件路径
      */
     async read(path: string) {
-        if (!(await this.exists(path))) {
-            console.warn("文件不存在");
-            return null;
-        }
         try {
+            if (!(await this.exists(path))) {
+                console.warn("文件不存在");
+                if (this.options.throwError) {
+                    throw new VVVFSError("Read", "文件不存在");
+                }
+                return null;
+            }
             const { name, parent } = parsePath(path);
             return (await this.db.files.where({ name, path: parent }).first())?.file;
         } catch (error) {
             console.error("读取文件失败", error);
+            if (this.options.throwError) {
+                throw new VVVFSError("Read", "读取文件失败" + error);
+            }
             return null;
         }
     }
@@ -204,10 +446,22 @@ class VVVFS {
      * @param path 文件路径
      */
     async readText(path: string) {
-        const file = await this.read(path);
-        if (file) {
-            return await file.text();
-        } else {
+        try {
+            const file = await this.read(path);
+            if (file) {
+                return await file.text();
+            } else {
+                console.warn("文件不存在");
+                if (this.options.throwError) {
+                    throw new VVVFSError("Read", "文件不存在");
+                }
+                return null;
+            }
+        } catch (error) {
+            console.error("读取文件失败", error);
+            if (this.options.throwError) {
+                throw new VVVFSError("Read", "读取文件失败" + error);
+            }
             return null;
         }
     }
@@ -216,15 +470,26 @@ class VVVFS {
      * @param path 文件路径
      */
     async readJson(path: string) {
-        const text = await this.readText(path);
-        if (text) {
-            try {
-                return JSON.parse(text);
-            } catch (error) {
-                console.error("解析JSON失败", error);
+        try {
+            const text = await this.readText(path);
+            if (text) {
+                try {
+                    return JSON.parse(text);
+                } catch (error) {
+                    console.error("解析JSON失败", error);
+                    if (this.options.throwError) {
+                        throw new VVVFSError("Read", "解析JSON失败" + error);
+                    }
+                    return null;
+                }
+            } else {
                 return null;
             }
-        } else {
+        } catch (error) {
+            console.error("读取文件失败", error);
+            if (this.options.throwError) {
+                throw new VVVFSError("Read", "读取文件失败" + error);
+            }
             return null;
         }
     }
@@ -233,24 +498,48 @@ class VVVFS {
      * @param path 文件路径
      */
     async isFile(path: string) {
-        const { name, parent } = parsePath(path);
-        return (await this.db.files.where({ name, path: parent, type: "file" }).count()) > 0;
+        try {
+            const { name, parent } = parsePath(path);
+            return (await this.db.files.where({ name, path: parent, type: "file" }).count()) > 0;
+        } catch (error) {
+            console.error("判断文件类型失败", error);
+            if (this.options.throwError) {
+                throw new VVVFSError("IsFile", "判断文件类型失败" + error);
+            }
+            return false;
+        }
     }
     /**
      * 判断是否是目录
      * @param path 文件路径
      */
     async isDir(path: string) {
-        const { name, parent } = parsePath(path);
-        return (await this.db.files.where({ path: parent, name, type: "dir" }).count()) > 0;
+        try {
+            const { name, parent } = parsePath(path);
+            return (await this.db.files.where({ path: parent, name, type: "dir" }).count()) > 0;
+        } catch (error) {
+            console.error("判断文件类型失败", error);
+            if (this.options.throwError) {
+                throw new VVVFSError("IsDir", "判断文件类型失败" + error);
+            }
+            return false;
+        }
     }
     /**
      * 列出目录下的文件
      * @param path 目录路径
      */
     async list(path: string) {
-        const { name, parent } = parsePath(path);
-        return (await this.db.files.where({ path: parent }).toArray()).map((file) => file.name);
+        try {
+            const { name, parent } = parsePath(path);
+            return (await this.db.files.where({ path: parent }).toArray()).map((file) => file.name).filter((item) => item != "");
+        } catch (error) {
+            console.error("列出目录下的文件失败", error);
+            if (this.options.throwError) {
+                throw new VVVFSError("List", "列出目录下的文件失败" + error);
+            }
+            return [];
+        }
     }
     /**
      * 重命名文件
@@ -258,8 +547,14 @@ class VVVFS {
      * @param newName 新文件名
      */
     async rename(path: string, newName: string) {
-        if (!(await this.exists(path))) throw new Error("File not exists");
         try {
+            if (!(await this.exists(path))) {
+                console.warn("文件不存在");
+                if (this.options.throwError) {
+                    throw new VVVFSError("Rename", "文件不存在");
+                }
+                return false;
+            }
             const { name, parent } = parsePath(path);
             const file = await this.db.files.get({ path, name });
             await this.db.files.put({
@@ -271,6 +566,9 @@ class VVVFS {
             return true;
         } catch (e) {
             console.error(e);
+            if (this.options.throwError) {
+                throw new VVVFSError("Rename", "重命名文件失败" + e);
+            }
             return false;
         }
     }
@@ -279,8 +577,14 @@ class VVVFS {
      * @param path 文件路径
      */
     async delete(path: string) {
-        if (!(await this.exists(path))) return false;
         try {
+            if (!(await this.exists(path))) {
+                console.warn("文件不存在");
+                if (this.options.throwError) {
+                    throw new VVVFSError("Delete", "文件不存在");
+                }
+                return false;
+            }
             const { name, parent } = parsePath(path);
             if (await this.isDir(path)) {
                 const files = await this.list(path);
@@ -301,6 +605,9 @@ class VVVFS {
             }
         } catch (e) {
             console.error(e);
+            if (this.options.throwError) {
+                throw new VVVFSError("Delete", "删除文件失败" + e);
+            }
             return false;
         }
     }
@@ -310,9 +617,21 @@ class VVVFS {
      * @param newPath 新路径
      */
     async move(path: string, newPath: string) {
-        if (await this.exists(newPath)) return false;
-        if (!(await this.exists(path))) return false;
         try {
+            if (await this.exists(newPath)) {
+                console.warn("目标文件已存在");
+                if (this.options.throwError) {
+                    throw new VVVFSError("Move", "目标文件已存在");
+                }
+                return false;
+            }
+            if (!(await this.exists(path))) {
+                console.warn("源文件不存在");
+                if (this.options.throwError) {
+                    throw new VVVFSError("Move", "源文件不存在");
+                }
+                return false;
+            }
             const { name, parent } = parsePath(path);
             const { name: newName, parent: newParent } = parsePath(newPath);
             await this.createDir(newParent);
@@ -329,6 +648,9 @@ class VVVFS {
             return true;
         } catch (e) {
             console.error(e);
+            if (this.options.throwError) {
+                throw new VVVFSError("Move", "移动文件失败" + e);
+            }
             return false;
         }
     }
@@ -338,9 +660,21 @@ class VVVFS {
      * @param newPath 新路径
      */
     async copy(path: string, newPath: string) {
-        if (await this.exists(newPath)) return false;
-        if (!(await this.exists(path))) return false;
         try {
+            if (await this.exists(newPath)) {
+                console.warn("目标文件已存在");
+                if (this.options.throwError) {
+                    throw new VVVFSError("Copy", "目标文件已存在");
+                }
+                return false;
+            }
+            if (!(await this.exists(path))) {
+                console.warn("源文件不存在");
+                if (this.options.throwError) {
+                    throw new VVVFSError("Copy", "源文件不存在");
+                }
+                return false;
+            }
             const { name, parent } = parsePath(path);
             const { name: newName, parent: newParent } = parsePath(newPath);
             await this.createDir(newParent);
@@ -356,6 +690,9 @@ class VVVFS {
             return true;
         } catch (e) {
             console.error(e);
+            if (this.options.throwError) {
+                throw new VVVFSError("Copy", "复制文件失败" + e);
+            }
             return false;
         }
     }
@@ -365,33 +702,47 @@ class VVVFS {
      * @param query 查询字符串
      */
     async search(basePath: string, query: string) {
-        if (!await this.isDir(basePath)) return null;
-        const that = this;
         try {
+            if (!(await this.isDir(basePath))) {
+                console.warn("基础路径不是目录");
+                if (this.options.throwError) {
+                    throw new VVVFSError("Search", "基础路径不是目录");
+                }
+                return null;
+            }
+            const that = this;
             const dirs = await this.list(basePath);
             return await search(basePath, dirs);
-        } catch (e) {
-            console.error(e);
-            return [];
-        }
-        async function search(parent: string, files: string[]) {
-            const result: string[] = [];
-            console.log(files)
-            for (const file of files) {
-                if (file == "") continue;
-                console.log(file);
-                if (await that.isDir(joinPath(parent, file))) {
-                    if (file.includes(query)) {
-                        result.push(joinPath(parent, file) + "/");
-                    }
-                    result.push(...await search(joinPath(parent, file), await that.list(joinPath(parent, file))));
-                } else {
-                    if (file.includes(query)) {
-                        result.push(joinPath(parent, file));
+            async function search(parent: string, files: string[]) {
+                const result: string[] = [];
+                console.log(files);
+                for (const file of files) {
+                    if (file == "") continue;
+                    console.log(file);
+                    if (await that.isDir(joinPath(parent, file))) {
+                        if (file.includes(query)) {
+                            result.push(joinPath(parent, file) + "/");
+                        }
+                        result.push(
+                            ...(await search(
+                                joinPath(parent, file),
+                                await that.list(joinPath(parent, file)),
+                            )),
+                        );
+                    } else {
+                        if (file.includes(query)) {
+                            result.push(joinPath(parent, file));
+                        }
                     }
                 }
+                return result;
             }
-            return result;
+        } catch (e) {
+            console.error(e);
+            if (this.options.throwError) {
+                throw new VVVFSError("Search", "搜索文件失败" + e);
+            }
+            return null;
         }
     }
 }
@@ -400,11 +751,12 @@ function parsePath(path: string) {
     const oldParts = path.split("/");
     const parts: string[] = [];
     for (let i = 0; i < oldParts.length; i++) {
+        if (oldParts[i].length > 255) throw new VVVFSError("ParsePath", "文件名过长");
         if (oldParts[i]) parts.push(oldParts[i]);
     }
     const name = parts.pop() || "";
     const parent = "/" + parts.join("/");
-    if ((parent + "/" + name).length > 255) throw new Error("文件名过长");
+    if (joinPath(parent, name).length > 4096) throw new VVVFSError("ParsePath", "文件路径过长");
     return { name, parent };
 }
 function joinPath(...paths: string[]) {
@@ -433,7 +785,7 @@ function joinPath(...paths: string[]) {
     return result || (isAbsolute ? "/" : ".");
 }
 Object.defineProperty(VVVFS, "version", {
-    value: packageJson.version,
+    value: version,
     writable: false,
     enumerable: true,
     configurable: false,