@b9g/filesystem 0.1.4 → 0.1.6

package/src/index.js

@@ -1,21 +1,325 @@
 /// <reference types="./index.d.ts" />
 // src/index.ts
-import { MemoryBucket } from "./memory.js";
-import { LocalBucket, NodeFileSystemDirectoryHandle, NodeFileSystemFileHandle } from "./node.js";
-import { S3Bucket, BunS3FileSystemDirectoryHandle, BunS3FileSystemFileHandle } from "./bun-s3.js";
-import { BucketStorage } from "./directory-storage.js";
-import { FileSystemRegistry, getDirectoryHandle, getBucket, getFileSystemRoot } from "./registry.js";
+import mime from "mime";
+var ShovelWritableFileStream = class extends WritableStream {
+  #chunks;
+  #backend;
+  #path;
+  constructor(backend, path) {
+    const chunks = [];
+    super({
+      write: (chunk) => {
+        const bytes = typeof chunk === "string" ? new TextEncoder().encode(chunk) : chunk;
+        chunks.push(bytes);
+        return Promise.resolve();
+      },
+      close: async () => {
+        const totalLength = chunks.reduce(
+          (sum, chunk) => sum + chunk.length,
+          0
+        );
+        const content = new Uint8Array(totalLength);
+        let offset = 0;
+        for (const chunk of chunks) {
+          content.set(chunk, offset);
+          offset += chunk.length;
+        }
+        await backend.writeFile(path, content);
+      },
+      abort: () => {
+        chunks.length = 0;
+        return Promise.resolve();
+      }
+    });
+    this.#chunks = chunks;
+    this.#backend = backend;
+    this.#path = path;
+  }
+  // File System Access API write method
+  async write(data) {
+    const writer = this.getWriter();
+    try {
+      if (typeof data === "string") {
+        await writer.write(new TextEncoder().encode(data));
+      } else if (data instanceof Uint8Array || data instanceof ArrayBuffer) {
+        const bytes = data instanceof ArrayBuffer ? new Uint8Array(data) : data;
+        await writer.write(bytes);
+      } else {
+        await writer.write(new TextEncoder().encode(String(data)));
+      }
+    } finally {
+      writer.releaseLock();
+    }
+  }
+  // File System Access API seek method
+  async seek(_position) {
+    throw new DOMException("Seek operation not supported", "NotSupportedError");
+  }
+  // File System Access API truncate method
+  async truncate(_size) {
+    throw new DOMException(
+      "Truncate operation not supported",
+      "NotSupportedError"
+    );
+  }
+};
+var ShovelHandle = class _ShovelHandle {
+  path;
+  #backend;
+  constructor(backend, path) {
+    this.#backend = backend;
+    this.path = path;
+  }
+  // Use getter so subclasses can override
+  get name() {
+    return this.path.split("/").filter(Boolean).pop() || "root";
+  }
+  get backend() {
+    return this.#backend;
+  }
+  async isSameEntry(other) {
+    if (other.kind !== this.kind)
+      return false;
+    if (!(other instanceof _ShovelHandle))
+      return false;
+    return this.path === other.path;
+  }
+  async queryPermission(descriptor) {
+    const _mode = descriptor?.mode || "read";
+    return "granted";
+  }
+  async requestPermission(descriptor) {
+    const _mode = descriptor?.mode || "read";
+    return "granted";
+  }
+  /**
+   * Validates that a name is actually a name and not a path
+   * The File System Access API only accepts names, not paths
+   */
+  validateName(name) {
+    if (!name || name.trim() === "") {
+      throw new DOMException("Name cannot be empty", "NotAllowedError");
+    }
+    if (name.includes("/") || name.includes("\\")) {
+      throw new DOMException(
+        "Name cannot contain path separators",
+        "NotAllowedError"
+      );
+    }
+    if (name === "." || name === "..") {
+      throw new DOMException("Name cannot be '.' or '..'", "NotAllowedError");
+    }
+  }
+};
+var ShovelFileHandle = class extends ShovelHandle {
+  kind;
+  constructor(backend, path) {
+    super(backend, path);
+    this.kind = "file";
+  }
+  async getFile() {
+    try {
+      const { content, lastModified } = await this.backend.readFile(this.path);
+      const filename = this.name;
+      const mimeType = this.#getMimeType(filename);
+      const buffer = content.slice().buffer;
+      return new File([buffer], filename, {
+        type: mimeType,
+        lastModified: lastModified ?? Date.now()
+      });
+    } catch (error) {
+      throw new DOMException(`File not found: ${this.path}`, "NotFoundError");
+    }
+  }
+  async createWritable() {
+    return new ShovelWritableFileStream(this.backend, this.path);
+  }
+  async createSyncAccessHandle() {
+    throw new DOMException(
+      "Synchronous access handles are not supported",
+      "InvalidStateError"
+    );
+  }
+  #getMimeType(filename) {
+    return mime.getType(filename) || "application/octet-stream";
+  }
+};
+var ShovelDirectoryHandle = class _ShovelDirectoryHandle extends ShovelHandle {
+  kind;
+  constructor(backend, path) {
+    super(backend, path);
+    this.kind = "directory";
+  }
+  async getFileHandle(name, options) {
+    this.validateName(name);
+    const filePath = this.#joinPath(this.path, 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) {
+    this.validateName(name);
+    const dirPath = this.#joinPath(this.path, name);
+    const stat = await this.backend.stat(dirPath);
+    if (!stat && options?.create) {
+      if (this.backend.createDir) {
+        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) {
+    this.validateName(name);
+    if (!this.backend.remove) {
+      throw new DOMException(
+        "Remove operation not supported by this backend",
+        "NotSupportedError"
+      );
+    }
+    const entryPath = this.#joinPath(this.path, name);
+    const stat = await this.backend.stat(entryPath);
+    if (!stat) {
+      throw new DOMException("Entry not found", "NotFoundError");
+    }
+    await this.backend.remove(entryPath, options?.recursive);
+  }
+  async resolve(possibleDescendant) {
+    if (!(possibleDescendant instanceof _ShovelDirectoryHandle || possibleDescendant instanceof ShovelFileHandle)) {
+      return null;
+    }
+    const shovelHandle = possibleDescendant;
+    const descendantPath = shovelHandle.path;
+    if (!descendantPath.startsWith(this.path)) {
+      return null;
+    }
+    const relativePath = descendantPath.slice(this.path.length);
+    return relativePath.split("/").filter(Boolean);
+  }
+  async *entries() {
+    try {
+      const entries = await this.backend.listDir(this.path);
+      for (const entry of entries) {
+        const entryPath = this.#joinPath(this.path, entry.name);
+        if (entry.kind === "file") {
+          yield [entry.name, new ShovelFileHandle(this.backend, entryPath)];
+        } else {
+          yield [
+            entry.name,
+            new _ShovelDirectoryHandle(this.backend, entryPath)
+          ];
+        }
+      }
+    } catch (error) {
+      return;
+    }
+  }
+  async *keys() {
+    for await (const [name] of this.entries()) {
+      yield name;
+    }
+  }
+  async *values() {
+    for await (const [, handle] of this.entries()) {
+      yield handle;
+    }
+  }
+  [Symbol.asyncIterator]() {
+    return this.entries();
+  }
+  #joinPath(base, name) {
+    if (base === "/" || base === "") {
+      return `/${name}`;
+    }
+    return `${base}/${name}`;
+  }
+};
+var CustomBucketStorage = class {
+  #instances;
+  #factory;
+  /**
+   * @param factory Function that creates bucket instances by name
+   */
+  constructor(factory) {
+    this.#instances = /* @__PURE__ */ new Map();
+    this.#factory = factory;
+  }
+  /**
+   * Open a named bucket - creates if it doesn't exist
+   *
+   * @param name Bucket name (e.g., 'tmp', 'dist', 'uploads')
+   * @returns FileSystemDirectoryHandle for the bucket
+   */
+  async open(name) {
+    const existing = this.#instances.get(name);
+    if (existing) {
+      return existing;
+    }
+    const bucket = await this.#factory(name);
+    this.#instances.set(name, bucket);
+    return bucket;
+  }
+  /**
+   * Check if a named bucket exists
+   *
+   * @param name Bucket name to check
+   * @returns true if bucket has been opened
+   */
+  async has(name) {
+    return this.#instances.has(name);
+  }
+  /**
+   * Delete a named bucket
+   *
+   * @param name Bucket name to delete
+   * @returns true if bucket was deleted, false if it didn't exist
+   */
+  async delete(name) {
+    const instance = this.#instances.get(name);
+    if (instance) {
+      this.#instances.delete(name);
+      return true;
+    }
+    return false;
+  }
+  /**
+   * List all opened bucket names
+   *
+   * @returns Array of bucket names
+   */
+  async keys() {
+    return Array.from(this.#instances.keys());
+  }
+  /**
+   * Get statistics about opened buckets (non-standard utility method)
+   *
+   * @returns Object with bucket statistics
+   */
+  getStats() {
+    return {
+      openInstances: this.#instances.size,
+      bucketNames: Array.from(this.#instances.keys())
+    };
+  }
+};
 export {
-  BucketStorage,
-  BunS3FileSystemDirectoryHandle,
-  BunS3FileSystemFileHandle,
-  FileSystemRegistry,
-  LocalBucket,
-  MemoryBucket,
-  NodeFileSystemDirectoryHandle,
-  NodeFileSystemFileHandle,
-  S3Bucket,
-  getBucket,
-  getDirectoryHandle,
-  getFileSystemRoot
+  CustomBucketStorage,
+  ShovelDirectoryHandle,
+  ShovelFileHandle,
+  ShovelHandle
 };

package/src/memory.d.ts

@@ -1,18 +1,79 @@
 /**
- * In-memory implementation of File System Access API
+ * In-memory filesystem implementation
  *
- * Provides a complete filesystem interface using in-memory data structures.
- * Useful for testing, development, and temporary storage scenarios.
+ * Provides MemoryBucket (root) and MemoryFileSystemBackend for storage operations
+ * using in-memory data structures.
  */
-import type { Bucket, FileSystemConfig } from "./types.js";
+import { type FileSystemBackend } from "./index.js";
 /**
- * Memory bucket
+ * In-memory file data
  */
-export declare class MemoryBucket implements Bucket {
-    private config;
-    private filesystems;
-    constructor(config?: FileSystemConfig);
-    getDirectoryHandle(name: string): Promise<FileSystemDirectoryHandle>;
-    getConfig(): FileSystemConfig;
-    dispose(): Promise<void>;
+interface MemoryFile {
+    name: string;
+    content: Uint8Array;
+    lastModified: number;
+    type: string;
 }
+/**
+ * In-memory directory data
+ */
+interface MemoryDirectory {
+    name: string;
+    files: Map<string, MemoryFile>;
+    directories: Map<string, MemoryDirectory>;
+}
+/**
+ * In-memory storage backend that implements FileSystemBackend
+ */
+export declare class MemoryFileSystemBackend implements FileSystemBackend {
+    #private;
+    constructor(root: MemoryDirectory);
+    stat(path: string): Promise<{
+        kind: "file" | "directory";
+    } | null>;
+    readFile(path: string): Promise<{
+        content: Uint8Array;
+        lastModified?: number;
+    }>;
+    writeFile(path: string, data: Uint8Array): Promise<void>;
+    listDir(path: string): Promise<Array<{
+        name: string;
+        kind: "file" | "directory";
+    }>>;
+    createDir(path: string): Promise<void>;
+    remove(path: string, recursive?: boolean): Promise<void>;
+}
+/**
+ * Memory bucket - root entry point for in-memory filesystem
+ * Implements FileSystemDirectoryHandle and owns the root data structure
+ */
+export declare class MemoryBucket implements FileSystemDirectoryHandle {
+    #private;
+    readonly kind: "directory";
+    readonly name: string;
+    constructor(name?: 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,
+        FileSystemFileHandle | FileSystemDirectoryHandle
+    ]>;
+    keys(): AsyncIterableIterator<string>;
+    values(): AsyncIterableIterator<FileSystemFileHandle | FileSystemDirectoryHandle>;
+    [Symbol.asyncIterator](): AsyncIterableIterator<[
+        string,
+        FileSystemFileHandle | FileSystemDirectoryHandle
+    ]>;
+    isSameEntry(other: FileSystemHandle): Promise<boolean>;
+    queryPermission(): Promise<PermissionState>;
+    requestPermission(): Promise<PermissionState>;
+}
+export {};