@happyvertical/smrt-ui 0.51.39 → 0.53.0

package/dist/components/forms/form-retry/controller.js

@@ -0,0 +1,404 @@
+/**
+ * `createFormRetry()`: the browser half of `runOnce()` for a SvelteKit
+ * enhanced form (#3291).
+ *
+ * One controller per form. It owns the submission key (`submission-key.ts`),
+ * the conditional reset (`form-draft.ts`) and, when asked, the
+ * restore-after-reload draft (`submitted-draft.ts`), and exposes them as:
+ *
+ * - `enhance(submit?)` — a submit function in SvelteKit's `SubmitFunction`
+ *   shape, for `<form method="POST" use:enhance={retry.enhance()}>`;
+ * - `attach` / `action` — an attachment (`{@attach retry.attach}`) or action
+ *   (`use:retry.action`) that keeps a hidden key field in the form and puts a
+ *   restored draft back into its controls;
+ * - `subscribe` — the Svelte store contract, so `$retry.status` and
+ *   `$retry.token` are reactive in a component without this module importing
+ *   Svelte.
+ *
+ * It is framework-free TypeScript: no `@sveltejs/kit` and no `svelte` import.
+ *
+ * ## What happens to one submit
+ *
+ * 1. A file the restored draft says was chosen, but is not chosen now, refuses
+ *    the submit (`status: 'files-required'`) — a native file input cannot be
+ *    restored, and sending without it would silently be different content.
+ * 2. A submit while another is unresolved is refused (`status: 'busy'`) and
+ *    nothing is sent; the form keeps what the person typed.
+ * 3. Otherwise the key is written into the outgoing `FormData` (so the body is
+ *    right even if a hidden field is stale or missing) and what the person can
+ *    see is snapshotted — before the page's own submit function runs, because
+ *    kit built the body before calling it. With restore enabled, the submitted
+ *    values are then kept beside the key.
+ * 4. The result settles the slot:
+ *    - `error` (transport failure, lost response, thrown server error): the key,
+ *      the form and the draft are all kept, and `update()` is NOT called —
+ *      `enhance`'s default would apply the error and can unmount the form. The
+ *      unchanged re-submit is the same claim.
+ *    - `failure` (validation): applied without rotating; the draft is dropped
+ *      because nothing was recorded.
+ *    - `success`: the draft is dropped; the form is reset — and the key
+ *      rotated — only if the fields are unchanged since the submit. A person who
+ *      typed the next entry while the first was in flight keeps it, under the
+ *      same key, and sending it is a different claim because its content
+ *      differs. With the page's own result callback, the key rotates only if
+ *      the form is actually reset while that callback runs.
+ *    - `redirect`: a confirmed write only with `redirectConfirmsWrite: true`.
+ *    - A late result for a submit already settled is ignored entirely.
+ *
+ * An aborted request (the page called `controller.abort()`, before or during
+ * the request — including from its own submit function) produces no result
+ * from `enhance`; it settles like a transport error so the form is not stuck
+ * refusing submits.
+ *
+ * @module
+ */
+import { draftOf, formWasCleared } from './form-draft.js';
+import { beginSubmit, isSubmissionKeyPersistent, readSubmissionKey, rotateSubmissionKey, settleSubmit, storageBase, } from './submission-key.js';
+import { applyDraftToForm, clearSubmittedDraft, DEFAULT_DRAFT_MAX_AGE_MS, describeFormData, isChosenFile, readSubmittedDraft, saveSubmittedDraft, } from './submitted-draft.js';
+const DEFAULT_FIELD = 'submissionKey';
+/** Create the retry controller for one form. */
+export function createFormRetry(options) {
+    const fieldName = options.fieldName ?? DEFAULT_FIELD;
+    const now = options.now ?? (() => new Date());
+    const location = {
+        form: options.form,
+        scope: options.scope,
+        storage: options.storage,
+        storageKey: options.storageKey,
+        mint: options.mint,
+    };
+    const restoreOptions = options.restore;
+    const draftName = restoreOptions?.storageKey ??
+        `${storageBase(options.form, options.scope)}:draft`;
+    const exclude = new Set([
+        fieldName,
+        ...(restoreOptions?.exclude ?? []),
+    ]);
+    // Left out of the edit comparison: the key field (it rotates by design)
+    // and whatever the page says changes on its own.
+    const notEdits = new Set([
+        fieldName,
+        ...(options.ignoreFields ?? []),
+    ]);
+    let slot = {
+        token: readSubmissionKey(location),
+        inFlight: null,
+    };
+    let restored = null;
+    if (restoreOptions) {
+        const maxAge = restoreOptions.maxAgeMs ?? DEFAULT_DRAFT_MAX_AGE_MS;
+        const fresh = (savedAt) => {
+            const current = now();
+            if (restoreOptions.fresh)
+                return restoreOptions.fresh(savedAt, current);
+            const age = current.getTime() - savedAt.getTime();
+            return age >= 0 && age <= maxAge;
+        };
+        restored = readSubmittedDraft(options.storage, draftName, {
+            token: slot.token,
+            owner: restoreOptions.owner,
+            fresh,
+        });
+        if (restored && restoreOptions.values && restored.values !== undefined) {
+            try {
+                restoreOptions.values.restore(restored.values);
+            }
+            catch {
+                // The page rejected the stored value (it is untrusted data): restore
+                // nothing rather than half a draft, and never break the page over it.
+                clearSubmittedDraft(options.storage, draftName);
+                restored = null;
+            }
+        }
+    }
+    let appliedRestore = false;
+    let state = {
+        token: slot.token,
+        inFlight: null,
+        status: 'idle',
+        restored: restored !== null,
+        filesToReselect: uniqueFields(restored),
+        persistent: isSubmissionKeyPersistent(location),
+    };
+    const listeners = new Set();
+    function setState(patch) {
+        state = {
+            ...state,
+            ...patch,
+            token: slot.token,
+            inFlight: slot.inFlight,
+            persistent: isSubmissionKeyPersistent(location),
+        };
+        for (const listener of listeners)
+            listener(state);
+    }
+    function writeSlot(next) {
+        slot = next;
+    }
+    function clearDraft() {
+        if (restoreOptions)
+            clearSubmittedDraft(options.storage, draftName);
+    }
+    function missingFiles(formData) {
+        return state.filesToReselect.filter((field) => !formData.getAll(field).some(isChosenFile));
+    }
+    function saveDraft(formData, token, skip) {
+        if (!restoreOptions)
+            return;
+        if (!restoreOptions.owner) {
+            // A draft can never be restored without an owner, so keeping one would
+            // only leave the person's values on shared hardware for nothing.
+            clearDraft();
+            return;
+        }
+        const described = describeFormData(formData, skip);
+        let values;
+        if (restoreOptions.values) {
+            try {
+                values = restoreOptions.values.capture(formData);
+            }
+            catch {
+                values = undefined;
+            }
+        }
+        saveSubmittedDraft(options.storage, draftName, {
+            token,
+            owner: restoreOptions.owner,
+            savedAt: now(),
+            fields: described.fields,
+            files: described.files,
+            values,
+        });
+    }
+    function passwordFields(form) {
+        const names = [];
+        for (const element of Array.from(form.elements)) {
+            if (element instanceof HTMLInputElement &&
+                element.type === 'password' &&
+                element.name) {
+                names.push(element.name);
+            }
+        }
+        return names;
+    }
+    function enhance(submit) {
+        return async (input) => {
+            const { formData, formElement, cancel, controller } = input;
+            const missing = missingFiles(formData);
+            if (missing.length > 0) {
+                cancel();
+                setState({ status: 'files-required', filesToReselect: missing });
+                return;
+            }
+            const begun = beginSubmit(slot);
+            if (!begun.start) {
+                cancel();
+                setState({ status: 'busy' });
+                return;
+            }
+            writeSlot(begun.state);
+            const sent = begun.sent;
+            formData.set(fieldName, sent);
+            // What was sent is what the form held when kit built `formData`, which
+            // it did before calling this function. Snapshot it now, before awaiting
+            // the page's submit function: an edit made while that is pending was
+            // never sent, and must read as an edit when the result arrives.
+            const submitted = draftOf(formElement, notEdits);
+            let innerCancelled = false;
+            let innerCallback;
+            if (submit) {
+                try {
+                    const returned = await submit({
+                        ...input,
+                        cancel: () => {
+                            innerCancelled = true;
+                            cancel();
+                        },
+                    });
+                    if (typeof returned === 'function')
+                        innerCallback = returned;
+                }
+                catch (error) {
+                    // The page's own submit threw before anything was sent: release the
+                    // slot so the form is not stuck refusing submits.
+                    cancel();
+                    writeSlot({ ...slot, inFlight: null });
+                    setState({ status: 'idle' });
+                    throw error;
+                }
+            }
+            if (innerCancelled) {
+                writeSlot({ ...slot, inFlight: null });
+                setState({ status: 'idle' });
+                return;
+            }
+            if (restoreOptions) {
+                saveDraft(formData, sent, new Set([...exclude, ...passwordFields(formElement)]));
+            }
+            setState({ status: 'submitting', filesToReselect: [] });
+            let settled = false;
+            const onAbort = () => {
+                if (settled)
+                    return;
+                settled = true;
+                const next = settleSubmit(slot, sent, 'error', {
+                    formCleared: false,
+                    mint: () => rotateSubmissionKey(location),
+                });
+                if (next.disposition === 'ignore')
+                    return;
+                writeSlot(next.state);
+                setState({ status: 'transport-error' });
+            };
+            controller.signal.addEventListener('abort', onAbort, { once: true });
+            // The page's own submit function may already have aborted (without
+            // cancelling): the abort event has fired, and kit will report no result.
+            if (controller.signal.aborted)
+                onAbort();
+            return async (resultInput) => {
+                controller.signal.removeEventListener('abort', onAbort);
+                if (settled)
+                    return;
+                settled = true;
+                const { result } = resultInput;
+                const formCleared = formWasCleared(formElement, submitted, notEdits);
+                // The default handling resets an unchanged form on success, so the key
+                // retires now. A page's own result callback decides the reset itself
+                // (`update({ reset: false })`, or no update at all), and values left on
+                // screen must keep their key: then the key retires only if the form is
+                // actually reset while the callback runs.
+                const retireOnReset = innerCallback !== undefined && result.type === 'success';
+                const next = settleSubmit(slot, sent, result.type, {
+                    formCleared: formCleared && !retireOnReset,
+                    mint: () => rotateSubmissionKey(location),
+                    redirectConfirmsWrite: options.redirectConfirmsWrite,
+                });
+                if (next.disposition === 'ignore')
+                    return;
+                writeSlot(next.state);
+                if (next.disposition === 'transport-error') {
+                    // Keep the key, the form and the draft. Do NOT call update(): on an
+                    // error result it applies the error and can unmount the form.
+                    setState({ status: 'transport-error' });
+                    return;
+                }
+                if (next.disposition === 'rotate-and-apply') {
+                    clearDraft();
+                    setState({
+                        status: result.type === 'redirect' ? 'redirect' : 'success',
+                        restored: false,
+                    });
+                }
+                else if (result.type === 'failure') {
+                    // Nothing was recorded, so there is nothing to retry after a reload.
+                    clearDraft();
+                    setState({ status: 'failure', restored: false });
+                }
+                else {
+                    setState({
+                        status: result.type === 'redirect' ? 'redirect' : 'idle',
+                    });
+                }
+                const update = (opts) => resultInput.update({ ...opts, reset: opts?.reset ?? formCleared });
+                if (!innerCallback) {
+                    await update();
+                    return;
+                }
+                if (!(retireOnReset && formCleared)) {
+                    await innerCallback({ ...resultInput, update });
+                    return;
+                }
+                // Watch for the reset like the capture fields do: capture phase on the
+                // document, so a page listener that stops propagation cannot hide it.
+                const doc = formElement.ownerDocument;
+                const seen = { reset: null };
+                const onReset = (event) => {
+                    if (event.target === formElement)
+                        seen.reset = event;
+                };
+                doc.addEventListener('reset', onReset, true);
+                try {
+                    await innerCallback({ ...resultInput, update });
+                }
+                finally {
+                    doc.removeEventListener('reset', onReset, true);
+                    // A submit started while the callback ran carries the current key:
+                    // rotating under it would hand its resend a different claim. Its own
+                    // result decides retirement instead.
+                    if (seen.reset &&
+                        !seen.reset.defaultPrevented &&
+                        slot.inFlight === null) {
+                        writeSlot({ token: rotateSubmissionKey(location), inFlight: null });
+                        setState({});
+                    }
+                }
+            };
+        };
+    }
+    function syncHiddenField(form) {
+        let field = Array.from(form.elements).find((element) => element instanceof HTMLInputElement && element.name === fieldName);
+        if (!field) {
+            field = form.ownerDocument.createElement('input');
+            field.type = 'hidden';
+            field.name = fieldName;
+            form.prepend(field);
+        }
+        field.value = slot.token;
+        return field;
+    }
+    function attach(form) {
+        syncHiddenField(form);
+        if (restored && !appliedRestore) {
+            appliedRestore = true;
+            applyDraftToForm(form, restored, exclude);
+        }
+        const unsubscribe = subscribe(() => {
+            syncHiddenField(form);
+        });
+        return unsubscribe;
+    }
+    function subscribe(listener) {
+        listeners.add(listener);
+        listener(state);
+        return () => {
+            listeners.delete(listener);
+        };
+    }
+    function discard() {
+        if (slot.inFlight !== null)
+            return false;
+        clearDraft();
+        restored = null;
+        writeSlot({
+            token: rotateSubmissionKey(location),
+            inFlight: null,
+        });
+        setState({ status: 'idle', restored: false, filesToReselect: [] });
+        return true;
+    }
+    return {
+        get token() {
+            return slot.token;
+        },
+        fieldName,
+        get state() {
+            return state;
+        },
+        get restored() {
+            return restored;
+        },
+        subscribe,
+        enhance,
+        attach,
+        action: (form) => {
+            const cleanup = attach(form);
+            return { destroy: cleanup };
+        },
+        discard,
+    };
+}
+function uniqueFields(draft) {
+    if (!draft)
+        return [];
+    return Array.from(new Set(draft.files.map((file) => file.field)));
+}

