@cplieger/actions 1.0.1 → 1.1.0

package/src/poll.test.ts

@@ -1,385 +0,0 @@
-// @vitest-environment happy-dom
-// Tests for pollAction.
-import { describe, it, expect, vi, beforeEach, afterEach } from "vitest";
-
-vi.mock("./notifier.js", () => ({
-  configure: vi.fn(),
-  notifySuccess: vi.fn(),
-  notifyError: vi.fn(),
-  _resetNotifierForTest: vi.fn(),
-}));
-
-import { defineAction, _resetForTest as resetDefine } from "./define.js";
-import { _resetForTest as resetRegistry } from "./registry.js";
-import { _resetForTest as resetCleanup, _cancelAllForTest as cancelAllForTest } from "./cleanup.js";
-import { pollAction } from "./poll.js";
-
-beforeEach(() => {
-  resetDefine();
-  resetRegistry();
-  resetCleanup();
-  vi.clearAllMocks();
-  Object.defineProperty(document, "hidden", { value: false, configurable: true });
-  Object.defineProperty(document, "visibilityState", { value: "visible", configurable: true });
-});
-
-afterEach(() => {
-  vi.useRealTimers();
-});
-
-describe("pollAction — basic scheduling", () => {
-  it("dispatches immediately on start, then at the interval", async () => {
-    let count = 0;
-    const action = defineAction<undefined, number>({
-      name: "test.poll.basic",
-      run: async () => ++count,
-    });
-
-    vi.useFakeTimers();
-    const stop = pollAction(action, undefined, { interval: 1000 });
-
-    await vi.runAllTicks();
-    await Promise.resolve();
-    await Promise.resolve();
-    expect(count).toBe(1);
-
-    await vi.advanceTimersByTimeAsync(1000);
-    expect(count).toBe(2);
-
-    await vi.advanceTimersByTimeAsync(1000);
-    expect(count).toBe(3);
-
-    stop();
-  });
-
-  it("stop() cancels the next scheduled poll", async () => {
-    let count = 0;
-    const action = defineAction<undefined, number>({
-      name: "test.poll.stop",
-      run: async () => ++count,
-    });
-
-    vi.useFakeTimers();
-    const stop = pollAction(action, undefined, { interval: 100 });
-    await Promise.resolve();
-    expect(count).toBe(1);
-
-    stop();
-    await vi.advanceTimersByTimeAsync(500);
-    expect(count).toBe(1);
-  });
-
-  it("stop() is idempotent", () => {
-    const action = defineAction<undefined, undefined>({
-      name: "test.poll.idempotent",
-      run: async () => undefined,
-    });
-    const stop = pollAction(action, undefined, { interval: 1000 });
-    expect(() => {
-      stop();
-      stop();
-      stop();
-    }).not.toThrow();
-  });
-});
-
-describe("pollAction — pauseWhenHidden", () => {
-  it("pauses on visibilitychange to hidden, resumes on visible with immediate dispatch", async () => {
-    let count = 0;
-    const action = defineAction<undefined, number>({
-      name: "test.poll.hidden",
-      run: async () => ++count,
-    });
-
-    vi.useFakeTimers();
-    const stop = pollAction(action, undefined, { interval: 1000, pauseWhenHidden: true });
-    await Promise.resolve();
-    expect(count).toBe(1);
-
-    Object.defineProperty(document, "hidden", { value: true, configurable: true });
-    document.dispatchEvent(new Event("visibilitychange"));
-    await vi.advanceTimersByTimeAsync(5000);
-    expect(count).toBe(1);
-
-    Object.defineProperty(document, "hidden", { value: false, configurable: true });
-    document.dispatchEvent(new Event("visibilitychange"));
-    await Promise.resolve();
-    await Promise.resolve();
-    expect(count).toBe(2);
-
-    stop();
-  });
-
-  it("doesn't fire the first poll if started while hidden", async () => {
-    let count = 0;
-    const action = defineAction<undefined, number>({
-      name: "test.poll.start_hidden",
-      run: async () => ++count,
-    });
-
-    Object.defineProperty(document, "hidden", { value: true, configurable: true });
-    vi.useFakeTimers();
-    const stop = pollAction(action, undefined, { interval: 1000, pauseWhenHidden: true });
-    await vi.advanceTimersByTimeAsync(5000);
-    expect(count).toBe(0);
-
-    Object.defineProperty(document, "hidden", { value: false, configurable: true });
-    document.dispatchEvent(new Event("visibilitychange"));
-    await Promise.resolve();
-    expect(count).toBe(1);
-
-    stop();
-  });
-
-  it("pauseWhenHidden: false keeps polling while hidden", async () => {
-    let count = 0;
-    const action = defineAction<undefined, number>({
-      name: "test.poll.always",
-      run: async () => ++count,
-    });
-
-    vi.useFakeTimers();
-    const stop = pollAction(action, undefined, { interval: 100, pauseWhenHidden: false });
-    await Promise.resolve();
-
-    Object.defineProperty(document, "hidden", { value: true, configurable: true });
-    document.dispatchEvent(new Event("visibilitychange"));
-    await vi.advanceTimersByTimeAsync(300);
-    expect(count).toBeGreaterThan(1);
-
-    stop();
-  });
-});
-
-describe("pollAction — refreshOnFocus", () => {
-  it("dispatches immediately on window focus", async () => {
-    let count = 0;
-    const action = defineAction<undefined, number>({
-      name: "test.poll.focus",
-      run: async () => ++count,
-    });
-
-    vi.useFakeTimers();
-    const stop = pollAction(action, undefined, { interval: 10_000, refreshOnFocus: true });
-
-    await vi.runAllTicks();
-    await vi.advanceTimersByTimeAsync(0);
-    expect(count).toBe(1);
-
-    window.dispatchEvent(new Event("focus"));
-
-    await vi.runAllTicks();
-    await vi.advanceTimersByTimeAsync(0);
-    expect(count).toBe(2);
-
-    stop();
-  });
-
-  it("refreshOnFocus: false ignores focus events", async () => {
-    let count = 0;
-    const action = defineAction<undefined, number>({
-      name: "test.poll.no_focus",
-      run: async () => ++count,
-    });
-
-    vi.useFakeTimers();
-    const stop = pollAction(action, undefined, { interval: 10_000, refreshOnFocus: false });
-
-    await vi.runAllTicks();
-    await vi.advanceTimersByTimeAsync(0);
-    expect(count).toBe(1);
-
-    window.dispatchEvent(new Event("focus"));
-
-    await vi.runAllTicks();
-    await vi.advanceTimersByTimeAsync(0);
-    expect(count).toBe(1);
-
-    stop();
-  });
-});
-
-describe("pollAction — backoffOnError", () => {
-  it("delays grow on consecutive failures", async () => {
-    let count = 0;
-    const action = defineAction<undefined, number>({
-      name: "test.poll.backoff",
-      run: async () => {
-        count++;
-        throw new Error("fail");
-      },
-      error: false,
-    });
-
-    vi.useFakeTimers();
-    const stop = pollAction(action, undefined, {
-      interval: 100,
-      backoffOnError: { factor: 2, max: 10_000 },
-    });
-
-    await vi.runAllTicks();
-    await vi.advanceTimersByTimeAsync(0);
-    const after1 = count;
-    expect(after1).toBeGreaterThanOrEqual(1);
-
-    await vi.advanceTimersByTimeAsync(1500);
-    expect(count).toBeGreaterThan(after1);
-    expect(count).toBeLessThan(10);
-
-    stop();
-  });
-
-  it("caps the delay at max", async () => {
-    let count = 0;
-    const action = defineAction<undefined, number>({
-      name: "test.poll.cap",
-      run: async () => {
-        count++;
-        throw new Error("fail");
-      },
-      error: false,
-    });
-
-    vi.useFakeTimers();
-    const stop = pollAction(action, undefined, {
-      interval: 100,
-      backoffOnError: { factor: 10, max: 500 },
-    });
-
-    await vi.runAllTicks();
-    await vi.advanceTimersByTimeAsync(0);
-    expect(count).toBeGreaterThanOrEqual(1);
-
-    await vi.advanceTimersByTimeAsync(2500);
-    expect(count).toBeGreaterThan(2);
-    expect(count).toBeLessThan(8);
-
-    stop();
-  });
-
-  it("resets to base interval after a successful poll", async () => {
-    let fail = true;
-    let count = 0;
-    const action = defineAction<undefined, number>({
-      name: "test.poll.reset",
-      run: async () => {
-        count++;
-        if (fail) {
-          throw new Error("fail");
-        }
-        return count;
-      },
-      error: false,
-    });
-
-    const stop = pollAction(action, undefined, {
-      interval: 20,
-      backoffOnError: { factor: 4, max: 10_000 },
-    });
-
-    await new Promise((r) => setTimeout(r, 200));
-    const failedCount = count;
-    expect(failedCount).toBeGreaterThanOrEqual(1);
-
-    fail = false;
-    await new Promise((r) => setTimeout(r, 400));
-    const finalCount = count;
-    expect(finalCount).toBeGreaterThan(failedCount);
-
-    stop();
-  });
-});
-
-describe("pollAction — onSuccess callback", () => {
-  it("invokes onSuccess with the result on each successful dispatch", async () => {
-    let count = 0;
-    const action = defineAction<undefined, number>({
-      name: "test.poll.onSuccess",
-      run: async () => ++count,
-    });
-    const onSuccess = vi.fn<(n: number) => void>();
-
-    const stop = pollAction(action, undefined, {
-      interval: 20,
-      onSuccess,
-      pauseWhenHidden: false,
-    });
-
-    await new Promise((r) => setTimeout(r, 100));
-    expect(onSuccess.mock.calls.length).toBeGreaterThan(1);
-    expect(onSuccess.mock.calls[0]?.[0]).toBe(1);
-
-    stop();
-  });
-
-  it("does not invoke onSuccess on failed dispatch", async () => {
-    let count = 0;
-    const action = defineAction<undefined, number>({
-      name: "test.poll.onSuccess_fail",
-      run: async () => {
-        count++;
-        throw new Error("fail");
-      },
-      error: false,
-    });
-    const onSuccess = vi.fn<(n: number) => void>();
-
-    const stop = pollAction(action, undefined, {
-      interval: 20,
-      onSuccess,
-      pauseWhenHidden: false,
-    });
-
-    await new Promise((r) => setTimeout(r, 100));
-    expect(count).toBeGreaterThan(0);
-    expect(onSuccess).not.toHaveBeenCalled();
-
-    stop();
-  });
-
-  it("catches errors thrown by onSuccess and continues polling", async () => {
-    let count = 0;
-    const action = defineAction<undefined, number>({
-      name: "test.poll.onSuccess_throws",
-      run: async () => ++count,
-    });
-
-    const consoleError = vi.spyOn(console, "error").mockImplementation(() => {});
-    const onSuccess = vi.fn<(n: number) => void>(() => {
-      throw new Error("kaboom");
-    });
-
-    const stop = pollAction(action, undefined, {
-      interval: 20,
-      onSuccess,
-      pauseWhenHidden: false,
-    });
-
-    await new Promise((r) => setTimeout(r, 100));
-    expect(count).toBeGreaterThan(1);
-    expect(consoleError).toHaveBeenCalled();
-
-    consoleError.mockRestore();
-    stop();
-  });
-});
-
-describe("pollAction — cleanup integration", () => {
-  it("auto-stops when registered cleanup fires (e.g. beforeunload)", async () => {
-    let count = 0;
-    const action = defineAction<undefined, number>({
-      name: "test.poll.cleanup",
-      run: async () => ++count,
-    });
-
-    vi.useFakeTimers();
-    pollAction(action, undefined, { interval: 100 });
-    await Promise.resolve();
-    expect(count).toBe(1);
-
-    cancelAllForTest();
-
-    await vi.advanceTimersByTimeAsync(500);
-    expect(count).toBe(1);
-  });
-});

