vvvfs 0.0.6 → 0.0.8

package/README.md

@@ -42,6 +42,9 @@ const vvvfs = new VVVFS("vvvfs", {
 (async function () {
     await vvvfs.reset(); // 重置文件系统
     await vvvfs.init("UserName"); // 初始化文件系统
+    await vvvfs.watch("/home/user/Desktop/test.txt", (type) => {
+        console.log(type); // 打印文件操作的类型
+    });
     await vvvfs.createDir("/home/user/Desktop"); // 创建目录，返回true和false
     await vvvfs.writeText("/home/user/Desktop/test.txt", "Hello World!"); // 写入文本文件，写入文件还包括write(path: string, content: Blob)和writeJson(path: string, content: Record<string, any>)方法，返回true和false
     console.log(await vvvfs.readText("/home/user/Desktop/test.txt")); // 读取文本文件，读取文件还包括read(path: string): Blob | null和readJson(path: string): Record<string, any> | null方法
@@ -78,6 +81,14 @@ const vvvfs = new VVVFS("vvvfs", {
 
 ## 更新日志
 
+### 0.0.8
+
+- 新增 `watch` 方法
+
+### 0.0.7
+
+- AI 了优化一下
+
 ### 0.0.6
 
 - `VVVFS.File` 类中新增 `dbname` 和 `options` 属性

package/index.html

@@ -16,6 +16,9 @@
                 await vvvfs.reset();
                 await vvvfs.init("IFTC");
                 console.log(vvvfs);
+                await vvvfs.watch("/test.txt", (type) => {
+                    console.log(type);
+                });
                 console.log("创建文件", await vvvfs.createFile("/test.txt"));
                 console.log("写入文件", await vvvfs.writeText("/test.txt", "Hello World"));
                 console.log("文件是否存在", await vvvfs.exists("/test.txt"));
@@ -26,6 +29,7 @@
                 console.log("移动文件", await vvvfs.move("/test2.txt", "/test3.txt"));
                 console.log("删除文件", await vvvfs.delete("/test.txt"));
                 const file = new VVVFS.File("test.txt");
+                console.log("写入文件", await file.writeText("Hello World"));
             } catch (error) {
                 console.error(error);
             }

package/index.ts

@@ -216,6 +216,9 @@ class VVVFSFile {
     async search(query: string) {
         return await this._vvvfs.search(this._path, query);
     }
+    async watch(handler: (type: string) => void) {
+        return await this._vvvfs.watch(this._path, handler);
+    }
 }
 
 const version = packageJson.version;
@@ -409,22 +412,22 @@ class VVVFS {
      * @param path 文件路径
      */
     async createFile(path: string) {
-        if (await this.exists(path)) {
+        const targetPath = joinPath(path);
+        if (await this.exists(targetPath)) {
             console.warn("文件已存在");
             return true;
         }
         try {
-            const { name, parent } = parsePath(path);
+            const { name, parent } = parsePath(targetPath);
             if (!(await this.exists(parent))) {
                 await this.createDir(parent);
             }
-            // console.log(name, parent);
             await this.db.files.add({
                 name: name,
                 path: parent,
                 type: "file",
                 file: new File([], name, {
-                    type: mime.getType(path) || "application/octet-stream",
+                    type: mime.getType(targetPath) || "application/octet-stream",
                 }),
             });
             return true;
@@ -441,12 +444,13 @@ class VVVFS {
      * @param path 目录路径
      */
     async createDir(path: string) {
-        if (await this.exists(path)) {
+        const targetPath = joinPath(path);
+        if (await this.exists(targetPath)) {
             console.warn("目录已存在");
             return true;
         }
         try {
-            const { name, parent } = parsePath(path);
+            const { name, parent } = parsePath(targetPath);
             if (!(await this.exists(parent))) {
                 if (parent == "/") {
                     await this.db.files.add({
@@ -460,7 +464,6 @@ class VVVFS {
                     await this.createDir(parent);
                 }
             }
-            console.log(name, parent);
             await this.db.files.add({
                 name: name,
                 path: parent,
@@ -482,7 +485,8 @@ class VVVFS {
      */
     async exists(path: string) {
         try {
-            const { name, parent } = parsePath(path);
+            const targetPath = joinPath(path);
+            const { name, parent } = parsePath(targetPath);
             return (
                 (await this.db.files
                     .where({
@@ -505,8 +509,9 @@ class VVVFS {
      */
     async write(path: string, content: Blob) {
         try {
-            if (!(await this.exists(path))) {
-                const success = await this.createFile(path);
+            const targetPath = joinPath(path);
+            if (!(await this.exists(targetPath))) {
+                const success = await this.createFile(targetPath);
                 if (!success) {
                     console.warn("创建文件失败");
                     if (this.options.throwError) {
@@ -515,19 +520,17 @@ class VVVFS {
                     return false;
                 }
             }
-            const { name, parent } = parsePath(path);
-            console.log(name, parent);
-            if (await this.isDir(parent + "/" + name)) {
+            if (await this.isDir(targetPath)) {
                 console.warn("路径已存在");
                 if (this.options.throwError) {
                     throw new VVVFSError("Write", "路径已存在");
                 }
                 return false;
             }
+            const { name, parent } = parsePath(targetPath);
             const file = new File([content], name, {
-                type: mime.getType(path) || "application/octet-stream",
+                type: mime.getType(targetPath) || "application/octet-stream",
             });
-            console.log(file);
             const fileRecord = await this.db.files.where({ name, path: parent }).first();
             if (fileRecord) {
                 await this.db.files.put({
@@ -593,14 +596,15 @@ class VVVFS {
      */
     async read(path: string) {
         try {
-            if (!(await this.exists(path))) {
+            const targetPath = joinPath(path);
+            if (!(await this.exists(targetPath))) {
                 console.warn("文件不存在");
                 if (this.options.throwError) {
                     throw new VVVFSError("Read", "文件不存在");
                 }
                 return null;
             }
-            const { name, parent } = parsePath(path);
+            const { name, parent } = parsePath(targetPath);
             return (await this.db.files.where({ name, path: parent }).first())?.file;
         } catch (error) {
             console.error("读取文件失败", error);
@@ -668,7 +672,8 @@ class VVVFS {
      */
     async isFile(path: string) {
         try {
-            const { name, parent } = parsePath(path);
+            const targetPath = joinPath(path);
+            const { name, parent } = parsePath(targetPath);
             return (await this.db.files.where({ name, path: parent, type: "file" }).count()) > 0;
         } catch (error) {
             console.error("判断文件类型失败", error);
@@ -684,7 +689,8 @@ class VVVFS {
      */
     async isDir(path: string) {
         try {
-            const { name, parent } = parsePath(path);
+            const targetPath = joinPath(path);
+            const { name, parent } = parsePath(targetPath);
             return (await this.db.files.where({ path: parent, name, type: "dir" }).count()) > 0;
         } catch (error) {
             console.error("判断文件类型失败", error);
@@ -700,8 +706,15 @@ class VVVFS {
      */
     async list(path: string) {
         try {
-            const { name, parent } = parsePath(path);
-            return (await this.db.files.where({ path: parent }).toArray())
+            const targetPath = joinPath(path);
+            if (!(await this.isDir(targetPath))) {
+                console.warn("路径不是目录");
+                if (this.options.throwError) {
+                    throw new VVVFSError("List", "路径不是目录");
+                }
+                return [];
+            }
+            return (await this.db.files.where({ path: targetPath }).toArray())
                 .map((file) => file.name)
                 .filter((item) => item != "");
         } catch (error) {
@@ -719,20 +732,50 @@ class VVVFS {
      */
     async rename(path: string, newName: string) {
         try {
-            if (!(await this.exists(path))) {
+            const sourcePath = joinPath(path);
+            const { name, parent } = parsePath(sourcePath);
+            if (!(await this.exists(sourcePath))) {
                 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({
+            const newPath = joinPath(parent, newName);
+            if (newPath === sourcePath) {
+                return true;
+            }
+            if (await this.exists(newPath)) {
+                console.warn("目标文件已存在");
+                if (this.options.throwError) {
+                    throw new VVVFSError("Rename", "目标文件已存在");
+                }
+                return false;
+            }
+            const fileRecord = await this.db.files.where({ path: parent, name }).first();
+            if (!fileRecord) {
+                console.warn("文件记录未找到");
+                if (this.options.throwError) {
+                    throw new VVVFSError("Rename", "文件记录未找到");
+                }
+                return false;
+            }
+            if (fileRecord.type === "dir") {
+                const descendants = await this.db.files
+                    .filter(
+                        (file) =>
+                            file.path === sourcePath || file.path.startsWith(sourcePath + "/"),
+                    )
+                    .toArray();
+                for (const descendant of descendants) {
+                    const relativePath = descendant.path.slice(sourcePath.length);
+                    const updatedPath = joinPath(newPath + relativePath);
+                    await this.db.files.update(descendant.id!, { path: updatedPath });
+                }
+            }
+            await this.db.files.update(fileRecord.id!, {
                 name: newName,
                 path: parent,
-                type: "file",
-                file: file!.file,
             });
             return true;
         } catch (e) {
@@ -749,29 +792,34 @@ class VVVFS {
      */
     async delete(path: string) {
         try {
-            if (!(await this.exists(path))) {
+            const targetPath = joinPath(path);
+            if (!(await this.exists(targetPath))) {
                 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);
+            const { name, parent } = parsePath(targetPath);
+            if (await this.isDir(targetPath)) {
+                const files = await this.list(targetPath);
                 for (const file of files) {
-                    if (await this.isDir(joinPath(path, file))) {
-                        const fileRecord = await this.db.files
-                            .where({ name, path: parent })
-                            .first();
-                        await this.db.files.delete(fileRecord!.id!);
-                    }
-                    await this.delete(joinPath(parent, file));
+                    await this.delete(joinPath(targetPath, file));
+                }
+                const dirRecord = await this.db.files
+                    .where({ name, path: parent, type: "dir" })
+                    .first();
+                if (dirRecord) {
+                    await this.db.files.delete(dirRecord.id!);
                 }
                 return true;
             } else {
-                const fileRecord = await this.db.files.where({ name, path: parent }).first();
-                await this.db.files.delete(fileRecord!.id!);
+                const fileRecord = await this.db.files
+                    .where({ name, path: parent, type: "file" })
+                    .first();
+                if (fileRecord) {
+                    await this.db.files.delete(fileRecord.id!);
+                }
                 return true;
             }
         } catch (e) {
@@ -789,34 +837,55 @@ class VVVFS {
      */
     async move(path: string, newPath: string) {
         try {
-            if (await this.exists(newPath)) {
+            const sourcePath = joinPath(path);
+            const destinationPath = joinPath(newPath);
+            if (await this.exists(destinationPath)) {
                 console.warn("目标文件已存在");
                 if (this.options.throwError) {
                     throw new VVVFSError("Move", "目标文件已存在");
                 }
                 return false;
             }
-            if (!(await this.exists(path))) {
+            if (!(await this.exists(sourcePath))) {
                 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);
-            if (await this.isDir(path)) {
-                const dirs = await this.list(path);
-                for (const dir of dirs) {
-                    await this.move(path + "/" + dir, newPath + "/" + dir);
+            if (destinationPath.startsWith(sourcePath + "/")) {
+                console.warn("目标路径是源路径的子路径");
+                if (this.options.throwError) {
+                    throw new VVVFSError("Move", "目标路径是源路径的子路径");
+                }
+                return false;
+            }
+            const { name, parent } = parsePath(sourcePath);
+            const { name: newName, parent: newParent } = parsePath(destinationPath);
+            if (await this.isDir(sourcePath)) {
+                await this.createDir(destinationPath);
+                const children = await this.list(sourcePath);
+                for (const child of children) {
+                    await this.move(joinPath(sourcePath, child), joinPath(destinationPath, child));
+                }
+                const dirRecord = await this.db.files
+                    .where({ name, path: parent, type: "dir" })
+                    .first();
+                if (dirRecord) {
+                    await this.db.files.delete(dirRecord.id!);
                 }
+                return true;
             } else {
-                const fileRecord = await this.db.files.where({ name, path: parent }).first();
-                await this.db.files.update(fileRecord!.id!, { name: newName, path: newParent });
+                await this.createDir(newParent);
+                const fileRecord = await this.db.files
+                    .where({ name, path: parent, type: "file" })
+                    .first();
+                if (fileRecord) {
+                    await this.db.files.update(fileRecord.id!, { name: newName, path: newParent });
+                    return true;
+                }
+                return false;
             }
-            await this.delete(path);
-            return true;
         } catch (e) {
             console.error(e);
             if (this.options.throwError) {
@@ -832,33 +901,53 @@ class VVVFS {
      */
     async copy(path: string, newPath: string) {
         try {
-            if (await this.exists(newPath)) {
+            const sourcePath = joinPath(path);
+            const destinationPath = joinPath(newPath);
+            if (await this.exists(destinationPath)) {
                 console.warn("目标文件已存在");
                 if (this.options.throwError) {
                     throw new VVVFSError("Copy", "目标文件已存在");
                 }
                 return false;
             }
-            if (!(await this.exists(path))) {
+            if (!(await this.exists(sourcePath))) {
                 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);
-            if (await this.isDir(path)) {
-                const dirs = await this.list(path);
-                for (const dir of dirs) {
-                    await this.move(path + "/" + dir, newPath + "/" + dir);
+            if (destinationPath.startsWith(sourcePath + "/")) {
+                console.warn("目标路径是源路径的子路径");
+                if (this.options.throwError) {
+                    throw new VVVFSError("Copy", "目标路径是源路径的子路径");
+                }
+                return false;
+            }
+            const { name, parent } = parsePath(sourcePath);
+            const { name: newName, parent: newParent } = parsePath(destinationPath);
+            if (await this.isDir(sourcePath)) {
+                await this.createDir(destinationPath);
+                const children = await this.list(sourcePath);
+                for (const child of children) {
+                    await this.copy(joinPath(sourcePath, child), joinPath(destinationPath, child));
                 }
+                return true;
             } else {
-                const fileRecord = await this.db.files.where({ name, path: parent }).first();
-                await this.db.files.update(fileRecord!.id!, { name: newName, path: newParent });
+                const fileRecord = await this.db.files
+                    .where({ name, path: parent, type: "file" })
+                    .first();
+                if (fileRecord) {
+                    await this.db.files.add({
+                        name: newName,
+                        path: newParent,
+                        type: fileRecord.type,
+                        file: fileRecord.file,
+                    });
+                    return true;
+                }
+                return false;
             }
-            return true;
         } catch (e) {
             console.error(e);
             if (this.options.throwError) {
@@ -917,6 +1006,63 @@ class VVVFS {
             return null;
         }
     }
+    async watch(path: string, handler: (type: string) => void) {
+        const targetPath = joinPath(path);
+
+        const getState = async () => {
+            const exists = await this.exists(targetPath);
+            if (!exists) {
+                return { exists: false, signature: "" };
+            }
+            if (await this.isDir(targetPath)) {
+                const records = await this.db.files
+                    .filter(
+                        (file) =>
+                            file.path === targetPath || file.path.startsWith(targetPath + "/"),
+                    )
+                    .toArray();
+                const signature = records
+                    .map((file) => {
+                        const fullPath = joinPath(file.path, file.name);
+                        const fileInfo = file.file
+                            ? `${file.file.type}:${file.file.size}:${file.file.lastModified}`
+                            : "null";
+                        return `${fullPath}:${file.type}:${fileInfo}`;
+                    })
+                    .sort()
+                    .join("|");
+                return { exists: true, signature };
+            }
+            const { name, parent } = parsePath(targetPath);
+            const record = await this.db.files.where({ name, path: parent, type: "file" }).first();
+            const signature = record?.file
+                ? `${record.file.type}:${record.file.size}:${record.file.lastModified}`
+                : "";
+            return { exists: true, signature };
+        };
+
+        let previousState = await getState();
+        setInterval(async () => {
+            try {
+                const currentState = await getState();
+                if (
+                    previousState.exists !== currentState.exists ||
+                    previousState.signature !== currentState.signature
+                ) {
+                    if (!previousState.exists && currentState.exists) {
+                        handler("create");
+                    } else if (previousState.exists && !currentState.exists) {
+                        handler("unlink");
+                    } else {
+                        handler("change");
+                    }
+                    previousState = currentState;
+                }
+            } catch (error) {
+                console.error("监听失败", error);
+            }
+        });
+    }
 }
 function parsePath(path: string) {
     path = joinPath(path);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "vvvfs",
-  "version": "0.0.6",
+  "version": "0.0.8",
   "description": "一个使用IndexDB实现的虚拟文件系统",
   "keywords": [
     "Virtual",