package/dist/components/forms/form-retry/form-draft.d.ts

@@ -0,0 +1,68 @@
+/**
+ * Whether a form still holds what it submitted, so a successful submit knows
+ * if it may clear the fields (#3291).
+ *
+ * The problem this solves is created by the in-flight refusal in
+ * `submission-key.ts`. A submit over a slow link is unresolved for a while;
+ * the fields stay editable, so the person can type the NEXT entry into them.
+ * They cannot send it yet — that is the point — but when the first submit
+ * finally succeeds, `enhance`'s `update()` resets the form by default and the
+ * typed draft is gone. Nothing downstream can recover it: it never reached the
+ * server, so no claim has ever seen it.
+ *
+ * So the reset becomes conditional. If the fields still hold exactly what was
+ * submitted, clearing them is right — the ordinary case, and what makes the
+ * next entry a fresh form with a fresh key. If they do not, the person has
+ * moved on and their work is kept.
+ *
+ * Every control that posts a value is compared, hidden inputs included: a
+ * `Listbox`, `Combobox` or `MultiSelect` posts its selection through hidden
+ * inputs, and a selection changed while a submit is in flight is an edit the
+ * server has never seen. The ONE exception is the retry helper's own key field
+ * (and any name the caller adds to `ignore`): a confirmed write rotates it, so
+ * comparing it would make every form look edited and nothing would ever
+ * reset. A page-managed hidden field that changes after a submit (a rewritten
+ * nonce) therefore keeps the form — the safe direction — unless it is ignored.
+ *
+ * Files are compared as the browser would post them. A control can contribute
+ * a file no element shows: a capture field on the `formdata`-event fallback
+ * appends its file while the entry list is built and keeps an empty, unnamed
+ * input. So the draft also records every `File` entry of `new FormData(form)`
+ * (which fires `formdata`, as a real submit does) by name, type, size and
+ * modification time; a capture replaced mid-submit then reads as an edit.
+ *
+ * @module
+ */
+/** The values a person can see and change, keyed by position and name. */
+export type FormDraft = ReadonlyMap<string, string>;
+/**
+ * What `form` would post at this moment, as far as an edit can change it:
+ * every value-carrying control except the names in `ignore` (by default the
+ * `submissionKey` key field).
+ */
+export declare function draftOf(form: HTMLFormElement, ignore?: ReadonlySet<string>): FormDraft;
+/**
+ * Has `form` been edited since `submitted` was taken? `true` means the person
+ * has typed something the server has never seen, so a reset would destroy it.
+ */
+export declare function draftChanged(form: HTMLFormElement, submitted: FormDraft, ignore?: ReadonlySet<string>): boolean;
+/**
+ * Did this submit leave the form EMPTY — the one question key retirement turns
+ * on (`settleSubmit()`)? Both of these must be no:
+ *
+ * - the person edited the fields while the submit was unresolved, so a reset
+ *   would destroy work the server has never seen;
+ * - **the submitted form is no longer in the document.** A form remounted
+ *   under a `{#key}` block, or unmounted when its panel closes, leaves a
+ *   detached node that still holds exactly what it submitted, so an
+ *   unchanged-check alone would retire the key — while the VISIBLE
+ *   replacement may hold the same content, one tap from a second record under
+ *   a fresh claim.
+ *
+ * A detached form therefore never counts as cleared. That is the safe
+ * direction: keeping a key can only make a later submit of the same content
+ * collapse onto the row that already exists, while retiring one wrongly is
+ * what records a duplicate.
+ */
+export declare function formWasCleared(form: HTMLFormElement, submitted: FormDraft, ignore?: ReadonlySet<string>): boolean;
+//# sourceMappingURL=form-draft.d.ts.map

