@neovici/cosmoz-form 2.1.1 → 2.2.0

package/dist/async-rule.d.ts

@@ -0,0 +1,83 @@
+/**
+ * Options passed to every async rule function.
+ * @template T - the form/item value type
+ */
+export type AsyncOpts<T> = {
+    /** Emit an intermediate partial patch immediately (e.g. a loading state). */
+    update: (patch: Partial<T>) => void;
+    /**
+     * AbortSignal that fires when the runner cancels this invocation
+     * (takeLatest supersession, debounce discard, or unmount).
+     * Pass to `fetch()`, `delay()`, or any other cancellable operation.
+     */
+    signal: AbortSignal;
+    /**
+     * Item index when running inside `useAsyncRules`.
+     * `undefined` when running inside `useAsyncFormCore`.
+     */
+    index?: number;
+};
+/**
+ * Plain async function that computes a partial state update.
+ *
+ * `values` is a snapshot at invocation time.
+ *
+ * @template T - the form/item value type
+ * @param values - snapshot of current form/item values
+ * @param opts - cancellation signal, intermediate update callback, and item index
+ * @returns a partial patch to merge into state
+ * @example
+ * async function myRule(values, { update, signal }) {
+ *   if (!values.supplierId) return { contactEmail: '' };
+ *   update({ contactEmail: 'loading…' });
+ *   const email = await fetchEmail(signal, values.supplierId);
+ *   return { contactEmail: email };
+ * }
+ */
+export type AsyncRule<T> = (values: T, opts: AsyncOpts<T>) => Promise<Partial<T>>;
+/**
+ * Callback invoked with intermediate partial patches during a rule run.
+ * @param patch - the intermediate partial state to apply immediately
+ */
+export type OnIntermediate<T> = (patch: Partial<T>) => void;
+/**
+ * Shared interface for all async runner strategies.
+ * @template T - the form/item value type
+ */
+export type AsyncRunner<T> = {
+    /**
+     * Run `fn` with `values` as input.
+     *
+     * @param fn - the async rule to execute
+     * @param values - snapshot of current values passed to `fn`
+     * @param onIntermediate - wired to `opts.update` inside the rule
+     * @param opts - optional `index` forwarded to `opts.index` inside the rule
+     * @returns the resolved patch from `fn`, or `null` if cancelled
+     */
+    run: (fn: AsyncRule<T>, values: T, onIntermediate: OnIntermediate<T>, opts?: {
+        index?: number;
+    }) => Promise<Partial<T> | null>;
+    /** Cancel the current in-flight run, resolving it as `null`. */
+    cancel: () => void;
+};
+/**
+ * Tuple describing a single async rule for use with `useAsyncRules`.
+ *
+ * @template T - the form/item value type
+ */
+export type AsyncItemRule<T> = readonly [
+    ruleFn: AsyncRule<T>,
+    depsFn: (current: T, index?: number) => unknown[],
+    runner?: () => AsyncRunner<T>
+];
+/**
+ * Cancellable delay. Rejects with `AbortError` if `signal` fires before `ms` elapses.
+ *
+ * @param signal - AbortSignal to cancel the delay early
+ * @param ms - milliseconds to wait
+ * @returns a Promise that resolves after `ms`, or rejects with `AbortError` if cancelled
+ * @example
+ * await delay(opts.signal, 400);
+ */
+export declare const delay: (signal: AbortSignal, ms: number) => Promise<void>;
+//# sourceMappingURL=async-rule.d.ts.map

