opfs-mock 2.1.1 → 2.3.0

package/README.md

@@ -1,7 +1,7 @@
 # opfs-mock
 
 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.
+on Node.js versions 20-24.
 
 ## Installation
 

package/dist/index.d.ts

@@ -1,5 +1,10 @@
-declare const storageFactory: ({ usage, quota }?: StorageEstimate) => StorageManager;
+//#region src/index.d.ts
+declare const storageFactory: ({
+  usage,
+  quota
+}?: StorageEstimate) => StorageManager;
 declare const mockOPFS: () => void;
 declare const resetMockOPFS: () => void;
 
-export { mockOPFS, resetMockOPFS, storageFactory };
+//#endregion
+export { mockOPFS, resetMockOPFS, storageFactory };

package/dist/index.js

@@ -1,321 +1,272 @@
-// src/utils.ts
-var isFileHandle = (handle) => {
-  return handle.kind === "file";
+//#region src/utils.ts
+const isFileHandle = (handle) => {
+	return handle.kind === "file";
 };
-var isDirectoryHandle = (handle) => {
-  return handle.kind === "directory";
+const 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;
+const 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 {
-    kind: "file",
-    name,
-    isSameEntry: async (other) => {
-      return other.name === name && other.kind === "file";
-    },
-    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: () => {
-        },
-        close: () => {
-        },
-        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;
-        }
-      });
-    },
-    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;
-        }
-      };
-    }
-  };
+//#endregion
+//#region src/opfs.ts
+const fileSystemFileHandleFactory = (name, fileData) => {
+	return {
+		kind: "file",
+		name,
+		isSameEntry: async (other) => {
+			return other.name === name && other.kind === "file";
+		},
+		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 ? new Uint8Array(fileData.content) : new Uint8Array();
+			let cursorPosition = keepExistingData ? fileData.content.length : 0;
+			const writableStream = new WritableStream({
+				write: () => {},
+				close: () => {},
+				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");
+					if (typeof chunk === "object" && "type" in chunk && chunk.type === "truncate") {
+						if (typeof chunk.size !== "number" || chunk.size < 0) throw new TypeError("Invalid size value in truncate parameters");
+						if (chunk.size < content.length) content = content.slice(0, chunk.size);
+						else {
+							const extended = new Uint8Array(chunk.size);
+							extended.set(content);
+							content = extended;
+						}
+						cursorPosition = Math.min(cursorPosition, chunk.size);
+						return;
+					}
+					let encoded;
+					if (typeof chunk === "string") encoded = new TextEncoder().encode(chunk);
+					else if (chunk instanceof Blob) {
+						const text = await chunk.text();
+						encoded = new TextEncoder().encode(text);
+					} else if (ArrayBuffer.isView(chunk)) encoded = new Uint8Array(chunk.buffer, chunk.byteOffset, chunk.byteLength);
+					else if (chunk instanceof ArrayBuffer) encoded = new Uint8Array(chunk);
+					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;
+						const data = chunk.data;
+						if (data === void 0 || data === null) encoded = new Uint8Array();
+						else if (typeof data === "string") encoded = new TextEncoder().encode(data);
+						else if (data instanceof Blob) {
+							const text = await data.text();
+							encoded = new TextEncoder().encode(text);
+						} else if (ArrayBuffer.isView(data)) encoded = new Uint8Array(data.buffer, data.byteOffset, data.byteLength);
+						else if (data instanceof ArrayBuffer) encoded = new Uint8Array(data);
+						else throw new TypeError("Invalid data in WriteParams");
+					} else throw new TypeError("Invalid data type written to the file. Data must be of type FileSystemWriteChunkType.");
+					const requiredSize = cursorPosition + encoded.length;
+					if (content.length < requiredSize) {
+						const extended = new Uint8Array(requiredSize);
+						extended.set(content);
+						content = extended;
+					}
+					content.set(encoded, cursorPosition);
+					cursorPosition += encoded.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 if (size > content.length) {
+						const newBuffer = new Uint8Array(size);
+						newBuffer.set(content);
+						content = newBuffer;
+					}
+					cursorPosition = Math.min(cursorPosition, size);
+				},
+				seek: async function(position) {
+					if (position < 0) throw new DOMException("Invalid seek position", "IndexSizeError");
+					cursorPosition = position;
+				}
+			});
+		},
+		createSyncAccessHandle: async () => {
+			let closed = false;
+			return {
+				getSize: () => {
+					if (closed) throw new DOMException("InvalidStateError", "The access handle is closed");
+					return fileData.content.byteLength;
+				},
+				read: (buffer, { at = 0 } = {}) => {
+					if (closed) throw new DOMException("InvalidStateError", "The access handle is closed");
+					const content = fileData.content;
+					if (at >= content.length) return 0;
+					const available = content.length - at;
+					const writable = buffer instanceof DataView ? buffer.byteLength : buffer.length;
+					const bytesToRead = Math.min(writable, available);
+					const slice = content.subarray(at, at + bytesToRead);
+					if (buffer instanceof DataView) for (let i = 0; i < slice.length; i++) buffer.setUint8(i, slice[i]);
+					else buffer.set(slice, 0);
+					return bytesToRead;
+				},
+				write: (data, { at = 0 } = {}) => {
+					if (closed) throw new DOMException("InvalidStateError", "The access handle is closed");
+					const writeLength = data instanceof DataView ? data.byteLength : data.length;
+					const requiredSize = at + writeLength;
+					if (fileData.content.length < requiredSize) {
+						const newBuffer = new Uint8Array(requiredSize);
+						newBuffer.set(fileData.content);
+						fileData.content = newBuffer;
+					}
+					if (data instanceof DataView) for (let i = 0; i < data.byteLength; i++) fileData.content[at + i] = data.getUint8(i);
+					else fileData.content.set(data, at);
+					return writeLength;
+				},
+				truncate: (size) => {
+					if (closed) throw new DOMException("InvalidStateError", "The access handle is closed");
+					if (size < fileData.content.length) fileData.content = fileData.content.slice(0, size);
+					else if (size > fileData.content.length) {
+						const newBuffer = new Uint8Array(size);
+						newBuffer.set(fileData.content);
+						fileData.content = newBuffer;
+					}
+				},
+				flush: async () => {
+					if (closed) throw new DOMException("InvalidStateError", "The access handle is closed");
+				},
+				close: async () => {
+					closed = true;
+				}
+			};
+		}
+	};
 };