package/dist/components/forms/form-retry/form-draft.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"form-draft.d.ts","sourceRoot":"","sources":["../../../../src/components/forms/form-retry/form-draft.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;GAkCG;AAEH,0EAA0E;AAC1E,MAAM,MAAM,SAAS,GAAG,WAAW,CAAC,MAAM,EAAE,MAAM,CAAC,CAAC;AAsDpD;;;;GAIG;AACH,wBAAgB,OAAO,CACrB,IAAI,EAAE,eAAe,EACrB,MAAM,GAAE,WAAW,CAAC,MAAM,CAAmB,GAC5C,SAAS,CAeX;AAgCD;;;GAGG;AACH,wBAAgB,YAAY,CAC1B,IAAI,EAAE,eAAe,EACrB,SAAS,EAAE,SAAS,EACpB,MAAM,GAAE,WAAW,CAAC,MAAM,CAAmB,GAC5C,OAAO,CAOT;AAED;;;;;;;;;;;;;;;;;GAiBG;AACH,wBAAgB,cAAc,CAC5B,IAAI,EAAE,eAAe,EACrB,SAAS,EAAE,SAAS,EACpB,MAAM,GAAE,WAAW,CAAC,MAAM,CAAmB,GAC5C,OAAO,CAGT"}

package/dist/components/forms/form-retry/form-draft.js

