@remix-run/file-storage 0.12.0 → 0.13.0

package/README.md

@@ -23,10 +23,12 @@ npm install @remix-run/file-storage
 
 ## Usage
 
+### File System
+
 ```ts
-import { LocalFileStorage } from '@remix-run/file-storage/local'
+import { createFsFileStorage } from '@remix-run/file-storage/fs'
 
-let storage = new LocalFileStorage('./user/files')
+let storage = createFsFileStorage('./user/files')
 
 let file = new File(['hello world'], 'hello.txt', { type: 'text/plain' })
 let key = 'hello-key'
@@ -44,39 +46,6 @@ fileFromStorage.type // 'text/plain'
 await storage.remove(key)
 ```
 
-The `FileStorage` interface allows you to implement your own file storage for custom storage backends:
-
-```ts
-import { type FileStorage } from '@remix-run/file-storage'
-
-class CustomFileStorage implements FileStorage {
-  /**
-   * Returns `true` if a file with the given key exists, `false` otherwise.
-   */
-  has(key: string): boolean | Promise<boolean> {
-    // ...
-  }
-  /**
-   * Puts a file in storage at the given key.
-   */
-  set(key: string, file: File): void | Promise<void> {
-    // ...
-  }
-  /**
-   * Returns the file with the given key, or `null` if no such key exists.
-   */
-  get(key: string): File | null | Promise<File | null> {
-    // ...
-  }
-  /**
-   * Removes the file with the given key from storage.
-   */
-  remove(key: string): void | Promise<void> {
-    // ...
-  }
-}
-```
-
 ## Related Packages
 
 - [`form-data-parser`](https://github.com/remix-run/remix/tree/main/packages/form-data-parser) - Pairs well with this library for storing `FileUpload` objects received in `multipart/form-data` requests

package/dist/fs.d.ts

@@ -0,0 +1,2 @@
+export { createFsFileStorage } from './lib/backends/fs.ts';
+//# sourceMappingURL=fs.d.ts.map

package/dist/fs.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"fs.d.ts","sourceRoot":"","sources":["../src/fs.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,mBAAmB,EAAE,MAAM,sBAAsB,CAAA"}

package/dist/fs.js

@@ -0,0 +1 @@
+export { createFsFileStorage } from "./lib/backends/fs.js";

package/dist/lib/backends/fs.d.ts

@@ -0,0 +1,17 @@
+import type { FileStorage } from '../file-storage.ts';
+/**
+ * Creates a `FileStorage` that is backed by a filesystem directory using node:fs.
+ *
+ * Important: No attempt is made to avoid overwriting existing files, so the directory used should
+ * be a new directory solely dedicated to this storage object.
+ *
+ * Note: Keys have no correlation to file names on disk, so they may be any string including
+ * characters that are not valid in file names. Additionally, individual `File` names have no
+ * correlation to names of files on disk, so multiple files with the same name may be stored in the
+ * same storage object.
+ *
+ * @param directory The directory where files are stored
+ * @returns A new file storage backed by a filesystem directory
+ */
+export declare function createFsFileStorage(directory: string): FileStorage;
+//# sourceMappingURL=fs.d.ts.map

package/dist/lib/backends/fs.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"fs.d.ts","sourceRoot":"","sources":["../../../src/lib/backends/fs.ts"],"names":[],"mappings":"AAKA,OAAO,KAAK,EAAE,WAAW,EAAyC,MAAM,oBAAoB,CAAA;AAI5F;;;;;;;;;;;;;GAaG;AACH,wBAAgB,mBAAmB,CAAC,SAAS,EAAE,MAAM,GAAG,WAAW,CA4JlE"}

package/dist/lib/backends/fs.js