package/src/primitive-edge-cases.test.ts

@@ -1,105 +0,0 @@
-// @vitest-environment happy-dom
-import { describe, it, expect, vi, beforeEach } from "vitest";
-vi.mock("./notifier.js", () => ({
-  configure: vi.fn(),
-  notifySuccess: vi.fn(),
-  notifyError: vi.fn(),
-  _resetNotifierForTest: vi.fn(),
-}));
-import { defineAction, _resetForTest as resetDefine } from "./define.js";
-import { _resetForTest as resetRegistry } from "./registry.js";
-import { _resetForTest as resetCleanup } from "./cleanup.js";
-import { ActionError, retryNetwork } from "./error.js";
-import * as notifier from "./notifier.js";
-
-beforeEach(() => {
-  resetDefine();
-  resetRegistry();
-  resetCleanup();
-  vi.clearAllMocks();
-});
-
-describe("dedupe with undefined args", () => {
-  it("dedupe: true collapses dispatches when args is undefined", async () => {
-    let runCalls = 0;
-    const action = defineAction<void, string>({
-      name: "test.dedupe_undefined_args",
-      dedupe: true,
-      run: () => {
-        runCalls++;
-        return new Promise<string>((r) =>
-          setTimeout(() => {
-            r("ok");
-          }, 10),
-        );
-      },
-    });
-    const p1 = action.dispatch(undefined);
-    const p2 = action.dispatch(undefined);
-    expect(runCalls).toBe(1);
-    const [r1, r2] = await Promise.all([p1, p2]);
-    expect(r1).toBe("ok");
-    expect(r2).toBe("ok");
-  });
-});
-
-describe("structuredClone fallback on retry (non-cloneable args)", () => {
-  it("retry button uses shallow copy when structuredClone fails (DOM refs)", async () => {
-    const el = { tagName: "BUTTON", focus: () => {} };
-    let lastArgs: { el: typeof el; label: string } | undefined;
-    const action = defineAction<{ el: typeof el; label: string }, string>({
-      name: "test.retry_dom_args",
-      run: async (args) => {
-        lastArgs = args;
-        throw new ActionError("fail", { status: 0 });
-      },
-      retryable: retryNetwork,
-    });
-    const args = { el, label: "Save" };
-    await action.dispatch(args);
-    args.label = "MUTATED";
-    const retryFn = vi.mocked(notifier.notifyError).mock.calls[0]?.[1]?.onClick as () => void;
-    expect(retryFn).toBeDefined();
-    retryFn();
-    await vi.waitFor(() => {
-      expect(lastArgs).toBeDefined();
-    });
-    expect(lastArgs!.label).toBe("Save");
-    expect(lastArgs!.el).toBe(el);
-  });
-});
-
-describe("cancel after dedupe entry created but before runOnce starts (scope-queued)", () => {
-  it("cancel while scope-queued resolves null without running", async () => {
-    let resolveOccupant: (() => void) | null = null;
-    let victimRan = false;
-    const occupant = defineAction<void, string>({
-      name: "test.scope_occ",
-      scope: "q",
-      run: () =>
-        new Promise<string>((r) => {
-          resolveOccupant = () => r("occ");
-        }),
-    });
-    const victim = defineAction<void, string>({
-      name: "test.scope_victim",
-      scope: "q",
-      dedupe: true,
-      error: false,
-      run: () => {
-        victimRan = true;
-        return Promise.resolve("v");
-      },
-    });
-    const pOcc = occupant.dispatch();
-    await Promise.resolve();
-    const pVictim = victim.dispatch();
-    await Promise.resolve();
-    victim.cancel();
-    resolveOccupant!();
-    await pOcc;
-    const rVictim = await pVictim;
-    expect(rVictim).toBeNull();
-    expect(victimRan).toBe(false);
-  });
-});