package/dist/async-rule.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"async-rule.d.ts","sourceRoot":"","sources":["../src/async-rule.ts"],"names":[],"mappings":"AAAA;;;GAGG;AACH,MAAM,MAAM,SAAS,CAAC,CAAC,IAAI;IAC1B,6EAA6E;IAC7E,MAAM,EAAE,CAAC,KAAK,EAAE,OAAO,CAAC,CAAC,CAAC,KAAK,IAAI,CAAC;IACpC;;;;OAIG;IACH,MAAM,EAAE,WAAW,CAAC;IACpB;;;OAGG;IACH,KAAK,CAAC,EAAE,MAAM,CAAC;CACf,CAAC;AAEF;;;;;;;;;;;;;;;;GAgBG;AACH,MAAM,MAAM,SAAS,CAAC,CAAC,IAAI,CAC1B,MAAM,EAAE,CAAC,EACT,IAAI,EAAE,SAAS,CAAC,CAAC,CAAC,KACd,OAAO,CAAC,OAAO,CAAC,CAAC,CAAC,CAAC,CAAC;AAEzB;;;GAGG;AACH,MAAM,MAAM,cAAc,CAAC,CAAC,IAAI,CAAC,KAAK,EAAE,OAAO,CAAC,CAAC,CAAC,KAAK,IAAI,CAAC;AAE5D;;;GAGG;AACH,MAAM,MAAM,WAAW,CAAC,CAAC,IAAI;IAC5B;;;;;;;;OAQG;IACH,GAAG,EAAE,CACJ,EAAE,EAAE,SAAS,CAAC,CAAC,CAAC,EAChB,MAAM,EAAE,CAAC,EACT,cAAc,EAAE,cAAc,CAAC,CAAC,CAAC,EACjC,IAAI,CAAC,EAAE;QAAE,KAAK,CAAC,EAAE,MAAM,CAAA;KAAE,KACrB,OAAO,CAAC,OAAO,CAAC,CAAC,CAAC,GAAG,IAAI,CAAC,CAAC;IAChC,gEAAgE;IAChE,MAAM,EAAE,MAAM,IAAI,CAAC;CACnB,CAAC;AAEF;;;;GAIG;AACH,MAAM,MAAM,aAAa,CAAC,CAAC,IAAI,SAAS;IACvC,MAAM,EAAE,SAAS,CAAC,CAAC,CAAC;IACpB,MAAM,EAAE,CAAC,OAAO,EAAE,CAAC,EAAE,KAAK,CAAC,EAAE,MAAM,KAAK,OAAO,EAAE;IACjD,MAAM,CAAC,EAAE,MAAM,WAAW,CAAC,CAAC,CAAC;CAC7B,CAAC;AAEF;;;;;;;;GAQG;AACH,eAAO,MAAM,KAAK,GAAI,QAAQ,WAAW,EAAE,IAAI,MAAM,KAAG,OAAO,CAAC,IAAI,CAejE,CAAC"}

package/dist/async-rule.js

@@ -0,0 +1,20 @@
+/**
+ * Cancellable delay. Rejects with `AbortError` if `signal` fires before `ms` elapses.
+ *
+ * @param signal - AbortSignal to cancel the delay early
+ * @param ms - milliseconds to wait
+ * @returns a Promise that resolves after `ms`, or rejects with `AbortError` if cancelled
+ * @example
+ * await delay(opts.signal, 400);
+ */
+export const delay = (signal, ms) => new Promise((resolve, reject) => {
+    if (signal.aborted) {
+        reject(new DOMException('Aborted', 'AbortError'));
+        return;
+    }
+    const t = setTimeout(resolve, ms);
+    signal.addEventListener('abort', () => {
+        clearTimeout(t);
+        reject(new DOMException('Aborted', 'AbortError'));
+    }, { once: true });
+});

package/dist/index.d.ts

@@ -1,16 +1,24 @@
+export * from './form-dialog';
 export * from './helpers';
 export * from './inputs';
 export * from './render';
-export * from './validation';
+export * from './touch';
 export * from './use-form';
-export * from './use-validated-form';
-export * from './use-validated-form$';
 export * from './use-items';
-export * from './touch';
 export * from './use-items-filter';
-export * from './form-dialog';
+export * from './use-validated-form';
+export * from './use-validated-form$';
+export * from './validation';
 export type * from './types';
 export { useFormCore, type FormValues } from './use-form-core';
 export { computeRules, useValidatedFormCore } from './use-validated-form-core';
 export * from './add';
+export { delay } from './async-rule';
+export type { AsyncItemRule, AsyncOpts, AsyncRule, AsyncRunner, OnIntermediate, } from './async-rule';
+export { makeDebounceRunner } from './make-debounce-runner';
+export type { DebounceRunner } from './make-debounce-runner';
+export { makeTakeLatestRunner } from './make-take-latest-runner';
+export type { TakeLatestRunner } from './make-take-latest-runner';
+export { useAsyncFormCore } from './use-async-form-core';
+export { useAsyncRules } from './use-items/use-async-rules';
 //# sourceMappingURL=index.d.ts.map