@@ -0,0 +1,161 @@
+/**
+ * Whether a form still holds what it submitted, so a successful submit knows
+ * if it may clear the fields (#3291).
+ *
+ * The problem this solves is created by the in-flight refusal in
+ * `submission-key.ts`. A submit over a slow link is unresolved for a while;
+ * the fields stay editable, so the person can type the NEXT entry into them.
+ * They cannot send it yet — that is the point — but when the first submit
+ * finally succeeds, `enhance`'s `update()` resets the form by default and the
+ * typed draft is gone. Nothing downstream can recover it: it never reached the
+ * server, so no claim has ever seen it.
+ *
+ * So the reset becomes conditional. If the fields still hold exactly what was
+ * submitted, clearing them is right — the ordinary case, and what makes the
+ * next entry a fresh form with a fresh key. If they do not, the person has
+ * moved on and their work is kept.
+ *
+ * Every control that posts a value is compared, hidden inputs included: a
+ * `Listbox`, `Combobox` or `MultiSelect` posts its selection through hidden
+ * inputs, and a selection changed while a submit is in flight is an edit the
+ * server has never seen. The ONE exception is the retry helper's own key field
+ * (and any name the caller adds to `ignore`): a confirmed write rotates it, so
+ * comparing it would make every form look edited and nothing would ever
+ * reset. A page-managed hidden field that changes after a submit (a rewritten
+ * nonce) therefore keeps the form — the safe direction — unless it is ignored.
+ *
+ * Files are compared as the browser would post them. A control can contribute
+ * a file no element shows: a capture field on the `formdata`-event fallback
+ * appends its file while the entry list is built and keeps an empty, unnamed
+ * input. So the draft also records every `File` entry of `new FormData(form)`
+ * (which fires `formdata`, as a real submit does) by name, type, size and
+ * modification time; a capture replaced mid-submit then reads as an edit.
+ *
+ * @module
+ */
+/**
+ * The names left out of the comparison by default: the controller's default
+ * key field. `createFormRetry()` passes its configured field name (plus
+ * `ignoreFields`) instead.
+ */
+const DEFAULT_IGNORED = new Set(['submissionKey']);
+function isEditableControl(element) {
+    if (!(element instanceof HTMLInputElement) &&
+        !(element instanceof HTMLTextAreaElement) &&
+        !(element instanceof HTMLSelectElement)) {
+        return false;
+    }
+    if (element instanceof HTMLInputElement) {
+        const type = element.type;
+        if (type === 'submit' ||
+            type === 'button' ||
+            type === 'reset' ||
+            type === 'image') {
+            return false;
+        }
+    }
+    return true;
+}
+function controlValue(element) {
+    if (element instanceof HTMLInputElement) {
+        if (element.type === 'checkbox' || element.type === 'radio') {
+            return element.checked ? 'on' : '';
+        }
+        if (element.type === 'file') {
+            // A file input cannot be restored from script, so the chosen files'
+            // identity (name, size, type) is all that can honestly be compared.
+            return Array.from(element.files ?? [], (file) => `${file.name}\u0000${file.size}\u0000${file.type}`).join('\u0001');
+        }
+        return element.value;
+    }
+    if (element instanceof HTMLSelectElement && element.multiple) {
+        return Array.from(element.selectedOptions, (option) => option.value).join('\u0001');
+    }
+    return element.value;
+}
+/**
+ * What `form` would post at this moment, as far as an edit can change it:
+ * every value-carrying control except the names in `ignore` (by default the
+ * `submissionKey` key field).
+ */
+export function draftOf(form, ignore = DEFAULT_IGNORED) {
+    const draft = new Map();
+    let index = 0;
+    for (const element of Array.from(form.elements)) {
+        if (!isEditableControl(element))
+            continue;
+        const controlName = element.name;
+        if (controlName && ignore.has(controlName))
+            continue;
+        const name = controlName || `#${index}`;
+        // Several controls can share a name (a radio group, repeated fields); the
+        // index keeps them distinct so a change in any one of them is visible.
+        draft.set(`${index}:${name}`, controlValue(element));
+        index += 1;
+    }
+    draft.set('files', postedFiles(form));
+    return draft;
+}
+/**
+ * The identity of every file `form` would post, in entry order. Bytes are
+ * never read. Empty when the entry list cannot be built here (no `FormData`,
+ * or a `formdata` listener is already building one for this form).
+ */
+function postedFiles(form) {
+    if (typeof FormData === 'undefined' || typeof File === 'undefined') {
+        return '';
+    }
+    let entries;
+    try {
+        entries = new FormData(form);
+    }
+    catch {
+        return '';
+    }
+    const files = [];
+    entries.forEach((value, name) => {
+        // Skip the "no file chosen" entry (empty name, no bytes): it is minted
+        // afresh, with a new modification time, every time the list is built.
+        if (value instanceof File && (value.name !== '' || value.size > 0)) {
+            files.push([name, value.name, value.type, value.size, value.lastModified].join('\u0000'));
+        }
+    });
+    return files.join('\u0001');
+}
+/**
+ * Has `form` been edited since `submitted` was taken? `true` means the person
+ * has typed something the server has never seen, so a reset would destroy it.
+ */
+export function draftChanged(form, submitted, ignore = DEFAULT_IGNORED) {
+    const now = draftOf(form, ignore);
+    if (now.size !== submitted.size)
+        return true;
+    for (const [key, value] of now) {
+        if (submitted.get(key) !== value)
+            return true;
+    }
+    return false;
+}
+/**
+ * Did this submit leave the form EMPTY — the one question key retirement turns
+ * on (`settleSubmit()`)? Both of these must be no:
+ *
+ * - the person edited the fields while the submit was unresolved, so a reset
+ *   would destroy work the server has never seen;
+ * - **the submitted form is no longer in the document.** A form remounted
+ *   under a `{#key}` block, or unmounted when its panel closes, leaves a
+ *   detached node that still holds exactly what it submitted, so an
+ *   unchanged-check alone would retire the key — while the VISIBLE
+ *   replacement may hold the same content, one tap from a second record under
+ *   a fresh claim.
+ *
+ * A detached form therefore never counts as cleared. That is the safe
+ * direction: keeping a key can only make a later submit of the same content
+ * collapse onto the row that already exists, while retiring one wrongly is
+ * what records a duplicate.
+ */
+export function formWasCleared(form, submitted, ignore = DEFAULT_IGNORED) {
+    if (!form.isConnected)
+        return false;
+    return !draftChanged(form, submitted, ignore);
+}

