@b9g/filesystem 0.1.4 → 0.1.5

package/README.md

@@ -244,45 +244,58 @@ router.post('/upload', async (request) => {
 });
 ```
 
+## Exports
+
+### Classes
+
+- `ShovelFileHandle` - FileSystemFileHandle implementation
+- `ShovelDirectoryHandle` - FileSystemDirectoryHandle implementation
+- `ShovelHandle` - Base handle class
+- `CustomBucketStorage` - Bucket storage with custom backend factories
+
+### Types
+
+- `Bucket` - Alias for FileSystemDirectoryHandle
+- `BucketStorage` - Interface for bucket storage (`open(name): Promise<FileSystemDirectoryHandle>`)
+- `BucketFactory` - Factory function type for creating bucket backends
+- `FileSystemConfig` - Configuration for filesystem backends
+- `FileSystemPermissionDescriptor` - Permission descriptor type
+- `FileSystemBackend` - Backend interface for filesystem implementations
+
 ## API Reference
 
-### FilesystemRegistry
+### BucketStorage
 
 ```typescript
-class FilesystemRegistry {
-  register(name: string, factory: () => Filesystem): void;
-  get(name: string): Promise<Filesystem>;
-  has(name: string): boolean;
-  delete(name: string): boolean;
-  keys(): string[];
+interface BucketStorage {
+  open(name: string): Promise<FileSystemDirectoryHandle>;
+}
+
+class CustomBucketStorage implements BucketStorage {
+  register(name: string, factory: BucketFactory): void;
+  open(name: string): Promise<FileSystemDirectoryHandle>;
 }
 ```
 
-### Filesystem Interface
+### FileSystemHandle Interface
 
 ```typescript
-interface Filesystem {
-  getDirectoryHandle(name: string, options?: GetDirectoryOptions): Promise<DirectoryHandle>;
-}
-
-interface DirectoryHandle {
+interface FileSystemDirectoryHandle {
   kind: 'directory';
   name: string;
-  
-  getDirectoryHandle(name: string, options?: GetDirectoryOptions): Promise<DirectoryHandle>;
-  getFileHandle(name: string, options?: GetFileOptions): Promise<FileHandle>;
-  removeEntry(name: string, options?: RemoveOptions): Promise<void>;
-  entries(): AsyncIterableIterator<[string, DirectoryHandle | FileHandle]>;
+  getDirectoryHandle(name: string, options?: { create?: boolean }): Promise<FileSystemDirectoryHandle>;
+  getFileHandle(name: string, options?: { create?: boolean }): Promise<FileSystemFileHandle>;
+  removeEntry(name: string, options?: { recursive?: boolean }): Promise<void>;
+  entries(): AsyncIterableIterator<[string, FileSystemDirectoryHandle | FileSystemFileHandle]>;
   keys(): AsyncIterableIterator<string>;
-  values(): AsyncIterableIterator<DirectoryHandle | FileHandle>;
+  values(): AsyncIterableIterator<FileSystemDirectoryHandle | FileSystemFileHandle>;
 }
 
-interface FileHandle {
+interface FileSystemFileHandle {
   kind: 'file';
   name: string;
-  
   getFile(): Promise<File>;
-  createWritable(options?: CreateWritableOptions): Promise<WritableStream>;
+  createWritable(): Promise<FileSystemWritableFileStream>;
 }
 ```
 

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@b9g/filesystem",
-  "version": "0.1.4",
+  "version": "0.1.5",
   "description": "Universal File System Access API implementations for all platforms",
   "license": "MIT",
   "devDependencies": {
@@ -8,7 +8,6 @@
     "@types/bun": "^1.2.2"
   },
   "peerDependencies": {
-    "@types/wicg-file-system-access": "^2023.10.7",
     "@types/node": "^18.0.0"
   },
   "peerDependenciesMeta": {
@@ -56,30 +55,6 @@
       "types": "./src/node.d.ts",
       "import": "./src/node.js"
     },
-    "./registry": {
-      "types": "./src/registry.d.ts",
-      "import": "./src/registry.js"
-    },
-    "./registry.js": {
-      "types": "./src/registry.d.ts",
-      "import": "./src/registry.js"
-    },
-    "./types": {
-      "types": "./src/types.d.ts",
-      "import": "./src/types.js"
-    },
-    "./types.js": {
-      "types": "./src/types.d.ts",
-      "import": "./src/types.js"
-    },
-    "./package.json": "./package.json",
-    "./directory-storage": {
-      "types": "./src/directory-storage.d.ts",
-      "import": "./src/directory-storage.js"
-    },
-    "./directory-storage.js": {
-      "types": "./src/directory-storage.d.ts",
-      "import": "./src/directory-storage.js"
-    }
+    "./package.json": "./package.json"
   }
 }

package/src/bun-s3.d.ts

@@ -1,46 +1,51 @@
 /**
- * Bun S3 implementation of File System Access API using built-in S3 support
+ * Bun S3 filesystem implementation
  *
- * Leverages Bun's native S3Client and S3File for high-performance
- * cloud storage operations with File System Access API compatibility.
+ * Provides S3Bucket (root) and S3FileSystemBackend for storage operations
+ * using Bun's native S3 client.
  */
-import type { Bucket, FileSystemConfig } from "./types.js";
+import { type FileSystemBackend } from "./index.js";
 /**
- * Bun S3 implementation of FileSystemWritableFileStream
+ * S3 storage backend that implements FileSystemBackend using Bun's S3 client
  */
-export declare class BunS3FileSystemWritableFileStream extends WritableStream<Uint8Array> {
-    private s3file;
-    private writer;
-    constructor(s3file: any);
+export declare class S3FileSystemBackend implements FileSystemBackend {
+    #private;
+    constructor(s3Client: any, bucketName: string, prefix?: string);
+    stat(path: string): Promise<{
+        kind: "file" | "directory";
+    } | null>;
+    readFile(path: string): Promise<Uint8Array>;
+    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>;
 }
 /**
- * Bun S3 implementation of FileSystemFileHandle
- */
-export declare class BunS3FileSystemFileHandle implements FileSystemFileHandle {
-    private s3Client;
-    private key;
-    readonly kind: "file";
-    readonly name: string;
-    constructor(s3Client: any, // Bun S3Client
-    key: string);
-    getFile(): Promise<File>;
-    createWritable(): Promise<FileSystemWritableFileStream>;
-    createSyncAccessHandle(): Promise<FileSystemSyncAccessHandle>;
-    isSameEntry(other: FileSystemHandle): Promise<boolean>;
-    queryPermission(): Promise<PermissionState>;
-    requestPermission(): Promise<PermissionState>;
-    private getMimeType;
-}
-/**
- * Bun S3 implementation of FileSystemDirectoryHandle
+ * S3 bucket - root entry point for S3 filesystem using Bun's S3 client
+ * Implements FileSystemDirectoryHandle for S3 object storage
+ *
+ * Example usage with namespacing:
+ * ```typescript
+ * const s3 = new S3Client({ ... });
+ *
+ * // Use in CustomBucketStorage factory for multi-tenancy
+ * const buckets = new CustomBucketStorage(async (name) => {
+ *   return new S3Bucket(
+ *     s3,
+ *     "my-company-bucket",
+ *     `my-app/production/${name}`  // Prefix for isolation
+ *   );
+ * });
+ * ```
  */
-export declare class BunS3FileSystemDirectoryHandle implements FileSystemDirectoryHandle {
-    private s3Client;
-    private prefix;
+export declare class S3Bucket implements FileSystemDirectoryHandle {
+    #private;
     readonly kind: "directory";
     readonly name: string;
-    constructor(s3Client: any, // Bun S3Client
-    prefix: string);
+    constructor(s3Client: any, bucketName: string, prefix?: string);
     getFileHandle(name: string, options?: {
         create?: boolean;
     }): Promise<FileSystemFileHandle>;
@@ -50,22 +55,18 @@ export declare class BunS3FileSystemDirectoryHandle implements FileSystemDirecto
     removeEntry(name: string, options?: {
         recursive?: boolean;
     }): Promise<void>;
-    resolve(_possibleDescendant: FileSystemHandle): Promise<string[] | null>;
-    entries(): AsyncIterableIterator<[string, FileSystemHandle]>;
+    resolve(possibleDescendant: FileSystemHandle): Promise<string[] | null>;
+    entries(): AsyncIterableIterator<[
+        string,
+        FileSystemFileHandle | FileSystemDirectoryHandle
+    ]>;
     keys(): AsyncIterableIterator<string>;
-    values(): AsyncIterableIterator<FileSystemHandle>;
+    values(): AsyncIterableIterator<FileSystemFileHandle | FileSystemDirectoryHandle>;
+    [Symbol.asyncIterator](): AsyncIterableIterator<[
+        string,
+        FileSystemFileHandle | FileSystemDirectoryHandle
+    ]>;
     isSameEntry(other: FileSystemHandle): Promise<boolean>;
     queryPermission(): Promise<PermissionState>;
     requestPermission(): Promise<PermissionState>;
 }
-/**
- * S3 bucket using Bun's native S3Client
- */
-export declare class S3Bucket implements Bucket {
-    private config;
-    private s3Client;
-    constructor(s3Client: any, config?: FileSystemConfig);
-    getDirectoryHandle(name: string): Promise<FileSystemDirectoryHandle>;
-    getConfig(): FileSystemConfig;
-    dispose(): Promise<void>;
-}