vvvfs 0.1.4 → 0.1.6

package/README.md

@@ -31,7 +31,7 @@ const VVVFS = require("vvvfs"); // CommonJS
 
 ```javascript
 const vvvfs = new VVVFS("vvvfs", {
-    throwError: true, // 设置为true后，操作文件失败时，不会返回false，而是会抛出错误
+  throwError: true, // 设置为true后，操作文件失败时，不会返回false，而是会抛出错误
 }); // 创建一个名为vvvfs的虚拟文件系统
 ```
 
@@ -40,34 +40,40 @@ const vvvfs = new VVVFS("vvvfs", {
 ```javascript
 // 所有操作都是异步的
 (async function () {
-    await vvvfs.reset(); // 重置文件系统
-    await vvvfs.init("UserName"); // 初始化文件系统
-    vvvfs.watch("/home/user/Desktop/test.txt", (type) => {
-        console.log(type); // 打印文件操作的类型
-        return true; // 返回true或false，表示是否取消该操作
-    });
-    await vvvfs.lock("/home/user/Desktop/test.txt"); // 锁定文件，防止其他代码访问该文件
-    await vvvfs.unlock("/home/user/Desktop/test.txt"); // 解锁文件
-    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
-    await vvvfs.appendText("/home/user/Desktop/test.txt", "Hello World!"); // 追加文本文件，返回true和false
-    console.log(await vvvfs.readText("/home/user/Desktop/test.txt")); // 读取文本文件，读取文件还包括read(path: string): Blob | null和readJson(path: string): Record<string, any> | null方法
-    console.log(await vvvfs.readChunkText("/home/user/Desktop/test.txt", 0, 5)); // 读取文件块，返回string | null
-    await vvvfs.delete("/home/user/Desktop/test.txt"); // 删除文件，返回true和false
-    if (await vvvfs.exists("/home/user/Desktop")) {
-        // 判断文件或目录是否存在
-    }
-    console.log(await vvvfs.list("/home/user/Desktop")); // 列出目录下的文件，返回string[] | null
-    if (await vvvfs.isDir("/home/user/Desktop")) {
-        // 判断是否为目录
-    }
-    if (await vvvfs.isFile("/home/user/Desktop/test.txt")) {
-        // 判断是否为文件
-    }
-    await vvvfs.rename("/home/user/Desktop/test.txt", "test2.txt"); // 重命名文件，返回true和false
-    await vvvfs.move("/home/user/Desktop/test2.txt", "/home/user/Desktop/test.txt"); // 移动文件，返回true和false
-    await vvvfs.copy("/home/user/Desktop/test.txt", "/home/user/Desktop/test2.txt"); // 复制文件，返回true和false
-    await vvvfs.search("/home/user/Desktop", "test.txt"); // 搜索文件，返回string[] | null
+  await vvvfs.reset(); // 重置文件系统
+  await vvvfs.init("UserName"); // 初始化文件系统
+  vvvfs.watch("/home/user/Desktop/test.txt", (type) => {
+    console.log(type); // 打印文件操作的类型
+    return true; // 返回true或false，表示是否取消该操作
+  });
+  await vvvfs.lock("/home/user/Desktop/test.txt"); // 锁定文件，防止其他代码访问该文件
+  await vvvfs.unlock("/home/user/Desktop/test.txt"); // 解锁文件
+  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
+  await vvvfs.appendText("/home/user/Desktop/test.txt", "Hello World!"); // 追加文本文件，返回true和false
+  console.log(await vvvfs.readText("/home/user/Desktop/test.txt")); // 读取文本文件，读取文件还包括read(path: string): Blob | null和readJson(path: string): Record<string, any> | null方法
+  console.log(await vvvfs.readChunkText("/home/user/Desktop/test.txt", 0, 5)); // 读取文件块，返回string | null
+  await vvvfs.delete("/home/user/Desktop/test.txt"); // 删除文件，返回true和false
+  if (await vvvfs.exists("/home/user/Desktop")) {
+    // 判断文件或目录是否存在
+  }
+  console.log(await vvvfs.list("/home/user/Desktop")); // 列出目录下的文件，返回string[] | null
+  if (await vvvfs.isDir("/home/user/Desktop")) {
+    // 判断是否为目录
+  }
+  if (await vvvfs.isFile("/home/user/Desktop/test.txt")) {
+    // 判断是否为文件
+  }
+  await vvvfs.rename("/home/user/Desktop/test.txt", "test2.txt"); // 重命名文件，返回true和false
+  await vvvfs.move(
+    "/home/user/Desktop/test2.txt",
+    "/home/user/Desktop/test.txt",
+  ); // 移动文件，返回true和false
+  await vvvfs.copy(
+    "/home/user/Desktop/test.txt",
+    "/home/user/Desktop/test2.txt",
+  ); // 复制文件，返回true和false
+  await vvvfs.search("/home/user/Desktop", "test.txt"); // 搜索文件，返回string[] | null
 })();
 ```
 
@@ -75,17 +81,25 @@ const vvvfs = new VVVFS("vvvfs", {
 
 ```javascript
 (async function () {
-    const file = new VVVFS.File("/home/user/Desktop/test.txt");
-    // file.options.throwError = true;
-    await file.writeText("Hello World!");
-    console.log(await file.readText());
-    await file.delete();
+  const file = new VVVFS.File("/home/user/Desktop/test.txt");
+  // file.options.throwError = true;
+  await file.writeText("Hello World!");
+  console.log(await file.readText());
+  await file.delete();
 })();
 // 用法与 vvvfs 相当
 ```
 
 ## 更新日志
 
+### 0.1.6
+
+- 新增 `VVVFS.path` ，用法与 NodeJS 的 `path` 模块类似。
+
+### 0.1.5
+
+- 重新 `lock` 和 `unlock` 方法
+
 ### 0.1.4
 
 - 使用 AI 优化代码
@@ -145,3 +159,169 @@ const vvvfs = new VVVFS("vvvfs", {
 ### 0.0.1
 
 - 发布正式版
+
+---
+
+# English
+
+# VVVFS
+
+A lightweight and simple Linux virtual file system in the browser, based on IndexedDB, built with Dexie.js
+
+## Quick Start
+
+1. Install the dependency
+
+```bash
+npm install vvvfs
+```
+
+2. Import
+
+```javascript
+import VVVFS from "vvvfs"; // ES6
+```
+
+```javascript
+const VVVFS = require("vvvfs"); // CommonJS
+```
+
+```html
+<script src="dist/vvvfs.min.js"></script>
+<script src="https://cdn.jsdelivr.net/npm/vvvfs@latest/dist/vvvfs.min.js"></script>
+<script src="https://unpkg.com/vvvfs@latest/dist/vvvfs.min.js"></script>
+<!-- Browser -->
+```
+
+3. Initialize
+
+```javascript
+const vvvfs = new VVVFS("vvvfs", {
+  throwError: true, // When set to true, failed file operations throw an error instead of returning false
+}); // Create a virtual file system named vvvfs
+```
+
+4. Usage
+
+```javascript
+// All operations are asynchronous
+(async function () {
+  await vvvfs.reset(); // Reset the file system
+  await vvvfs.init("UserName"); // Initialize the file system
+  vvvfs.watch("/home/user/Desktop/test.txt", (type) => {
+    console.log(type); // Log the type of the file operation
+    return true; // Return true or false to indicate whether to cancel the operation
+  });
+  await vvvfs.lock("/home/user/Desktop/test.txt"); // Lock the file to prevent other code from accessing it
+  await vvvfs.unlock("/home/user/Desktop/test.txt"); // Unlock the file
+  await vvvfs.createDir("/home/user/Desktop"); // Create a directory, returns true and false
+  await vvvfs.writeText("/home/user/Desktop/test.txt", "Hello World!"); // Write a text file. Writing also includes write(path: string, content: Blob) and writeJson(path: string, content: Record<string, any>), returns true and false
+  await vvvfs.appendText("/home/user/Desktop/test.txt", "Hello World!"); // Append text to a file, returns true and false
+  console.log(await vvvfs.readText("/home/user/Desktop/test.txt")); // Read a text file. Reading also includes read(path: string): Blob | null and readJson(path: string): Record<string, any> | null
+  console.log(await vvvfs.readChunkText("/home/user/Desktop/test.txt", 0, 5)); // Read a file chunk, returns string | null
+  await vvvfs.delete("/home/user/Desktop/test.txt"); // Delete a file, returns true and false
+  if (await vvvfs.exists("/home/user/Desktop")) {
+    // Check whether a file or directory exists
+  }
+  console.log(await vvvfs.list("/home/user/Desktop")); // List the files in a directory, returns string[] | null
+  if (await vvvfs.isDir("/home/user/Desktop")) {
+    // Check whether it is a directory
+  }
+  if (await vvvfs.isFile("/home/user/Desktop/test.txt")) {
+    // Check whether it is a file
+  }
+  await vvvfs.rename("/home/user/Desktop/test.txt", "test2.txt"); // Rename a file, returns true and false
+  await vvvfs.move(
+    "/home/user/Desktop/test2.txt",
+    "/home/user/Desktop/test.txt",
+  ); // Move a file, returns true and false
+  await vvvfs.copy(
+    "/home/user/Desktop/test.txt",
+    "/home/user/Desktop/test2.txt",
+  ); // Copy a file, returns true and false
+  await vvvfs.search("/home/user/Desktop", "test.txt"); // Search for files, returns string[] | null
+})();
+```
+
+Using the `VVVFS.File` class:
+
+```javascript
+(async function () {
+  const file = new VVVFS.File("/home/user/Desktop/test.txt");
+  // file.options.throwError = true;
+  await file.writeText("Hello World!");
+  console.log(await file.readText());
+  await file.delete();
+})();
+// The usage is equivalent to vvvfs
+```
+
+## Changelog
+
+### 0.1.6
+
+- Added `VVVFS.path`, which works in a similar way to the `path` module in NodeJS.
+
+### 0.1.5
+
+- Redesigned the `lock` and `unlock` methods
+
+### 0.1.4
+
+- Optimized the code with AI
+
+### 0.1.3
+
+- Added the `lock` and `unlock` methods, which can lock files to prevent other code from accessing them
+
+### 0.1.2
+
+- Added the `readChunk` and `readChunkText` methods for reading file chunks
+
+### 0.1.1
+
+- Added the `append` and `appendText` methods for appending content
+
+### 0.1.0
+
+- Fixed `init` rewriting existing files and directories when initialized repeatedly
+
+### 0.0.9
+
+- Updated the `watch` method: while watching, returning `true` cancels the operation
+
+### 0.0.8
+
+- Added the `watch` method (this is an experimental feature and may change in the future)
+
+### 0.0.7
+
+- Optimized a bit with AI
+
+### 0.0.6
+
+- Added the `dbname` and `options` properties to the `VVVFS.File` class
+- Added the `defaultDBName` property to `VVVFS`
+
+### 0.0.5
+
+- Added the `VVVFS.File` class
+
+### 0.0.4
+
+- Fixed IndexedDB spamming a bunch of warnings
+- Fixed a bug in `search`
+
+### 0.0.3
+
+- Added maximum length limits: 4096 characters for full paths and 255 characters for file names
+- Added the `init` method for initializing Linux files and directories
+- Fixed a bug where `list` returned an empty string (the root directory itself) in the array when listing the root directory
+
+### 0.0.2
+
+- Added the `throwError` option, which defaults to `false`
+
+### 0.0.1
+
+- Initial release

package/index.html

@@ -9,37 +9,7 @@
 </head>
 
 <body>
-    <script>
-        (async () => {
-            try {
-                globalThis.vvvfs = new VVVFS();
-                vvvfs.options.throwError = true;
-                await vvvfs.reset();
-                await vvvfs.init("IFTC");
-                console.log(vvvfs);
-                vvvfs.watch("/test.txt", (type) => {
-                    console.log(type);
-                    // return true;
-                });
-                console.log("创建文件", await vvvfs.createFile("/test.txt"));
-                console.log("写入文件", await vvvfs.writeText("/test.txt", "Hello World"));
-                console.log("追加文件", await vvvfs.appendText("/test.txt", " - Appended"));
-                // await vvvfs.lock("/test.txt");
-                console.log("文件是否存在", await vvvfs.exists("/test.txt"));
-                console.log("文件是否存在", await vvvfs.exists("/test2.txt"));
-                console.log("读取文件", await vvvfs.readText("/test.txt"));
-                console.log("读取文件块", await vvvfs.readTextChunk("/test.txt", 0, 5));
-                console.log("复制文件", await vvvfs.copy("/test.txt", "/test2.txt"));
-                console.log("搜索文件", await vvvfs.search("/", "t"));
-                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);
-            }
-        })();
-    </script>
+    <script src="index.js"></script>
 </body>
 
 </html>

package/index.js

@@ -0,0 +1,34 @@
+/// <reference path="./types/index.d.ts" />
+/**
+ * @class VVVFS
+ * @description VVVFS 虚拟文件系统
+ */
+(async () => {
+    try {
+        globalThis.vvvfs = new VVVFS();
+        vvvfs.options.throwError = true;
+        await vvvfs.reset();
+        await vvvfs.init("IFTC");
+        console.log(vvvfs);
+        vvvfs.watch("/test.txt", (type) => {
+            console.log(type);
+            // return true;
+        });
+        console.log("创建文件", await vvvfs.createFile("/test.txt"));
+        console.log("写入文件", await vvvfs.writeText("/test.txt", "Hello World"));
+        console.log("追加文件", await vvvfs.appendText("/test.txt", " - Appended"));
+        // await vvvfs.lock("/test.txt");
+        console.log("文件是否存在", await vvvfs.exists("/test.txt"));
+        console.log("文件是否存在", await vvvfs.exists("/test2.txt"));
+        console.log("读取文件", await vvvfs.readText("/test.txt"));
+        console.log("读取文件块", await vvvfs.readTextChunk("/test.txt", 0, 5));
+        console.log("复制文件", await vvvfs.copy("/test.txt", "/test2.txt"));
+        console.log("搜索文件", await vvvfs.search("/", "t"));
+        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

@@ -15,6 +15,7 @@ import mime from "mime";
  * @param path 文件路径
  * @param type 文件类型(file或dir)
  * @param file 文件对象
+ * @param locked 是否锁定
  */
 export interface FileRecord {
     id?: number;
@@ -22,6 +23,7 @@ export interface FileRecord {
     path: string;
     type: string;
     file: File | null;
+    locked?: boolean;
 }
 
 /**
@@ -264,6 +266,221 @@ class VVVFSFile {
     async unlock() {
         return await this._vvvfs.unlock(this._path);
     }
+    /**
+     * 判断文件是否已锁定
+     */
+    async isLocked() {
+        return await this._vvvfs.isLocked(this._path);
+    }
+}
+
+/**
+ * path类（类似于NodeJS中的path模块）
+ */
+class Path {
+    /**
+     * 路径分隔符
+     */
+    static readonly sep = "/";
+    /**
+     * 环境变量PATH的分隔符
+     */
+    static readonly delimiter = ":";
+    /**
+     * 内部存储的路径
+     */
+    private _path: string;
+    /**
+     * 构造函数
+     * @param paths 路径片段
+     */
+    constructor(...paths: string[]) {
+        this._path = Path.resolve(...paths);
+    }
+    /**
+     * 获取路径
+     */
+    get path() {
+        return this._path;
+    }
+    /**
+     * 设置路径
+     * @param path 路径
+     */
+    set path(path: string) {
+        this._path = Path.resolve(path);
+    }
+    /**
+     * 获取文件名
+     */
+    get name() {
+        return Path.basename(this._path);
+    }
+    /**
+     * 获取文件所在目录
+     */
+    get parent() {
+        return Path.dirname(this._path);
+    }
+    /**
+     * 获取文件扩展名
+     */
+    get ext() {
+        return Path.extname(this._path);
+    }
+    /**
+     * 获取根目录（"/"或""）
+     */
+    get root() {
+        return Path.parse(this._path).root;
+    }
+    /**
+     * 判断路径是否为绝对路径
+     */
+    isAbsolute() {
+        return Path.isAbsolute(this._path);
+    }
+    /**
+     * 合并路径
+     * @param paths 路径片段
+     */
+    join(...paths: string[]) {
+        return Path.join(this._path, ...paths);
+    }
+    /**
+     * 转换为字符串
+     */
+    toString() {
+        return this._path;
+    }
+    /**
+     * 合并路径
+     * @param paths 路径片段
+     */
+    static join(...paths: string[]) {
+        return joinPath(...paths);
+    }
+    /**
+     * 解析路径为绝对路径
+     * @param paths 路径片段
+     */
+    static resolve(...paths: string[]) {
+        return paths.length === 0 ? "/" : joinPath(...paths);
+    }
+    /**
+     * 规范化路径（清除"."、解析".."）
+     * @param path 路径
+     */
+    static normalize(path: string) {
+        if (path.length === 0) return ".";
+        const isAbsolute = path.startsWith("/");
+        const trailingSlash = path.length > 1 && path.endsWith("/");
+        const stack: string[] = [];
+        for (const part of path.split("/")) {
+            if (part === "" || part === ".") {
+                continue;
+            } else if (part === "..") {
+                if (stack.length > 0 && stack[stack.length - 1] !== "..") {
+                    stack.pop();
+                } else if (!isAbsolute) {
+                    stack.push("..");
+                }
+            } else {
+                stack.push(part);
+            }
+        }
+        let result = stack.join("/");
+        if (isAbsolute) {
+            result = "/" + result;
+        } else if (result.length === 0) {
+            result = ".";
+        }
+        if (trailingSlash && result !== "/" && result !== "." && !result.endsWith("/")) {
+            result += "/";
+        }
+        return result;
+    }
+    /**
+     * 判断路径是否为绝对路径
+     * @param path 路径
+     */
+    static isAbsolute(path: string) {
+        return path.length > 0 && path.startsWith("/");
+    }
+    /**
+     * 获取文件名（可去除后缀）
+     * @param path 路径
+     * @param suffix 后缀（如扩展名）
+     */
+    static basename(path: string, suffix?: string) {
+        if (path.length === 0) return "";
+        const normalized = Path.normalize(path);
+        if (normalized === "/") return "/";
+        let base = normalized.endsWith("/") ? normalized.slice(0, -1) : normalized;
+        base = base.slice(base.lastIndexOf("/") + 1);
+        if (suffix && base !== suffix && base.endsWith(suffix)) {
+            base = base.slice(0, base.length - suffix.length);
+        }
+        return base;
+    }
+    /**
+     * 获取文件所在目录
+     * @param path 路径
+     */
+    static dirname(path: string) {
+        const normalized = Path.normalize(path);
+        if (normalized === "/" || normalized === ".") return normalized;
+        const parts = normalized.split("/");
+        parts.pop();
+        const result = parts.join("/");
+        if (result.length === 0) {
+            return Path.isAbsolute(normalized) ? "/" : ".";
+        }
+        return result;
+    }
+    /**
+     * 获取文件扩展名
+     * @param path 路径
+     */
+    static extname(path: string) {
+        const base = Path.basename(path);
+        const lastDot = base.lastIndexOf(".");
+        if (lastDot <= 0) return "";
+        return base.slice(lastDot);
+    }
+    /**
+     * 解析路径
+     * @param path 路径
+     */
+    static parse(path: string) {
+        const base = Path.basename(path);
+        const ext = Path.extname(base);
+        return {
+            root: Path.isAbsolute(path) ? "/" : "",
+            dir: Path.dirname(path),
+            base,
+            ext,
+            name: ext.length > 0 ? base.slice(0, base.length - ext.length) : base,
+        };
+    }
+    /**
+     * 计算从from到to的相对路径
+     * @param from 起始路径
+     * @param to 目标路径
+     */
+    static relative(from: string, to: string) {
+        const fromParts = Path.resolve(from).split("/").filter((part) => part.length > 0);
+        const toParts = Path.resolve(to).split("/").filter((part) => part.length > 0);
+        let i = 0;
+        while (i < fromParts.length && i < toParts.length && fromParts[i] === toParts[i]) {
+            i++;
+        }
+        const up = new Array<string>(Math.max(0, fromParts.length - i)).fill("..").join("/");
+        const down = toParts.slice(i).join("/");
+        if (up.length > 0 && down.length > 0) return up + "/" + down;
+        if (up.length > 0) return up;
+        return down;
+    }
 }
 
 const version = packageJson.version;
@@ -281,13 +498,13 @@ class VVVFS {
      */
     static File = VVVFSFile;
     /**
-     * 虚拟文件系统监听器
+     * path类（类似于NodeJS中的path模块）
      */
-    #watchers: Record<string, Array<(type: string) => Promise<boolean>>> = {};
+    static path = Path;
     /**
-     * 锁定的文件
+     * 虚拟文件系统监听器
      */
-    #lockedFiles: Record<string, boolean> = {};
+    #watchers: Record<string, Array<(type: string) => Promise<boolean>>> = {};
 
     /**
      * 检查文件访问权限（监听器和锁定状态）
@@ -309,7 +526,7 @@ class VVVFS {
                 }
             }
         }
-        if (this.#lockedFiles[path]) {
+        if (await this.#isLocked(path)) {
             if (this.options.throwError) {
                 throw new VVVFSError(
                     operation.charAt(0).toUpperCase() + operation.slice(1),
@@ -321,6 +538,15 @@ class VVVFS {
         return true;
     }
 
+    /**
+     * 内部判断是否锁定（跳过错误包装）
+     */
+    async #isLocked(path: string): Promise<boolean> {
+        const { name, parent } = parsePath(path);
+        const fileRecord = await this.#db.files.where({ name, path: parent }).first();
+        return !!fileRecord?.locked;
+    }
+
     /**
      * 错误处理包装器
      * @param operation 操作名称
@@ -364,6 +590,15 @@ class VVVFS {
             this.#db.version(1).stores({
                 files: "++id, name, path, type, file, [name+path+type]",
             });
+            this.#db.version(2).stores({
+                files: "++id, name, path, type, file, locked, [name+path+type]",
+            }).upgrade(async (tx) => {
+                await tx.table("files").toCollection().modify((file: FileRecord) => {
+                    if (file.locked === undefined) {
+                        file.locked = false;
+                    }
+                });
+            });
         } catch (error) {
             console.error("创建数据库失败", error);
             throw new VVVFSError("CreateDatabase", "创建数据库失败");
@@ -384,12 +619,14 @@ class VVVFS {
             path: "/",
             type: "dir" as const,
             file: new File([], name),
+            locked: false,
         }));
         linuxInitFiles.push({
             name: user || "root",
             path: "/home",
             type: "dir" as const,
             file: new File([], "home"),
+            locked: false,
         });
         try {
             for (const file of linuxInitFiles) {
@@ -411,6 +648,9 @@ class VVVFS {
             this.#db.version(1).stores({
                 files: "++id, name, path, type, file, [name+path+type]",
             });
+            this.#db.version(2).stores({
+                files: "++id, name, path, type, file, locked, [name+path+type]",
+            });
         } catch (error) {
             console.error("重置数据库失败", error);
             throw new VVVFSError("ResetDatabase", "重置数据库失败" + error);
@@ -439,6 +679,7 @@ class VVVFS {
                 file: new File([], name, {
                     type: mime.getType(targetPath) || "application/octet-stream",
                 }),
+                locked: false,
             });
             return true;
         }, false);
@@ -463,6 +704,7 @@ class VVVFS {
                         path: "/",
                         type: "dir",
                         file: new File([], ""),
+                        locked: false,
                     });
                     if (name === "") return true;
                 } else {
@@ -474,6 +716,7 @@ class VVVFS {
                 path: parent,
                 type: "dir",
                 file: new File([], name),
+                locked: false,
             });
             return true;
         }, false);
@@ -862,6 +1105,7 @@ class VVVFS {
                     path: newParent,
                     type: fileRecord.type,
                     file: fileRecord.file,
+                    locked: false,
                 });
                 return true;
             }
@@ -922,16 +1166,22 @@ class VVVFS {
      */
     async lock(path: string) {
         return this.#withErrorHandling("lock", async () => {
-            path = joinPath(path);
-            if (!(await this.exists(path))) {
+            const targetPath = joinPath(path);
+            if (!(await this.exists(targetPath))) {
                 console.warn("文件不存在");
                 return false;
             }
-            if (this.#lockedFiles[path]) {
+            if (await this.#isLocked(targetPath)) {
                 console.warn("文件已被锁定");
                 return false;
             }
-            this.#lockedFiles[path] = true;
+            const { name, parent } = parsePath(targetPath);
+            const fileRecord = await this.#db.files.where({ name, path: parent }).first();
+            if (!fileRecord?.id) {
+                console.warn("文件记录未找到");
+                return false;
+            }
+            await this.#db.files.update(fileRecord.id, { locked: true });
             return true;
         }, false);
     }
@@ -941,19 +1191,38 @@ class VVVFS {
      */
     async unlock(path: string) {
         return this.#withErrorHandling("unlock", async () => {
-            path = joinPath(path);
-            if (!(await this.exists(path))) {
+            const targetPath = joinPath(path);
+            if (!(await this.exists(targetPath))) {
                 console.warn("文件不存在");
                 return false;
             }
-            if (!this.#lockedFiles[path]) {
+            if (!(await this.#isLocked(targetPath))) {
                 console.warn("文件未被锁定");
                 return false;
             }
-            delete this.#lockedFiles[path];
+            const { name, parent } = parsePath(targetPath);
+            const fileRecord = await this.#db.files.where({ name, path: parent }).first();
+            if (!fileRecord?.id) {
+                console.warn("文件记录未找到");
+                return false;
+            }
+            await this.#db.files.update(fileRecord.id, { locked: false });
             return true;
         }, false);
     }
+    /**
+     * 判断文件是否已锁定
+     * @param path 文件路径
+     */
+    async isLocked(path: string) {
+        return this.#withErrorHandling("isLocked", async () => {
+            const targetPath = joinPath(path);
+            if (!(await this.exists(targetPath))) {
+                return false;
+            }
+            return await this.#isLocked(targetPath);
+        }, false);
+    }
 }
 /**
  * 解析路径

package/package.json

@@ -1,33 +1,33 @@
-{
-  "name": "vvvfs",
-  "version": "0.1.4",
-  "description": "一个使用IndexDB实现的虚拟文件系统",
-  "keywords": [
-    "Virtual",
-    "File",
-    "System",
-    "IFTC",
-    "VV",
-    "File",
-    "System",
-    "vfs",
-    "fs"
-  ],
-  "license": "MIT",
-  "author": "IFTC",
-  "type": "module",
-  "main": "index.js",
-  "scripts": {
-    "test": "echo \"Error: no test specified\" && exit 1",
-    "build": "node esbuild.config.js"
-  },
-  "dependencies": {
-    "dexie": "^4.3.0",
-    "esbuild": "^0.27.3",
-    "mime": "^4.1.0"
-  },
-  "repository": {
-    "type": "git",
-    "url": "https://github.com/IFTC-XLKJ/vvvfs.git"
-  }
-}
+{
+  "name": "vvvfs",
+  "version": "0.1.6",
+  "description": "一个使用IndexDB实现的虚拟文件系统",
+  "keywords": [
+    "Virtual",
+    "File",
+    "System",
+    "IFTC",
+    "VV",
+    "File",
+    "System",
+    "vfs",
+    "fs"
+  ],
+  "license": "MIT",
+  "author": "IFTC",
+  "type": "module",
+  "main": "index.js",
+  "scripts": {
+    "test": "echo \"Error: no test specified\" && exit 1",
+    "build": "node esbuild.config.js"
+  },
+  "dependencies": {
+    "dexie": "^4.3.0",
+    "esbuild": "^0.27.3",
+    "mime": "^4.1.0"
+  },
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/IFTC-XLKJ/vvvfs.git"
+  }
+}

package/types/index.d.ts

@@ -0,0 +1,504 @@
+import { Dexie, Table } from "dexie";
+
+/**
+ * 虚拟文件系统
+ */
+declare global {
+    // 扩展 Window 接口
+    interface window {
+        VVVFS: typeof VVVFS; // 如果 VVFS 是个类，这里可能需要调整，或者直接定义 vvfs 实例
+    }
+
+    // 扩展 GlobalThis (针对你在 index.js 里的 globalThis.vvfs 写法)
+    // 注意：GlobalThis 和 Window 往往指向同一个对象，但在 TS 类型中有时需要分别处理
+    // var VVVFS: typeof VVVFS; 
+}
+
+
+/**
+ * 文件记录
+ * @param id 文件id
+ * @param name 文件名
+ * @param path 文件路径
+ * @param type 文件类型(file或dir)
+ * @param file 文件对象
+ * @param locked 是否锁定
+ */
+declare interface FileRecord {
+    id?: number;
+    name: string;
+    path: string;
+    type: string;
+    file: File | null;
+    locked?: boolean;
+}
+
+/**
+ * 虚拟文件系统数据库
+ * @param files 文件存储数据表
+ */
+declare interface VVVFSDatabase extends Dexie {
+    files: Table<FileRecord, number>;
+}
+
+/**
+ * 虚拟文件系统配置项
+ * @param throwError 是否抛出错误
+ */
+declare interface VVVFSOptions {
+    throwError: boolean;
+}
+
+/**
+ * 虚拟文件系统错误类
+ */
+declare class VVVFSError extends Error {
+    /**
+     * @param type 错误类型
+     * @param message 错误信息
+     */
+    constructor(type: string, message: string);
+}
+
+/**
+ * 虚拟文件系统文件类
+ * @param path 文件路径
+ */
+declare class VVVFSFile {
+    /**
+     * 获取文件路径
+     */
+    get path(): string;
+    /**
+     * 设置文件路径
+     * @param path 文件路径
+     */
+    set path(path: string);
+    /**
+     * 设置数据库名称
+     * @param dbname 数据库名称
+     */
+    set dbname(dbname: string);
+    /**
+     * 获取数据库名称
+     */
+    get dbname(): string;
+    set options(options: VVVFSOptions);
+    get options(): VVVFSOptions;
+
+    /**
+     * 构造函数
+     * @param paths 文件路径
+     */
+    constructor(...paths: string[]);
+
+    /**
+     * 读取文件
+     */
+    read(): Promise<File | null>;
+    /**
+     * 读取文件文本内容
+     */
+    readText(): Promise<string | null>;
+    /**
+     * 读取文件JSON内容
+     */
+    readJSON(): Promise<Record<string, unknown> | null>;
+    /**
+     * 读取文件内容
+     * @param start 起始位置
+     * @param end 结束位置
+     */
+    readChunk(start: number, end: number): Promise<Blob | null>;
+    /**
+     * 读取文件内容
+     * @param start 起始位置
+     * @param end 结束位置
+     */
+    readTextChunk(start: number, end: number): Promise<string | null>;
+    /**
+     * 写入文件
+     * @param file 文件对象
+     */
+    write(file: Blob): Promise<boolean>;
+    /**
+     * 写入文件文本内容
+     * @param text 文件文本内容
+     */
+    writeText(text: string): Promise<boolean>;
+    /**
+     * 写入文件JSON内容
+     * @param json 文件JSON内容
+     */
+    writeJSON(json: Record<string, unknown>, format?: boolean): Promise<boolean>;
+    /**
+     * 追加文件内容
+     * @param file 文件对象
+     */
+    append(file: Blob): Promise<boolean>;
+    /**
+     * 追加文件文本内容
+     * @param text 文件文本内容
+     */
+    appendText(text: string): Promise<boolean>;
+    /**
+     * 创建文件
+     */
+    createFile(): Promise<boolean>;
+    /**
+     * 创建文件夹
+     */
+    createDir(): Promise<boolean>;
+    /**
+     * 删除文件
+     */
+    delete(): Promise<boolean>;
+    /**
+     * 判断文件是否存在
+     */
+    exists(): Promise<boolean>;
+    /**
+     * 获取文件大小
+     */
+    isFile(): Promise<boolean>;
+    /**
+     * 判断文件是否是文件夹
+     */
+    isDir(): Promise<boolean>;
+    /**
+     * 列出文件
+     */
+    list(): Promise<string[]>;
+    /**
+     * 重命名文件
+     */
+    rename(newName: string): Promise<boolean>;
+    /**
+     * 移动文件
+     */
+    move(newPath: string): Promise<boolean>;
+    /**
+     * 复制文件
+     */
+    copy(newPath: string): Promise<boolean>;
+    /**
+     * 搜索文件
+     */
+    search(query: string): Promise<string[] | null>;
+    /**
+     * 监听文件
+     */
+    watch(handler: (type: string) => Promise<boolean>): void;
+    /**
+     * 锁定文件
+     */
+    lock(): Promise<boolean>;
+    /**
+     * 解锁文件
+     */
+    unlock(): Promise<boolean>;
+    /**
+     * 判断文件是否已锁定
+     */
+    isLocked(): Promise<boolean>;
+}
+
+/**
+ * path类（类似于NodeJS中的path模块）
+ */
+declare class Path {
+    /**
+     * 路径分隔符
+     */
+    static readonly sep: string;
+    /**
+     * 环境变量PATH的分隔符
+     */
+    static readonly delimiter: string;
+    /**
+     * 构造函数
+     * @param paths 路径片段
+     */
+    constructor(...paths: string[]);
+    /**
+     * 获取路径
+     */
+    get path(): string;
+    /**
+     * 设置路径
+     * @param path 路径
+     */
+    set path(path: string);
+    /**
+     * 获取文件名
+     */
+    get name(): string;
+    /**
+     * 获取文件所在目录
+     */
+    get parent(): string;
+    /**
+     * 获取文件扩展名
+     */
+    get ext(): string;
+    /**
+     * 获取根目录（"/"或""）
+     */
+    get root(): string;
+    /**
+     * 判断路径是否为绝对路径
+     */
+    isAbsolute(): boolean;
+    /**
+     * 合并路径
+     * @param paths 路径片段
+     */
+    join(...paths: string[]): string;
+    /**
+     * 转换为字符串
+     */
+    toString(): string;
+    /**
+     * 合并路径
+     * @param paths 路径片段
+     */
+    static join(...paths: string[]): string;
+    /**
+     * 解析路径为绝对路径
+     * @param paths 路径片段
+     */
+    static resolve(...paths: string[]): string;
+    /**
+     * 规范化路径（清除"."、解析".."）
+     * @param path 路径
+     */
+    static normalize(path: string): string;
+    /**
+     * 判断路径是否为绝对路径
+     * @param path 路径
+     */
+    static isAbsolute(path: string): boolean;
+    /**
+     * 获取文件名（可去除后缀）
+     * @param path 路径
+     * @param suffix 后缀（如扩展名）
+     */
+    static basename(path: string, suffix?: string): string;
+    /**
+     * 获取文件所在目录
+     * @param path 路径
+     */
+    static dirname(path: string): string;
+    /**
+     * 获取文件扩展名
+     * @param path 路径
+     */
+    static extname(path: string): string;
+    /**
+     * 解析路径
+     * @param path 路径
+     */
+    static parse(path: string): { root: string; dir: string; base: string; ext: string; name: string };
+    /**
+     * 计算从from到to的相对路径
+     * @param from 起始路径
+     * @param to 目标路径
+     */
+    static relative(from: string, to: string): string;
+}
+
+/**
+ * 虚拟文件系统
+ * @author IFTC
+ * @description 虚拟文件系统
+ */
+declare class VVVFS {
+    static defaultDBName: string;
+    /**
+     * 虚拟文件系统版本
+     */
+    static readonly version: string;
+    /**
+     * 虚拟文件系统作者
+     */
+    static readonly author: string;
+    /**
+     * 虚拟文件系统文件类
+     */
+    static File: typeof VVVFSFile;
+    /**
+     * path类（类似于NodeJS中的path模块）
+     */
+    static path: typeof Path;
+
+    options: VVVFSOptions;
+
+    /**
+     * 创建虚拟文件系统
+     * @param name 虚拟文件系统名称
+     * @param options 配置项
+     */
+    constructor(name?: string, options?: VVVFSOptions);
+
+    /**
+     * 初始化虚拟文件系统
+     * @description 将Linux的系统初始文件初始化到数据库中
+     */
+    init(user?: string): Promise<void>;
+    /**
+     * 重置虚拟文件系统
+     */
+    reset(): Promise<void>;
+    /**
+     * 创建文件
+     * @param path 文件路径
+     */
+    createFile(path: string): Promise<boolean>;
+    /**
+     * 创建目录
+     * @param path 目录路径
+     */
+    createDir(path: string): Promise<boolean>;
+    /**
+     * 判断文件是否存在
+     * @param path 文件路径
+     */
+    exists(path: string): Promise<boolean>;
+    /**
+     * 读取文件内容
+     * @param path 文件路径
+     */
+    read(path: string): Promise<File | null>;
+    /**
+     * 读取文件文本内容
+     * @param path 文件路径
+     */
+    readText(path: string): Promise<string | null>;
+    /**
+     * 读取JSON内容
+     * @param path 文件路径
+     */
+    readJson(path: string): Promise<Record<string, unknown> | null>;
+    /**
+     * 写入文件
+     * @param path 文件路径
+     * @param content 文件内容
+     */
+    write(path: string, content: Blob): Promise<boolean>;
+    /**
+     * 写入文本内容
+     * @param path 文件路径
+     * @param content 文本内容
+     */
+    writeText(path: string, content: string): Promise<boolean>;
+    /**
+     * 写入JSON内容
+     * @param path 文件路径
+     * @param content JSON内容
+     * @param format 是否格式化
+     */
+    writeJson(path: string, content: Record<string, unknown>, format?: boolean): Promise<boolean>;
+    /**
+     * 追加内容
+     * @param path 文件路径
+     * @param content 追加内容
+     */
+    append(path: string, content: Blob): Promise<boolean>;
+    /**
+     * 追加文本内容
+     * @param path 文件路径
+     * @param content 追加内容
+     */
+    appendText(path: string, content: string): Promise<boolean>;
+    /**
+     * 读取文件内容
+     * @param path 文件路径
+     * @param start 开始位置
+     * @param end 结束位置
+     */
+    readChunk(path: string, start: number, end: number): Promise<Blob | null>;
+    /**
+     * 读取文件内容
+     * @param path 文件路径
+     * @param start 读取开始位置
+     * @param end 读取结束位置
+     */
+    readTextChunk(path: string, start: number, end: number): Promise<string | null>;
+    /**
+     * 判断是否是文件
+     * @param path 文件路径
+     */
+    isFile(path: string): Promise<boolean>;
+    /**
+     * 判断是否是目录
+     * @param path 文件路径
+     */
+    isDir(path: string): Promise<boolean>;
+    /**
+     * 列出目录下的文件
+     * @param path 目录路径
+     */
+    list(path: string): Promise<string[]>;
+    /**
+     * 重命名文件
+     * @param path 文件路径
+     * @param newName 新文件名
+     */
+    rename(path: string, newName: string): Promise<boolean>;
+    /**
+     * 删除文件
+     * @param path 文件路径
+     */
+    delete(path: string): Promise<boolean>;
+    /**
+     * 移动文件
+     * @param path 文件路径
+     * @param newPath 新路径
+     */
+    move(path: string, newPath: string): Promise<boolean>;
+    /**
+     * 复制文件
+     * @param path 文件路径
+     * @param newPath 新路径
+     */
+    copy(path: string, newPath: string): Promise<boolean>;
+    /**
+     * 搜索文件
+     * @param basePath 基础路径
+     * @param query 查询字符串
+     */
+    search(basePath: string, query: string): Promise<string[] | null>;
+    /**
+     * 监听文件
+     * @param path 文件路径
+     * @param handler 监听器
+     */
+    watch(path: string, handler: (type: string) => Promise<boolean>): void;
+    /**
+     * 锁定文件
+     * @param path 文件路径
+     */
+    lock(path: string): Promise<boolean>;
+    /**
+     * 解锁文件
+     * @param path 文件路径
+     */
+    unlock(path: string): Promise<boolean>;
+    /**
+     * 判断文件是否已锁定
+     * @param path 文件路径
+     */
+    isLocked(path: string): Promise<boolean>;
+}
+
+/**
+ * 解析路径
+ * @param path 路径
+ */
+declare function parsePath(path: string): { name: string; parent: string };
+
+/**
+ * 合并路径
+ * @param paths 路径
+ */
+declare function joinPath(...paths: string[]): string;