@davidsouther/jiffies 2026.4.0 → 2026.24.0

package/src/components/virtual_scroll.test.ts

@@ -1,30 +0,0 @@
-import { State } from "../dom/fc.ts";
-import { div } from "../dom/html.ts";
-import { describe, expect, it } from "../scope/index.ts";
-import VirtualScroll, {
-  arrayAdapter,
-  type VirtualScrollProps,
-} from "./virtual_scroll.ts";
-
-describe("VirtualScroll", () => {
-  it("tracks scroll position", () => {
-    const data = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9];
-
-    const props: VirtualScrollProps<number, HTMLDivElement> = {
-      settings: { count: 3, startIndex: 2 },
-      get: arrayAdapter(data),
-      row: (i) => div(`${i}`),
-    };
-
-    const scroll = VirtualScroll(
-      // @ts-expect-error
-      props,
-    );
-
-    expect(scroll[State]?.bufferedItems).toBe(9);
-    expect(scroll[State]?.data).toEqual([0, 1, 2, 3, 4]);
-    //expect(scroll.state.topPaddingHeight).toBe(0);
-    expect(scroll[State]?.viewportHeight).toBe(60);
-    //expect(scroll.state.totalHeight).toBe(200);
-  });
-});

package/src/context.test.ts

@@ -1,58 +0,0 @@
-import { type Context, Enter, Exit, using } from "./context.ts";
-import { Err, isErr, isOk, Ok, unwrap } from "./result.ts";
-import { describe, it } from "./scope/describe.ts";
-import { expect } from "./scope/expect.ts";
-
-describe("Context", () => {
-  it("performs an operation using a context", () => {
-    const context = TestContext();
-    const result = using(context, () => Ok(5));
-    expect(unwrap(result)).toBe(5);
-    expect(context.initialized).toBe(true);
-    expect(context.completed).toBe(true);
-  });
-
-  it("reports the result of a thrown error", () => {
-    const context = TestContext();
-
-    const result = using(context, () => {
-      throw new Error("Failed");
-    });
-
-    expect(isErr(result)).toBe(true);
-    expect(Err(result as Err<Error>)).toMatchObject({
-      message: "Failed",
-    });
-  });
-
-  it("passes the context to the operation", () => {
-    const op = using(TestContext, ({ initialized, completed }) => ({
-      initialized,
-      completed,
-    }));
-
-    expect(isOk(op)).toBe(true);
-    const { completed, initialized } = unwrap(op);
-    expect(initialized).toBe(true);
-    expect(completed).toBe(false);
-  });
-});
-
-interface TestContext {
-  initialized: boolean;
-  completed: boolean;
-}
-
-function TestContext(): Context & TestContext {
-  const context = {
-    [Enter]: () => {
-      context.initialized = true;
-    },
-    [Exit]: () => {
-      context.completed = true;
-    },
-    initialized: false,
-    completed: false,
-  };
-  return context;
-}

package/src/context.ts

@@ -1,67 +0,0 @@
-import { Err, isResult, Ok, type Result } from "./result.ts";
-
-export const Enter = Symbol("Context Enter");
-export const Exit = Symbol("Context Exit");
-
-export interface Context {
-  [Enter]: () => void;
-  [Exit]: () => void;
-}
-
-export type Operation<T, E extends Error, C extends Context> = (
-  c: C,
-) => T | Result<T, E>;
-
-export type AsyncOperation<T, E extends Error, C extends Context> = (
-  c: C,
-) => Promise<T | Result<T, E>>;
-
-export function using<T, E extends Error, C extends Context>(
-  context: C | (() => C) | Operation<T, E, C>,
-  operation?: Operation<T, E, C>,
-  normalizeError: (e: Error | unknown) => Err<E> = (e) =>
-    // @ts-expect-error
-    Err(e),
-): Result<T, E> {
-  if (typeof context === "function") {
-    if (context.length === 1) {
-      operation = context as Operation<T, E, C>;
-      context = {} as C;
-    } else {
-      context = (context as () => C)() as C;
-    }
-  }
-  let result: Result<T, E>;
-  try {
-    context[Enter]();
-    const op = operation?.(context);
-    result = isResult(op as Result<T, E>) ? (op as Result<T, E>) : Ok(op as T);
-  } catch (e) {
-    result = normalizeError(e);
-  } finally {
-    context[Exit]();
-  }
-  return result;
-}
-
-export async function asyncUsing<T, E extends Error, C extends Context>(
-  context: C | (() => Promise<C>),
-  operation: AsyncOperation<T, E, C>,
-  normalizeError: (e: E) => Err<E> = (e: E) => Err(e),
-): Promise<Result<T, E>> {
-  context = typeof context === "function" ? await context() : context;
-  let result: Result<T, E>;
-  try {
-    context[Enter]();
-    const op = await operation(context);
-    result = isResult(op as Result<T, E>) ? (op as Result<T, E>) : Ok(op as T);
-  } catch (e) {
-    result = normalizeError(
-      // @ts-expect-error
-      e,
-    );
-  } finally {
-    context[Exit]();
-  }
-  return result;
-}

