@itmetsam/samurai-framework 0.1.0 → 0.2.0

package/src/wait/wait-until.test.ts

@@ -1,117 +0,0 @@
-import { test } from "node:test";
-import assert from "node:assert/strict";
-import { resolveTimeout, waitUntil, WaitTimeoutError } from "./wait-until.js";
-import { resolveRunSettings, setRunSettings } from "../config/run-settings.js";
-
-/** Probe returning the given values in order; the last one repeats */
-function sequence<T>(...values: T[]) {
-  let calls = 0;
-  const probe = async () => values[Math.min(calls++, values.length - 1)]!;
-  return { probe, calls: () => calls };
-}
-
-test("probes until isDone and resolves with that value", async () => {
-  const { probe, calls } = sequence(1, 2, 3);
-  assert.equal(await waitUntil(probe, (value) => value === 3, { timeout: 2000 }), 3);
-  assert.equal(calls(), 3);
-});
-
-test("passes the previous value to isDone", async () => {
-  const { probe } = sequence(1, 2, 2);
-  const seen: Array<[number, number | undefined]> = [];
-  await waitUntil(
-    probe,
-    (current, previous) => {
-      seen.push([current, previous]);
-      return current === previous;
-    },
-    { timeout: 2000 },
-  );
-  assert.deepEqual(seen, [
-    [1, undefined],
-    [2, 1],
-    [2, 2],
-  ]);
-});
-
-test("times out with the last value, ending at the deadline", async () => {
-  const { probe, calls } = sequence("a", "b");
-  const start = Date.now();
-  await assert.rejects(waitUntil(probe, () => false, { timeout: 250 }), (err) => {
-    assert.ok(err instanceof WaitTimeoutError);
-    assert.equal(err.name, "WaitTimeoutError");
-    assert.equal(err.timeout, 250);
-    assert.equal(err.last, "b");
-    return true;
-  });
-  const elapsed = Date.now() - start;
-  // probes at ~0, ~100, ~200; the final sleep is clamped to the ~50ms left, and no probe starts after the deadline
-  assert.ok(elapsed >= 245 && elapsed < 295, `elapsed ${elapsed}ms`);
-  assert.equal(calls(), 3);
-});
-
-test("timeout 0 probes exactly once", async () => {
-  const { probe, calls } = sequence(false);
-  await assert.rejects(waitUntil(probe, (value) => value, { timeout: 0 }), WaitTimeoutError);
-  assert.equal(calls(), 1);
-});
-
-test("timeout 0 resolves when the single probe is done", async () => {
-  const { probe } = sequence(true);
-  assert.equal(await waitUntil(probe, (value) => value, { timeout: 0 }), true);
-});
-
-test("probe errors are rethrown without retrying", async () => {
-  let calls = 0;
-  const probe = async () => {
-    calls++;
-    throw new Error("boom");
-  };
-  await assert.rejects(waitUntil(probe, () => true, { timeout: 2000 }), /boom/);
-  assert.equal(calls, 1);
-});
-
-test("a probe that never settles stops at the deadline", async () => {
-  const start = Date.now();
-  await assert.rejects(
-    waitUntil(() => new Promise<never>(() => {}), () => true, { timeout: 200 }),
-    (err) => {
-      assert.ok(err instanceof WaitTimeoutError);
-      assert.equal(err.last, undefined);
-      return true;
-    },
-  );
-  assert.ok(Date.now() - start < 400);
-});
-
-test("a probe that hangs after earlier results reports the last completed value", async () => {
-  let calls = 0;
-  const probe = () => (calls++ === 0 ? Promise.resolve("first") : new Promise<string>(() => {}));
-  await assert.rejects(waitUntil(probe, () => false, { timeout: 200 }), (err) => {
-    assert.ok(err instanceof WaitTimeoutError);
-    assert.equal(err.last, "first");
-    return true;
-  });
-});
-
-test("no timer outlives a resolved wait", async () => {
-  const timers = () => process.getActiveResourcesInfo().filter((name) => name === "Timeout").length;
-  const before = timers();
-  await waitUntil(async () => true, (value) => value, { timeout: 10000 });
-  assert.equal(timers(), before);
-});
-
-test("resolveTimeout prefers the per-call value", async () => {
-  assert.equal(await resolveTimeout(1234), 1234);
-  assert.equal(await resolveTimeout(0), 0);
-});
-
-test("resolveTimeout uses the active run's expect timeout", async () => {
-  setRunSettings(resolveRunSettings({}, { expectTimeout: 1234 }));
-  try {
-    assert.equal(await resolveTimeout(), 1234);
-    assert.equal(await resolveTimeout(10), 10);
-  } finally {
-    setRunSettings(undefined);
-  }
-});

package/src/wait/wait-until.ts