package/dist/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,cAAc,WAAW,CAAC;AAC1B,cAAc,UAAU,CAAC;AACzB,cAAc,UAAU,CAAC;AACzB,cAAc,cAAc,CAAC;AAC7B,cAAc,YAAY,CAAC;AAC3B,cAAc,sBAAsB,CAAC;AACrC,cAAc,uBAAuB,CAAC;AACtC,cAAc,aAAa,CAAC;AAC5B,cAAc,SAAS,CAAC;AACxB,cAAc,oBAAoB,CAAC;AACnC,cAAc,eAAe,CAAC;AAE9B,mBAAmB,SAAS,CAAC;AAG7B,OAAO,EAAE,WAAW,EAAE,KAAK,UAAU,EAAE,MAAM,iBAAiB,CAAC;AAC/D,OAAO,EAAE,YAAY,EAAE,oBAAoB,EAAE,MAAM,2BAA2B,CAAC;AAG/E,cAAc,OAAO,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../src/index.ts"],"names":[],"mappings":"AAAA,cAAc,eAAe,CAAC;AAC9B,cAAc,WAAW,CAAC;AAC1B,cAAc,UAAU,CAAC;AACzB,cAAc,UAAU,CAAC;AACzB,cAAc,SAAS,CAAC;AACxB,cAAc,YAAY,CAAC;AAC3B,cAAc,aAAa,CAAC;AAC5B,cAAc,oBAAoB,CAAC;AACnC,cAAc,sBAAsB,CAAC;AACrC,cAAc,uBAAuB,CAAC;AACtC,cAAc,cAAc,CAAC;AAE7B,mBAAmB,SAAS,CAAC;AAG7B,OAAO,EAAE,WAAW,EAAE,KAAK,UAAU,EAAE,MAAM,iBAAiB,CAAC;AAC/D,OAAO,EAAE,YAAY,EAAE,oBAAoB,EAAE,MAAM,2BAA2B,CAAC;AAG/E,cAAc,OAAO,CAAC;AAGtB,OAAO,EAAE,KAAK,EAAE,MAAM,cAAc,CAAC;AACrC,YAAY,EACX,aAAa,EACb,SAAS,EACT,SAAS,EACT,WAAW,EACX,cAAc,GACd,MAAM,cAAc,CAAC;AAQtB,OAAO,EAAE,kBAAkB,EAAE,MAAM,wBAAwB,CAAC;AAC5D,YAAY,EAAE,cAAc,EAAE,MAAM,wBAAwB,CAAC;AAC7D,OAAO,EAAE,oBAAoB,EAAE,MAAM,2BAA2B,CAAC;AACjE,YAAY,EAAE,gBAAgB,EAAE,MAAM,2BAA2B,CAAC;AAClE,OAAO,EAAE,gBAAgB,EAAE,MAAM,uBAAuB,CAAC;AACzD,OAAO,EAAE,aAAa,EAAE,MAAM,6BAA6B,CAAC"}

package/dist/index.js

@@ -1,16 +1,29 @@
+export * from './form-dialog';
 export * from './helpers';
 export * from './inputs';
 export * from './render';
-export * from './validation';
+export * from './touch';
 export * from './use-form';
-export * from './use-validated-form';
-export * from './use-validated-form$';
 export * from './use-items';
-export * from './touch';
 export * from './use-items-filter';
-export * from './form-dialog';
+export * from './use-validated-form';
+export * from './use-validated-form$';
+export * from './validation';
 // Core hooks
 export { useFormCore } from './use-form-core';
 export { computeRules, useValidatedFormCore } from './use-validated-form-core';
 // Add form utilities
 export * from './add';
+// Async rules
+export { delay } from './async-rule';
+// Async runners — choose the concurrency strategy that fits your use case:
+//   makeTakeLatestRunner  cancels the previous run when a new one arrives (switchMap)
+//   makeDebounceRunner    waits for silence before running; resets timer on each call (debounce + switchMap)
+//
+// Future ideas:
+//   makeThrottleRunner    fires immediately, queues one trailing call (runs when in-flight finishes)
+//   makeExhaustRunner     ignores new calls while one is in-flight (exhaustMap)
+export { makeDebounceRunner } from './make-debounce-runner';
+export { makeTakeLatestRunner } from './make-take-latest-runner';
+export { useAsyncFormCore } from './use-async-form-core';
+export { useAsyncRules } from './use-items/use-async-rules';

package/dist/make-debounce-runner.d.ts

@@ -0,0 +1,4 @@
+import type { AsyncRunner } from './async-rule';
+export type DebounceRunner<T> = AsyncRunner<T>;
+export declare const makeDebounceRunner: <T>(ms: number) => DebounceRunner<T>;
+//# sourceMappingURL=make-debounce-runner.d.ts.map