package/src/primitive-interactions.test.ts

@@ -1,112 +0,0 @@
-// @vitest-environment happy-dom
-import { describe, it, expect, vi, beforeEach, afterEach } from "vitest";
-vi.mock("./notifier.js", () => ({
-  configure: vi.fn(),
-  notifySuccess: vi.fn(),
-  notifyError: vi.fn(),
-  _resetNotifierForTest: vi.fn(),
-}));
-import { defineAction, _resetForTest as resetDefine } from "./define.js";
-import { _resetForTest as resetRegistry } from "./registry.js";
-import { _resetForTest as resetCleanup } from "./cleanup.js";
-import { debouncedDispatch } from "./debounce.js";
-import { configureTransport, transportAction, _resetTransportForTest } from "./transport.js";
-
-const mockSend = vi.fn();
-
-beforeEach(() => {
-  resetDefine();
-  resetRegistry();
-  resetCleanup();
-  _resetTransportForTest();
-  vi.clearAllMocks();
-  configureTransport(mockSend);
-});
-
-describe("dedupe + cancel interaction", () => {
-  it("two concurrent dispatches with dedupe, then cancel — both resolve null", async () => {
-    let runCalls = 0;
-    const action = defineAction<{ id: string }, string>({
-      name: "test.dedupe_cancel",
-      dedupe: true,
-      run: (_args, signal) => {
-        runCalls++;
-        return new Promise<string>((_resolve, reject) => {
-          signal.addEventListener("abort", () => {
-            reject(new DOMException("aborted", "AbortError"));
-          });
-        });
-      },
-    });
-    const p1 = action.dispatch({ id: "a" });
-    const p2 = action.dispatch({ id: "a" });
-    expect(runCalls).toBe(1);
-    action.cancel();
-    const [r1, r2] = await Promise.all([p1, p2]);
-    expect(r1).toBeNull();
-    expect(r2).toBeNull();
-  });
-});
-
-describe("debouncedDispatch leading + flush interaction", () => {
-  beforeEach(() => {
-    vi.useFakeTimers();
-  });
-  afterEach(() => {
-    vi.useRealTimers();
-  });
-
-  it("flush after leading fire dispatches the trailing args immediately", () => {
-    const runArgs: string[] = [];
-    const action = defineAction<string, void>({
-      name: "test.leading_flush",
-      run: (args) => {
-        runArgs.push(args);
-        return Promise.resolve();
-      },
-    });
-    const dbg = debouncedDispatch(action, { wait: 100, leading: true });
-    dbg("a");
-    expect(runArgs).toEqual(["a"]);
-    dbg("b");
-    dbg.flush();
-    expect(runArgs).toEqual(["a", "b"]);
-  });
-});
-
-describe("transportAction idempotency_key interaction", () => {
-  it("transportAction with idempotencyKey: true sends key in command", async () => {
-    mockSend.mockResolvedValue({ ok: true, status: 200 });
-    const action = transportAction<{ chatID: string }>({
-      name: "test.transport_idem",
-      idempotencyKey: true,
-      command: ({ chatID }) => ({ type: "send", chat_id: chatID }),
-      error: false,
-    });
-    await action.dispatch({ chatID: "c1" });
-    const sentCmd = mockSend.mock.calls[0]![0] as { idempotency_key?: string };
-    expect(sentCmd.idempotency_key).toEqual(expect.any(String));
-  });
-});
-
-describe("per-call callbacks on deduped dispatches", () => {
-  it("both callers' onSuccess fire with the same result", async () => {
-    let resolveRun: ((v: string) => void) | undefined;
-    const action = defineAction<string, string>({
-      name: "test.dedupe_cb",
-      dedupe: true,
-      run: () =>
-        new Promise<string>((r) => {
-          resolveRun = r;
-        }),
-    });
-    const onSuccess1 = vi.fn();
-    const onSuccess2 = vi.fn();
-    const p1 = action.dispatch("k", { onSuccess: onSuccess1 });
-    const p2 = action.dispatch("k", { onSuccess: onSuccess2 });
-    resolveRun!("shared");
-    await Promise.all([p1, p2]);
-    expect(onSuccess1).toHaveBeenCalledWith("shared", "k");
-    expect(onSuccess2).toHaveBeenCalledWith("shared", "k");
-  });
-});