@davidsouther/jiffies 2.2.5 → 2026.4.0

package/LICENSE

@@ -1,4 +1,4 @@
-Copyright 2022 David Souther
+Copyright 2022-2026 David Souther
 
 Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
 

package/package.json

@@ -1,41 +1,38 @@
 {
   "name": "@davidsouther/jiffies",
-  "version": "2.2.5",
+  "version": "2026.4.0",
   "private": false,
   "displayName": "JEFRi Jiffies",
   "type": "module",
-  "main": "./lib/cjs/",
-  "module": "./lib/esm/",
-  "types": "./lib/esm/index.d.ts",
-  "directories": {
-    "lib": "./lib/cjs"
+  "exports": {
+    "./*.ts": "./src/*.ts"
   },
+  "files": [
+    "src",
+    "LICENSE",
+    "package.json",
+    "README.md",
+    "tsconfig.json"
+  ],
   "engines": {
-    "node": ">=20.0.9"
+    "node": ">=22.18.0"
   },
   "scripts": {
-    "node": "node --import ./src/loader-register.mjs",
-    "start": "npm run node ./src/server/main.js",
-    "test": "npm run node ./src/test.mjs",
+    "start": "node ./src/server/main.ts",
+    "test": "node ./src/test.mjs",
     "ci": "npm run node ./src/test.mjs --mode=junit",
-    "lint": "prettier . --check",
-    "check": "tsc --noEmit",
-    "format": "prettier . --write",
-    "build": "npm run build:esm & npm run build:cjs & npm run build:css",
-    "postbuild": "npm run fixup",
-    "build:esm": "tsc",
-    "build:cjs": "tsc --module commonjs --outDir lib/cjs",
-    "fixup:cjs": "echo '{\"module\":\"commonjs\"}' > lib/cjs/package.json",
-    "fixup": "npm run fixup:cjs",
-    "build:css": "sass ./src/pico/pico.scss ./build/pico.css",
-    "watch": "npx tsc --watch",
-    "all": "npm run lint && npm run test && npm run build"
+    "format": "biome format --write",
+    "fix": "biome check --write --unsafe",
+    "check:format": "biome format",
+    "check:lint": "biome check",
+    "all": "npm run check:lint && npm run test"
   },
   "devDependencies": {
+    "@biomejs/biome": "^2.3.11",
     "@types/node": "^20.8.9"
   },
   "dependencies": {
-    "sass": "^1.49.9",
-    "typescript": "^4.7.1"
+    "ts-blank-space": "^0.7.0",
+    "typescript": "^5.9.3"
   }
-}
+}

package/src/assert.ts

