@davidsouther/jiffies 2.0.6 → 2.1.0

package/src/fs.test.ts

@@ -1,5 +1,10 @@
-import { FileSystem, RecordFileSystemAdapter } from "./fs.js";
-import { describe, it, expect } from "./scope/index.js";
+import {
+  FileSystem,
+  ObjectFileSystemAdapter,
+  RecordFileSystemAdapter,
+} from "./fs.js";
+import { describe, it, expect, beforeEach } from "./scope/index.js";
+import { cleanState } from "./scope/state.js";
 
 describe("FileSystem", () => {
   describe("Writing", () => {
@@ -50,4 +55,48 @@ describe("FileSystem", () => {
       expect(dir.sort()).toEqual(["bonjour", "hello"]);
     });
   });
+
+  describe("stat", () => {
+    const state = cleanState(() => {
+      const fsObj = {
+        "/deep/hello": "world",
+        "/deep/bonjour": "monde",
+        "/other/file": "text",
+      };
+      return { fs: new FileSystem(new RecordFileSystemAdapter(fsObj)) };
+    }, beforeEach);
+
+    it("stats a directory", async () => {
+      const deep = await state.fs.stat("/deep");
+      expect(deep.isDirectory()).toBe(true);
+      expect(deep.isFile()).toBe(false);
+    });
+
+    it("stats a file", async () => {
+      const deep = await state.fs.stat("/deep/hello");
+      expect(deep.isDirectory()).toBe(false);
+      expect(deep.isFile()).toBe(true);
+    });
+  });
+
+  describe("ObjectFileSystem", () => {
+    it("treats object keys as directories and final values as strings", async () => {
+      let fs = new FileSystem(
+        new ObjectFileSystemAdapter({
+          deep: {
+            hello: "world",
+            bonjour: "monde",
+          },
+          other_file: "text",
+        })
+      );
+
+      const deep = await fs.stat("/deep");
+      expect(deep.isDirectory()).toBe(true);
+      expect(deep.isFile()).toBe(false);
+
+      const deep_bonjour = await fs.readFile("/deep/bonjour");
+      expect(deep_bonjour).toBe("monde");
+    });
+  });
 });

package/src/fs.ts

@@ -8,9 +8,11 @@ export interface Stats {
   name: string;
 }
 
-export function basename(filename: PathLike) {
-  const end = filename.lastIndexOf("/");
-  const basename = filename.substring(end === -1 ? 0 : end);
+export function basename(filename: PathLike): string {
+  if (filename.endsWith("/")) {
+    filename = filename.substring(0, filename.length - 1);
+  }
+  const basename = filename.split("/").at(-1) ?? "";
   return basename;
 }
 
@@ -108,8 +110,8 @@ export class RecordFileSystemAdapter implements FileSystemAdapter {
 
   stat(path: PathLike): Promise<Stats> {
     return new Promise((resolve, reject) => {
-      if (this.fs[path] != null) {
-        resolve({
+      if (this.fs[path]) {
+        return resolve({
           name: basename(path),
           isDirectory() {
             return false;
@@ -118,9 +120,24 @@ export class RecordFileSystemAdapter implements FileSystemAdapter {
             return true;
           },
         });
-      } else {
-        reject();
       }
+
+      if (!path.endsWith("/")) path += "/";
+      for (let filename of Object.keys(this.fs)) {
+        if (filename.startsWith(path)) {
+          return resolve({
+            name: basename(path),
+            isDirectory() {
+              return true;
+            },
+            isFile() {
+              return false;
+            },
+          });
+        }
+      }
+
+      reject();
     });
   }
 
@@ -197,7 +214,30 @@ export class LocalStorageFileSystemAdapter extends RecordFileSystemAdapter {
   }
 }
 
-export class ObjectFileSystemAdapter extends RecordFileSystemAdapter {}
+export type ObjectFileSystem = { [k: string]: string | ObjectFileSystem };
+export class ObjectFileSystemAdapter extends RecordFileSystemAdapter {
+  constructor(object: ObjectFileSystem) {
+    super(reduceObjectFileSystem(object));
+  }
+}
+
+function reduceObjectFileSystem(
+  object: ObjectFileSystem
+): Record<string, string> {
+  let level: Record<string, string> = {};
+
+  for (let [k, v] of Object.entries(object)) {
+    if (typeof v == "string") {
+      level[`/${k}`] = v;
+    } else {
+      for (let [k2, v2] of Object.entries(reduceObjectFileSystem(v))) {
+        level[`/${k}/${k2}`] = v2;
+      }
+    }
+  }
+
+  return level;
+}
 
 export interface Tree {
   [k: string]: string | Tree;

package/src/fs_node.ts

@@ -0,0 +1,46 @@
+import { FileSystem, FileSystemAdapter, Stats } from "./fs";
+import { copyFile, readdir, readFile, rm, stat, writeFile } from "fs/promises";
+import { basename, join } from "path";
+
+export class NodeFileSystem extends FileSystem {
+  constructor(cd: string = process.cwd()) {
+    super(new NodeFileSystemAdapter());
+    this.cd(cd);
+  }
+}
+
+/** Jiffies FileSystemAdapter using NodeJS' fs/promises. */
+export class NodeFileSystemAdapter implements FileSystemAdapter {
+  async stat(path: string): Promise<Stats> {
+    const fsStat = await stat(path);
+    return {
+      name: basename(path),
+      isDirectory() {
+        return fsStat.isDirectory();
+      },
+      isFile() {
+        return !fsStat.isDirectory();
+      },
+    };
+  }
+  readdir(path: string): Promise<string[]> {
+    return readdir(path);
+  }
+  async scandir(path: string): Promise<Stats[]> {
+    return Promise.all(
+      (await this.readdir(path)).map((name) => this.stat(join(path, name)))
+    );
+  }
+  copyFile(from: string, to: string): Promise<void> {
+    return copyFile(from, to);
+  }
+  readFile(path: string): Promise<string> {
+    return readFile(path, "utf-8");
+  }
+  writeFile(path: string, contents: string): Promise<void> {
+    return writeFile(path, contents, "utf-8");
+  }
+  rm(path: string): Promise<void> {
+    return rm(path);
+  }
+}

package/src/transpile.mjs

@@ -14,7 +14,7 @@ export async function transpile(
   /** @type string */ url,
   /** @type {() => Promise<{toString(): string}>} */ get
 ) {
-  if (!tsmap.has(url) || true) {
+  if (!tsmap.has(url)) {
     const source = ts.transpile(
       (await get()).toString(),
       compilerOptions,