opfs-mock 1.0.0 → 1.0.2

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

@@ -18,12 +18,27 @@ The easiest way to use it is to import `opfs-mock`, which will polyfill OPFS API
 import "opfs-mock";
 ```
 
-Alternatively, you can explicitly import `storage`:
+Alternatively, you can explicitly import `storageFactory`:
 
 ```ts
-import { storage } from "opfs-mock";
+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
@@ -37,14 +52,22 @@ To use `opfs-mock` in a single Vitest test suite, require `opfs-mock` at the beg
 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.js
+// 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.
@@ -60,13 +83,20 @@ Add that file to your `test.setupFiles` array:
 ```ts
 // vite.config.ts
 
-import { defineConfig } from 'vite'
+import { defineConfig as defineViteConfig, mergeConfig } from 'vite';
+import { defineConfig as defineVitestConfig } from 'vitest/config';
 
-export default defineConfig({
+const viteConfig = defineViteConfig({
+  ...
+});
+
+const vitestConfig = defineVitestConfig({
   test: {
     setupFiles: ['vitest-setup.ts'],
-  }
+  },
 });
+
+export default mergeConfig(viteConfig, vitestConfig);
 ```
 
 

package/dist/index.d.ts

@@ -1,4 +1,5 @@
-declare const storage: () => StorageManager;
+declare const storageFactory: ({ usage, quota }?: StorageEstimate) => StorageManager;
 declare const mockOPFS: () => void;
 declare const resetMockOPFS: () => void;
-export { mockOPFS, resetMockOPFS, storage };
+
+export { mockOPFS, resetMockOPFS, storageFactory };

package/dist/index.js