@@ -0,0 +1,165 @@
+import * as fs from 'node:fs';
+import * as fsp from 'node:fs/promises';
+import * as path from 'node:path';
+import { openFile, writeFile } from '@remix-run/fs';
+/**
+ * Creates a `FileStorage` that is backed by a filesystem directory using node:fs.
+ *
+ * Important: No attempt is made to avoid overwriting existing files, so the directory used should
+ * be a new directory solely dedicated to this storage object.
+ *
+ * Note: Keys have no correlation to file names on disk, so they may be any string including
+ * characters that are not valid in file names. Additionally, individual `File` names have no
+ * correlation to names of files on disk, so multiple files with the same name may be stored in the
+ * same storage object.
+ *
+ * @param directory The directory where files are stored
+ * @returns A new file storage backed by a filesystem directory
+ */
+export function createFsFileStorage(directory) {
+    let rootDir = path.resolve(directory);
+    try {
+        let stats = fs.statSync(rootDir);
+        if (!stats.isDirectory()) {
+            throw new Error(`Path "${rootDir}" is not a directory`);
+        }
+    }
+    catch (error) {
+        if (!isNoEntityError(error)) {
+            throw error;
+        }
+        fs.mkdirSync(rootDir, { recursive: true });
+    }
+    async function getPaths(key) {
+        let hash = await computeHash(key);
+        let directory = path.join(rootDir, hash.slice(0, 2));
+        return {
+            directory,
+            filePath: path.join(directory, `${hash}.dat`),
+            metaPath: path.join(directory, `${hash}.meta.json`),
+        };
+    }
+    async function putFile(key, file) {
+        let { directory, filePath, metaPath } = await getPaths(key);
+        // Ensure directory exists
+        await fsp.mkdir(directory, { recursive: true });
+        await writeFile(filePath, file);
+        let meta = {
+            key,
+            lastModified: file.lastModified,
+            name: file.name,
+            type: file.type,
+        };
+        await fsp.writeFile(metaPath, JSON.stringify(meta));
+        let metaData = await readMetadata(metaPath);
+        return openFile(filePath, {
+            lastModified: metaData.lastModified,
+            name: metaData.name,
+            type: metaData.type,
+        });
+    }
+    return {
+        async get(key) {
+            let { filePath, metaPath } = await getPaths(key);
+            try {
+                let meta = await readMetadata(metaPath);
+                return openFile(filePath, {
+                    lastModified: meta.lastModified,
+                    name: meta.name,
+                    type: meta.type,
+                });
+            }
+            catch (error) {
+                if (!isNoEntityError(error)) {
+                    throw error;
+                }
+                return null;
+            }
+        },
+        async has(key) {
+            let { metaPath } = await getPaths(key);
+            try {
+                await fsp.access(metaPath);
+                return true;
+            }
+            catch {
+                return false;
+            }
+        },
+        async list(options) {
+            let { cursor, includeMetadata = false, limit = 32, prefix } = options ?? {};
+            let files = [];
+            let foundCursor = cursor === undefined;
+            let nextCursor;
+            let lastHash;
+            outerLoop: for await (let subdir of await fsp.opendir(rootDir)) {
+                if (!subdir.isDirectory())
+                    continue;
+                for await (let file of await fsp.opendir(path.join(rootDir, subdir.name))) {
+                    if (!file.isFile() || !file.name.endsWith('.meta.json'))
+                        continue;
+                    let hash = file.name.slice(0, -10); // Remove ".meta.json"
+                    if (foundCursor) {
+                        let meta = await readMetadata(path.join(rootDir, subdir.name, file.name));
+                        if (prefix != null && !meta.key.startsWith(prefix)) {
+                            continue;
+                        }
+                        if (files.length >= limit) {
+                            nextCursor = lastHash;
+                            break outerLoop;
+                        }
+                        if (includeMetadata) {
+                            let size = (await fsp.stat(path.join(rootDir, subdir.name, `${hash}.dat`))).size;
+                            files.push({ ...meta, size });
+                        }
+                        else {
+                            files.push({ key: meta.key });
+                        }
+                    }
+                    else if (hash === cursor) {
+                        foundCursor = true;
+                    }
+                    lastHash = hash;
+                }
+            }
+            return {
+                cursor: nextCursor,
+                files,
+            };
+        },
+        put(key, file) {
+            return putFile(key, file);
+        },
+        async remove(key) {
+            let { directory, filePath, metaPath } = await getPaths(key);
+            try {
+                await Promise.all([fsp.unlink(filePath), fsp.unlink(metaPath)]);
+                // Check if directory is empty and remove it if so
+                let files = await fsp.readdir(directory);
+                if (files.length === 0) {
+                    await fsp.rmdir(directory);
+                }
+            }
+            catch (error) {
+                if (!isNoEntityError(error)) {
+                    throw error;
+                }
+            }
+        },
+        async set(key, file) {
+            await putFile(key, file);
+        },
+    };
+}
+async function readMetadata(metaPath) {
+    return JSON.parse(await fsp.readFile(metaPath, 'utf-8'));
+}
+async function computeHash(key, algorithm = 'SHA-256') {
+    let digest = await crypto.subtle.digest(algorithm, new TextEncoder().encode(key));
+    return Array.from(new Uint8Array(digest))
+        .map((b) => b.toString(16).padStart(2, '0'))
+        .join('');
+}
+function isNoEntityError(obj) {
+    return obj instanceof Error && 'code' in obj && obj.code === 'ENOENT';
+}

package/dist/lib/backends/memory.d.ts

@@ -0,0 +1,7 @@
+import type { FileStorage } from '../file-storage.ts';
+/**
+ * Creates a simple, in-memory implementation of the `FileStorage` interface.
+ * @returns A new in-memory file storage instance
+ */
+export declare function createMemoryFileStorage(): FileStorage;
+//# sourceMappingURL=memory.d.ts.map

package/dist/lib/backends/memory.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"memory.d.ts","sourceRoot":"","sources":["../../../src/lib/backends/memory.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,WAAW,EAA2B,MAAM,oBAAoB,CAAA;AAE9E;;;GAGG;AACH,wBAAgB,uBAAuB,IAAI,WAAW,CAqErD"}

package/dist/lib/backends/memory.js

@@ -0,0 +1,69 @@
+/**
+ * Creates a simple, in-memory implementation of the `FileStorage` interface.
+ * @returns A new in-memory file storage instance
+ */
+export function createMemoryFileStorage() {
+    let map = new Map();
+    async function putFile(key, file) {
+        let buffer = await file.arrayBuffer();
+        let newFile = new File([buffer], file.name, {
+            lastModified: file.lastModified,
+            type: file.type,
+        });
+        map.set(key, newFile);
+        return newFile;
+    }
+    return {
+        get(key) {
+            return map.get(key) ?? null;
+        },
+        has(key) {
+            return map.has(key);
+        },
+        list(options) {
+            let { cursor, includeMetadata = false, limit = Infinity, prefix } = options ?? {};
+            let files = [];
+            let foundCursor = cursor === undefined;
+            let nextCursor;
+            for (let [key, file] of map.entries()) {
+                if (foundCursor) {
+                    if (prefix != null && !key.startsWith(prefix)) {
+                        continue;
+                    }
+                    if (files.length >= limit) {
+                        nextCursor = files[files.length - 1]?.key;
+                        break;
+                    }
+                    if (includeMetadata) {
+                        files.push({
+                            key,
+                            lastModified: file.lastModified,
+                            name: file.name,
+                            size: file.size,
+                            type: file.type,
+                        });
+                    }
+                    else {
+                        files.push({ key });
+                    }
+                }
+                else if (key === cursor) {
+                    foundCursor = true;
+                }
+            }
+            return {
+                cursor: nextCursor,
+                files,
+            };
+        },
+        put(key, file) {
+            return putFile(key, file);
+        },
+        remove(key) {
+            map.delete(key);
+        },
+        async set(key, file) {
+            await putFile(key, file);
+        },
+    };
+}