package/dist/components/forms/form-retry/index.d.ts

@@ -0,0 +1,19 @@
+/**
+ * Form retry — subpath `@happyvertical/smrt-ui/form-retry` (#3291).
+ *
+ * The browser half of `runOnce()` (`@happyvertical/smrt-core`): a per-tab,
+ * per-form submission key, retained values across a failed submit, a
+ * conditional reset that keeps the next entry typed while the first was in
+ * flight, and opt-in restore-after-reload. Framework-free and Svelte-free, so
+ * this entry imports under plain Node and in any bundler; the same exports are
+ * also re-exported from `@happyvertical/smrt-ui/forms`, beside `Form`.
+ *
+ * Guide: docs/content/form-retry.md.
+ */
+export { digestSubmissionContent } from './content-digest.js';
+export { createFormRetry, type FormRetry, type FormRetryOptions, type FormRetryRestoreOptions, type FormRetryState, type FormRetryStatus, type FormRetryValuesHook, } from './controller.js';
+export { draftChanged, draftOf, type FormDraft, formWasCleared, } from './form-draft.js';
+export { beginSubmit, clearSubmissionKey, type FormRetryStorage, mintSubmissionKey, readSubmissionKey, rotateSubmissionKey, type SubmissionKeyLocation, type SubmissionSlot, type SubmitDisposition, type SubmitOutcome, settleSubmit, submitDisposition, } from './submission-key.js';
+export type { SubmittedDraft, SubmittedFileInfo, } from './submitted-draft.js';
+export type { FormRetryActionResult, FormRetryResultCallback, FormRetryResultInput, FormRetrySubmitFunction, FormRetrySubmitInput, FormRetryUpdateOptions, MaybePromise, } from './types.js';
+//# sourceMappingURL=index.d.ts.map