package/dist/make-debounce-runner.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"make-debounce-runner.d.ts","sourceRoot":"","sources":["../src/make-debounce-runner.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAa,WAAW,EAAE,MAAM,cAAc,CAAC;AAE3D,MAAM,MAAM,cAAc,CAAC,CAAC,IAAI,WAAW,CAAC,CAAC,CAAC,CAAC;AAE/C,eAAO,MAAM,kBAAkB,GAAI,CAAC,EAAE,IAAI,MAAM,KAAG,cAAc,CAAC,CAAC,CA4DlE,CAAC"}

package/dist/make-debounce-runner.js

@@ -0,0 +1,50 @@
+export const makeDebounceRunner = (ms) => {
+    let timer = null;
+    let ac = null;
+    let pending = null;
+    return {
+        run: (fn, values, onIntermediate, opts) => new Promise((resolve, reject) => {
+            if (pending !== null) {
+                // Debounced-away call resolves null (same as cancelled in takeLatest)
+                pending.resolve(null);
+                clearTimeout(timer);
+            }
+            pending = { fn, values, index: opts?.index, resolve, reject };
+            timer = setTimeout(async () => {
+                const { fn: f, values: v, index, resolve: res, reject: rej, } = pending;
+                pending = null;
+                timer = null;
+                ac = new AbortController();
+                const asyncOpts = {
+                    update: onIntermediate,
+                    signal: ac.signal,
+                    index,
+                };
+                try {
+                    res(await f(v, asyncOpts));
+                }
+                catch (e) {
+                    if (e instanceof DOMException && e.name === 'AbortError')
+                        res(null);
+                    else
+                        rej(e);
+                }
+                finally {
+                    ac = null;
+                }
+            }, ms);
+        }),
+        cancel: () => {
+            if (timer !== null) {
+                clearTimeout(timer);
+                timer = null;
+            }
+            if (pending !== null) {
+                pending.resolve(null);
+                pending = null;
+            }
+            ac?.abort();
+            ac = null;
+        },
+    };
+};

package/dist/make-take-latest-runner.d.ts

@@ -0,0 +1,4 @@
+import type { AsyncRunner } from './async-rule';
+export type TakeLatestRunner<T> = AsyncRunner<T>;
+export declare const makeTakeLatestRunner: <T>() => TakeLatestRunner<T>;
+//# sourceMappingURL=make-take-latest-runner.d.ts.map

package/dist/make-take-latest-runner.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"make-take-latest-runner.d.ts","sourceRoot":"","sources":["../src/make-take-latest-runner.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,WAAW,EAAE,MAAM,cAAc,CAAC;AAEhD,MAAM,MAAM,gBAAgB,CAAC,CAAC,IAAI,WAAW,CAAC,CAAC,CAAC,CAAC;AAEjD,eAAO,MAAM,oBAAoB,GAAI,CAAC,OAAK,gBAAgB,CAAC,CAAC,CAyB5D,CAAC"}

package/dist/make-take-latest-runner.js

@@ -0,0 +1,27 @@
+export const makeTakeLatestRunner = () => {
+    let ac = null;
+    return {
+        run: async (fn, values, onIntermediate, opts) => {
+            ac?.abort(); // cancel previous (takeLatest / switchMap)
+            ac = new AbortController();
+            const asyncOpts = {
+                update: onIntermediate,
+                signal: ac.signal,
+                index: opts?.index,
+            };
+            try {
+                return await fn(values, asyncOpts);
+            }
+            catch (e) {
+                // AbortError from delay() or fetch() when cancelled — not a real error
+                if (e instanceof DOMException && e.name === 'AbortError')
+                    return null;
+                throw e;
+            }
+        },
+        cancel: () => {
+            ac?.abort();
+            ac = null;
+        },
+    };
+};

package/dist/test/make-debounce-runner.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=make-debounce-runner.test.d.ts.map

package/dist/test/make-debounce-runner.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"make-debounce-runner.test.d.ts","sourceRoot":"","sources":["../../src/test/make-debounce-runner.test.ts"],"names":[],"mappings":""}

package/dist/test/make-debounce-runner.test.js