package/src/diff.test.ts

@@ -1,48 +0,0 @@
-import { diff } from "./diff.ts";
-import { describe, it } from "./scope/describe.ts";
-import { expect } from "./scope/expect.ts";
-
-describe("diff", () => {
-  it("diffs primitives", () => {
-    const diffed = diff(1, 2);
-    expect(diffed).toEqual([{ key: "", left: 1, right: 2 }]);
-  });
-
-  it("diffs objects", () => {
-    const diffed = diff({ a: 1, b: 2 }, { a: 2, b: 2 });
-    expect(diffed).toEqual([{ key: "a", left: 1, right: 2 }]);
-  });
-
-  it("diffs nested objects", () => {
-    const diffed = diff({ a: { c: 1 }, b: 2 }, { a: { c: 2 }, b: 2 });
-    expect(diffed).toEqual([
-      { key: "a", children: [{ key: "c", left: 1, right: 2 }] },
-    ]);
-  });
-
-  it("diffs missing sides", () => {
-    const diffed = diff<{ a?: number; b?: number }>({ a: 1 }, { b: 2 });
-    expect(diffed).toEqual([
-      { key: "a", left: 1, right: undefined },
-      { key: "b", left: undefined, right: 2 },
-    ]);
-  });
-
-  it("diffs arrays", () => {
-    const diffed = diff<number[]>([1, 2, 3], [1, 4, 3]);
-    expect(diffed).toEqual([{ key: 1, left: 2, right: 4 }]);
-  });
-
-  it("diffs objects in an array", () => {
-    const diffed = diff(
-      [{ a: { b: 1 } }, { a: { b: 2 } }, { a: { b: 3 } }],
-      [{ a: { b: 1 } }, { a: { b: 4 } }, { a: { b: 3 } }],
-    );
-    expect(diffed).toEqual([
-      {
-        key: 1,
-        children: [{ key: "a", children: [{ key: "b", left: 2, right: 4 }] }],
-      },
-    ]);
-  });
-});

package/src/dom/fc.test.ts

@@ -1,43 +0,0 @@
-import { describe, expect, it } from "../scope/index.ts";
-import { FC } from "./fc.ts";
-import { button, div, form, input, label, small } from "./html.ts";
-
-describe("FC", () => {
-  it("creates FCs", () => {
-    const Input = FC<{
-      placeholder: string;
-      name: string;
-      required?: boolean;
-      type?: string;
-    }>("fc-input", (_el, attrs, children) =>
-      label(attrs.placeholder ?? attrs.name, input(attrs), ...children),
-    );
-
-    const f = form(
-      { action: "#", method: "POST" },
-      div(
-        { class: "grid" },
-        Input({
-          name: "firstName",
-          placeholder: "First Name",
-          required: true,
-        }),
-        Input({
-          name: "lastName",
-          placeholder: "Last Name",
-          required: true,
-        }),
-      ),
-      Input(
-        { name: "email", type: "email", placeholder: "E-Mail" },
-        small("We'll never share your information."),
-      ),
-      button({ type: "submit" }, "Submit"),
-    );
-
-    // document.body.appendChild(f);
-    expect(f.children.length).toBe(3);
-    expect(f.querySelectorAll("input[required]").length).toBe(2);
-    expect(f.querySelectorAll('input[name="firstName"]').length).toBe(1);
-  });
-});

