opfs-mock 2.0.0 → 2.1.1

package/README.md

@@ -1,6 +1,7 @@
 # opfs-mock
 
-This is a pure JS in-memory implementation of the [origin private file system](https://developer.mozilla.org/en-US/docs/Web/API/File_System_API/Origin_private_file_system). Its main utility is for testing OPFS-dependent code in Node.js.
+In-memory implementation of the [origin private file system](https://developer.mozilla.org/en-US/docs/Web/API/File_System_API/Origin_private_file_system). Its main utility is for testing OPFS-dependent code in Node.js. It's tested
+on Node.js versions 20-23.
 
 ## Installation
 
@@ -8,6 +9,14 @@ This is a pure JS in-memory implementation of the [origin private file system](h
 npm install -save-dev opfs-mock
 ```
 
+## Limitations
+
+- `opfs-mock` requires **Node.js v20.0.0** or higher. It can work on Node v18.0.0 with either `--experimental-fetch` flag enabled or a global
+`File` polyfill.
+
+- `jsdom` testing environment is missing `File.prototype.text()` method, which is required for reading opfs files. Ensure your opfs-dependant tests are ran
+in `node` or `happy-dom` environment.
+
 ## Usage
 
 It replicates the behavior of origin private file system, except data is not persisted to disk.
@@ -31,14 +40,14 @@ test('Your test', async () => {
 });
 ```
 
-`storageFactory` has predefined `quota` and `estimate` values set to `0`, which is fine if you're not using these properties.
+`storageFactory` has `quota` and `usage` values set to `1024 ** 3 (1 GB)` and `0` respectively. When calling `storage.estimate()`, `usage` is dynamically calculated by summing the predefined usage value and any additional computed storage consumption.
 In case you need specific values, you can pass both as arguments to `storageFactory`.
 
 ```ts
 import { storageFactory } from "opfs-mock";
 
 test('Your test', async () => {
-  const storage = await storageFactory({ quota: 1_000_000, estimate: 1_000 });
+  const storage = await storageFactory({ quota: 1_000_000, usage: 1_000 });
   const root = await storage.getDirectory();
   const directoryHandle = await root.getFileHandle('test-file.txt', { create: true });
   // rest of your test

package/dist/index.js

@@ -1,3 +1,23 @@
+// src/utils.ts
+var isFileHandle = (handle) => {
+  return handle.kind === "file";
+};
+var isDirectoryHandle = (handle) => {
+  return handle.kind === "directory";
+};
+var getSizeOfDirectory = async (directory) => {
+  let totalSize = 0;
+  for await (const handle of directory.values()) {
+    if (isFileHandle(handle)) {
+      const file = await handle.getFile();
+      totalSize += file.size;
+    } else if (isDirectoryHandle(handle)) {
+      totalSize += await getSizeOfDirectory(handle);
+    }
+  }
+  return totalSize;
+};
+
 // src/opfs.ts
 var fileSystemFileHandleFactory = (name, fileData) => {
   return {
@@ -7,18 +27,28 @@ var fileSystemFileHandleFactory = (name, fileData) => {
       return other.name === name && other.kind === "file";
     },
     getFile: async () => new File([fileData.content], name),
-    createWritable: async (_options) => {
-      let newContent = "";
-      let cursorPosition = 0;
-      let aborted = false;
-      let closed = false;
-      const locked = false;
+    createWritable: async (options) => {
+      const keepExistingData = options?.keepExistingData;
+      let abortReason = "";
+      let isAborted = false;
+      let isClosed = false;
+      let content = keepExistingData ? fileData.content : "";
+      let cursorPosition = keepExistingData ? fileData.content.length : 0;
       const writableStream = new WritableStream({
-        write: async (chunk) => {
-          if (aborted) {
-            throw new DOMException("Write operation aborted", "AbortError");
+        write: () => {
+        },
+        close: () => {
+        },
+        abort: () => {
+        }
+      });
+      return Object.assign(writableStream, {
+        getWriter: () => writableStream.getWriter(),
+        write: async function(chunk) {
+          if (isAborted) {
+            throw new Error(abortReason);
           }
-          if (closed) {
+          if (isClosed) {
             throw new TypeError("Cannot write to a CLOSED writable stream");
           }
           if (chunk === void 0) {
@@ -55,78 +85,95 @@ var fileSystemFileHandleFactory = (name, fileData) => {
           } else {
             throw new TypeError("Invalid data type written to the file. Data must be of type FileSystemWriteChunkType.");
           }
-          newContent = newContent.slice(0, cursorPosition) + chunkText + newContent.slice(cursorPosition + chunkText.length);
+          content = content.slice(0, cursorPosition) + chunkText + content.slice(cursorPosition + chunkText.length);
           cursorPosition += chunkText.length;
         },
-        close: async () => {
-          if (aborted) {
-            throw new DOMException("Stream has been aborted", "AbortError");
+        close: async function() {
+          if (isClosed) {
+            throw new TypeError("Cannot close a CLOSED writable stream");
           }
-          closed = true;
-          fileData.content = newContent;
+          if (isAborted) {
+            throw new TypeError("Cannot close a ERRORED writable stream");
+          }
+          isClosed = true;
+          fileData.content = content;
         },
-        abort: (reason) => {
-          if (aborted) {
-            return Promise.reject(new TypeError("Cannot abort an already aborted writable stream"));
+        abort: async function(reason) {
+          if (isAborted) {
+            return;
           }
-          if (locked) {
-            return Promise.reject(new TypeError("Cannot abort a locked writable stream"));
+          if (reason && !abortReason) {
+            abortReason = reason;
           }
-          aborted = true;
-          return Promise.resolve(reason);
-        }
-      });
-      const writer = writableStream.getWriter();
-      return Object.assign(writer, {
-        locked: false,
-        truncate: async (size) => {
+          isAborted = true;
+          return Promise.resolve(void 0);
+        },
+        truncate: async function(size) {
           if (size < 0) {
             throw new DOMException("Invalid truncate size", "IndexSizeError");
           }
-          if (size < newContent.length) {
-            newContent = newContent.slice(0, size);
+          if (size < content.length) {
+            content = content.slice(0, size);
           } else {
-            newContent = newContent.padEnd(size, "\0");
+            content = content.padEnd(size, "\0");
           }
           cursorPosition = Math.min(cursorPosition, size);
         },
-        getWriter: () => writer,
-        seek: async (position) => {
-          if (position < 0 || position > newContent.length) {
+        seek: async function(position) {
+          if (position < 0 || position > content.length) {
             throw new DOMException("Invalid seek position", "IndexSizeError");
           }
           cursorPosition = position;
         }
       });
     },
-    createSyncAccessHandle: async () => ({
-      getSize: () => fileData.content.length,
-      read: (buffer, { at = 0 } = {}) => {
-        const text = new TextEncoder().encode(fileData.content);
-        const bytesRead = Math.min(buffer.length, text.length - at);
-        buffer.set(text.subarray(at, at + bytesRead));
-        return bytesRead;
-      },
-      write: (data, { at = 0 } = {}) => {
-        const newContent = new TextDecoder().decode(data);
-        const originalLength = fileData.content.length;
-        if (at < originalLength) {
-          fileData.content = fileData.content.slice(0, at) + newContent + fileData.content.slice(at + newContent.length);
-        } else {
-          fileData.content += newContent;
+    createSyncAccessHandle: async () => {
+      let closed = false;
+      return {
+        getSize: () => {
+          if (closed) {
+            throw new DOMException("InvalidStateError", "The access handle is closed");
+          }
+          return fileData.content.length;
+        },
+        read: (buffer, { at = 0 } = {}) => {
+          if (closed) {
+            throw new DOMException("InvalidStateError", "The access handle is closed");
+          }
+          const text = new TextEncoder().encode(fileData.content);
+          const bytesRead = Math.min(buffer.length, text.length - at);
+          buffer.set(text.subarray(at, at + bytesRead));
+          return bytesRead;
+        },
+        write: (data, options) => {
+          const at = options?.at ?? 0;
+          if (closed) {
+            throw new DOMException("InvalidStateError", "The access handle is closed");
+          }
+          const newContent = new TextDecoder().decode(data);
+          if (at < fileData.content.length) {
+            fileData.content = fileData.content.slice(0, at) + newContent + fileData.content.slice(at + newContent.length);
+          } else {
+            fileData.content += newContent;
+          }
+          return data.byteLength;
+        },
+        truncate: (size) => {
+          if (closed) {
+            throw new DOMException("InvalidStateError", "The access handle is closed");
+          }
+          fileData.content = fileData.content.slice(0, size);
+        },
+        flush: async () => {
+          if (closed) {
+            throw new DOMException("InvalidStateError", "The access handle is closed");
+          }
+        },
+        close: async () => {
+          closed = true;
         }
-        return data.byteLength;
-      },
-      // Flush is a no-op in memory
-      flush: async () => {
-      },
-      // Close is a no-op in memory
-      close: async () => {
-      },
-      truncate: async (size) => {
-        fileData.content = fileData.content.slice(0, size);
-      }
-    })
+      };
+    }
   };
 };
 var fileSystemDirectoryHandleFactory = (name) => {
@@ -147,7 +194,7 @@ var fileSystemDirectoryHandleFactory = (name) => {
       }
       const fileHandle = files.get(fileName);
       if (!fileHandle) {
-        throw new Error(`File not found: ${fileName}`);
+        throw new DOMException(`File not found: ${fileName}`, "NotFoundError");
       }
       return fileHandle;
     },
@@ -157,18 +204,29 @@ var fileSystemDirectoryHandleFactory = (name) => {
       }
       const directoryHandle = directories.get(dirName);
       if (!directoryHandle) {
-        throw new Error(`Directory not found: ${dirName}`);
+        throw new DOMException(`Directory not found: ${dirName}`, "NotFoundError");
       }
       return directoryHandle;
     },
-    removeEntry: async (entryName) => {
+    removeEntry: async (entryName, options) => {
       if (files.has(entryName)) {
         files.delete(entryName);
       } else if (directories.has(entryName)) {
-        directories.delete(entryName);
+        if (options?.recursive) {
+          directories.delete(entryName);
+        } else {
+          throw new DOMException(`Failed to remove directory: $1${entryName}`, "InvalidModificationError");
+        }
       } else {
-        throw new Error(`Entry not found: ${entryName}`);
+        throw new DOMException(`No such file or directory: $1${entryName}`, "NotFoundError");
+      }
+    },
+    [Symbol.asyncIterator]: async function* () {
+      const entries = getJoinedMaps();
+      for (const [name2, handle] of entries) {
+        yield [name2, handle];
       }
+      return void 0;
     },
     entries: async function* () {
       const joinedMaps = getJoinedMaps();
@@ -182,19 +240,18 @@ var fileSystemDirectoryHandleFactory = (name) => {
       const joinedMaps = getJoinedMaps();
       yield* joinedMaps.values();
     },
-    resolve: async (possibleDescendant) => {
+    resolve: async function(possibleDescendant) {
       const traverseDirectory = async (directory, target, path = []) => {
         if (await directory.isSameEntry(target)) {
           return path;
         }
         for await (const [name2, handle] of directory.entries()) {
-          if (handle.kind === "directory") {
-            const subDirectory = handle;
-            const result = await traverseDirectory(subDirectory, target, [...path, name2]);
+          if (isDirectoryHandle(handle)) {
+            const result = await traverseDirectory(handle, target, [...path, name2]);
             if (result) {
               return result;
             }
-          } else if (handle.kind === "file") {
+          } else if (isFileHandle(handle)) {
             if (await handle.isSameEntry(target)) {
               return [...path, name2];
             }
@@ -202,18 +259,20 @@ var fileSystemDirectoryHandleFactory = (name) => {
         }
         return null;
       };
-      return traverseDirectory(void 0, possibleDescendant);
+      return traverseDirectory(this, possibleDescendant);
     }
   };
 };
 
 // src/index.ts
-var storageFactory = ({ usage = 0, quota = 0 } = {}) => {
+var storageFactory = ({ usage = 0, quota = 1024 ** 3 } = {}) => {
   const root = fileSystemDirectoryHandleFactory("root");
   return {
     estimate: async () => {
+      const defaultUsage = usage;
+      const calculatedUsage = await getSizeOfDirectory(root);
       return {
-        usage,
+        usage: defaultUsage + calculatedUsage,
         quota
       };
     },

package/package.json

@@ -1,11 +1,11 @@
 {
   "name": "opfs-mock",
-  "version": "2.0.0",
+  "version": "2.1.1",
   "type": "module",
   "description": "Mock all origin private file system APIs for your Jest or Vitest tests",
   "author": "Jure Rotar <hello@jurerotar.com>",
   "license": "MIT",
-  "homepage": "https://github.com/jurerotar/opfs-mock#README",
+  "homepage": "https://github.com/jurerotar/opfs-mock#readme",
   "repository": {
     "type": "git",
     "url": "git+https://github.com/jurerotar/opfs-mock.git"
@@ -26,6 +26,9 @@
   "main": "dist/index.js",
   "module": "dist/index.js",
   "files": ["dist"],
+  "engines": {
+    "node": ">=20.0.0"
+  },
   "scripts": {
     "dev": "tsup --watch",
     "build": "tsup",
@@ -34,14 +37,20 @@
     "format:check": "npx @biomejs/biome format",
     "format": "npx @biomejs/biome format --write",
     "type-check": "tsc --noEmit",
-    "test": "vitest",
+    "test": "npm run test:node && npm run test:happy-dom",
+    "test:node": "vitest --environment=node",
+    "test:jsdom": "vitest --environment=jsdom",
+    "test:happy-dom": "vitest --environment=happy-dom",
     "prepublishOnly": "npm run build",
     "release": "npm publish --access public"
   },
   "devDependencies": {
     "@biomejs/biome": "1.9.4",
-    "tsup": "8.3.6",
-    "typescript": "5.7.3",
-    "vitest": "3.0.6"
+    "@web-std/file": "3.0.3",
+    "happy-dom": "17.4.4",
+    "jsdom": "26.0.0",
+    "tsup": "8.4.0",
+    "typescript": "5.8.2",
+    "vitest": "3.0.9"
   }
 }