package/dist/components/forms/form-retry/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/components/forms/form-retry/index.ts"],"names":[],"mappings":"AAAA;;;;;;;;;;;GAWG;AAEH,OAAO,EAAE,uBAAuB,EAAE,MAAM,qBAAqB,CAAC;AAC9D,OAAO,EACL,eAAe,EACf,KAAK,SAAS,EACd,KAAK,gBAAgB,EACrB,KAAK,uBAAuB,EAC5B,KAAK,cAAc,EACnB,KAAK,eAAe,EACpB,KAAK,mBAAmB,GACzB,MAAM,iBAAiB,CAAC;AACzB,OAAO,EACL,YAAY,EACZ,OAAO,EACP,KAAK,SAAS,EACd,cAAc,GACf,MAAM,iBAAiB,CAAC;AACzB,OAAO,EACL,WAAW,EACX,kBAAkB,EAClB,KAAK,gBAAgB,EACrB,iBAAiB,EACjB,iBAAiB,EACjB,mBAAmB,EACnB,KAAK,qBAAqB,EAC1B,KAAK,cAAc,EACnB,KAAK,iBAAiB,EACtB,KAAK,aAAa,EAClB,YAAY,EACZ,iBAAiB,GAClB,MAAM,qBAAqB,CAAC;AAC7B,YAAY,EACV,cAAc,EACd,iBAAiB,GAClB,MAAM,sBAAsB,CAAC;AAC9B,YAAY,EACV,qBAAqB,EACrB,uBAAuB,EACvB,oBAAoB,EACpB,uBAAuB,EACvB,oBAAoB,EACpB,sBAAsB,EACtB,YAAY,GACb,MAAM,YAAY,CAAC"}

package/dist/components/forms/form-retry/index.js

@@ -0,0 +1,16 @@
+/**
+ * Form retry — subpath `@happyvertical/smrt-ui/form-retry` (#3291).
+ *
+ * The browser half of `runOnce()` (`@happyvertical/smrt-core`): a per-tab,
+ * per-form submission key, retained values across a failed submit, a
+ * conditional reset that keeps the next entry typed while the first was in
+ * flight, and opt-in restore-after-reload. Framework-free and Svelte-free, so
+ * this entry imports under plain Node and in any bundler; the same exports are
+ * also re-exported from `@happyvertical/smrt-ui/forms`, beside `Form`.
+ *
+ * Guide: docs/content/form-retry.md.
+ */
+export { digestSubmissionContent } from './content-digest.js';
+export { createFormRetry, } from './controller.js';
+export { draftChanged, draftOf, formWasCleared, } from './form-draft.js';
+export { beginSubmit, clearSubmissionKey, mintSubmissionKey, readSubmissionKey, rotateSubmissionKey, settleSubmit, submitDisposition, } from './submission-key.js';