package/src/dom/html.test.ts

@@ -1,74 +0,0 @@
-import { describe, it } from "../scope/describe.ts";
-import { expect } from "../scope/expect.ts";
-import { button, table, tbody, td, th, thead, tr } from "./html.ts";
-
-describe("html", () => {
-  it("creates HTML Elements", () => {
-    const tableBody = tbody();
-    const tableHead = thead(tr(th("Col A"), th("Col B")));
-    const myTable = table(tableHead, tableBody);
-    for (let x = 1; x <= 3; x++) {
-      tableBody.appendChild(tr(td(`${x}`), td(`${x * 2}`)));
-    }
-    expect(myTable.textContent).toEqual("Col ACol B122436");
-  });
-
-  it("attaches event handlers", () => {
-    let clicked = 0;
-    const btn = button({
-      events: {
-        click: () => {
-          clicked += 1;
-        },
-      },
-    });
-    btn.dispatchEvent(new Event("click"));
-    expect(clicked).toBe(1);
-  });
-
-  it("removes event handlers", () => {
-    let clicked = 0;
-    const btn = button({
-      events: {
-        click: () => {
-          clicked += 1;
-        },
-      },
-    });
-    btn.dispatchEvent(new Event("click"));
-
-    expect(clicked).toBe(1);
-
-    btn.update({ events: { click: null } });
-    btn.dispatchEvent(new Event("click"));
-    expect(clicked).toBe(1);
-  });
-
-  it("sets style properties", () => {
-    const btn = button({
-      style: { flexDirection: "column" },
-    });
-
-    expect(btn.style.flexDirection).toBe("column");
-  });
-
-  it("sets style, attributes, and events together", () => {
-    let clicked = false;
-    const btn = button({
-      class: "test-class",
-      style: { flexDirection: "column" },
-      events: {
-        click: () => {
-          clicked = true;
-        },
-      },
-    });
-    btn.dispatchEvent(new Event("click"));
-
-    expect(btn.classList.contains("test-class")).toBe(true);
-    expect((btn as unknown as HTMLButtonElement).style.flexDirection).toBe(
-      "column",
-    );
-    expect(clicked).toBe(true);
-  });
-});

package/src/dom/observable.test.ts

@@ -1,43 +0,0 @@
-import { map, Subject } from "../observable/observable.ts";
-import { describe, it } from "../scope/describe.ts";
-import { expect } from "../scope/expect.ts";
-import type { DOMUpdates } from "./dom.ts";
-import { div, span } from "./html.ts";
-import { O } from "./observable.ts";
-
-describe("DOM Observable", () => {
-  it("updates a dom node with observable results", async () => {
-    const subject = new Subject<string>();
-    const observable = subject.pipe(map((s) => [s]));
-
-    const element = O(div(), observable);
-
-    expect(element.innerText).toEqual("");
-    await subject.next("H");
-    expect(element.innerText).toEqual("H");
-    await subject.next("He");
-    expect(element.innerText).toEqual("He");
-  });
-
-  it("updates a dom node's attributes", async () => {
-    const classes = new Subject<string[]>();
-    const observable = classes.map<DOMUpdates>((c) => [{ class: c.join(" ") }]);
-
-    const element = O(span(), observable);
-
-    expect(element.classList.contains("warning")).toBe(false);
-    expect(element.classList.contains("error")).toBe(false);
-
-    await classes.next(["warning"]);
-    expect(element.classList.contains("warning")).toBe(true);
-    expect(element.classList.contains("error")).toBe(false);
-
-    await classes.next(["error"]);
-    expect(element.classList.contains("warning")).toBe(true);
-    expect(element.classList.contains("error")).toBe(true);
-
-    await classes.next(["!warning", "!error"]);
-    expect(element.classList.contains("warning")).toBe(false);
-    expect(element.classList.contains("error")).toBe(false);
-  });
-});

package/src/dom/test.ts