@@ -11,8 +11,8 @@ export class AssertionError extends Error {
  */
 export function assert<_T extends true>(
   condition: boolean,
-  message?: AssertMessage
-): void | never {
+  message?: AssertMessage,
+): undefined | never {
   if (!condition) {
     throw new AssertionError(message instanceof Function ? message() : message);
   }
@@ -27,7 +27,7 @@ export function assert<_T extends true>(
  */
 export function assertExists<T>(
   t: T,
-  message: AssertMessage = "Assertion failed: value does not exist"
+  message: AssertMessage = "Assertion failed: value does not exist",
 ): NonNullable<T> {
   assert(t != null, message);
   return t as NonNullable<T>;
@@ -39,7 +39,7 @@ export function assertExists<T>(
  */
 export function assertString(
   n: unknown,
-  message: AssertMessage = () => `Assertion failed: ${n} is not a string`
+  message: AssertMessage = () => `Assertion failed: ${n} is not a string`,
 ): string {
   assert(typeof n === "string", message);
   return n as string;
@@ -50,7 +50,7 @@ export function assertString(
  */
 export function checkExhaustive(
   value: never,
-  message: AssertMessage = `Unexpected value ${value}`
+  message: AssertMessage = `Unexpected value ${value}`,
 ): never {
   throw new Error(message instanceof Function ? message() : message);
 }

package/src/components/button_bar.ts

@@ -1,44 +1,42 @@
-import { display } from "../display.js";
-import { FC } from "../dom/fc.js";
-import { fieldset, input, label } from "../dom/html.js";
+import { display } from "../display.ts";
+import { FC } from "../dom/fc.ts";
+import { fieldset, input, label } from "../dom/html.ts";
 
 let buttonBarId = 1;
-let nextId = () => buttonBarId++;
+const nextId = () => buttonBarId++;
 
 const ButtonBar = FC<{
   // T extends Display
-  // @ts-ignore TODO(TFC)
+  // @ts-expect-error TODO(TFC)
   value: T;
-  // @ts-ignore TODO(TFC)
+  // @ts-expect-error TODO(TFC)
   values: T[];
-  // @ts-ignore TODO(TFC)
+  // @ts-expect-error TODO(TFC)
   events: { onSelect: (current: T) => void };
-}>("button-bar", (el, { value, values, events }) => {
+}>("button-bar", (_el, { value, values, events }) => {
   const name = `button-bar-${nextId()}`;
   return fieldset(
     { class: "input-group" },
-    ...values
-      .map((option) => {
-        const opt = `${option}`.replace(/\s+/g, "_").toLowerCase();
-        const id = `${name}-${opt}`;
-        return [
-          label(
-            { role: "button", htmlFor: id },
-            input({
-              type: "radio",
-              id,
-              name,
-              value: option,
-              checked: option === value,
-              events: {
-                change: () => events.onSelect(option),
-              },
-            }),
-            display(option)
-          ),
-        ];
-      })
-      .flat()
+    ...values.flatMap((option) => {
+      const opt = `${option}`.replace(/\s+/g, "_").toLowerCase();
+      const id = `${name}-${opt}`;
+      return [
+        label(
+          { role: "button", htmlFor: id },
+          input({
+            type: "radio",
+            id,
+            name,
+            value: option,
+            checked: option === value,
+            events: {
+              change: () => events.onSelect(option),
+            },
+          }),
+          display(option),
+        ),
+      ];
+    }),
   );
 });
 export default ButtonBar;

package/src/components/inline_edit.ts

@@ -1,6 +1,6 @@
-import { width } from "../dom/css/sizing.js";
-import { FC, State } from "../dom/fc.js";
-import { input, span } from "../dom/html.js";
+import { width } from "../dom/css/sizing.ts";
+import { FC, State } from "../dom/fc.ts";
+import { input, span } from "../dom/html.ts";
 
 const Mode = { VIEW: 0, EDIT: 1 };
 
@@ -19,7 +19,8 @@ export const InlineEdit = FC<
   },
   InlineEditState
 >("inline-edit", (el, { mode = Mode.VIEW, value, events }) => {
-  const state = (el[State] ??= { mode, value });
+  el[State] ??= { mode, value };
+  const state = el[State];
 
   const render = () => {
     switch (state.mode) {
@@ -43,7 +44,7 @@ export const InlineEdit = FC<
           },
         },
       },
-      state.value ?? ""
+      state.value ?? "",
     );
 
   const edit = () => {
@@ -61,9 +62,9 @@ export const InlineEdit = FC<
             events.change((target as HTMLInputElement)?.value ?? ""),
         },
         type: "text",
-        value: state.value,
+        value: state.value ?? "",
       }),
-      "\u00a0" // Hack to get the span to take up space
+      "\u00a0", // Hack to get the span to take up space
     );
     setTimeout(() => {
       edit.dispatchEvent(new Event("focus"));

package/src/components/logger.ts

@@ -1,18 +1,18 @@
-import { display, Display } from "../display.js";
-import { div, span, ul, li, pre, code } from "../dom/html.js";
-import { LEVEL, Logger } from "../log.js";
+import { type Display, display } from "../display.ts";
+import { code, div, li, pre, span, ul } from "../dom/html.ts";
+import { LEVEL, type Logger } from "../log.ts";
 
 export interface HTMLLogger extends Logger {
   root: Element;
 }
 
 export function isHTMLLogger(logger: Logger): logger is HTMLLogger {
-  return (logger as HTMLLogger).root != undefined;
+  return (logger as HTMLLogger).root !== undefined;
 }
 
 export function makeHTMLLogger(name: string): HTMLLogger {
-  let log: Element;
-  const root = div(div(span(name)), (log = ul()));
+  const log = ul();
+  const root = div(div(span(name)), log);
   const logger: Partial<HTMLLogger> = { level: LEVEL.INFO, root };
 
   function append(message: string): void {

package/src/components/select.ts

@@ -1,6 +1,6 @@
-import { EventHandler } from "../dom/dom.js";
-import { FC } from "../dom/fc.js";
-import { option, select } from "../dom/html.js";
+import type { EventHandler } from "../dom/dom.ts";
+import { FC } from "../dom/fc.ts";
+import { option, select } from "../dom/html.ts";
 
 export const Select = FC<{
   name: string;
@@ -12,11 +12,11 @@ export const Select = FC<{
   options: [string, string][];
 }>(
   "jiffies-select",
-  (el, { name, events: { change }, disabled, value, options }) =>
+  (_el, { name, events: { change }, disabled, value, options }) =>
     select(
       { name, events: { change }, disabled },
       ...options.map(([v, name]) =>
-        option({ value: v, selected: value === v }, `${name}`)
-      )
-    )
+        option({ value: v, selected: value === v }, `${name}`),
+      ),
+    ),
 );

package/src/components/test.ts

@@ -0,0 +1,5 @@
+import { IsBrowser } from "../is_browser.js";
+
+export async function loadTests() {
+  if (IsBrowser) await import("./virtual_scroll.test.ts");
+}

package/src/components/virtual_scroll.test.ts

@@ -1,10 +1,10 @@
-import { State } from "../dom/fc.js";
-import { div } from "../dom/html.js";
-import { describe, it, expect } from "../scope/index.js";
+import { State } from "../dom/fc.ts";
+import { div } from "../dom/html.ts";
+import { describe, expect, it } from "../scope/index.ts";
 import VirtualScroll, {
   arrayAdapter,
-  VirtualScrollProps,
-} from "./virtual_scroll.js";
+  type VirtualScrollProps,
+} from "./virtual_scroll.ts";
 
 describe("VirtualScroll", () => {
   it("tracks scroll position", () => {
@@ -16,7 +16,10 @@ describe("VirtualScroll", () => {
       row: (i) => div(`${i}`),
     };
 
-    const scroll = VirtualScroll(props);
+    const scroll = VirtualScroll(
+      // @ts-expect-error
+      props,
+    );
 
     expect(scroll[State]?.bufferedItems).toBe(9);
     expect(scroll[State]?.data).toEqual([0, 1, 2, 3, 4]);

package/src/components/virtual_scroll.ts

@@ -1,6 +1,6 @@
-import { debounce } from "../debounce.js";
-import { FC, State } from "../dom/fc.js";
-import { div } from "../dom/html.js";
+import { debounce } from "../debounce.ts";
+import { FC, State } from "../dom/fc.ts";
+import { div } from "../dom/html.ts";
 
 export interface VirtualScrollSettings {
   minIndex: number;
@@ -11,9 +11,10 @@ export interface VirtualScrollSettings {
   tolerance: number;
 }
 
-export interface VirtualScrollDataAdapter<T> {
-  (offset: number, limit: number): Iterable<T>;
-}
+export type VirtualScrollDataAdapter<T> = (
+  offset: number,
+  limit: number,
+) => Iterable<T>;
 
 export function arrayAdapter<T>(data: T[]): VirtualScrollDataAdapter<T> {
   return (offset, limit) => data.slice(offset, offset + limit);
@@ -26,7 +27,7 @@ export interface VirtualScrollProps<T, U extends HTMLElement> {
 }
 
 export function fillVirtualScrollSettings(
-  settings: Partial<VirtualScrollSettings>
+  settings: Partial<VirtualScrollSettings>,
 ): VirtualScrollSettings {
   const {
     minIndex = 0,
@@ -41,7 +42,7 @@ export function fillVirtualScrollSettings(
 }
 
 export function initialState<T>(
-  settings: VirtualScrollSettings
+  settings: VirtualScrollSettings,
 ): VirtualScrollState<T> {
   // From Denis Hilt, https://blog.logrocket.com/virtual-scrolling-core-principles-and-basic-implementation-in-react/
   const { minIndex, maxIndex, startIndex, itemHeight, count, tolerance } =
@@ -75,7 +76,7 @@ export function getData<T>(
   maxIndex: number,
   offset: number,
   limit: number,
-  get: VirtualScrollDataAdapter<T>
+  get: VirtualScrollDataAdapter<T>,
 ): T[] {
   const start = Math.max(0, minIndex, offset);
   const end = Math.min(maxIndex, offset + limit - 1);
@@ -86,7 +87,7 @@ export function getData<T>(
 export function doScroll<T>(
   scrollTop: number,
   state: VirtualScrollState<T>,
-  get: VirtualScrollDataAdapter<T>
+  get: VirtualScrollDataAdapter<T>,
 ): {
   scrollTop: number;
   topPaddingHeight: number;
@@ -105,7 +106,7 @@ export function doScroll<T>(
   const topPaddingHeight = Math.max((index - minIndex) * itemHeight, 0);
   const bottomPaddingHeight = Math.max(
     totalHeight - (topPaddingHeight + data.length * itemHeight),
-    0
+    0,
   );
 
   return { scrollTop, topPaddingHeight, bottomPaddingHeight, data };
@@ -124,23 +125,24 @@ interface VirtualScrollState<T, U extends HTMLElement = HTMLElement> {
   rows: U[];
 }
 
-// export interface VirtualScroll<T, U extends HTMLElement> {
-//   state: VirtualScrollState<T>;
-//   rows: UHTMLElement<U>[];
-// }
+export interface VirtualScroll<T, U extends HTMLElement> {
+  state: VirtualScrollState<T>;
+  rows: U[];
+}
 
 export const VirtualScroll = FC<
-  VirtualScrollProps<any, HTMLElement>,
-  VirtualScrollState<any, HTMLElement>
+  VirtualScrollProps<unknown, HTMLElement>,
+  VirtualScrollState<unknown, HTMLElement>
 >("virtual-scroll", (element, props) => {
   const settings = fillVirtualScrollSettings(props.settings);
-  const state = (element[State] = {
+  const state = {
     ...initialState(settings),
     ...element[State],
-  });
+  };
+  element[State] = state;
 
   const scrollTo = (
-    { target }: { target?: { scrollTop: number } } = { target: state }
+    { target }: { target?: { scrollTop: number } } = { target: state },
   ) => {
     const scrollTop = target?.scrollTop ?? state.topPaddingHeight;
     const updatedSate = {
@@ -152,7 +154,10 @@ export const VirtualScroll = FC<
 
   const viewportElement = div({
     style: { height: `${state.viewportHeight}px`, overflowY: "scroll" },
-    events: { scroll: debounce(scrollTo, 0) },
+    events: {
+      // @ts-expect-error
+      scroll: debounce(scrollTo, 0),
+    },
   });
   setTimeout(() => {
     viewportElement.scroll({ top: state.scrollTop });
@@ -176,13 +181,13 @@ export const VirtualScroll = FC<
             class: `VirtualScroll__item_${i}`,
             style: { height: `${settings.itemHeight}px` },
           },
-          row
-        )
+          row,
+        ),
       ),
       div({
         class: "VirtualScroll__bottomPadding",
         style: { height: `${state.bottomPaddingHeight}px` },
-      })
+      }),
     );
   };
 

package/src/context.test.ts

@@ -1,7 +1,7 @@
-import { Context, Enter, Exit, using } from "./context.js";
-import { Err, isErr, isOk, Ok, unwrap } from "./result.js";
-import { describe, it } from "./scope/describe.js";
-import { expect } from "./scope/expect.js";
+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", () => {

package/src/context.ts

@@ -1,4 +1,4 @@
-import { Ok, Err, isResult, Result } from "./result.js";
+import { Err, isResult, Ok, type Result } from "./result.ts";
 
 export const Enter = Symbol("Context Enter");
 export const Exit = Symbol("Context Exit");
@@ -8,18 +8,20 @@ export interface Context {
   [Exit]: () => void;
 }
 
-export interface Operation<T, E extends Error, C extends Context> {
-  (c: C): T | Result<T, E>;
-}
+export type Operation<T, E extends Error, C extends Context> = (
+  c: C,
+) => T | Result<T, E>;
 
-export interface AsyncOperation<T, E extends Error, C extends Context> {
-  (c: C): Promise<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 | any) => Err<E> = (e) => Err(e)
+  normalizeError: (e: Error | unknown) => Err<E> = (e) =>
+    // @ts-expect-error
+    Err(e),
 ): Result<T, E> {
   if (typeof context === "function") {
     if (context.length === 1) {
@@ -32,7 +34,7 @@ export function using<T, E extends Error, C extends Context>(
   let result: Result<T, E>;
   try {
     context[Enter]();
-    const op = operation!(context);
+    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);
@@ -45,7 +47,7 @@ export function using<T, E extends Error, C extends Context>(
 export async function asyncUsing<T, E extends Error, C extends Context>(
   context: C | (() => Promise<C>),
   operation: AsyncOperation<T, E, C>,
-  normalizeError: (e: Error | unknown | any) => Err<E> = (e: E) => Err(e)
+  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>;
@@ -54,7 +56,10 @@ export async function asyncUsing<T, E extends Error, C extends Context>(
     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(e);
+    result = normalizeError(
+      // @ts-expect-error
+      e,
+    );
   } finally {
     context[Exit]();
   }

package/src/debounce.ts

@@ -1,8 +1,14 @@
-export function debounce(fn: (...args: any[]) => any, ms = 32) {
+export function debounce<T extends unknown[]>(
+  fn: (...args: T) => void,
+  ms = 32,
+): (...args: T) => void {
   let timer: ReturnType<typeof setTimeout>;
-  return (...args: Parameters<typeof fn>) => {
+  return (...args: T) => {
     clearTimeout(timer);
-    timer = setTimeout(() => (clearTimeout(timer), fn(...args)), ms);
+    timer = setTimeout(() => {
+      clearTimeout(timer);
+      return fn(...args);
+    }, ms);
     return timer;
   };
 }

package/src/diff.test.ts

@@ -1,6 +1,6 @@
-import { diff } from "./diff.js";
-import { describe, it } from "./scope/describe.js";
-import { expect } from "./scope/expect.js";
+import { diff } from "./diff.ts";
+import { describe, it } from "./scope/describe.ts";
+import { expect } from "./scope/expect.ts";
 
 describe("diff", () => {
   it("diffs primitives", () => {
@@ -36,7 +36,7 @@ describe("diff", () => {
   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 } }]
+      [{ a: { b: 1 } }, { a: { b: 4 } }, { a: { b: 3 } }],
     );
     expect(diffed).toEqual([
       {

package/src/diff.ts

@@ -1,5 +1,5 @@
-import { range } from "./range.js";
-import { isSome, None, Option, Some } from "./result.js";
+import { range } from "./range.ts";
+import { isSome, None, type Option, Some } from "./result.ts";
 
 export const DiffA = Symbol("A");
 export const DiffB = Symbol("B");
@@ -20,29 +20,27 @@ interface DiffList {
 
 function doDiff<T>(va: T, vb: T, k: DiffIndex): Option<DiffList | DiffEntry> {
   if (Array.isArray(va)) {
-    // @ts-ignore
+    // @ts-expect-error
     return diffArray(va, vb, k);
   }
   if (typeof va === "object") {
-    const d = diffObject(va, vb, k);
+    const d = diffObject(va ?? {}, vb ?? {}, k);
     if (d.children.length === 0) {
       return None();
-    } else {
-      return Some(d);
     }
+    return Some(d);
   }
   if (Object.is(va, vb)) {
     return None();
-  } else {
-    // @ts-ignore
-    return { key: k, left: va, right: vb };
   }
+  // @ts-expect-error
+  return { key: k, left: va, right: vb };
 }
 
 function diffArray<T>(
   a: Partial<T>[],
   b: Partial<T>[],
-  key: DiffIndex
+  key: DiffIndex,
 ): Option<DiffList> {
   const indexes = Math.max(a.length, b.length);
   const children = range(0, indexes)
@@ -54,11 +52,11 @@ function diffArray<T>(
 function diffObject<T>(
   a: Partial<T>,
   b: Partial<T>,
-  key: DiffIndex = ""
+  key: DiffIndex = "",
 ): DiffList {
   const keys = new Set([...Object.keys(a), ...Object.keys(b)]);
   const children = [...keys]
-    // @ts-ignore
+    // @ts-expect-error
     .map((k) => doDiff(a[k], b[k], k))
     .filter(isSome);
   return {
@@ -69,16 +67,16 @@ function diffObject<T>(
 
 export function diff<T>(
   a: Partial<T>,
-  b: Partial<T>
+  b: Partial<T>,
 ): (DiffEntry | DiffList)[] {
-  if (typeof a != "object" && !Object.is(a, b)) {
-    // @ts-ignore
+  if (typeof a !== "object" && !Object.is(a, b)) {
+    // @ts-expect-error
     return [{ key: "", left: a, right: b }];
   }
   return (
     Array.isArray(a)
       ? // @ts-ignore
-        diffArray(a, b, "") ?? { children: [] }
+        (diffArray(a, b, "") ?? { children: [] })
       : diffObject(a, b, "")
   ).children;
 }