opfs-mock 1.0.2 → 2.1.0

package/LICENSE.md

@@ -1,21 +1,21 @@
-The MIT License (MIT)
-
-Copyright © 2024 Jure Rotar
-
-Permission is hereby granted, free of charge, to any person obtaining a copy
-of this software and associated documentation files (the "Software"), to deal
-in the Software without restriction, including without limitation the rights
-to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
-copies of the Software, and to permit persons to whom the Software is
-furnished to do so, subject to the following conditions:
-
-The above copyright notice and this permission notice shall be included in all
-copies or substantial portions of the Software.
-
-THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
-IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
-FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
-AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
-LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
-OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
-SOFTWARE
+The MIT License (MIT)
+
+Copyright © 2024 Jure Rotar
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE

package/README.md

@@ -1,159 +1,159 @@
-# 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.
-
-## Installation
-
-```shell
-npm install -save-dev opfs-mock
-```
-
-## Usage
-
-It replicates the behavior of origin private file system, except data is not persisted to disk.
-
-The easiest way to use it is to import `opfs-mock`, which will polyfill OPFS API to global scope.
-
-```ts
-import "opfs-mock";
-```
-
-Alternatively, you can explicitly import `storageFactory`:
-
-```ts
-import { storageFactory } from "opfs-mock";
-
-test('Your test', async () => {
-  const storage = await storageFactory();
-  const root = await storage.getDirectory();
-  const directoryHandle = await root.getFileHandle('test-file.txt', { create: true });
-  // rest of your test
-});
-```
-
-`storageFactory` has predefined `quota` and `estimate` values set to `0`, which is fine if you're not using these properties.
-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 root = await storage.getDirectory();
-  const directoryHandle = await root.getFileHandle('test-file.txt', { create: true });
-  // rest of your test
-});
-```
-
-### Vitest
-
-To use `opfs-mock` in a single Vitest test suite, require `opfs-mock` at the beginning of the test file, as described above.
-
-To use it on all Vitest tests without having to include it in each file, add the auto setup script to the `test.setupFiles` in your Vite config:
-
-```ts
-// vite.config.ts
-
-import { defineConfig as defineViteConfig, mergeConfig } from 'vite';
-import { defineConfig as defineVitestConfig } from 'vitest/config';
-
-const viteConfig = defineViteConfig({
-  ...
-});
-
-const vitestConfig = defineVitestConfig({
-  test: {
-    setupFiles: ['opfs-mock'],
-  },
-});
-
-export default mergeConfig(viteConfig, vitestConfig);
-```
-
-Alternatively you can create a new setup file which then imports this module.
-
-```ts
-// vitest-setup.ts
-
-import "opfs-mock";
-```
-
-Add that file to your `test.setupFiles` array:
-
-```ts
-// vite.config.ts
-
-import { defineConfig as defineViteConfig, mergeConfig } from 'vite';
-import { defineConfig as defineVitestConfig } from 'vitest/config';
-
-const viteConfig = defineViteConfig({
-  ...
-});
-
-const vitestConfig = defineVitestConfig({
-  test: {
-    setupFiles: ['vitest-setup.ts'],
-  },
-});
-
-export default mergeConfig(viteConfig, vitestConfig);
-```
-
-
-### Jest
-
-To use `opfs-mock` in a single Jest test suite, require `opfs-mock` at the beginning of the test file, as described above.
-
-To use it on all Jest tests without having to include it in each file, add the auto setup script to the `setupFiles` in your Jest config:
-
-```ts
-// jest.config.js
-
-{
-  ...
-  "setupFiles": [
-    "opfs-mock"
-  ]
-}
-```
-
-Alternatively you can create a new setup file which then imports this module.
-
-```ts
-// jest-setup.ts
-
-import "opfs-mock";
-```
-
-Add that file to your `setupFiles` array:
-
-```ts
-// jest.config.js
-
-{
-  ...
-  "setupFiles": [
-    "jest-setup"
-  ]
-}
-```
-
-## Wiping/resetting the OPFS mock for a fresh state
-
-If you are keeping your tests completely isolated you might want to "reset" the state of the mocked OPFS. You can do this by using `resetMockOPFS` function, which creates a completely new instance of the mock.
-
-```ts
-import { resetMockOPFS } from 'opfs-mock';
-
-beforeEach(() => {
-  resetMockOPFS();
-});
-
-test('First isolated test', async () => {
-  // rest of your test
-});
-
-test('Second isolated test', async () => {
-  // rest of your test
-});
-```
+# 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.
+
+## Installation
+
+```shell
+npm install -save-dev opfs-mock
+```
+
+## Usage
+
+It replicates the behavior of origin private file system, except data is not persisted to disk.
+
+The easiest way to use it is to import `opfs-mock`, which will polyfill OPFS API to global scope.
+
+```ts
+import "opfs-mock";
+```
+
+Alternatively, you can explicitly import `storageFactory`:
+
+```ts
+import { storageFactory } from "opfs-mock";
+
+test('Your test', async () => {
+  const storage = await storageFactory();
+  const root = await storage.getDirectory();
+  const directoryHandle = await root.getFileHandle('test-file.txt', { create: true });
+  // rest of your test
+});
+```
+
+`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, usage: 1_000 });
+  const root = await storage.getDirectory();
+  const directoryHandle = await root.getFileHandle('test-file.txt', { create: true });
+  // rest of your test
+});
+```
+
+### Vitest
+
+To use `opfs-mock` in a single Vitest test suite, require `opfs-mock` at the beginning of the test file, as described above.
+
+To use it on all Vitest tests without having to include it in each file, add the auto setup script to the `test.setupFiles` in your Vite config:
+
+```ts
+// vite.config.ts
+
+import { defineConfig as defineViteConfig, mergeConfig } from 'vite';
+import { defineConfig as defineVitestConfig } from 'vitest/config';
+
+const viteConfig = defineViteConfig({
+  ...
+});
+
+const vitestConfig = defineVitestConfig({
+  test: {
+    setupFiles: ['opfs-mock'],
+  },
+});
+
+export default mergeConfig(viteConfig, vitestConfig);
+```
+
+Alternatively you can create a new setup file which then imports this module.
+
+```ts
+// vitest-setup.ts
+
+import "opfs-mock";
+```
+
+Add that file to your `test.setupFiles` array:
+
+```ts
+// vite.config.ts
+
+import { defineConfig as defineViteConfig, mergeConfig } from 'vite';
+import { defineConfig as defineVitestConfig } from 'vitest/config';
+
+const viteConfig = defineViteConfig({
+  ...
+});
+
+const vitestConfig = defineVitestConfig({
+  test: {
+    setupFiles: ['vitest-setup.ts'],
+  },
+});
+
+export default mergeConfig(viteConfig, vitestConfig);
+```
+
+
+### Jest
+
+To use `opfs-mock` in a single Jest test suite, require `opfs-mock` at the beginning of the test file, as described above.
+
+To use it on all Jest tests without having to include it in each file, add the auto setup script to the `setupFiles` in your Jest config:
+
+```ts
+// jest.config.js
+
+{
+  ...
+  "setupFiles": [
+    "opfs-mock"
+  ]
+}
+```
+
+Alternatively you can create a new setup file which then imports this module.
+
+```ts
+// jest-setup.ts
+
+import "opfs-mock";
+```
+
+Add that file to your `setupFiles` array:
+
+```ts
+// jest.config.js
+
+{
+  ...
+  "setupFiles": [
+    "jest-setup"
+  ]
+}
+```
+
+## Wiping/resetting the OPFS mock for a fresh state
+
+If you are keeping your tests completely isolated you might want to "reset" the state of the mocked OPFS. You can do this by using `resetMockOPFS` function, which creates a completely new instance of the mock.
+
+```ts
+import { resetMockOPFS } from 'opfs-mock';
+
+beforeEach(() => {
+  resetMockOPFS();
+});
+
+test('First isolated test', async () => {
+  // rest of your test
+});
+
+test('Second isolated test', async () => {
+  // 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 {
@@ -6,51 +26,154 @@ var fileSystemFileHandleFactory = (name, fileData) => {
     isSameEntry: async (other) => {
       return other.name === name && other.kind === "file";
     },
-    getFile: async () => new File([fileData.content], name, {
-      type: "application/json"
-    }),
-    // @ts-ignore TODO: Implement options, add missing properties
-    createWritable: async (_options) => {
+    getFile: async () => new File([fileData.content], name),
+    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: (chunk) => {
-          const newContent = new TextDecoder().decode(chunk);
-          fileData.content += newContent;
+        write: () => {
         },
         close: () => {
         },
-        abort: (_reason) => {
+        abort: () => {
+        }
+      });
+      return Object.assign(writableStream, {
+        getWriter: () => writableStream.getWriter(),
+        write: async function(chunk) {
+          if (isAborted) {
+            throw new Error(abortReason);
+          }
+          if (isClosed) {
+            throw new TypeError("Cannot write to a CLOSED writable stream");
+          }
+          if (chunk === void 0) {
+            throw new TypeError("Cannot write undefined data to the stream");
+          }
+          let chunkText;
+          if (typeof chunk === "string") {
+            chunkText = chunk;
+          } else if (chunk instanceof Blob) {
+            chunkText = await chunk.text();
+          } else if (ArrayBuffer.isView(chunk)) {
+            chunkText = new TextDecoder().decode(new Uint8Array(chunk.buffer));
+          } else if (typeof chunk === "object" && "data" in chunk) {
+            if (chunk.position !== void 0 && (typeof chunk.position !== "number" || chunk.position < 0)) {
+              throw new TypeError("Invalid position value in write parameters");
+            }
+            if (chunk.size !== void 0 && (typeof chunk.size !== "number" || chunk.size < 0)) {
+              throw new TypeError("Invalid size value in write parameters");
+            }
+            if (chunk.position !== void 0 && chunk.position !== null) {
+              cursorPosition = chunk.position;
+            }
+            if (chunk.data) {
+              if (typeof chunk.data === "string") {
+                chunkText = chunk.data;
+              } else if (chunk.data instanceof Blob) {
+                chunkText = await chunk.data.text();
+              } else {
+                chunkText = new TextDecoder().decode(new Uint8Array(chunk.data instanceof ArrayBuffer ? chunk.data : chunk.data.buffer));
+              }
+            } else {
+              chunkText = "";
+            }
+          } else {
+            throw new TypeError("Invalid data type written to the file. Data must be of type FileSystemWriteChunkType.");
+          }
+          content = content.slice(0, cursorPosition) + chunkText + content.slice(cursorPosition + chunkText.length);
+          cursorPosition += chunkText.length;
+        },
+        close: async function() {
+          if (isClosed) {
+            throw new TypeError("Cannot close a CLOSED writable stream");
+          }
+          if (isAborted) {
+            throw new TypeError("Cannot close a ERRORED writable stream");
+          }
+          isClosed = true;
+          fileData.content = content;
+        },
+        abort: async function(reason) {
+          if (isAborted) {
+            return;
+          }
+          if (reason && !abortReason) {
+            abortReason = reason;
+          }
+          isAborted = true;
+          return Promise.resolve(void 0);
+        },
+        truncate: async function(size) {
+          if (size < 0) {
+            throw new DOMException("Invalid truncate size", "IndexSizeError");
+          }
+          if (size < content.length) {
+            content = content.slice(0, size);
+          } else {
+            content = content.padEnd(size, "\0");
+          }
+          cursorPosition = Math.min(cursorPosition, size);
+        },
+        seek: async function(position) {
+          if (position < 0 || position > content.length) {
+            throw new DOMException("Invalid seek position", "IndexSizeError");
+          }
+          cursorPosition = position;
         }
       });
-      return writableStream.getWriter();
     },
-    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) => {
@@ -85,14 +208,25 @@ var fileSystemDirectoryHandleFactory = (name) => {
       }
       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();
@@ -106,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];
             }
@@ -126,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": "1.0.2",
+  "version": "2.1.0",
   "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"
@@ -40,8 +40,8 @@
   },
   "devDependencies": {
     "@biomejs/biome": "1.9.4",
-    "tsup": "8.3.5",
+    "tsup": "8.4.0",
     "typescript": "5.7.3",
-    "vitest": "2.1.8"
+    "vitest": "3.0.7"
   }
 }