@@ -1,11 +0,0 @@
-import { IsBrowser } from "../is_browser.js";
-
-export async function loadTests() {
-  if (!IsBrowser) return;
-  if (process?.env.CI?.toLowerCase() === "true") return;
-  await Promise.all([
-    import("./html.test.js"),
-    import("./fc.test.js"),
-    import("./observable.test.js"),
-  ]);
-}

package/src/equal.test.ts

@@ -1,23 +0,0 @@
-import { equalArrays, equals, matchArrays } from "./equal.ts";
-import { describe, expect, it } from "./scope/index.ts";
-
-describe("Equality", () => {
-  it("compares objects", () => {
-    expect(equals({ a: 1, b: 2 }, { b: 2, a: 1 })).toBe(true);
-    expect(equals({ a: 1, b: 2 }, { b: 1, a: 2 })).toBe(false);
-  });
-
-  it("compares primitives", () => {
-    expect(equals(1, 1)).toBe(true);
-    expect(equals(1, -1)).toBe(false);
-    expect(equals(0, -0)).toBe(false);
-    expect(equals(Number.NaN, Number.NaN)).toBe(true);
-  });
-
-  it("compares arrays", () => {
-    expect(equalArrays([1, 2, 3], [1, 2, 3])).toBe(true);
-    expect(equalArrays([1], [2, 3])).toBe(false);
-    expect(equalArrays([{ a: 1 }], [{ a: 1 }])).toBe(false);
-    expect(matchArrays([{ a: 1 }], [{ a: 1 }])).toBe(true);
-  });
-});

package/src/flags.test.ts

@@ -1,43 +0,0 @@
-import { parse } from "./flags.ts";
-import { describe, expect, it } from "./scope/index.ts";
-
-const TEST_CASES = {
-  SIMPLE: "program",
-  NODE: "/usr/local/bin/node program",
-  ONE_FLAG: "program --fun",
-  ONE_PARAM: "program --fun=100",
-  ONE_ARG: "program cat",
-  ONE_NO_FLAG: "program --no-fun",
-  MIXED: "program --fun=dog cat --port=8080 mouse --hamster --no-bird",
-};
-
-const makeFlags = (commandLine: string) => {
-  return parse(commandLine.split(" "));
-};
-
-describe("Flags", () => {
-  it("stores the program name", () => {
-    const flags = makeFlags(TEST_CASES.SIMPLE);
-
-    expect(flags.argv0).toEqual("program");
-    expect(flags.args).toEqual([]);
-  });
-
-  it("stores the program name ignoring node", () => {
-    const flags = makeFlags(TEST_CASES.NODE);
-
-    expect(flags.argv0).toEqual("program");
-    expect(flags.args).toEqual([]);
-  });
-
-  it("parses a flag", () => {
-    const flags = makeFlags(TEST_CASES.ONE_FLAG);
-    expect(flags.get("fun")).toBe(true);
-  });
-
-  it("parses a flag with a default value", () => {
-    const flags = makeFlags(TEST_CASES.SIMPLE);
-    expect(flags.get("missing")).toBe(false);
-    expect(flags.get("missing", true)).toBe(true);
-  });
-});

package/src/flags.ts

@@ -1,53 +0,0 @@
-export const parse = (parseArgs: string[]) => {
-  const fromNode = parseArgs[0].endsWith("node");
-  const argv = parseArgs[fromNode ? 1 : 0];
-  const params = new Map<string, string>();
-  const flags = new Map<string, boolean>();
-  const args: string[] = [];
-
-  let index = fromNode ? 2 : 1;
-  const hasNext = () => index < parseArgs.length;
-  const peek = () => parseArgs[index];
-  const advance = () => parseArgs[index++];
-
-  const parseLong = (arg: string) => {
-    if (arg.substring(0, 3) === "no-") {
-      flags.set(arg.substring(3), false);
-    } else if (!arg.includes("=")) {
-      flags.set(arg, true);
-    } else {
-      const [param, ...value] = arg.split("=");
-      params.set(param, value.join("="));
-    }
-  };
-
-  while (hasNext()) {
-    if (peek().substr(0, 2) === "--") {
-      parseLong(advance().substr(2));
-    } else {
-      args.push(advance());
-    }
-  }
-
-  return {
-    get argv0() {
-      return argv;
-    },
-
-    get args(): ReadonlyArray<string> {
-      return args;
-    },
-
-    get(flag: string, def = false) {
-      return flags.get(flag) ?? def;
-    },
-
-    asNumber(param: string, def = 0): number {
-      return Number.parseFloat(params.get(param) ?? `${def}`);
-    },
-
-    asString(param: string, def = ""): string {
-      return params.get(param) ?? def;
-    },
-  };
-};