@@ -1,86 +0,0 @@
-import { setTimeout as sleep } from "node:timers/promises";
-import { readConfig } from "../config/config.js";
-import { peekRunSettings } from "../config/run-settings.js";
-
-const DEFAULT_TIMEOUT = 5000;
-const DEFAULT_INTERVAL = 100;
-
-export interface WaitOptions {
-  /** Total time (ms) to keep probing; 0 probes exactly once */
-  timeout: number;
-  /** Time (ms) between probes. @default 100 */
-  interval?: number;
-}
-
-export class WaitTimeoutError<T> extends Error {
-  public readonly timeout: number;
-  /** Last completed probe result; undefined when no probe completed */
-  public readonly last: T | undefined;
-
-  constructor(timeout: number, last: T | undefined) {
-    super(`Condition not met within ${timeout}ms`);
-    this.name = "WaitTimeoutError";
-    this.timeout = timeout;
-    this.last = last;
-  }
-}
-
-/** Per-call timeout, else the active run's expect timeout, else config `expect.timeout`, else 5000 */
-export async function resolveTimeout(perCall?: number): Promise<number> {
-  if (perCall !== undefined) return perCall;
-  const run = peekRunSettings();
-  if (run) return run.expectTimeout;
-  return (await readConfig("expect"))?.timeout ?? DEFAULT_TIMEOUT;
-}
-
-const DEADLINE = Symbol("deadline");
-
-/**
- * Races `probe()` against the time left. Resolves `{ value }` when the probe wins,
- * DEADLINE when the time runs out first; probe errors reject as-is.
- */
-function probeBefore<T>(
-  probe: () => Promise<T>,
-  remaining: number,
-): Promise<{ value: T } | typeof DEADLINE> {
-  const probing = probe();
-  let timer: ReturnType<typeof setTimeout> | undefined;
-  const expired = new Promise<typeof DEADLINE>((resolve) => {
-    timer = setTimeout(() => resolve(DEADLINE), remaining);
-  });
-  // A probe that loses the race may still fail later; nobody is waiting for it any more
-  probing.catch(() => {});
-  return Promise.race([probing.then((value) => ({ value })), expired]).finally(() =>
-    clearTimeout(timer),
-  );
-}
-
-/**
- * Probes until `isDone(current, previous)` is true and resolves with that result.
- * Always probes at least once; with `timeout > 0` every probe races the time left.
- * Probe errors are rethrown immediately. Throws WaitTimeoutError at the deadline.
- */
-export async function waitUntil<T>(
-  probe: () => Promise<T>,
-  isDone: (current: T, previous: T | undefined) => boolean,
-  { timeout, interval = DEFAULT_INTERVAL }: WaitOptions,
-): Promise<T> {
-  const deadline = Date.now() + timeout;
-  let previous: T | undefined;
-
-  for (let first = true; ; first = false) {
-    const remaining = deadline - Date.now();
-    // Only start a probe while time remains; a later one could only lose the race
-    if (!first && remaining <= 0) throw new WaitTimeoutError(timeout, previous);
-
-    // timeout 0 keeps the single probe un-raced so it always completes
-    const result = timeout > 0 ? await probeBefore(probe, remaining) : { value: await probe() };
-    if (result === DEADLINE) throw new WaitTimeoutError(timeout, previous);
-    if (isDone(result.value, previous)) return result.value;
-    previous = result.value;
-
-    const left = deadline - Date.now();
-    if (left <= 0) throw new WaitTimeoutError(timeout, previous);
-    await sleep(Math.min(interval, left));
-  }
-}

package/tsconfig.json

@@ -1,44 +0,0 @@
-{
-  // Visit https://aka.ms/tsconfig to read more about this file
-  "compilerOptions": {
-    // File Layout
-    "rootDir": "./src",
-    "outDir": "./dist",
-    "paths": {
-      "browsers/*": ["./browsers"]
-    },
-
-    // Environment Settings
-    // See also https://aka.ms/tsconfig/module
-    "module": "nodenext",
-    "target": "es2021",
-    "types": ["node"],
-    // For nodejs:
-    // "lib": ["esnext"],
-
-    // Other Outputs
-    "sourceMap": false,
-    "declaration": true,
-    "declarationMap": false,
-
-    // Stricter Typechecking Options
-    "noUncheckedIndexedAccess": true,
-
-    // Style Optiong
-    // "noImplicitReturns": true,
-    // "noImplicitOverride": true,
-    // "noUnusedLocals": true,
-    // "noUnusedParameters": true,
-    // "noFallthroughCasesInSwitch": true,
-    // "noPropertyAccessFromIndexSignature": true,
-
-    // Recommended Options
-    "strict": true,
-    "verbatimModuleSyntax": true,
-    "isolatedModules": true,
-    "noUncheckedSideEffectImports": true,
-    "moduleDetection": "force",
-    "skipLibCheck": true
-  },
-  "include": ["src"]
-}