-var fileSystemDirectoryHandleFactory = (name) => {
-  const files = /* @__PURE__ */ new Map();
-  const directories = /* @__PURE__ */ new Map();
-  const getJoinedMaps = () => {
-    return new Map([...files, ...directories]);
-  };
-  return {
-    kind: "directory",
-    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 DOMException(`File not found: ${fileName}`, "NotFoundError");
-      }
-      return fileHandle;
-    },
-    getDirectoryHandle: async (dirName, options) => {
-      if (!directories.has(dirName) && options?.create) {
-        directories.set(dirName, fileSystemDirectoryHandleFactory(dirName));
-      }
-      const directoryHandle = directories.get(dirName);
-      if (!directoryHandle) {
-        throw new DOMException(`Directory not found: ${dirName}`, "NotFoundError");
-      }
-      return directoryHandle;
-    },
-    removeEntry: async (entryName, options) => {
-      if (files.has(entryName)) {
-        files.delete(entryName);
-      } else if (directories.has(entryName)) {
-        if (options?.recursive) {
-          directories.delete(entryName);
-        } else {
-          throw new DOMException(`Failed to remove directory: $1${entryName}`, "InvalidModificationError");
-        }
-      } else {
-        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();
-      yield* joinedMaps.entries();
-    },
-    keys: async function* () {
-      const joinedMaps = getJoinedMaps();
-      yield* joinedMaps.keys();
-    },
-    values: async function* () {
-      const joinedMaps = getJoinedMaps();
-      yield* joinedMaps.values();
-    },
-    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 (isDirectoryHandle(handle)) {
-            const result = await traverseDirectory(handle, target, [...path, name2]);
-            if (result) {
-              return result;
-            }
-          } else if (isFileHandle(handle)) {
-            if (await handle.isSameEntry(target)) {
-              return [...path, name2];
-            }
-          }
-        }
-        return null;
-      };
-      return traverseDirectory(this, possibleDescendant);
-    }
-  };
+const fileSystemDirectoryHandleFactory = (name) => {
+	const files = new Map();
+	const directories = new Map();
+	const getJoinedMaps = () => {
+		return new Map([...files, ...directories]);
+	};
+	return {
+		kind: "directory",
+		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: new Uint8Array() }));
+			const fileHandle = files.get(fileName);
+			if (!fileHandle) throw new DOMException(`File not found: ${fileName}`, "NotFoundError");
+			return fileHandle;
+		},
+		getDirectoryHandle: async (dirName, options) => {
+			if (!directories.has(dirName) && options?.create) directories.set(dirName, fileSystemDirectoryHandleFactory(dirName));
+			const directoryHandle = directories.get(dirName);
+			if (!directoryHandle) throw new DOMException(`Directory not found: ${dirName}`, "NotFoundError");
+			return directoryHandle;
+		},
+		removeEntry: async (entryName, options) => {
+			if (files.has(entryName)) files.delete(entryName);
+			else if (directories.has(entryName)) if (options?.recursive) directories.delete(entryName);
+			else throw new DOMException(`Failed to remove directory: $1${entryName}`, "InvalidModificationError");
+			else throw new DOMException(`No such file or directory: $1${entryName}`, "NotFoundError");
+		},
+		[Symbol.asyncIterator]: async function* () {
+			const entries = getJoinedMaps();
+			for (const [name$1, handle] of entries) yield [name$1, handle];
+			return void 0;
+		},
+		entries: async function* () {
+			const joinedMaps = getJoinedMaps();
+			yield* joinedMaps.entries();
+		},
+		keys: async function* () {
+			const joinedMaps = getJoinedMaps();
+			yield* joinedMaps.keys();
+		},
+		values: async function* () {
+			const joinedMaps = getJoinedMaps();
+			yield* joinedMaps.values();
+		},
+		resolve: async function(possibleDescendant) {
+			const traverseDirectory = async (directory, target, path = []) => {
+				if (await directory.isSameEntry(target)) return path;
+				for await (const [name$1, handle] of directory.entries()) if (isDirectoryHandle(handle)) {
+					const result = await traverseDirectory(handle, target, [...path, name$1]);
+					if (result) return result;
+				} else if (isFileHandle(handle)) {
+					if (await handle.isSameEntry(target)) return [...path, name$1];
+				}
+				return null;
+			};
+			return traverseDirectory(this, possibleDescendant);
+		}
+	};
 };
 
