@davidsouther/jiffies 2.0.5 → 2.0.7

package/src/equal.ts

@@ -10,7 +10,7 @@ export const equalArrays = compareArrays(Object.is);
 export const matchArrays: <A>(a: A[], b: A[], partial?: boolean) => boolean =
   compareArrays(equals);
 
-function asArray(a: Record<string, unknown>): [string, unknown][] {
+export function asArray<T = unknown>(a: Record<string, T>): [string, T][] {
   return Object.entries(a).sort((a, b) => a[0].localeCompare(b[0]));
 }
 
@@ -25,6 +25,8 @@ export const matchObjects = (a: {}, b: {}, partial = true) => {
 
 export function equals<A>(a: A | A[], b: A | A[], partial = false): boolean {
   // runtime type checking
+  if (a === null && a === b) return true;
+  if (a === undefined && a === b) return true;
   switch (typeof a) {
     case "object":
       if (b === undefined) {
@@ -41,3 +43,11 @@ export function equals<A>(a: A | A[], b: A | A[], partial = false): boolean {
       return Object.is(a, b);
   }
 }
+
+// prettier-ignore
+export type Equals<T1, T2> =
+  (<T>() => (T extends T2 ? true : false)) extends
+  (<T>() => (T extends T1 ? true : false))
+      ? true : false;
+
+export type Not<B extends boolean> = B extends true ? false : true;

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/loader.mjs

@@ -5,7 +5,7 @@ import { transpile } from "./transpile.mjs";
 
 const baseURL = pathToFileURL(`${cwd()}/`).href;
 
-/** @returns {Promise<{url: string}>} */
+/** @returns {Promise<{url: string, shortCircuit?: boolean}>} */
 export async function resolve(
   /** @type string */ specifier,
   /** @type {{parentURL?: string}} */ context,
@@ -19,7 +19,8 @@ export async function resolve(
   try {
     const stats = await stat(fileURLToPath(tsURL));
     if (stats.isFile()) {
-      return { url: tsSpecifier };
+      // return { url: tsSpecifier, shortCircuit: true };
+      return defaultResolve(tsSpecifier, context, defaultResolve);
     }
   } catch (e) {
     // Do nothing

package/src/scope/state.ts

@@ -1,10 +1,13 @@
+import { Awaitable } from "../awaitable";
+
 export function cleanState<State extends {}>(
-  init: () => State,
-  runner: (action: () => void) => void
+  init: () => Awaitable<State>,
+  runner: (action: () => Promise<void>) => void
 ): State {
   const state = {};
-  runner(() => {
-    Object.assign(state, init());
+  runner(async () => {
+    const freshState = await init();
+    Object.assign(state, freshState);
   });
   return state as State;
-}
+}

package/src/test_all.ts

@@ -22,11 +22,10 @@ import "./lock.test.js";
 import "./result.test.js";
 import "./observable/observable.test.js";
 
-import * as components from "./components/test.js";
-import * as dom from "./dom/test.js";
-
 if (process?.env.CI?.toLowerCase() !== "true") {
   (async () => {
+    const components = await import("./components/test.js");
+    const dom = await import("./dom/test.js");
     await components.loadTests();
     await dom.loadTests();
   })();

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,