sandlot 0.1.4 → 0.2.0

package/src/{fs.ts → core/fs.ts}

@@ -1,5 +1,4 @@
 import type {
-  IFileSystem,
   FsEntry,
   FsStat,
   MkdirOptions,
@@ -8,32 +7,30 @@ import type {
   FileContent,
   InitialFiles,
   FileInit,
+  IFileSystem,
 } from "just-bash/browser";
 
 /**
- * Supported buffer encodings
+ * Supported buffer encodings (matches just-bash)
  */
 type BufferEncoding = "utf8" | "utf-8" | "ascii" | "binary" | "base64" | "hex" | "latin1";
 
 /**
- * Options for reading files
+ * Options for reading files (matches just-bash)
  */
 interface ReadFileOptions {
   encoding?: BufferEncoding | null;
 }
 
 /**
- * Options for writing files.
- * Note: In this browser-based filesystem, content is stored as-is.
- * The encoding option is accepted for API compatibility but not used.
+ * Options for writing files (matches just-bash)
  */
 interface WriteFileOptions {
-  /** Accepted for API compatibility but not used - content is stored as-is */
   encoding?: BufferEncoding;
 }
 
 /**
- * Directory entry with type information (similar to Node's Dirent)
+ * Directory entry with type information (matches just-bash DirentEntry)
  */
 interface DirentEntry {
   name: string;
@@ -69,7 +66,7 @@ export interface FilesystemOptions {
  * const fs = Filesystem.create({ initialFiles: { '/src/index.ts': 'export const x = 1;' } });
  * 
  * // Use filesystem
- * await fs.writeFile('/src/app.ts', 'console.log("hello")');
+ * fs.writeFile('/src/app.ts', 'console.log("hello")');
  * 
  * // Export for persistence
  * const files = fs.getFiles();
@@ -80,7 +77,7 @@ export interface FilesystemOptions {
  * const fs2 = Filesystem.create({ initialFiles: saved });
  * ```
  */
-export class Filesystem implements IFileSystem {
+export class Filesystem {
   private entries: Map<string, FsEntry>;
   private maxSizeBytes: number;
 
@@ -153,7 +150,7 @@ export class Filesystem implements IFileSystem {
    */
   getFiles(): Record<string, string> {
     const files: Record<string, string> = {};
-    
+
     for (const [path, entry] of this.entries) {
       if (entry.type === "file") {
         if (typeof entry.content === "string") {
@@ -165,7 +162,7 @@ export class Filesystem implements IFileSystem {
         }
       }
     }
-    
+
     return files;
   }
 
@@ -189,10 +186,10 @@ export class Filesystem implements IFileSystem {
 
   // ============ IFileSystem Implementation ============
 
-  async readFile(
+  readFile(
     path: string,
     options?: ReadFileOptions | BufferEncoding
-  ): Promise<string> {
+  ): string {
     const normalizedPath = this.normalizePath(path);
     const entry = this.resolveSymlinks(normalizedPath);
 
@@ -213,7 +210,7 @@ export class Filesystem implements IFileSystem {
     return this.decodeBuffer(content, encoding);
   }
 
-  async readFileBuffer(path: string): Promise<Uint8Array> {
+  readFileBuffer(path: string): Uint8Array {
     const normalizedPath = this.normalizePath(path);
     const entry = this.resolveSymlinks(normalizedPath);
 
@@ -233,11 +230,11 @@ export class Filesystem implements IFileSystem {
     return new TextEncoder().encode(content);
   }
 
-  async writeFile(
+  writeFile(
     path: string,
     content: FileContent,
     _options?: WriteFileOptions | BufferEncoding
-  ): Promise<void> {
+  ): void {
     const normalizedPath = this.normalizePath(path);
     this.checkSizeLimit(content);
     this.ensureParentDirs(normalizedPath);
@@ -255,16 +252,16 @@ export class Filesystem implements IFileSystem {
     });
   }
 
-  async appendFile(
+  appendFile(
     path: string,
     content: FileContent,
     options?: WriteFileOptions | BufferEncoding
-  ): Promise<void> {
+  ): void {
     const normalizedPath = this.normalizePath(path);
     let existing: string | Uint8Array = "";
 
     try {
-      existing = await this.readFile(normalizedPath);
+      existing = this.readFile(normalizedPath);
     } catch {
       // File doesn't exist, will be created
     }
@@ -277,15 +274,15 @@ export class Filesystem implements IFileSystem {
           typeof content === "string" ? new TextEncoder().encode(content) : content
         );
 
-    await this.writeFile(normalizedPath, newContent, options);
+    this.writeFile(normalizedPath, newContent, options);
   }
 
-  async exists(path: string): Promise<boolean> {
+  exists(path: string): boolean {
     const normalizedPath = this.normalizePath(path);
     return this.entries.has(normalizedPath);
   }
 
-  async stat(path: string): Promise<FsStat> {
+  stat(path: string): FsStat {
     const normalizedPath = this.normalizePath(path);
     const entry = this.resolveSymlinks(normalizedPath);
 
@@ -296,7 +293,7 @@ export class Filesystem implements IFileSystem {
     return this.entryToStat(entry);
   }
 
-  async lstat(path: string): Promise<FsStat> {
+  lstat(path: string): FsStat {
     const normalizedPath = this.normalizePath(path);
     const entry = this.entries.get(normalizedPath);
 
@@ -307,7 +304,7 @@ export class Filesystem implements IFileSystem {
     return this.entryToStat(entry);
   }
 
-  async mkdir(path: string, options?: MkdirOptions): Promise<void> {
+  mkdir(path: string, options?: MkdirOptions): void {
     const normalizedPath = this.normalizePath(path);
 
     if (this.entries.has(normalizedPath)) {
@@ -333,7 +330,7 @@ export class Filesystem implements IFileSystem {
     });
   }
 
-  async readdir(path: string): Promise<string[]> {
+  readdir(path: string): string[] {
     const normalizedPath = this.normalizePath(path);
     const entry = this.resolveSymlinks(normalizedPath);
 
@@ -360,7 +357,7 @@ export class Filesystem implements IFileSystem {
     return names.sort();
   }
 
-  async readdirWithFileTypes(path: string): Promise<DirentEntry[]> {
+  readdirWithFileTypes(path: string): DirentEntry[] {
     const normalizedPath = this.normalizePath(path);
     const entry = this.resolveSymlinks(normalizedPath);
 
@@ -392,7 +389,7 @@ export class Filesystem implements IFileSystem {
     return dirents.sort((a, b) => a.name.localeCompare(b.name));
   }
 
-  async rm(path: string, options?: RmOptions): Promise<void> {
+  rm(path: string, options?: RmOptions): void {
     const normalizedPath = this.normalizePath(path);
     const entry = this.entries.get(normalizedPath);
 
@@ -402,7 +399,7 @@ export class Filesystem implements IFileSystem {
     }
 
     if (entry.type === "directory") {
-      const children = await this.readdir(normalizedPath);
+      const children = this.readdir(normalizedPath);
       if (children.length > 0 && !options?.recursive) {
         throw new Error(`ENOTEMPTY: directory not empty, rm '${path}'`);
       }
@@ -421,7 +418,7 @@ export class Filesystem implements IFileSystem {
     this.entries.delete(normalizedPath);
   }
 
-  async cp(src: string, dest: string, options?: CpOptions): Promise<void> {
+  cp(src: string, dest: string, options?: CpOptions): void {
     const srcPath = this.normalizePath(src);
     const destPath = this.normalizePath(dest);
     const entry = this.entries.get(srcPath);
@@ -453,7 +450,7 @@ export class Filesystem implements IFileSystem {
     }
   }
 
-  async mv(src: string, dest: string): Promise<void> {
+  mv(src: string, dest: string): void {
     const srcPath = this.normalizePath(src);
     const destPath = this.normalizePath(dest);
     const entry = this.entries.get(srcPath);
@@ -511,7 +508,7 @@ export class Filesystem implements IFileSystem {
     return [...this.entries.keys()].sort();
   }
 
-  async chmod(path: string, mode: number): Promise<void> {
+  chmod(path: string, mode: number): void {
     const normalizedPath = this.normalizePath(path);
     const entry = this.entries.get(normalizedPath);
 
@@ -523,7 +520,7 @@ export class Filesystem implements IFileSystem {
     entry.mtime = new Date();
   }
 
-  async symlink(target: string, linkPath: string): Promise<void> {
+  symlink(target: string, linkPath: string): void {
     const normalizedLinkPath = this.normalizePath(linkPath);
 
     if (this.entries.has(normalizedLinkPath)) {
@@ -540,7 +537,7 @@ export class Filesystem implements IFileSystem {
     });
   }
 
-  async link(existingPath: string, newPath: string): Promise<void> {
+  link(existingPath: string, newPath: string): void {
     const srcPath = this.normalizePath(existingPath);
     const destPath = this.normalizePath(newPath);
 
@@ -566,7 +563,7 @@ export class Filesystem implements IFileSystem {
     });
   }
 
-  async readlink(path: string): Promise<string> {
+  readlink(path: string): string {
     const normalizedPath = this.normalizePath(path);
     const entry = this.entries.get(normalizedPath);
 
@@ -580,7 +577,7 @@ export class Filesystem implements IFileSystem {
     return entry.target;
   }
 
-  async realpath(path: string): Promise<string> {
+  realpath(path: string): string {
     const normalizedPath = this.normalizePath(path);
     const parts = normalizedPath.split("/").filter(Boolean);
     let resolved = "/";
@@ -617,7 +614,7 @@ export class Filesystem implements IFileSystem {
     return resolved;
   }
 
-  async utimes(path: string, atime: Date, mtime: Date): Promise<void> {
+  utimes(path: string, atime: Date, mtime: Date): void {
     const normalizedPath = this.normalizePath(path);
     const entry = this.entries.get(normalizedPath);
 
@@ -807,3 +804,28 @@ export function createFilesystem(options?: FilesystemOptions): Filesystem {
   return Filesystem.create(options);
 }
 
+export function wrapFilesystemForJustBash(fs: Filesystem): IFileSystem {
+  return {
+    readFile: async (path: string, options?: ReadFileOptions | BufferEncoding): Promise<string> => fs.readFile(path, options),
+    writeFile: async (path: string, content: FileContent, options?: WriteFileOptions | BufferEncoding): Promise<void> => fs.writeFile(path, content, options),
+    appendFile: async (path: string, content: FileContent, options?: WriteFileOptions | BufferEncoding): Promise<void> => fs.appendFile(path, content, options),
+    exists: async (path: string): Promise<boolean> => fs.exists(path),
+    stat: async (path: string): Promise<FsStat> => fs.stat(path),
+    lstat: async (path: string): Promise<FsStat> => fs.lstat(path),
+    mkdir: async (path: string, options?: MkdirOptions): Promise<void> => fs.mkdir(path, options),
+    readdir: async (path: string): Promise<string[]> => fs.readdir(path),
+    readdirWithFileTypes: async (path: string): Promise<DirentEntry[]> => fs.readdirWithFileTypes(path),
+    rm: async (path: string, options?: RmOptions) => fs.rm(path, options),
+    cp: async (src: string, dest: string, options?: CpOptions): Promise<void> => fs.cp(src, dest, options),
+    mv: async (src: string, dest: string): Promise<void> => fs.mv(src, dest),
+    chmod: async (path: string, mode: number) => fs.chmod(path, mode),
+    symlink: async (target: string, linkPath: string): Promise<void> => fs.symlink(target, linkPath),
+    link: async (existingPath: string, newPath: string) => fs.link(existingPath, newPath),
+    readlink: async (path: string): Promise<string> => fs.readlink(path),
+    realpath: async (path: string): Promise<string> => fs.realpath(path),
+    utimes: async (path: string, atime: Date, mtime: Date): Promise<void> => fs.utimes(path, atime, mtime),
+    readFileBuffer: async (path: string): Promise<Uint8Array> => fs.readFileBuffer(path),
+    resolvePath: (base: string, path: string): string => fs.resolvePath(base, path),
+    getAllPaths: (): string[] => fs.getAllPaths(),
+  };
+}