@@ -0,0 +1,123 @@
+import { assert } from '@open-wc/testing';
+import { spy, useFakeTimers } from 'sinon';
+import { delay } from '../async-rule';
+import { makeDebounceRunner, } from '../make-debounce-runner';
+const noop = () => {
+    /* intentionally empty */
+};
+const returns = (value) => async () => value;
+// ── Suite ─────────────────────────────────────────────────────────────────────
+suite('makeDebounceRunner', () => {
+    let clock;
+    let runner;
+    setup(() => {
+        clock = useFakeTimers();
+        runner = makeDebounceRunner(50);
+    });
+    teardown(() => {
+        runner.cancel();
+        clock.restore();
+    });
+    test('run() resolves with fn return value after debounce delay', async () => {
+        const promise = runner.run(returns({ name: 'Alice' }), {}, noop);
+        await clock.tickAsync(50);
+        const result = await promise;
+        assert.deepEqual(result, { name: 'Alice' });
+    });
+    test('second run() within window resolves first as null and resets timer', async () => {
+        const first = runner.run(returns({ from: 'first' }), {}, noop);
+        await clock.tickAsync(30);
+        const second = runner.run(returns({ from: 'second' }), {}, noop);
+        await clock.tickAsync(50);
+        const [firstResult, secondResult] = await Promise.all([first, second]);
+        assert.isNull(firstResult, 'debounced-away run() resolves null');
+        assert.deepEqual(secondResult, { from: 'second' });
+    });
+    test('only the last run() in a burst executes; earlier ones resolve null', async () => {
+        const bodySpy = spy();
+        const tracked = (tag) => async () => {
+            bodySpy(tag);
+            return { tag };
+        };
+        const p1 = runner.run(tracked('a'), {}, noop);
+        const p2 = runner.run(tracked('b'), {}, noop);
+        const p3 = runner.run(tracked('c'), {}, noop);
+        await clock.tickAsync(50);
+        const [r1, r2, r3] = await Promise.all([p1, p2, p3]);
+        assert.isNull(r1);
+        assert.isNull(r2);
+        assert.deepEqual(r3, { tag: 'c' });
+        assert.equal(bodySpy.callCount, 1);
+        assert.equal(bodySpy.firstCall.args[0], 'c');
+    });
+    test('fn body runs once when calls stop arriving', async () => {
+        const bodySpy = spy();
+        const counted = async (_, { signal }) => {
+            bodySpy();
+            await delay(signal, 10);
+            return { counted: true };
+        };
+        const p = runner.run(counted, {}, noop);
+        await clock.tickAsync(60);
+        const result = await p;
+        assert.deepEqual(result, { counted: true });
+        assert.equal(bodySpy.callCount, 1);
+    });
+    test('cancel() before timer fires resolves pending run() as null', async () => {
+        const promise = runner.run(returns({ x: 1 }), {}, noop);
+        runner.cancel();
+        await clock.tickAsync(50);
+        const result = await promise;
+        assert.isNull(result);
+    });
+    test('cancel() while fn is in-flight resolves run() as null', async () => {
+        const slow = async (_, { signal }) => {
+            await delay(signal, 5000);
+            return { slow: true };
+        };
+        const promise = runner.run(slow, {}, noop);
+        await clock.tickAsync(50); // let debounce fire so fn starts
+        runner.cancel();
+        await clock.tickAsync(5000);
+        const result = await promise;
+        assert.isNull(result);
+    });
+    test('non-abort errors from the fn are re-thrown', async () => {
+        const boom = async () => {
+            throw new Error('network error');
+        };
+        const promise = runner.run(boom, {}, noop);
+        await clock.tickAsync(50);
+        try {
+            await promise;
+            assert.fail('should have thrown');
+        }
+        catch (e) {
+            assert.instanceOf(e, Error);
+            assert.equal(e.message, 'network error');
+        }
+    });
+    test('opts.update calls onIntermediate during fn execution', async () => {
+        const patches = [];
+        const withUpdate = async (_, { update }) => {
+            update({ status: 'loading' });
+            return { status: 'done' };
+        };
+        const promise = runner.run(withUpdate, {}, (p) => patches.push(p));
+        await clock.tickAsync(50);
+        const result = await promise;
+        assert.deepEqual(patches, [{ status: 'loading' }]);
+        assert.deepEqual(result, { status: 'done' });
+    });
+    test('values snapshot is passed to fn', async () => {
+        let receivedValues;
+        const captureValues = async (values) => {
+            receivedValues = values;
+            return {};
+        };
+        const promise = runner.run(captureValues, { city: 'Oslo' }, noop);
+        await clock.tickAsync(50);
+        await promise;
+        assert.deepEqual(receivedValues, { city: 'Oslo' });
+    });
+});

package/dist/test/make-take-latest-runner.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=make-take-latest-runner.test.d.ts.map