package/dist/lib/file-storage.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"file-storage.d.ts","sourceRoot":"","sources":["../../src/lib/file-storage.ts"],"names":[],"mappings":"AAAA;;GAEG;AACH,MAAM,WAAW,WAAW;IAC1B;;;;OAIG;IACH,GAAG,CAAC,GAAG,EAAE,MAAM,GAAG,IAAI,GAAG,IAAI,GAAG,OAAO,CAAC,IAAI,GAAG,IAAI,CAAC,CAAA;IAEpD;;;;OAIG;IACH,GAAG,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,GAAG,OAAO,CAAC,OAAO,CAAC,CAAA;IAE5C;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OA0DG;IACH,IAAI,CAAC,CAAC,SAAS,WAAW,EAAE,OAAO,CAAC,EAAE,CAAC,GAAG,UAAU,CAAC,CAAC,CAAC,GAAG,OAAO,CAAC,UAAU,CAAC,CAAC,CAAC,CAAC,CAAA;IAEhF;;;;;;OAMG;IACH,GAAG,CAAC,GAAG,EAAE,MAAM,EAAE,IAAI,EAAE,IAAI,GAAG,IAAI,GAAG,OAAO,CAAC,IAAI,CAAC,CAAA;IAElD;;;;OAIG;IACH,MAAM,CAAC,GAAG,EAAE,MAAM,GAAG,IAAI,GAAG,OAAO,CAAC,IAAI,CAAC,CAAA;IAEzC;;;;;;OAMG;IACH,GAAG,CAAC,GAAG,EAAE,MAAM,EAAE,IAAI,EAAE,IAAI,GAAG,IAAI,GAAG,OAAO,CAAC,IAAI,CAAC,CAAA;CACnD;AAED,MAAM,WAAW,OAAO;IACtB;;OAEG;IACH,GAAG,EAAE,MAAM,CAAA;CACZ;AAED;;GAEG;AACH,MAAM,WAAW,YAAa,SAAQ,OAAO;IAC3C;;OAEG;IACH,YAAY,EAAE,MAAM,CAAA;IACpB;;OAEG;IACH,IAAI,EAAE,MAAM,CAAA;IACZ;;OAEG;IACH,IAAI,EAAE,MAAM,CAAA;IACZ;;OAEG;IACH,IAAI,EAAE,MAAM,CAAA;CACb;AAED,MAAM,WAAW,WAAW;IAC1B;;OAEG;IACH,MAAM,CAAC,EAAE,MAAM,CAAA;IACf;;OAEG;IACH,eAAe,CAAC,EAAE,OAAO,CAAA;IACzB;;OAEG;IACH,KAAK,CAAC,EAAE,MAAM,CAAA;IACd;;OAEG;IACH,MAAM,CAAC,EAAE,MAAM,CAAA;CAChB;AAED,MAAM,WAAW,UAAU,CAAC,CAAC,SAAS,WAAW;IAC/C;;;OAGG;IACH,MAAM,CAAC,EAAE,MAAM,CAAA;IACf;;OAEG;IACH,KAAK,EAAE,CAAC,CAAC,SAAS;QAAE,eAAe,EAAE,IAAI,CAAA;KAAE,GAAG,YAAY,GAAG,OAAO,CAAC,EAAE,CAAA;CACxE"}
+{"version":3,"file":"file-storage.d.ts","sourceRoot":"","sources":["../../src/lib/file-storage.ts"],"names":[],"mappings":"AAAA;;GAEG;AACH,MAAM,WAAW,WAAW;IAC1B;;;;OAIG;IACH,GAAG,CAAC,GAAG,EAAE,MAAM,GAAG,IAAI,GAAG,IAAI,GAAG,OAAO,CAAC,IAAI,GAAG,IAAI,CAAC,CAAA;IACpD;;;;OAIG;IACH,GAAG,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,GAAG,OAAO,CAAC,OAAO,CAAC,CAAA;IAC5C;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;OA0DG;IACH,IAAI,CAAC,CAAC,SAAS,WAAW,EAAE,OAAO,CAAC,EAAE,CAAC,GAAG,UAAU,CAAC,CAAC,CAAC,GAAG,OAAO,CAAC,UAAU,CAAC,CAAC,CAAC,CAAC,CAAA;IAChF;;;;;;OAMG;IACH,GAAG,CAAC,GAAG,EAAE,MAAM,EAAE,IAAI,EAAE,IAAI,GAAG,IAAI,GAAG,OAAO,CAAC,IAAI,CAAC,CAAA;IAClD;;;;OAIG;IACH,MAAM,CAAC,GAAG,EAAE,MAAM,GAAG,IAAI,GAAG,OAAO,CAAC,IAAI,CAAC,CAAA;IACzC;;;;;;OAMG;IACH,GAAG,CAAC,GAAG,EAAE,MAAM,EAAE,IAAI,EAAE,IAAI,GAAG,IAAI,GAAG,OAAO,CAAC,IAAI,CAAC,CAAA;CACnD;AAED,MAAM,WAAW,OAAO;IACtB;;OAEG;IACH,GAAG,EAAE,MAAM,CAAA;CACZ;AAED;;GAEG;AACH,MAAM,WAAW,YAAa,SAAQ,OAAO;IAC3C;;OAEG;IACH,YAAY,EAAE,MAAM,CAAA;IACpB;;OAEG;IACH,IAAI,EAAE,MAAM,CAAA;IACZ;;OAEG;IACH,IAAI,EAAE,MAAM,CAAA;IACZ;;OAEG;IACH,IAAI,EAAE,MAAM,CAAA;CACb;AAED,MAAM,WAAW,WAAW;IAC1B;;OAEG;IACH,MAAM,CAAC,EAAE,MAAM,CAAA;IACf;;OAEG;IACH,eAAe,CAAC,EAAE,OAAO,CAAA;IACzB;;OAEG;IACH,KAAK,CAAC,EAAE,MAAM,CAAA;IACd;;OAEG;IACH,MAAM,CAAC,EAAE,MAAM,CAAA;CAChB;AAED,MAAM,WAAW,UAAU,CAAC,CAAC,SAAS,WAAW;IAC/C;;;OAGG;IACH,MAAM,CAAC,EAAE,MAAM,CAAA;IACf;;OAEG;IACH,KAAK,EAAE,CAAC,CAAC,SAAS;QAAE,eAAe,EAAE,IAAI,CAAA;KAAE,GAAG,YAAY,GAAG,OAAO,CAAC,EAAE,CAAA;CACxE"}

package/dist/memory.d.ts

@@ -1,2 +1,2 @@
-export { MemoryFileStorage } from './lib/memory-file-storage.ts';
+export { createMemoryFileStorage } from './lib/backends/memory.ts';
 //# sourceMappingURL=memory.d.ts.map

