@davidsouther/jiffies 2.2.5 → 2026.4.0

package/src/result.ts

@@ -1,13 +1,3 @@
-export type None = null;
-export type Some<T> = T;
-export type Option<T> = Some<T> | None;
-export type Err<E = Error> = {
-  err: E;
-  map: <U>(fn: (t: unknown) => Result<U>) => Result<U>;
-};
-export type Ok<T> = { ok: T; map: <U>(fn: (t: T) => Result<U>) => Result<U> };
-export type Result<T, E = Error> = Ok<T> | Err<E>;
-
 export const isNone = <T>(s: Option<T>): s is None => s === null;
 export const isSome = <T>(s: Option<T>): s is Some<T> => s != null;
 
@@ -17,87 +7,101 @@ export function None<T = unknown>(_?: T): Option<T> {
 
 export function Some<T>(t: Option<T>): Option<T>;
 export function Some<T>(t: T): Option<T>;
-export function Some(t: any): any {
+export function Some<T>(t: Option<T> | T): Option<T> {
   return t;
 }
 
 export const isOk = <T, E>(t: Result<T, E>): t is Ok<T> =>
-  Object.prototype.hasOwnProperty.call(t ?? {}, "ok");
+  t && Object.hasOwn(t, "ok");
 export const isErr = <T, E>(e: Result<T, E>): e is Err<E> =>
-  Object.prototype.hasOwnProperty.call(e, "err");
+  e && Object.hasOwn(e, "err");
 export const isResult = <T, E>(t: Result<T, E>): t is Result<T, E> =>
   isOk(t) || isErr(t);
 
 // Beware: Order matters for correct inference.
-export function Ok<T>(ok: Ok<T>): T;
-export function Ok<T>(t?: T): Ok<T>;
-export function Ok<T, E>(t: any): any {
-  return isOk(t)
-    ? t.ok
-    : {
+export function Ok<T, _E = unknown>(ok: Ok<T>): T;
+export function Ok<T, _E = unknown>(t?: T): Ok<T>;
+export function Ok<T, E = unknown>(t: T | Ok<T>): T | Ok<T> {
+  return isOk(t as Ok<T>)
+    ? (t as Ok<T>).ok
+    : ({
         ok: t,
         map<U>(fn: (_: typeof t) => Result<U, E>): Result<U, E> {
           return fn(Ok(this));
         },
-      };
+      } as Ok<T>);
 }
 
 // Beware: Order matters for correct inference.
-export function Err<E>(e: Err<E>): E;
-export function Err<E>(e: E): Err<E>;
-export function Err<E>(e: string): Err<E>;
-export function Err<T, E>(e: any): any {
+export function Err<_T, E>(e: Err<E>): E;
+export function Err<_T, E>(e: E): Err<E>;
+export function Err<_T, E>(e: string): Err<E>;
+export function Err<T, E>(e: E | string | Err<E>): E | Err<E> {
   return (
-    e.err ?? {
+    ((e as Err<E>).err as E) ??
+    ({
       err: e,
       map<U>(this: Result<T, E>, _fn: (t: unknown) => Result<U>): Result<U, E> {
         return this as Result<U, E>;
       },
-    }
+    } as Err<E>)
   );
 }
 
 export function unwrap<T, E>(result: Result<T, E>): T | never;
 export function unwrap<O>(some: Option<O>): O | never;
-export function unwrap(t: any): any {
-  if (isNone(t)) {
-    throw new Error(`Attempted to unwrap None`);
+export function unwrap<T, E>(t: Result<T, E> | Option<T> | T): T | never {
+  if (isNone(t as Option<T>)) {
+    throw new Error("Attempted to unwrap None");
   }
-  if (isErr(t)) {
+  if (isErr(t as Result<T, E>)) {
     throw Err(t);
   }
-  if (isOk(t)) {
-    return Ok(t);
+  if (isOk(t as Result<T, E>)) {
+    return Ok(t as Ok<T>);
   }
-  return t;
+  return t as T;
 }
 
 export function unwrapOr<T, E>(result: Result<T, E>, def: T): T;
 export function unwrapOr<T>(some: Some<T>, def: T): T;
-export function unwrapOr(t: any, def: any): any {
-  if (isNone(t)) {
+export function unwrapOr<T, E>(t: Some<T> | Result<T, E>, def: T): T {
+  if (isNone(t as Some<T>)) {
     return def;
   }
-  if (isErr(t)) {
+  if (isErr(t as Result<T, E>)) {
     return def;
   }
-  if (isOk(t)) {
-    return Ok(t);
+  if (isOk(t as Result<T, E>)) {
+    return Ok(t as Ok<T>);
   }
-  return t;
+  return t as T;
 }
 
-export function unwrapOrElse<T, E>(result: Result<T, Error>, def: () => T): T;
-export function unwrapOrElse<T>(some: Some<T>, def: () => T): T;
-export function unwrapOrElse(t: any, def: any): any {
-  if (isNone(t)) {
+export function unwrapOrElse<T, E>(result: Result<T, E>, def: () => T): T;
+export function unwrapOrElse<T, _E>(some: Some<T>, def: () => T): T;
+export function unwrapOrElse<T, E>(t: Result<T, E> | Some<T>, def: () => T): T {
+  if (isNone(t as Some<T>)) {
     return def();
   }
-  if (isErr(t)) {
+  if (isErr(t as Err<T>)) {
     return def();
   }
-  if (isOk(t)) {
-    return Ok(t);
+  if (isOk(t as Ok<T>)) {
+    return Ok(t as Ok<T>);
   }
-  return t;
+  return t as T;
 }
+
+export type None = null;
+// biome-ignore lint/suspicious/noRedeclare: This file does trickery with const and type.
+export type Some<T> = T;
+export type Option<T> = Some<T> | None;
+// biome-ignore lint/suspicious/noRedeclare: This file does trickery with const and type.
+export type Err<E = Error> = {
+  err: E;
+  map: <U>(fn: (t: unknown) => Result<U>) => Result<U>;
+};
+// biome-ignore lint/suspicious/noRedeclare: This file does trickery with const and type.
+export type Ok<T> = { ok: T; map: <U>(fn: (t: T) => Result<U>) => Result<U> };
+export type Result<T, E = Error> = Ok<T> | Err<E>;

package/src/safe.ts

@@ -1,4 +1,4 @@
-import { error } from "./log.js";
+import { error } from "./log.ts";
 
 export const safe =
   <A extends unknown[], R>(fn: (...args: A) => R, r: R): ((...args: A) => R) =>

package/src/scope/describe.ts

@@ -1,7 +1,7 @@
-import { assert } from "../assert.js";
-import { getLogger } from "../log.js";
-import { TestCase } from "./scope.js";
-import * as state from "./state.js";
+import { assert } from "../assert.ts";
+import { getLogger } from "../log.ts";
+import type { TestCase } from "./scope.ts";
+import * as state from "./state.ts";
 
 export const beforeall = Symbol("beforeAll");
 export const beforeeach = Symbol("beforeEach");
@@ -11,12 +11,13 @@ export const aftereach = Symbol("afterEach");
 const logger = getLogger("scope");
 
 const CASES: TestCase = {};
-let cases = [CASES];
+const cases = [CASES];
 let totalCases = 0;
 let skippedCases = 0;
 
 function push(title: string) {
-  const next = (cases[0][title] = cases[0][title] ?? {}) as TestCase;
+  cases[0][title] = cases[0][title] ?? {};
+  const next = cases[0][title] as TestCase;
   cases.unshift(next);
 }
 
@@ -36,21 +37,21 @@ export function getSkippedCases() {
   return skippedCases;
 }
 
-export function describe(title: string, block: Function) {
+export function describe(title: string, block: CallableFunction) {
   logger.debug(`describe(${title})`);
   push(title);
   block();
   pop();
 }
 
-export function it(title: string, block: Function) {
+export function it(title: string, block: CallableFunction) {
   logger.debug(`it(${title})`);
-  assert(cases[0][title] == undefined, `Block already has test ${title}`);
+  assert(cases[0][title] === undefined, `Block already has test ${title}`);
   totalCases += 1;
   cases[0][title] = block;
 }
 
-it.skip = (title: string, _block: Function) => {
+it.skip = (title: string, _block: CallableFunction) => {
   logger.debug(`it.skip(${title})`);
   totalCases += 1;
   skippedCases += 1;
@@ -74,7 +75,7 @@ export function afterAll(fn: () => void) {
 
 export function cleanState<State extends {}>(
   init: () => State,
-  runner: (action: () => void) => void = beforeEach
+  runner: (action: () => void) => void = beforeEach,
 ): State {
   return state.cleanState(init, runner);
 }

package/src/scope/display/console.ts

@@ -1,7 +1,7 @@
-import { getLogger } from "../../log.js"
-import { getTotalCases } from "../describe.js"
-import { flattenResults } from "../execute.js"
-import { TestResult } from "../scope.js"
+import { getLogger } from "../../log.ts";
+import { getTotalCases } from "../describe.ts";
+import { flattenResults } from "../execute.ts";
+import type { TestResult } from "../scope.ts";
 
 const logger = getLogger("Scope Test Runner");
 

package/src/scope/display/dom.ts

@@ -1,21 +1,21 @@
-import { isHTMLLogger, makeHTMLLogger } from "../../components/logger.js"
-import { DOMElement } from "../../dom/dom.js"
-import { DEFAULT_LOGGER, LEVEL } from "../../log.js"
-import { getTotalCases } from "../describe.js"
-import { flattenResults } from "../execute.js"
-import { TestResult } from "../scope.js"
+import { isHTMLLogger, makeHTMLLogger } from "../../components/logger.ts";
+import type { DOMElement } from "../../dom/dom.ts";
+import { DEFAULT_LOGGER, LEVEL } from "../../log.ts";
+import { getTotalCases } from "../describe.ts";
+import { flattenResults } from "../execute.ts";
+import type { TestResult } from "../scope.ts";
 
 export function displayStatistics(
   results: TestResult,
-  root: DOMElement = document.body as DOMElement
+  root: DOMElement = document.body as DOMElement,
 ) {
   const { executed, failed } = results;
   const logger = (() => {
     try {
       return makeHTMLLogger(
-        `Executed ${executed} of ${getTotalCases()}; ${failed} failed.`
+        `Executed ${executed} of ${getTotalCases()}; ${failed} failed.`,
       );
-    } catch (e) {
+    } catch (_e) {
       return DEFAULT_LOGGER;
     }
   })();

package/src/scope/display/junit.ts

@@ -1,43 +1,40 @@
-import { xml } from "../../dom/xml.js"
-import { FlatResult, flattenResults } from "../execute.js"
-import { TestResult } from "../scope.js"
+import { xml } from "../../dom/xml.ts";
+import { type FlatResult, flattenResults } from "../execute.ts";
+import type { TestResult } from "../scope.ts";
 
 const cases = (results: TestResult) =>
   Object.entries(results).filter(
-    ([key]) => !["executed", "passed", "failed"].includes(key)
+    ([key]) => !["executed", "passed", "failed"].includes(key),
   );
 
 export function asXML(results: TestResult) {
-  return (
-    `<?xml version="1.0" encoding="UTF-8" ?>` +
-    xml(
-      "testsuites",
-      { tests: results.executed, failures: results.failed },
-      cases(results).map(([title, children]) =>
-        testsuite(
-          title,
-          (children as TestResult).executed,
-          (children as TestResult).failed,
-          flattenResults(children as TestResult)
-        )
-      )
-    )
-  );
+  return `<?xml version="1.0" encoding="UTF-8" ?>${xml(
+    "testsuites",
+    { tests: results.executed, failures: results.failed },
+    cases(results).map(([title, children]) =>
+      testsuite(
+        title,
+        (children as TestResult).executed,
+        (children as TestResult).failed,
+        flattenResults(children as TestResult),
+      ),
+    ),
+  )}`;
 }
 
 function testsuite(
   name: string,
   tests: number,
   failures: number,
-  cases: FlatResult[]
+  cases: FlatResult[],
 ) {
   const id = name.replace("s+", "_");
   return xml(
     "testsuite",
     { id, name, tests, failures },
     cases.map(({ test, stack }) =>
-      testcase({ name: `${name} ${test}` }, stack ? [stack as string] : [])
-    )
+      testcase({ name: `${name} ${test}` }, stack ? [stack as string] : []),
+    ),
   );
 }
 
@@ -47,12 +44,12 @@ function testcase(
     id = name.replace(/\s+/g, "_"),
     time = "0.00",
   }: { name: string; id?: string; time?: string },
-  failures: string[]
+  failures: string[],
 ) {
   return xml(
     "testcase",
     { id, name, time },
-    failures.map((stack) => failure({ text: stack }))
+    failures.map((stack) => failure({ text: stack })),
   );
 }
 

package/src/scope/execute.ts

@@ -4,8 +4,13 @@ import {
   beforeall,
   beforeeach,
   rootCases,
-} from "./describe.js"
-import { TestFailed, TestPassed, TestResult, TestSummary } from "./scope.js"
+} from "./describe.ts";
+import type {
+  TestFailed,
+  TestPassed,
+  TestResult,
+  TestSummary,
+} from "./scope.ts";
 
 export async function execute(cases = rootCases()): Promise<TestResult> {
   const beforeallfn = cases[beforeall] ?? (() => {});
@@ -18,7 +23,7 @@ export async function execute(cases = rootCases()): Promise<TestResult> {
   try {
     await beforeallfn();
   } catch (e) {
-    result["_beforeAll"] = { error: e };
+    result._beforeAll = { error: e };
     return result;
   }
 
@@ -50,20 +55,20 @@ export async function execute(cases = rootCases()): Promise<TestResult> {
   try {
     await afterallfn();
   } catch (e) {
-    result["_afterAll"] = { error: e };
+    result._afterAll = { error: e };
   }
 
   return result;
 }
 
 export function getError({ error }: TestResult) {
-  if (typeof error == "string") {
+  if (typeof error === "string") {
     return error;
-  } else if ((error as TestResult).message) {
+  }
+  if ((error as TestResult).message) {
     return (error as TestResult).stack;
-  } else {
-    return "unknown error";
   }
+  return "unknown error";
 }
 
 export interface FlatResult {
@@ -74,7 +79,7 @@ export interface FlatResult {
 
 function makeResult(
   test: string,
-  result: TestResult | TestSummary
+  result: TestResult | TestSummary,
 ): FlatResult[] {
   if ((result as TestFailed).error)
     return [
@@ -91,13 +96,13 @@ function makeResult(
 }
 
 export function flattenResults(results: TestResult, prefix = ""): FlatResult[] {
-  const arrow = prefix == "" ? "" : " -> ";
+  const arrow = prefix === "" ? "" : " -> ";
   let errorList: FlatResult[] = [];
   for (const [title, result] of Object.entries(results).filter(
-    ([key]) => !["executed", "passed", "failed"].includes(key)
+    ([key]) => !["executed", "passed", "failed"].includes(key),
   )) {
     const test = `${prefix}${arrow}${title}`;
-    if (typeof result == "number") continue;
+    if (typeof result === "number") continue;
     const flatResult = makeResult(test, result);
     errorList = errorList.concat(flatResult);
   }

package/src/scope/expect.ts

@@ -1,6 +1,6 @@
-import { assert } from "../assert.js";
-import { display } from "../display.js";
-import { equals } from "../equal.js";
+import { assert } from "../assert.ts";
+import { display } from "../display.ts";
+import { equals } from "../equal.ts";
 
 export class Matcher<T> {
   actual: T;
@@ -21,27 +21,27 @@ export class Matcher<T> {
       equals(this.actual, expected, partial),
       () =>
         `Objects are not equivalent: ${display(this.actual)}, ${display(
-          expected
-        )}`
+          expected,
+        )}`,
     );
   }
 
   toMatch(expected: RegExp | string) {
     assert(
       typeof this.actual === "string",
-      () => "Must have string for regexp match"
+      () => "Must have string for regexp match",
     );
     // @ts-expect-error
     const actual: string = this.actual;
     if (typeof expected === "string") {
       assert(
         actual.includes(expected),
-        () => `${actual} does not include ${expected}`
+        () => `${actual} does not include ${expected}`,
       );
     } else {
       assert(
         expected.test(actual),
-        () => `${actual} does not match ${expected}`
+        () => `${actual} does not match ${expected}`,
       );
     }
   }
@@ -54,8 +54,8 @@ export class Matcher<T> {
         equals(actual, v, true),
         () =>
           `Comparing ${k}, properties not equal: ${display(actual)}, ${display(
-            v
-          )}`
+            v,
+          )}`,
       );
     }
   }
@@ -63,21 +63,21 @@ export class Matcher<T> {
   toBeNull() {
     assert(
       this.actual === null,
-      () => `Expected null, got ${JSON.stringify(this.actual)}`
+      () => `Expected null, got ${JSON.stringify(this.actual)}`,
     );
   }
 
   toThrow(message = "") {
     let didThrow = false;
 
-    let result: unknown = undefined;
+    let result: unknown;
     try {
       // @ts-expect-error
       result = this.actual();
     } catch (e) {
       assert(
         ((e as { message?: string }).message ?? "").match(message) !== null,
-        () => `Expected thrown message to match ${message}, got ${e}`
+        () => `Expected thrown message to match ${message}, got ${e}`,
       );
       didThrow = true;
     }
@@ -105,22 +105,22 @@ export class NotMatcher<T> {
       !equals(this.actual, expected),
       () =>
         `Objects are equivalent: ${JSON.stringify(
-          this.actual
-        )}, ${JSON.stringify(expected)}`
+          this.actual,
+        )}, ${JSON.stringify(expected)}`,
     );
   }
 
   toMatch(expected: RegExp | string) {
     assert(
       typeof this.actual === "string",
-      () => "Must have string for regexp match"
+      () => "Must have string for regexp match",
     );
     // @ts-expect-error
     const actual: string = this.actual;
     if (typeof expected === "string") {
       assert(
         !actual.includes(expected),
-        () => `${actual} includes ${expected}`
+        () => `${actual} includes ${expected}`,
       );
     } else {
       assert(!expected.test(actual), () => `${actual} matches ${expected}`);
@@ -135,27 +135,27 @@ export class NotMatcher<T> {
         !equals(actual, v),
         () =>
           `Comparing ${k}, properties equal: ${JSON.stringify(
-            actual
-          )}, ${JSON.stringify(v)}`
+            actual,
+          )}, ${JSON.stringify(v)}`,
       );
     }
   }
 
   toBeNull() {
-    assert(this.actual !== null, () => `Expected not null`);
+    assert(this.actual !== null, () => "Expected not null");
   }
 
   toThrow(message = "") {
     let didThrow = false;
 
-    let result: unknown = undefined;
+    let result: unknown;
     try {
       // @ts-expect-error
       result = this.actual();
     } catch (e) {
       assert(
         ((e as { message?: string }).message ?? "").match(message) !== null,
-        () => `Expected thrown message to match ${message}, got ${e}`
+        () => `Expected thrown message to match ${message}, got ${e}`,
       );
       didThrow = true;
     }

package/src/scope/fix.ts

@@ -3,27 +3,28 @@
  */
 export function fix<T>(n: T): T {
   if (typeof n === "number") {
-    // @ts-ignore
     return +n.toFixed(1) as T;
   }
   if (n !== Object(n)) {
     // A primitive
     return n;
   }
-  if (n instanceof Array) {
-    // @ts-ignore
+  if (Array.isArray(n)) {
     return n.map(fix) as T;
   }
-  // @ts-ignore
+  // @ts-expect-error
   return mapreduce<T>(fix, n as Record<string, T>);
 }
 
 function mapreduce<T, U>(
   fn: (t: T) => U,
-  iter: Record<string, T>
+  iter: Record<string, T>,
 ): Record<string, U> {
   return Object.entries(iter).reduce(
-    (acc, [k, v]) => ((acc[k] = fn(v)), acc),
-    {} as Record<string, U>
+    (acc, [k, v]) => {
+      acc[k] = fn(v);
+      return acc;
+    },
+    {} as Record<string, U>,
   );
 }

package/src/scope/index.ts

@@ -1,5 +1,3 @@
-export { expect } from "./expect.js";
-export { fix } from "./fix.js";
 export {
   afterAll,
   afterEach,
@@ -8,4 +6,6 @@ export {
   cleanState,
   describe,
   it,
-} from "./describe.js";
+} from "./describe.ts";
+export { expect } from "./expect.ts";
+export { fix } from "./fix.ts";

package/src/scope/scope.ts

@@ -1,6 +1,6 @@
 export interface TestCase {
-  [k: string]: Function | TestCase;
-  [k: symbol]: Function;
+  [k: string]: CallableFunction | TestCase;
+  [k: symbol]: CallableFunction;
 }
 
 export interface TestResult {

package/src/scope/state.ts

@@ -1,8 +1,8 @@
-import { Awaitable } from "../awaitable.js";
+import type { Awaitable } from "../awaitable.ts";
 
 export function cleanState<State extends {}>(
   init: () => Awaitable<State>,
-  runner: (action: () => Promise<void>) => void
+  runner: (action: () => Promise<void>) => void,
 ): State {
   const state = {};
   runner(async () => {

package/src/server/http/apps.ts

@@ -1,7 +1,7 @@
-import * as fs from "fs/promises";
-import * as path from "path";
-import { MiddlewareFactory } from "./index.js";
-import { fileResponse } from "./response.js";
+import * as fs from "node:fs/promises";
+import * as path from "node:path";
+import type { MiddlewareFactory } from "./index.ts";
+import { fileResponse } from "./response.ts";
 
 /**
  * Searches up the request path until the first index is found.
@@ -18,7 +18,7 @@ export const findIndex: MiddlewareFactory =
       try {
         const stat = await fs.stat(index);
         return fileResponse(index, stat);
-      } catch (e) {
+      } catch (_e) {
         filename = path.dirname(filename);
       }
     }