@@ -1,128 +1,186 @@
-const g = (o, n) => ({
-  kind: "file",
-  name: o,
-  isSameEntry: async (t) => t.name === o && t.kind === "file",
-  getFile: async () => new File([n.content], o, {
-    type: "application/json"
-  }),
-  // @ts-ignore TODO: Implement options, add missing properties
-  createWritable: async (t) => new WritableStream({
-    write: (e) => {
-      const r = new TextDecoder().decode(e);
-      n.content += r;
-    },
-    close: () => {
-    },
-    abort: (e) => {
-    }
-  }).getWriter(),
-  createSyncAccessHandle: async () => ({
-    getSize: () => n.content.length,
-    read: (t, { at: s = 0 } = {}) => {
-      const e = new TextEncoder().encode(n.content), r = Math.min(t.length, e.length - s);
-      return t.set(e.subarray(s, s + r)), r;
-    },
-    write: (t, { at: s = 0 } = {}) => {
-      const e = new TextDecoder().decode(t), r = n.content.length;
-      return s < r ? n.content = n.content.slice(0, s) + e + n.content.slice(s + e.length) : n.content += e, t.byteLength;
-    },
-    // Flush is a no-op in memory
-    flush: async () => {
+// src/opfs.ts
+var fileSystemFileHandleFactory = (name, fileData) => {
+  return {
+    kind: "file",
+    name,
+    isSameEntry: async (other) => {
+      return other.name === name && other.kind === "file";
     },
-    // Close is a no-op in memory
-    close: async () => {
+    getFile: async () => new File([fileData.content], name, {
+      type: "application/json"
+    }),
+    // @ts-ignore TODO: Implement options, add missing properties
+    createWritable: async (_options) => {
+      const writableStream = new WritableStream({
+        write: (chunk) => {
+          const newContent = new TextDecoder().decode(chunk);
+          fileData.content += newContent;
+        },
+        close: () => {
+        },
+        abort: (_reason) => {
+        }
+      });
+      return writableStream.getWriter();
     },
-    truncate: async (t) => {
-      n.content = n.content.slice(0, t);
-    }
-  })
-}), y = (o) => {
-  const n = /* @__PURE__ */ new Map(), t = /* @__PURE__ */ new Map(), s = () => new Map([...n, ...t]);
+    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;
+        }
+        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) => {
+  const files = /* @__PURE__ */ new Map();
+  const directories = /* @__PURE__ */ new Map();
+  const getJoinedMaps = () => {
+    return new Map([...files, ...directories]);
+  };
   return {
     kind: "directory",
-    name: o,
-    isSameEntry: async (e) => e.name === o && e.kind === "directory",
-    getFileHandle: async (e, r) => {
-      !n.has(e) && (r != null && r.create) && n.set(e, g(e, { content: "" }));
-      const c = n.get(e);
-      if (!c)
-        throw new Error(`File not found: ${e}`);
-      return c;
+    name,
+    isSameEntry: async (other) => {
+      return other.name === name && other.kind === "directory";
+    },
+    getFileHandle: async (fileName, options) => {
+      if (!files.has(fileName) && options?.create) {
+        files.set(fileName, fileSystemFileHandleFactory(fileName, { content: "" }));
+      }
+      const fileHandle = files.get(fileName);
+      if (!fileHandle) {
+        throw new Error(`File not found: ${fileName}`);
+      }
+      return fileHandle;
     },
-    getDirectoryHandle: async (e, r) => {
-      !t.has(e) && (r != null && r.create) && t.set(e, y(e));
-      const c = t.get(e);
-      if (!c)
-        throw new Error(`Directory not found: ${e}`);
-      return c;
+    getDirectoryHandle: async (dirName, options) => {
+      if (!directories.has(dirName) && options?.create) {
+        directories.set(dirName, fileSystemDirectoryHandleFactory(dirName));
+      }
+      const directoryHandle = directories.get(dirName);
+      if (!directoryHandle) {
+        throw new Error(`Directory not found: ${dirName}`);
+      }
+      return directoryHandle;
     },
-    removeEntry: async (e) => {
-      if (n.has(e))
-        n.delete(e);
-      else if (t.has(e))
-        t.delete(e);
-      else
-        throw new Error(`Entry not found: ${e}`);
+    removeEntry: async (entryName) => {
+      if (files.has(entryName)) {
+        files.delete(entryName);
+      } else if (directories.has(entryName)) {
+        directories.delete(entryName);
+      } else {
+        throw new Error(`Entry not found: ${entryName}`);
+      }
     },
     entries: async function* () {
-      yield* s().entries();
+      const joinedMaps = getJoinedMaps();
+      yield* joinedMaps.entries();
     },
     keys: async function* () {
-      yield* s().keys();
+      const joinedMaps = getJoinedMaps();
+      yield* joinedMaps.keys();
     },
     values: async function* () {
-      yield* s().values();
+      const joinedMaps = getJoinedMaps();
+      yield* joinedMaps.values();
     },
-    resolve: async (e) => {
-      const r = async (c, a, l = []) => {
-        if (await c.isSameEntry(a))
-          return l;
-        for await (const [d, i] of c.entries())
-          if (i.kind === "directory") {
-            const u = await r(i, a, [...l, d]);
-            if (u)
-              return u;
-          } else if (i.kind === "file" && await i.isSameEntry(a))
-            return [...l, d];
+    resolve: async (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 (result) {
+              return result;
+            }
+          } else if (handle.kind === "file") {
+            if (await handle.isSameEntry(target)) {
+              return [...path, name2];
+            }
+          }
+        }
         return null;
       };
-      return r(void 0, e);
+      return traverseDirectory(void 0, possibleDescendant);
     }
   };
-}, w = () => {
-  const o = y("root");
+};
+
+// src/index.ts
+var storageFactory = ({ usage = 0, quota = 0 } = {}) => {
+  const root = fileSystemDirectoryHandleFactory("root");
   return {
-    estimate: async () => ({
-      usage: 0,
-      quota: 0
-    }),
-    getDirectory: async () => o,
-    persist: async () => !0,
-    persisted: async () => !0
+    estimate: async () => {
+      return {
+        usage,
+        quota
+      };
+    },
+    getDirectory: async () => {
+      return root;
+    },
+    persist: async () => {
+      return true;
+    },
+    persisted: async () => {
+      return true;
+    }
   };
-}, b = () => {
-  if ("navigator" in globalThis || Object.defineProperty(globalThis, "navigator", {
-    value: {},
-    writable: !0
-  }), !globalThis.navigator.storage) {
-    const { getDirectory: o } = w();
+};
+var mockOPFS = () => {
+  if (!("navigator" in globalThis)) {
+    Object.defineProperty(globalThis, "navigator", {
+      value: {},
+      writable: true
+    });
+  }
+  if (!globalThis.navigator.storage) {
+    const { getDirectory } = storageFactory();
     Object.defineProperty(globalThis.navigator, "storage", {
       value: {
-        getDirectory: o
+        getDirectory
       },
-      writable: !0
+      writable: true
     });
   }
-}, h = () => {
-  const o = y("root");
+};
+var resetMockOPFS = () => {
+  const root = fileSystemDirectoryHandleFactory("root");
   Object.defineProperty(globalThis.navigator.storage, "getDirectory", {
-    value: () => o,
-    writable: !0
+    value: () => root,
+    writable: true
   });
 };
-typeof globalThis < "u" && b();
+if (typeof globalThis !== "undefined") {
+  mockOPFS();
+}
 export {
-  b as mockOPFS,
-  h as resetMockOPFS,
-  w as storage
+  mockOPFS,
+  resetMockOPFS,
+  storageFactory
 };

package/package.json

@@ -1,9 +1,9 @@
 {
   "name": "opfs-mock",
-  "version": "1.0.0",
+  "version": "1.0.2",
   "type": "module",
   "description": "Mock all origin private file system APIs for your Jest or Vitest tests",
-  "author": "jurerotar <hello@jurerotar.com>",
+  "author": "Jure Rotar <hello@jurerotar.com>",
   "license": "MIT",
   "homepage": "https://github.com/jurerotar/opfs-mock#README",
   "repository": {
@@ -23,25 +23,25 @@
       "import": "./dist/index.js"
     }
   },
+  "main": "dist/index.js",
   "module": "dist/index.js",
   "files": ["dist"],
   "scripts": {
-    "dev": "vite",
-    "build": "vite build",
+    "dev": "tsup --watch",
+    "build": "tsup",
     "lint:check": "npx @biomejs/biome lint",
     "lint": "npx @biomejs/biome lint --fix",
     "format:check": "npx @biomejs/biome format",
     "format": "npx @biomejs/biome format --write",
     "type-check": "tsc --noEmit",
     "test": "vitest",
-    "build:types": "tsc --emitDeclarationOnly",
-    "prepublishOnly": "npm run build && npm run build:types",
+    "prepublishOnly": "npm run build",
     "release": "npm publish --access public"
   },
   "devDependencies": {
-    "@biomejs/biome": "1.9.3",
-    "typescript": "5.6.2",
-    "vite": "5.4.8",
-    "vitest": "2.1.2"
+    "@biomejs/biome": "1.9.4",
+    "tsup": "8.3.5",
+    "typescript": "5.7.3",
+    "vitest": "2.1.8"
   }
 }

package/dist/opfs.d.ts

@@ -1 +0,0 @@
-export declare const fileSystemDirectoryHandleFactory: (name: string) => FileSystemDirectoryHandle;