package/dist/test/make-take-latest-runner.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"make-take-latest-runner.test.d.ts","sourceRoot":"","sources":["../../src/test/make-take-latest-runner.test.ts"],"names":[],"mappings":""}

package/dist/test/make-take-latest-runner.test.js

@@ -0,0 +1,110 @@
+import { assert } from '@open-wc/testing';
+import { spy } from 'sinon';
+import { delay } from '../async-rule';
+import { makeTakeLatestRunner, } from '../make-take-latest-runner';
+const noop = () => {
+    /* intentionally empty */
+};
+const returns = (value) => async () => value;
+// ── Suite ─────────────────────────────────────────────────────────────────────
+suite('makeTakeLatestRunner', () => {
+    let runner;
+    setup(() => {
+        runner = makeTakeLatestRunner();
+    });
+    teardown(() => {
+        runner.cancel();
+    });
+    test('run() resolves with fn return value', async () => {
+        const result = await runner.run(returns({ name: 'Alice' }), {}, noop);
+        assert.deepEqual(result, { name: 'Alice' });
+    });
+    test('second run() aborts the first before starting', async () => {
+        const firstCompleted = spy();
+        const slow = async (_, { signal }) => {
+            await delay(signal, 200);
+            firstCompleted();
+            return { from: 'first' };
+        };
+        const fast = async (_, { signal }) => {
+            await delay(signal, 10);
+            return { from: 'second' };
+        };
+        const first = runner.run(slow, {}, noop);
+        const second = runner.run(fast, {}, noop);
+        const [firstResult, secondResult] = await Promise.all([first, second]);
+        assert.isNull(firstResult, 'first run is cancelled');
+        assert.deepEqual(secondResult, { from: 'second' });
+        assert.isFalse(firstCompleted.called, 'first body should not complete');
+    });
+    test('cancel() aborts current run, resolves null', async () => {
+        const slow = async (_, { signal }) => {
+            await delay(signal, 5000);
+            return {};
+        };
+        const promise = runner.run(slow, {}, noop);
+        runner.cancel();
+        const result = await promise;
+        assert.isNull(result);
+    });
+    test('non-abort errors are re-thrown (not swallowed)', async () => {
+        const boom = async () => {
+            throw new Error('network error');
+        };
+        try {
+            await runner.run(boom, {}, noop);
+            assert.fail('should have thrown');
+        }
+        catch (e) {
+            assert.instanceOf(e, Error);
+            assert.equal(e.message, 'network error');
+        }
+    });
+    test('AbortErrors are swallowed and resolve null', async () => {
+        const aborting = async (_, { signal }) => {
+            await delay(signal, 5000);
+            return {};
+        };
+        const promise = runner.run(aborting, {}, noop);
+        runner.cancel();
+        const result = await promise;
+        assert.isNull(result);
+    });
+    test('opts.signal is the live AbortController signal', async () => {
+        let receivedSignal;
+        const captureSignal = async (_, { signal }) => {
+            receivedSignal = signal;
+            return {};
+        };
+        await runner.run(captureSignal, {}, noop);
+        assert.instanceOf(receivedSignal, AbortSignal);
+    });
+    test('opts.update calls onIntermediate immediately', async () => {
+        const patches = [];
+        const withUpdate = async (_, { update }) => {
+            update({ status: 'loading' });
+            return { status: 'done' };
+        };
+        const result = await runner.run(withUpdate, {}, (p) => patches.push(p));
+        assert.deepEqual(patches, [{ status: 'loading' }]);
+        assert.deepEqual(result, { status: 'done' });
+    });
+    test('opts.index is forwarded from run opts', async () => {
+        let receivedIndex;
+        const captureIndex = async (_, opts) => {
+            receivedIndex = opts.index;
+            return {};
+        };
+        await runner.run(captureIndex, {}, noop, { index: 3 });
+        assert.equal(receivedIndex, 3);
+    });
+    test('values snapshot is passed to fn', async () => {
+        let receivedValues;
+        const captureValues = async (values) => {
+            receivedValues = values;
+            return {};
+        };
+        await runner.run(captureValues, { name: 'Bob' }, noop);
+        assert.deepEqual(receivedValues, { name: 'Bob' });
+    });
+});

package/dist/test/use-async-form-core.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=use-async-form-core.test.d.ts.map

package/dist/test/use-async-form-core.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"use-async-form-core.test.d.ts","sourceRoot":"","sources":["../../src/test/use-async-form-core.test.ts"],"names":[],"mappings":""}