-// src/index.ts
-var storageFactory = ({ usage = 0, quota = 1024 ** 3 } = {}) => {
-  const root = fileSystemDirectoryHandleFactory("root");
-  return {
-    estimate: async () => {
-      const defaultUsage = usage;
-      const calculatedUsage = await getSizeOfDirectory(root);
-      return {
-        usage: defaultUsage + calculatedUsage,
-        quota
-      };
-    },
-    getDirectory: async () => {
-      return root;
-    },
-    persist: async () => {
-      return true;
-    },
-    persisted: async () => {
-      return true;
-    }
-  };
+//#endregion
+//#region src/index.ts
+const storageFactory = ({ usage = 0, quota = 1024 ** 3 } = {}) => {
+	const root = fileSystemDirectoryHandleFactory("root");
+	return {
+		estimate: async () => {
+			const defaultUsage = usage;
+			const calculatedUsage = await getSizeOfDirectory(root);
+			return {
+				usage: defaultUsage + calculatedUsage,
+				quota
+			};
+		},
+		getDirectory: async () => {
+			return root;
+		},
+		persist: async () => {
+			return true;
+		},
+		persisted: async () => {
+			return true;
+		}
+	};
 };
-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
-      },
-      writable: true
-    });
-  }
+const mockOPFS = () => {
+	if (!("navigator" in globalThis)) Object.defineProperty(globalThis, "navigator", {
+		value: {},
+		writable: true
+	});
+	if (!globalThis.navigator.storage) Object.defineProperty(globalThis.navigator, "storage", {
+		value: storageFactory(),
+		writable: true
+	});
 };
-var resetMockOPFS = () => {
-  const root = fileSystemDirectoryHandleFactory("root");
-  Object.defineProperty(globalThis.navigator.storage, "getDirectory", {
-    value: () => root,
-    writable: true
-  });
-};
-if (typeof globalThis !== "undefined") {
-  mockOPFS();
-}
-export {
-  mockOPFS,
-  resetMockOPFS,
-  storageFactory
+const resetMockOPFS = () => {
+	const root = fileSystemDirectoryHandleFactory("root");
+	Object.defineProperty(globalThis.navigator.storage, "getDirectory", {
+		value: () => root,
+		writable: true
+	});
 };
+if (typeof globalThis !== "undefined") mockOPFS();
+
+//#endregion
+export { mockOPFS, resetMockOPFS, storageFactory };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "opfs-mock",
-  "version": "2.1.1",
+  "version": "2.3.0",
   "type": "module",
   "description": "Mock all origin private file system APIs for your Jest or Vitest tests",
   "author": "Jure Rotar <hello@jurerotar.com>",
@@ -30,8 +30,8 @@
     "node": ">=20.0.0"
   },
   "scripts": {
-    "dev": "tsup --watch",
-    "build": "tsup",
+    "dev": "tsdown --watch",
+    "build": "tsdown",
     "lint:check": "npx @biomejs/biome lint",
     "lint": "npx @biomejs/biome lint --fix",
     "format:check": "npx @biomejs/biome format",
@@ -47,10 +47,10 @@
   "devDependencies": {
     "@biomejs/biome": "1.9.4",
     "@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"
+    "happy-dom": "17.4.7",
+    "jsdom": "26.1.0",
+    "tsdown": "0.12.3",
+    "typescript": "5.8.3",
+    "vitest": "3.1.4"
   }
 }