@b9g/filesystem 0.1.4 → 0.1.6

package/src/memory.js

@@ -1,187 +1,236 @@
 /// <reference types="./memory.d.ts" />
 // src/memory.ts
-var MemoryFileSystemWritableFileStream = class extends WritableStream {
-  constructor(onClose) {
-    super({
-      write: (chunk) => {
-        this.chunks.push(chunk);
-        return Promise.resolve();
-      },
-      close: () => {
-        const totalLength = this.chunks.reduce((sum, chunk) => sum + chunk.length, 0);
-        const content = new Uint8Array(totalLength);
-        let offset = 0;
-        for (const chunk of this.chunks) {
-          content.set(chunk, offset);
-          offset += chunk.length;
-        }
-        this.onClose(content);
-        return Promise.resolve();
-      },
-      abort: () => {
-        this.chunks = [];
-        return Promise.resolve();
-      }
-    });
-    this.onClose = onClose;
-  }
-  chunks = [];
-};
-var MemoryFileSystemFileHandle = class _MemoryFileSystemFileHandle {
-  constructor(file, updateFile) {
-    this.file = file;
-    this.updateFile = updateFile;
-    this.name = file.name;
-  }
-  kind = "file";
-  name;
-  async getFile() {
-    return new File([this.file.content], this.file.name, {
-      lastModified: this.file.lastModified,
-      type: this.file.type
-    });
-  }
-  async createWritable() {
-    return new MemoryFileSystemWritableFileStream((content) => {
-      this.updateFile(content);
-    });
-  }
-  async createSyncAccessHandle() {
-    throw new DOMException(
-      "Synchronous access handles are not supported in memory filesystem",
-      "InvalidStateError"
-    );
-  }
-  async isSameEntry(other) {
-    if (other.kind !== "file")
-      return false;
-    if (!(other instanceof _MemoryFileSystemFileHandle))
-      return false;
-    return this.file === other.file;
-  }
-  async queryPermission() {
-    return "granted";
-  }
-  async requestPermission() {
-    return "granted";
+import {
+  ShovelDirectoryHandle,
+  ShovelFileHandle
+} from "./index.js";
+var MemoryFileSystemBackend = class {
+  #root;
+  constructor(root) {
+    this.#root = root;
+  }
+  async stat(path) {
+    const entry = this.#resolvePath(path);
+    if (!entry)
+      return null;
+    if ("content" in entry) {
+      return { kind: "file" };
+    } else {
+      return { kind: "directory" };
+    }
   }
-};
-var MemoryFileSystemDirectoryHandle = class _MemoryFileSystemDirectoryHandle {
-  constructor(directory) {
-    this.directory = directory;
-    this.name = directory.name;
+  async readFile(path) {
+    const entry = this.#resolvePath(path);
+    if (!entry || !("content" in entry)) {
+      throw new DOMException("File not found", "NotFoundError");
+    }
+    return {
+      content: entry.content,
+      lastModified: entry.lastModified
+    };
   }
-  kind = "directory";
-  name;
-  async getFileHandle(name, options) {
-    const file = this.directory.files.get(name);
-    if (!file && options?.create) {
-      const newFile = {
+  async writeFile(path, data) {
+    const { parentDir, name } = this.#resolveParent(path);
+    if (!parentDir) {
+      throw new DOMException("Parent directory not found", "NotFoundError");
+    }
+    const existingFile = parentDir.files.get(name);
+    if (existingFile) {
+      existingFile.content = data;
+      existingFile.lastModified = Date.now();
+    } else {
+      parentDir.files.set(name, {
         name,
-        content: new Uint8Array(0),
+        content: data,
         lastModified: Date.now(),
         type: "application/octet-stream"
-      };
-      this.directory.files.set(name, newFile);
-      return new MemoryFileSystemFileHandle(newFile, (content, type) => {
-        newFile.content = content;
-        newFile.lastModified = Date.now();
-        if (type)
-          newFile.type = type;
       });
-    } else if (!file) {
-      throw new DOMException("File not found", "NotFoundError");
     }
-    return new MemoryFileSystemFileHandle(file, (content, type) => {
-      file.content = content;
-      file.lastModified = Date.now();
-      if (type)
-        file.type = type;
-    });
   }
-  async getDirectoryHandle(name, options) {
-    const dir = this.directory.directories.get(name);
-    if (!dir && options?.create) {
-      const newDir = {
+  async listDir(path) {
+    const entry = this.#resolvePath(path);
+    if (!entry || "content" in entry) {
+      throw new DOMException("Directory not found", "NotFoundError");
+    }
+    const results = [];
+    for (const fileName of entry.files.keys()) {
+      results.push({ name: fileName, kind: "file" });
+    }
+    for (const dirName of entry.directories.keys()) {
+      results.push({ name: dirName, kind: "directory" });
+    }
+    return results;
+  }
+  async createDir(path) {
+    const { parentDir, name } = this.#resolveParent(path);
+    if (!parentDir) {
+      throw new DOMException("Parent directory not found", "NotFoundError");
+    }
+    if (!parentDir.directories.has(name)) {
+      parentDir.directories.set(name, {
         name,
         files: /* @__PURE__ */ new Map(),
         directories: /* @__PURE__ */ new Map()
-      };
-      this.directory.directories.set(name, newDir);
-      return new _MemoryFileSystemDirectoryHandle(newDir);
-    } else if (!dir) {
-      throw new DOMException("Directory not found", "NotFoundError");
+      });
     }
-    return new _MemoryFileSystemDirectoryHandle(dir);
   }
-  async removeEntry(name, options) {
-    if (this.directory.files.has(name)) {
-      this.directory.files.delete(name);
+  async remove(path, recursive) {
+    const { parentDir, name } = this.#resolveParent(path);
+    if (!parentDir) {
+      throw new DOMException("Entry not found", "NotFoundError");
+    }
+    if (parentDir.files.has(name)) {
+      parentDir.files.delete(name);
       return;
     }
-    const dir = this.directory.directories.get(name);
+    const dir = parentDir.directories.get(name);
     if (dir) {
-      if (dir.files.size > 0 || dir.directories.size > 0) {
-        if (!options?.recursive) {
-          throw new DOMException(
-            "Directory is not empty",
-            "InvalidModificationError"
-          );
-        }
+      if ((dir.files.size > 0 || dir.directories.size > 0) && !recursive) {
+        throw new DOMException(
+          "Directory is not empty",
+          "InvalidModificationError"
+        );
       }
-      this.directory.directories.delete(name);
+      parentDir.directories.delete(name);
       return;
     }
     throw new DOMException("Entry not found", "NotFoundError");
   }
-  async resolve(possibleDescendant) {
-    if (possibleDescendant instanceof MemoryFileSystemFileHandle) {
-      if (this.directory.files.has(possibleDescendant.name)) {
-        return [possibleDescendant.name];
+  #resolvePath(path) {
+    if (path.includes("..") || path.includes("\0")) {
+      throw new DOMException(
+        "Invalid path: contains path traversal or null bytes",
+        "NotAllowedError"
+      );
+    }
+    const parts = path.split("/").filter(Boolean);
+    if (parts.length === 0) {
+      return this.#root;
+    }
+    for (const part of parts) {
+      if (part === "." || part === ".." || part.includes("/") || part.includes("\\")) {
+        throw new DOMException("Invalid path component", "NotAllowedError");
       }
     }
-    if (possibleDescendant instanceof _MemoryFileSystemDirectoryHandle) {
-      if (this.directory.directories.has(possibleDescendant.name)) {
-        return [possibleDescendant.name];
+    let current = this.#root;
+    for (let i = 0; i < parts.length - 1; i++) {
+      const nextDir = current.directories.get(parts[i]);
+      if (!nextDir)
+        return null;
+      current = nextDir;
+    }
+    const finalName = parts[parts.length - 1];
+    const file = current.files.get(finalName);
+    if (file)
+      return file;
+    const dir = current.directories.get(finalName);
+    if (dir)
+      return dir;
+    return null;
+  }
+  #resolveParent(path) {
+    const parts = path.split("/").filter(Boolean);
+    const name = parts.pop() || "";
+    if (parts.length === 0) {
+      return { parentDir: this.#root, name };
+    }
+    let current = this.#root;
+    for (const part of parts) {
+      const nextDir = current.directories.get(part);
+      if (!nextDir) {
+        return { parentDir: null, name };
       }
+      current = nextDir;
+    }
+    return { parentDir: current, name };
+  }
+};
+var MemoryBucket = class _MemoryBucket {
+  kind;
+  name;
+  #backend;
+  constructor(name = "root") {
+    this.kind = "directory";
+    this.name = name;
+    const root = {
+      name,
+      files: /* @__PURE__ */ new Map(),
+      directories: /* @__PURE__ */ new Map()
+    };
+    this.#backend = new MemoryFileSystemBackend(root);
+  }
+  async getFileHandle(name, options) {
+    const filePath = `/${name}`;
+    const stat = await this.#backend.stat(filePath);
+    if (!stat && options?.create) {
+      await this.#backend.writeFile(filePath, new Uint8Array(0));
+    } else if (!stat) {
+      throw new DOMException("File not found", "NotFoundError");
+    } else if (stat.kind !== "file") {
+      throw new DOMException(
+        "Path exists but is not a file",
+        "TypeMismatchError"
+      );
+    }
+    return new ShovelFileHandle(this.#backend, filePath);
+  }
+  async getDirectoryHandle(name, options) {
+    const dirPath = `/${name}`;
+    const stat = await this.#backend.stat(dirPath);
+    if (!stat && options?.create) {
+      await this.#backend.createDir(dirPath);
+    } else if (!stat) {
+      throw new DOMException("Directory not found", "NotFoundError");
+    } else if (stat.kind !== "directory") {
+      throw new DOMException(
+        "Path exists but is not a directory",
+        "TypeMismatchError"
+      );
+    }
+    return new ShovelDirectoryHandle(this.#backend, dirPath);
+  }
+  async removeEntry(name, options) {
+    const entryPath = `/${name}`;
+    await this.#backend.remove(entryPath, options?.recursive);
+  }
+  async resolve(possibleDescendant) {
+    if (!(possibleDescendant instanceof ShovelDirectoryHandle || possibleDescendant instanceof ShovelFileHandle)) {
+      return null;
+    }
+    const descendantPath = possibleDescendant.path;
+    if (typeof descendantPath === "string" && descendantPath.startsWith("/")) {
+      return descendantPath.split("/").filter(Boolean);
     }
     return null;
   }
   async *entries() {
-    for (const [name, file] of this.directory.files) {
-      yield [
-        name,
-        new MemoryFileSystemFileHandle(file, (content, type) => {
-          file.content = content;
-          file.lastModified = Date.now();
-          if (type)
-            file.type = type;
-        })
-      ];
-    }
-    for (const [name, dir] of this.directory.directories) {
-      yield [name, new _MemoryFileSystemDirectoryHandle(dir)];
+    const entries = await this.#backend.listDir("/");
+    for (const entry of entries) {
+      const entryPath = `/${entry.name}`;
+      if (entry.kind === "file") {
+        yield [entry.name, new ShovelFileHandle(this.#backend, entryPath)];
+      } else {
+        yield [entry.name, new ShovelDirectoryHandle(this.#backend, entryPath)];
+      }
     }
   }
   async *keys() {
-    for (const name of this.directory.files.keys()) {
-      yield name;
-    }
-    for (const name of this.directory.directories.keys()) {
+    for await (const [name] of this.entries()) {
       yield name;
     }
   }
   async *values() {
-    for (const [, handle] of this.entries()) {
+    for await (const [, handle] of this.entries()) {
       yield handle;
     }
   }
+  [Symbol.asyncIterator]() {
+    return this.entries();
+  }
   async isSameEntry(other) {
     if (other.kind !== "directory")
       return false;
-    if (!(other instanceof _MemoryFileSystemDirectoryHandle))
-      return false;
-    return this.directory === other.directory;
+    return other instanceof _MemoryBucket && other.name === this.name;
   }
   async queryPermission() {
     return "granted";
@@ -190,35 +239,7 @@ var MemoryFileSystemDirectoryHandle = class _MemoryFileSystemDirectoryHandle {
     return "granted";
   }
 };
-var MemoryBucket = class {
-  config;
-  filesystems = /* @__PURE__ */ new Map();
-  constructor(config = {}) {
-    this.config = {
-      name: "memory",
-      ...config
-    };
-  }
-  async getDirectoryHandle(name) {
-    const dirName = name || "root";
-    if (!this.filesystems.has(dirName)) {
-      const root2 = {
-        name: "root",
-        files: /* @__PURE__ */ new Map(),
-        directories: /* @__PURE__ */ new Map()
-      };
-      this.filesystems.set(dirName, root2);
-    }
-    const root = this.filesystems.get(dirName);
-    return new MemoryFileSystemDirectoryHandle(root);
-  }
-  getConfig() {
-    return { ...this.config };
-  }
-  async dispose() {
-    this.filesystems.clear();
-  }
-};
 export {
-  MemoryBucket
+  MemoryBucket,
+  MemoryFileSystemBackend
 };

package/src/node.d.ts

@@ -1,67 +1,37 @@
 /**
- * Node.js implementation of File System Access API
+ * Node.js filesystem implementation
  *
- * Implements FileSystemDirectoryHandle and FileSystemFileHandle using fs/promises
- * to provide universal File System Access API on Node.js platforms.
+ * Provides NodeBucket (root) and NodeFileSystemBackend for storage operations
+ * using Node.js fs module.
  */
-import type { Bucket, FileSystemConfig } from "./types.js";
+import { type FileSystemBackend, ShovelDirectoryHandle } from "./index.js";
 /**
- * Node.js implementation of FileSystemWritableFileStream
+ * Node.js storage backend that implements FileSystemBackend
  */
-export declare class NodeFileSystemWritableFileStream extends WritableStream<Uint8Array> {
-    private filePath;
-    constructor(filePath: string);
-    write(data: Uint8Array | string): Promise<void>;
-    close(): Promise<void>;
+export declare class NodeFileSystemBackend implements FileSystemBackend {
+    #private;
+    constructor(rootPath: string);
+    stat(filePath: string): Promise<{
+        kind: "file" | "directory";
+    } | null>;
+    readFile(filePath: string): Promise<{
+        content: Uint8Array;
+        lastModified?: number;
+    }>;
+    writeFile(filePath: string, data: Uint8Array): Promise<void>;
+    listDir(dirPath: string): Promise<Array<{
+        name: string;
+        kind: "file" | "directory";
+    }>>;
+    createDir(dirPath: string): Promise<void>;
+    remove(entryPath: string, recursive?: boolean): Promise<void>;
 }
 /**
- * Node.js implementation of FileSystemFileHandle
+ * Node bucket - root entry point for Node.js filesystem
+ * Extends ShovelDirectoryHandle with "/" as root path
  */
-export declare class NodeFileSystemFileHandle implements FileSystemFileHandle {
-    private filePath;
-    readonly kind: "file";
-    readonly name: string;
-    constructor(filePath: string);
-    getFile(): Promise<File>;
-    createWritable(): Promise<FileSystemWritableFileStream>;
-    createSyncAccessHandle(): Promise<FileSystemSyncAccessHandle>;
-    isSameEntry(other: FileSystemHandle): Promise<boolean>;
-    queryPermission(): Promise<PermissionState>;
-    requestPermission(): Promise<PermissionState>;
-    private getMimeType;
-}
-/**
- * Node.js implementation of FileSystemDirectoryHandle
- */
-export declare class NodeFileSystemDirectoryHandle implements FileSystemDirectoryHandle {
-    private dirPath;
-    readonly kind: "directory";
-    readonly name: string;
-    constructor(dirPath: string);
-    getFileHandle(name: string, options?: {
-        create?: boolean;
-    }): Promise<FileSystemFileHandle>;
-    getDirectoryHandle(name: string, options?: {
-        create?: boolean;
-    }): Promise<FileSystemDirectoryHandle>;
-    removeEntry(name: string, options?: {
-        recursive?: boolean;
-    }): Promise<void>;
-    resolve(_possibleDescendant: FileSystemHandle): Promise<string[] | null>;
-    entries(): AsyncIterableIterator<[string, FileSystemHandle]>;
-    keys(): AsyncIterableIterator<string>;
-    values(): AsyncIterableIterator<FileSystemHandle>;
-    isSameEntry(other: FileSystemHandle): Promise<boolean>;
-    queryPermission(): Promise<PermissionState>;
-    requestPermission(): Promise<PermissionState>;
-}
-/**
- * Local filesystem bucket using Node.js fs
- */
-export declare class LocalBucket implements Bucket {
-    private config;
-    private rootPath;
-    constructor(config?: FileSystemConfig);
-    getDirectoryHandle(name: string): Promise<FileSystemDirectoryHandle>;
-    getConfig(): FileSystemConfig;
+export declare class NodeBucket extends ShovelDirectoryHandle {
+    #private;
+    constructor(rootPath: string);
+    get name(): string;
 }