package/src/fs.test.ts

@@ -1,106 +0,0 @@
-import {
-  FileSystem,
-  ObjectFileSystemAdapter,
-  RecordFileSystemAdapter,
-} from "./fs.ts";
-import { beforeEach, describe, expect, it } from "./scope/index.ts";
-import { cleanState } from "./scope/state.ts";
-
-describe("FileSystem", () => {
-  describe("Writing", () => {
-    it("Writes files", async () => {
-      const fsObj = {};
-      const fs = new FileSystem(new RecordFileSystemAdapter(fsObj));
-      await fs.writeFile("hello", "world");
-
-      expect(fsObj).toEqual({ "/hello": "world" });
-    });
-
-    it("Writes deep files", async () => {
-      const fsObj = {};
-      const fs = new FileSystem(new RecordFileSystemAdapter(fsObj));
-      await fs.writeFile("deep/hello", "world");
-
-      expect(fsObj).toEqual({ "/deep/hello": "world" });
-    });
-
-    it("Writes deep files from root", async () => {
-      const fsObj = {};
-      const fs = new FileSystem(new RecordFileSystemAdapter(fsObj));
-      await fs.writeFile("/root/deep/hello", "world");
-
-      expect(fsObj).toEqual({ "/root/deep/hello": "world" });
-    });
-
-    it("Writes files after cd", async () => {
-      const fsObj = {};
-      const fs = new FileSystem(new RecordFileSystemAdapter(fsObj));
-      await fs.cd("deep");
-      await fs.writeFile("hello", "world");
-
-      expect(fsObj).toEqual({ "/deep/hello": "world" });
-    });
-  });
-
-  describe("directory", () => {
-    it("returns directory listing", async () => {
-      const fsObj = {
-        "/deep/hello": "world",
-        "/deep/bonjour": "monde",
-        "/other/file": "text",
-      };
-      const fs = new FileSystem(new RecordFileSystemAdapter(fsObj));
-
-      const dir = await fs.readdir("deep");
-      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 () => {
-      const fsAdapter = new ObjectFileSystemAdapter({
-        deep: {
-          hello: "world",
-          bonjour: "monde",
-        },
-        other_file: "text",
-      });
-      expect([
-        ...Object.keys(
-          (fsAdapter as unknown as { fs: Record<string, string> }).fs,
-        ),
-      ]).toEqual(["/deep/hello", "/deep/bonjour", "/other_file"]);
-      const fs = new FileSystem(fsAdapter);
-
-      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_win.test.ts

@@ -1,11 +0,0 @@
-import { NodeFileSystem } from "./fs_node.ts";
-
-const fs = new NodeFileSystem();
-
-async function main() {
-  for (const stats of await fs.scandir(".")) {
-    console.log(stats);
-  }
-}
-
-main();

package/src/generator.test.ts

@@ -1,27 +0,0 @@
-import { takeWhile } from "./generator.ts";
-import { describe, expect, it } from "./scope/index.ts";
-
-describe("Generator", () => {
-  it("takes from a generator until a predicate", () => {
-    const generator = function* () {
-      let i = 1;
-      while (true) {
-        i = i * 2;
-        yield i;
-      }
-    };
-    const filter = () => {
-      let previousValue = 0;
-      return (n: number) => {
-        if (previousValue < 100) {
-          previousValue = n;
-          return true;
-        }
-        return false;
-      };
-    };
-
-    const values = [...takeWhile(filter(), generator())];
-    expect(values).toEqual([2, 4, 8, 16, 32, 64, 128]);
-  });
-});