package/dist/memory.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"memory.d.ts","sourceRoot":"","sources":["../src/memory.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,iBAAiB,EAAE,MAAM,8BAA8B,CAAA"}
+{"version":3,"file":"memory.d.ts","sourceRoot":"","sources":["../src/memory.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,uBAAuB,EAAE,MAAM,0BAA0B,CAAA"}

package/dist/memory.js

@@ -1 +1 @@
-export { MemoryFileStorage } from "./lib/memory-file-storage.js";
+export { createMemoryFileStorage } from "./lib/backends/memory.js";

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@remix-run/file-storage",
-  "version": "0.12.0",
+  "version": "0.13.0",
   "description": "Key/value storage for JavaScript File objects",
   "author": "Michael Jackson <mjijackson@gmail.com>",
   "repository": {
@@ -23,9 +23,9 @@
       "types": "./dist/index.d.ts",
       "default": "./dist/index.js"
     },
-    "./local": {
-      "types": "./dist/local.d.ts",
-      "default": "./dist/local.js"
+    "./fs": {
+      "types": "./dist/fs.d.ts",
+      "default": "./dist/fs.js"
     },
     "./memory": {
       "types": "./dist/memory.d.ts",

package/src/fs.ts

@@ -0,0 +1 @@
+export { createFsFileStorage } from './lib/backends/fs.ts'

package/src/lib/backends/fs.ts

@@ -0,0 +1,195 @@
+import * as fs from 'node:fs'
+import * as fsp from 'node:fs/promises'
+import * as path from 'node:path'
+import { openFile, writeFile } from '@remix-run/fs'
+
+import type { FileStorage, FileMetadata, ListOptions, ListResult } from '../file-storage.ts'
+
+type MetadataJson = Omit<FileMetadata, 'size'>
+
+/**
+ * Creates a `FileStorage` that is backed by a filesystem directory using node:fs.
+ *
+ * Important: No attempt is made to avoid overwriting existing files, so the directory used should
+ * be a new directory solely dedicated to this storage object.
+ *
+ * Note: Keys have no correlation to file names on disk, so they may be any string including
+ * characters that are not valid in file names. Additionally, individual `File` names have no
+ * correlation to names of files on disk, so multiple files with the same name may be stored in the
+ * same storage object.
+ *
+ * @param directory The directory where files are stored
+ * @returns A new file storage backed by a filesystem directory
+ */
+export function createFsFileStorage(directory: string): FileStorage {
+  let rootDir = path.resolve(directory)
+
+  try {
+    let stats = fs.statSync(rootDir)
+
+    if (!stats.isDirectory()) {
+      throw new Error(`Path "${rootDir}" is not a directory`)
+    }
+  } catch (error) {
+    if (!isNoEntityError(error)) {
+      throw error
+    }
+
+    fs.mkdirSync(rootDir, { recursive: true })
+  }
+
+  async function getPaths(
+    key: string,
+  ): Promise<{ directory: string; filePath: string; metaPath: string }> {
+    let hash = await computeHash(key)
+    let directory = path.join(rootDir, hash.slice(0, 2))
+
+    return {
+      directory,
+      filePath: path.join(directory, `${hash}.dat`),
+      metaPath: path.join(directory, `${hash}.meta.json`),
+    }
+  }
+
+  async function putFile(key: string, file: File): Promise<File> {
+    let { directory, filePath, metaPath } = await getPaths(key)
+
+    // Ensure directory exists
+    await fsp.mkdir(directory, { recursive: true })
+
+    await writeFile(filePath, file)
+
+    let meta: MetadataJson = {
+      key,
+      lastModified: file.lastModified,
+      name: file.name,
+      type: file.type,
+    }
+    await fsp.writeFile(metaPath, JSON.stringify(meta))
+
+    let metaData = await readMetadata(metaPath)
+
+    return openFile(filePath, {
+      lastModified: metaData.lastModified,
+      name: metaData.name,
+      type: metaData.type,
+    })
+  }
+
+  return {
+    async get(key: string): Promise<File | null> {
+      let { filePath, metaPath } = await getPaths(key)
+
+      try {
+        let meta = await readMetadata(metaPath)
+
+        return openFile(filePath, {
+          lastModified: meta.lastModified,
+          name: meta.name,
+          type: meta.type,
+        })
+      } catch (error) {
+        if (!isNoEntityError(error)) {
+          throw error
+        }
+
+        return null
+      }
+    },
+    async has(key: string): Promise<boolean> {
+      let { metaPath } = await getPaths(key)
+
+      try {
+        await fsp.access(metaPath)
+        return true
+      } catch {
+        return false
+      }
+    },
+    async list<opts extends ListOptions>(options?: opts): Promise<ListResult<opts>> {
+      let { cursor, includeMetadata = false, limit = 32, prefix } = options ?? {}
+
+      let files: any[] = []
+      let foundCursor = cursor === undefined
+      let nextCursor: string | undefined
+      let lastHash: string | undefined
+
+      outerLoop: for await (let subdir of await fsp.opendir(rootDir)) {
+        if (!subdir.isDirectory()) continue
+
+        for await (let file of await fsp.opendir(path.join(rootDir, subdir.name))) {
+          if (!file.isFile() || !file.name.endsWith('.meta.json')) continue
+
+          let hash = file.name.slice(0, -10) // Remove ".meta.json"
+
+          if (foundCursor) {
+            let meta = await readMetadata(path.join(rootDir, subdir.name, file.name))
+
+            if (prefix != null && !meta.key.startsWith(prefix)) {
+              continue
+            }
+
+            if (files.length >= limit) {
+              nextCursor = lastHash
+              break outerLoop
+            }
+
+            if (includeMetadata) {
+              let size = (await fsp.stat(path.join(rootDir, subdir.name, `${hash}.dat`))).size
+              files.push({ ...meta, size })
+            } else {
+              files.push({ key: meta.key })
+            }
+          } else if (hash === cursor) {
+            foundCursor = true
+          }
+
+          lastHash = hash
+        }
+      }
+
+      return {
+        cursor: nextCursor,
+        files,
+      }
+    },
+    put(key: string, file: File): Promise<File> {
+      return putFile(key, file)
+    },
+    async remove(key: string): Promise<void> {
+      let { directory, filePath, metaPath } = await getPaths(key)
+
+      try {
+        await Promise.all([fsp.unlink(filePath), fsp.unlink(metaPath)])
+
+        // Check if directory is empty and remove it if so
+        let files = await fsp.readdir(directory)
+        if (files.length === 0) {
+          await fsp.rmdir(directory)
+        }
+      } catch (error) {
+        if (!isNoEntityError(error)) {
+          throw error
+        }
+      }
+    },
+    async set(key: string, file: File): Promise<void> {
+      await putFile(key, file)
+    },
+  }
+}
+
+async function readMetadata(metaPath: string): Promise<MetadataJson> {
+  return JSON.parse(await fsp.readFile(metaPath, 'utf-8'))
+}
+
+async function computeHash(key: string, algorithm = 'SHA-256'): Promise<string> {
+  let digest = await crypto.subtle.digest(algorithm, new TextEncoder().encode(key))
+  return Array.from(new Uint8Array(digest))
+    .map((b) => b.toString(16).padStart(2, '0'))
+    .join('')
+}
+
+function isNoEntityError(obj: unknown): obj is NodeJS.ErrnoException & { code: 'ENOENT' } {
+  return obj instanceof Error && 'code' in obj && (obj as NodeJS.ErrnoException).code === 'ENOENT'
+}

package/src/lib/backends/memory.ts

@@ -0,0 +1,76 @@
+import type { FileStorage, ListOptions, ListResult } from '../file-storage.ts'
+
+/**
+ * Creates a simple, in-memory implementation of the `FileStorage` interface.
+ * @returns A new in-memory file storage instance
+ */
+export function createMemoryFileStorage(): FileStorage {
+  let map = new Map<string, File>()
+
+  async function putFile(key: string, file: File): Promise<File> {
+    let buffer = await file.arrayBuffer()
+    let newFile = new File([buffer], file.name, {
+      lastModified: file.lastModified,
+      type: file.type,
+    })
+    map.set(key, newFile)
+    return newFile
+  }
+
+  return {
+    get(key: string): File | null {
+      return map.get(key) ?? null
+    },
+    has(key: string): boolean {
+      return map.has(key)
+    },
+    list<opts extends ListOptions>(options?: opts): ListResult<opts> {
+      let { cursor, includeMetadata = false, limit = Infinity, prefix } = options ?? {}
+
+      let files: any[] = []
+      let foundCursor = cursor === undefined
+      let nextCursor: string | undefined
+
+      for (let [key, file] of map.entries()) {
+        if (foundCursor) {
+          if (prefix != null && !key.startsWith(prefix)) {
+            continue
+          }
+
+          if (files.length >= limit) {
+            nextCursor = files[files.length - 1]?.key
+            break
+          }
+
+          if (includeMetadata) {
+            files.push({
+              key,
+              lastModified: file.lastModified,
+              name: file.name,
+              size: file.size,
+              type: file.type,
+            })
+          } else {
+            files.push({ key })
+          }
+        } else if (key === cursor) {
+          foundCursor = true
+        }
+      }
+
+      return {
+        cursor: nextCursor,
+        files,
+      }
+    },
+    put(key: string, file: File): Promise<File> {
+      return putFile(key, file)
+    },
+    remove(key: string): void {
+      map.delete(key)
+    },
+    async set(key: string, file: File): Promise<void> {
+      await putFile(key, file)
+    },
+  }
+}

package/src/lib/file-storage.ts

@@ -8,14 +8,12 @@ export interface FileStorage {
    * @returns The file with the given key, or `null` if no such key exists
    */
   get(key: string): File | null | Promise<File | null>
-
   /**
    * Check if a file with the given key exists.
    * @param key The key to look up
    * @returns `true` if a file with the given key exists, `false` otherwise
    */
   has(key: string): boolean | Promise<boolean>
-
   /**
    * List the files in storage.
    *
@@ -76,7 +74,6 @@ export interface FileStorage {
    * @returns An object with an array of `files` and an optional `cursor` property
    */
   list<T extends ListOptions>(options?: T): ListResult<T> | Promise<ListResult<T>>
-
   /**
    * Put a [`File`](https://developer.mozilla.org/en-US/docs/Web/API/File) in storage and return
    * a new file backed by this storage.
@@ -85,14 +82,12 @@ export interface FileStorage {
    * @returns A new File object backed by this storage
    */
   put(key: string, file: File): File | Promise<File>
-
   /**
    * Remove the file with the given key from storage.
    * @param key The key to remove
    * @returns A promise that resolves when the file has been removed
    */
   remove(key: string): void | Promise<void>
-
   /**
    * Put a [`File`](https://developer.mozilla.org/en-US/docs/Web/API/File) in storage at the given
    * key.

package/src/memory.ts

@@ -1 +1 @@
-export { MemoryFileStorage } from './lib/memory-file-storage.ts'
+export { createMemoryFileStorage } from './lib/backends/memory.ts'

package/dist/lib/local-file-storage.d.ts

@@ -1,26 +0,0 @@
-import type { FileStorage, ListOptions, ListResult } from './file-storage.ts';
-/**
- * A `FileStorage` that is backed by a directory on the local filesystem.
- *
- * Important: No attempt is made to avoid overwriting existing files, so the directory used should
- * be a new directory solely dedicated to this storage object.
- *
- * Note: Keys have no correlation to file names on disk, so they may be any string including
- * characters that are not valid in file names. Additionally, individual `File` names have no
- * correlation to names of files on disk, so multiple files with the same name may be stored in the
- * same storage object.
- */
-export declare class LocalFileStorage implements FileStorage {
-    #private;
-    /**
-     * @param directory The directory where files are stored
-     */
-    constructor(directory: string);
-    get(key: string): Promise<File | null>;
-    has(key: string): Promise<boolean>;
-    list<T extends ListOptions>(options?: T): Promise<ListResult<T>>;
-    put(key: string, file: File): Promise<File>;
-    remove(key: string): Promise<void>;
-    set(key: string, file: File): Promise<void>;
-}
-//# sourceMappingURL=local-file-storage.d.ts.map

package/dist/lib/local-file-storage.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"local-file-storage.d.ts","sourceRoot":"","sources":["../../src/lib/local-file-storage.ts"],"names":[],"mappings":"AAKA,OAAO,KAAK,EAAE,WAAW,EAAgB,WAAW,EAAE,UAAU,EAAE,MAAM,mBAAmB,CAAA;AAI3F;;;;;;;;;;GAUG;AACH,qBAAa,gBAAiB,YAAW,WAAW;;IAGlD;;OAEG;gBACS,SAAS,EAAE,MAAM;IAkBvB,GAAG,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,GAAG,IAAI,CAAC;IAoBtC,GAAG,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,CAAC,OAAO,CAAC;IAWlC,IAAI,CAAC,CAAC,SAAS,WAAW,EAAE,OAAO,CAAC,EAAE,CAAC,GAAG,OAAO,CAAC,UAAU,CAAC,CAAC,CAAC,CAAC;IAgDhE,GAAG,CAAC,GAAG,EAAE,MAAM,EAAE,IAAI,EAAE,IAAI,GAAG,OAAO,CAAC,IAAI,CAAC;IAK3C,MAAM,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO,CAAC,IAAI,CAAC;IAkBlC,GAAG,CAAC,GAAG,EAAE,MAAM,EAAE,IAAI,EAAE,IAAI,GAAG,OAAO,CAAC,IAAI,CAAC;CA2BlD"}

package/dist/lib/local-file-storage.js

@@ -1,158 +0,0 @@
-import * as fs from 'node:fs';
-import * as fsp from 'node:fs/promises';
-import * as path from 'node:path';
-import { openFile, writeFile } from '@remix-run/fs';
-/**
- * A `FileStorage` that is backed by a directory on the local filesystem.
- *
- * Important: No attempt is made to avoid overwriting existing files, so the directory used should
- * be a new directory solely dedicated to this storage object.
- *
- * Note: Keys have no correlation to file names on disk, so they may be any string including
- * characters that are not valid in file names. Additionally, individual `File` names have no
- * correlation to names of files on disk, so multiple files with the same name may be stored in the
- * same storage object.
- */
-export class LocalFileStorage {
-    #dirname;
-    /**
-     * @param directory The directory where files are stored
-     */
-    constructor(directory) {
-        this.#dirname = path.resolve(directory);
-        try {
-            let stats = fs.statSync(this.#dirname);
-            if (!stats.isDirectory()) {
-                throw new Error(`Path "${this.#dirname}" is not a directory`);
-            }
-        }
-        catch (error) {
-            if (!isNoEntityError(error)) {
-                throw error;
-            }
-            fs.mkdirSync(this.#dirname, { recursive: true });
-        }
-    }
-    async get(key) {
-        let { filePath, metaPath } = await this.#getPaths(key);
-        try {
-            let meta = await readMetadata(metaPath);
-            return openFile(filePath, {
-                lastModified: meta.lastModified,
-                name: meta.name,
-                type: meta.type,
-            });
-        }
-        catch (error) {
-            if (!isNoEntityError(error)) {
-                throw error;
-            }
-            return null;
-        }
-    }
-    async has(key) {
-        let { metaPath } = await this.#getPaths(key);
-        try {
-            await fsp.access(metaPath);
-            return true;
-        }
-        catch {
-            return false;
-        }
-    }
-    async list(options) {
-        let { cursor, includeMetadata = false, limit = 32, prefix } = options ?? {};
-        let files = [];
-        let foundCursor = cursor === undefined;
-        let nextCursor;
-        let lastHash;
-        outerLoop: for await (let subdir of await fsp.opendir(this.#dirname)) {
-            if (!subdir.isDirectory())
-                continue;
-            for await (let file of await fsp.opendir(path.join(this.#dirname, subdir.name))) {
-                if (!file.isFile() || !file.name.endsWith('.meta.json'))
-                    continue;
-                let hash = file.name.slice(0, -10); // Remove ".meta.json"
-                if (foundCursor) {
-                    let meta = await readMetadata(path.join(this.#dirname, subdir.name, file.name));
-                    if (prefix != null && !meta.key.startsWith(prefix)) {
-                        continue;
-                    }
-                    if (files.length >= limit) {
-                        nextCursor = lastHash;
-                        break outerLoop;
-                    }
-                    if (includeMetadata) {
-                        let size = (await fsp.stat(path.join(this.#dirname, subdir.name, `${hash}.dat`))).size;
-                        files.push({ ...meta, size });
-                    }
-                    else {
-                        files.push({ key: meta.key });
-                    }
-                }
-                else if (hash === cursor) {
-                    foundCursor = true;
-                }
-                lastHash = hash;
-            }
-        }
-        return {
-            cursor: nextCursor,
-            files,
-        };
-    }
-    async put(key, file) {
-        await this.set(key, file);
-        return (await this.get(key));
-    }
-    async remove(key) {
-        let { directory, filePath, metaPath } = await this.#getPaths(key);
-        try {
-            await Promise.all([fsp.unlink(filePath), fsp.unlink(metaPath)]);
-            // Check if directory is empty and remove it if so
-            let files = await fsp.readdir(directory);
-            if (files.length === 0) {
-                await fsp.rmdir(directory);
-            }
-        }
-        catch (error) {
-            if (!isNoEntityError(error)) {
-                throw error;
-            }
-        }
-    }
-    async set(key, file) {
-        let { directory, filePath, metaPath } = await this.#getPaths(key);
-        // Ensure directory exists
-        await fsp.mkdir(directory, { recursive: true });
-        await writeFile(filePath, file);
-        let meta = {
-            key,
-            lastModified: file.lastModified,
-            name: file.name,
-            type: file.type,
-        };
-        await fsp.writeFile(metaPath, JSON.stringify(meta));
-    }
-    async #getPaths(key) {
-        let hash = await computeHash(key);
-        let directory = path.join(this.#dirname, hash.slice(0, 2));
-        return {
-            directory,
-            filePath: path.join(directory, `${hash}.dat`),
-            metaPath: path.join(directory, `${hash}.meta.json`),
-        };
-    }
-}
-async function readMetadata(metaPath) {
-    return JSON.parse(await fsp.readFile(metaPath, 'utf-8'));
-}
-async function computeHash(key, algorithm = 'SHA-256') {
-    let digest = await crypto.subtle.digest(algorithm, new TextEncoder().encode(key));
-    return Array.from(new Uint8Array(digest))
-        .map((b) => b.toString(16).padStart(2, '0'))
-        .join('');
-}
-function isNoEntityError(obj) {
-    return obj instanceof Error && 'code' in obj && obj.code === 'ENOENT';
-}

package/dist/lib/memory-file-storage.d.ts

@@ -1,14 +0,0 @@
-import type { FileStorage, ListOptions, ListResult } from './file-storage.ts';
-/**
- * A simple, in-memory implementation of the `FileStorage` interface.
- */
-export declare class MemoryFileStorage implements FileStorage {
-    #private;
-    get(key: string): File | null;
-    has(key: string): boolean;
-    list<T extends ListOptions>(options?: T): ListResult<T>;
-    put(key: string, file: File): Promise<File>;
-    remove(key: string): void;
-    set(key: string, file: File): Promise<void>;
-}
-//# sourceMappingURL=memory-file-storage.d.ts.map

package/dist/lib/memory-file-storage.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"memory-file-storage.d.ts","sourceRoot":"","sources":["../../src/lib/memory-file-storage.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,WAAW,EAAE,WAAW,EAAE,UAAU,EAAE,MAAM,mBAAmB,CAAA;AAE7E;;GAEG;AACH,qBAAa,iBAAkB,YAAW,WAAW;;IAGnD,GAAG,CAAC,GAAG,EAAE,MAAM,GAAG,IAAI,GAAG,IAAI;IAI7B,GAAG,CAAC,GAAG,EAAE,MAAM,GAAG,OAAO;IAIzB,IAAI,CAAC,CAAC,SAAS,WAAW,EAAE,OAAO,CAAC,EAAE,CAAC,GAAG,UAAU,CAAC,CAAC,CAAC;IAwCjD,GAAG,CAAC,GAAG,EAAE,MAAM,EAAE,IAAI,EAAE,IAAI,GAAG,OAAO,CAAC,IAAI,CAAC;IAKjD,MAAM,CAAC,GAAG,EAAE,MAAM,GAAG,IAAI;IAInB,GAAG,CAAC,GAAG,EAAE,MAAM,EAAE,IAAI,EAAE,IAAI,GAAG,OAAO,CAAC,IAAI,CAAC;CASlD"}

package/dist/lib/memory-file-storage.js

@@ -1,63 +0,0 @@
-/**
- * A simple, in-memory implementation of the `FileStorage` interface.
- */
-export class MemoryFileStorage {
-    #map = new Map();
-    get(key) {
-        return this.#map.get(key) ?? null;
-    }
-    has(key) {
-        return this.#map.has(key);
-    }
-    list(options) {
-        let { cursor, includeMetadata = false, limit = Infinity, prefix } = options ?? {};
-        let files = [];
-        let foundCursor = cursor === undefined;
-        let nextCursor;
-        for (let [key, file] of this.#map.entries()) {
-            if (foundCursor) {
-                if (prefix != null && !key.startsWith(prefix)) {
-                    continue;
-                }
-                if (files.length >= limit) {
-                    nextCursor = files[files.length - 1]?.key;
-                    break;
-                }
-                if (includeMetadata) {
-                    files.push({
-                        key,
-                        lastModified: file.lastModified,
-                        name: file.name,
-                        size: file.size,
-                        type: file.type,
-                    });
-                }
-                else {
-                    files.push({ key });
-                }
-            }
-            else if (key === cursor) {
-                foundCursor = true;
-            }
-        }
-        return {
-            cursor: nextCursor,
-            files,
-        };
-    }
-    async put(key, file) {
-        await this.set(key, file);
-        return this.get(key);
-    }
-    remove(key) {
-        this.#map.delete(key);
-    }
-    async set(key, file) {
-        let buffer = await file.arrayBuffer();
-        let newFile = new File([buffer], file.name, {
-            lastModified: file.lastModified,
-            type: file.type,
-        });
-        this.#map.set(key, newFile);
-    }
-}

package/dist/local.d.ts

@@ -1,2 +0,0 @@
-export { LocalFileStorage } from './lib/local-file-storage.ts';
-//# sourceMappingURL=local.d.ts.map

package/dist/local.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"local.d.ts","sourceRoot":"","sources":["../src/local.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,gBAAgB,EAAE,MAAM,6BAA6B,CAAA"}

package/dist/local.js

@@ -1 +0,0 @@
-export { LocalFileStorage } from "./lib/local-file-storage.js";

package/src/lib/local-file-storage.ts

@@ -1,189 +0,0 @@
-import * as fs from 'node:fs'
-import * as fsp from 'node:fs/promises'
-import * as path from 'node:path'
-import { openFile, writeFile } from '@remix-run/fs'
-
-import type { FileStorage, FileMetadata, ListOptions, ListResult } from './file-storage.ts'
-
-type MetadataJson = Omit<FileMetadata, 'size'>
-
-/**
- * A `FileStorage` that is backed by a directory on the local filesystem.
- *
- * Important: No attempt is made to avoid overwriting existing files, so the directory used should
- * be a new directory solely dedicated to this storage object.
- *
- * Note: Keys have no correlation to file names on disk, so they may be any string including
- * characters that are not valid in file names. Additionally, individual `File` names have no
- * correlation to names of files on disk, so multiple files with the same name may be stored in the
- * same storage object.
- */
-export class LocalFileStorage implements FileStorage {
-  #dirname: string
-
-  /**
-   * @param directory The directory where files are stored
-   */
-  constructor(directory: string) {
-    this.#dirname = path.resolve(directory)
-
-    try {
-      let stats = fs.statSync(this.#dirname)
-
-      if (!stats.isDirectory()) {
-        throw new Error(`Path "${this.#dirname}" is not a directory`)
-      }
-    } catch (error) {
-      if (!isNoEntityError(error)) {
-        throw error
-      }
-
-      fs.mkdirSync(this.#dirname, { recursive: true })
-    }
-  }
-
-  async get(key: string): Promise<File | null> {
-    let { filePath, metaPath } = await this.#getPaths(key)
-
-    try {
-      let meta = await readMetadata(metaPath)
-
-      return openFile(filePath, {
-        lastModified: meta.lastModified,
-        name: meta.name,
-        type: meta.type,
-      })
-    } catch (error) {
-      if (!isNoEntityError(error)) {
-        throw error
-      }
-
-      return null
-    }
-  }
-
-  async has(key: string): Promise<boolean> {
-    let { metaPath } = await this.#getPaths(key)
-
-    try {
-      await fsp.access(metaPath)
-      return true
-    } catch {
-      return false
-    }
-  }
-
-  async list<T extends ListOptions>(options?: T): Promise<ListResult<T>> {
-    let { cursor, includeMetadata = false, limit = 32, prefix } = options ?? {}
-
-    let files: any[] = []
-    let foundCursor = cursor === undefined
-    let nextCursor: string | undefined
-    let lastHash: string | undefined
-
-    outerLoop: for await (let subdir of await fsp.opendir(this.#dirname)) {
-      if (!subdir.isDirectory()) continue
-
-      for await (let file of await fsp.opendir(path.join(this.#dirname, subdir.name))) {
-        if (!file.isFile() || !file.name.endsWith('.meta.json')) continue
-
-        let hash = file.name.slice(0, -10) // Remove ".meta.json"
-
-        if (foundCursor) {
-          let meta = await readMetadata(path.join(this.#dirname, subdir.name, file.name))
-
-          if (prefix != null && !meta.key.startsWith(prefix)) {
-            continue
-          }
-
-          if (files.length >= limit) {
-            nextCursor = lastHash
-            break outerLoop
-          }
-
-          if (includeMetadata) {
-            let size = (await fsp.stat(path.join(this.#dirname, subdir.name, `${hash}.dat`))).size
-            files.push({ ...meta, size })
-          } else {
-            files.push({ key: meta.key })
-          }
-        } else if (hash === cursor) {
-          foundCursor = true
-        }
-
-        lastHash = hash
-      }
-    }
-
-    return {
-      cursor: nextCursor,
-      files,
-    }
-  }
-
-  async put(key: string, file: File): Promise<File> {
-    await this.set(key, file)
-    return (await this.get(key))!
-  }
-
-  async remove(key: string): Promise<void> {
-    let { directory, filePath, metaPath } = await this.#getPaths(key)
-
-    try {
-      await Promise.all([fsp.unlink(filePath), fsp.unlink(metaPath)])
-
-      // Check if directory is empty and remove it if so
-      let files = await fsp.readdir(directory)
-      if (files.length === 0) {
-        await fsp.rmdir(directory)
-      }
-    } catch (error) {
-      if (!isNoEntityError(error)) {
-        throw error
-      }
-    }
-  }
-
-  async set(key: string, file: File): Promise<void> {
-    let { directory, filePath, metaPath } = await this.#getPaths(key)
-
-    // Ensure directory exists
-    await fsp.mkdir(directory, { recursive: true })
-
-    await writeFile(filePath, file)
-
-    let meta: MetadataJson = {
-      key,
-      lastModified: file.lastModified,
-      name: file.name,
-      type: file.type,
-    }
-    await fsp.writeFile(metaPath, JSON.stringify(meta))
-  }
-
-  async #getPaths(key: string): Promise<{ directory: string; filePath: string; metaPath: string }> {
-    let hash = await computeHash(key)
-    let directory = path.join(this.#dirname, hash.slice(0, 2))
-
-    return {
-      directory,
-      filePath: path.join(directory, `${hash}.dat`),
-      metaPath: path.join(directory, `${hash}.meta.json`),
-    }
-  }
-}
-
-async function readMetadata(metaPath: string): Promise<MetadataJson> {
-  return JSON.parse(await fsp.readFile(metaPath, 'utf-8'))
-}
-
-async function computeHash(key: string, algorithm = 'SHA-256'): Promise<string> {
-  let digest = await crypto.subtle.digest(algorithm, new TextEncoder().encode(key))
-  return Array.from(new Uint8Array(digest))
-    .map((b) => b.toString(16).padStart(2, '0'))
-    .join('')
-}
-
-function isNoEntityError(obj: unknown): obj is NodeJS.ErrnoException & { code: 'ENOENT' } {
-  return obj instanceof Error && 'code' in obj && (obj as NodeJS.ErrnoException).code === 'ENOENT'
-}

package/src/lib/memory-file-storage.ts

@@ -1,75 +0,0 @@
-import type { FileStorage, ListOptions, ListResult } from './file-storage.ts'
-
-/**
- * A simple, in-memory implementation of the `FileStorage` interface.
- */
-export class MemoryFileStorage implements FileStorage {
-  #map = new Map<string, File>()
-
-  get(key: string): File | null {
-    return this.#map.get(key) ?? null
-  }
-
-  has(key: string): boolean {
-    return this.#map.has(key)
-  }
-
-  list<T extends ListOptions>(options?: T): ListResult<T> {
-    let { cursor, includeMetadata = false, limit = Infinity, prefix } = options ?? {}
-
-    let files: any[] = []
-    let foundCursor = cursor === undefined
-    let nextCursor: string | undefined
-
-    for (let [key, file] of this.#map.entries()) {
-      if (foundCursor) {
-        if (prefix != null && !key.startsWith(prefix)) {
-          continue
-        }
-
-        if (files.length >= limit) {
-          nextCursor = files[files.length - 1]?.key
-          break
-        }
-
-        if (includeMetadata) {
-          files.push({
-            key,
-            lastModified: file.lastModified,
-            name: file.name,
-            size: file.size,
-            type: file.type,
-          })
-        } else {
-          files.push({ key })
-        }
-      } else if (key === cursor) {
-        foundCursor = true
-      }
-    }
-
-    return {
-      cursor: nextCursor,
-      files,
-    }
-  }
-
-  async put(key: string, file: File): Promise<File> {
-    await this.set(key, file)
-    return this.get(key)!
-  }
-
-  remove(key: string): void {
-    this.#map.delete(key)
-  }
-
-  async set(key: string, file: File): Promise<void> {
-    let buffer = await file.arrayBuffer()
-    let newFile = new File([buffer], file.name, {
-      lastModified: file.lastModified,
-      type: file.type,
-    })
-
-    this.#map.set(key, newFile)
-  }
-}

package/src/local.ts

@@ -1 +0,0 @@
-export { LocalFileStorage } from './lib/local-file-storage.ts'