@connextar/house 0.2.0 → 0.3.0

package/dist/ux/navigation-progress.js

@@ -0,0 +1,245 @@
+"use client";
+import { jsx as _jsx } from "react/jsx-runtime";
+import { usePathname, useRouter, useSearchParams } from "next/navigation.js";
+import * as React from "react";
+/**
+ * Feedback for the other half of "nothing answers my click": moving between
+ * screens.
+ *
+ * Two signals, because they answer two different questions:
+ *
+ * - **A bar across the top of the page** — "something is happening". It waits
+ *   a moment before appearing so a fast navigation does not flash it.
+ * - **A spinner on the thing that was clicked** — "*that* is what is
+ *   happening". Without it, a slow route on a page full of links gives no clue
+ *   which one took, which is when people click a second one.
+ *
+ * The second is set on the DOM node directly rather than through React state.
+ * The click can land on any link anywhere in the tree, including ones rendered
+ * by pages this component knows nothing about, and an attribute is the only
+ * thing they all have in common. `data-busy` is the same attribute the button
+ * primitive sets for an action, so one rule in the stylesheet covers both.
+ */
+/** Delay before the bar appears, so fast navigations do not flash it. */
+const START_DELAY_MS = 140;
+/** Cadence of the trickle that creeps the bar towards 90%. */
+const TRICKLE_MS = 220;
+/** Safety net: never leave the bar running forever if a navigation never commits. */
+const MAX_PENDING_MS = 20_000;
+/** How long the completed bar stays at 100% before fading out. */
+const COMPLETE_MS = 260;
+const START_EVENT = "cx:navigation-start";
+/** The attribute every busy control carries, action or navigation alike. */
+export const BUSY_ATTRIBUTE = "data-busy";
+/** The control currently marked as the reason for a navigation. */
+let marked = null;
+function unmark() {
+    if (!marked)
+        return;
+    marked.removeAttribute(BUSY_ATTRIBUTE);
+    marked.removeAttribute("aria-busy");
+    marked = null;
+}
+function mark(element) {
+    if (marked === element)
+        return;
+    unmark();
+    if (!element)
+        return;
+    marked = element;
+    element.setAttribute(BUSY_ATTRIBUTE, "true");
+    element.setAttribute("aria-busy", "true");
+}
+/**
+ * Show the navigation feedback for something this module cannot see on its
+ * own — a programmatic `router.push`. Pass the control that caused it and it
+ * gets the spinner too.
+ */
+export function startNavigation(element) {
+    if (typeof window === "undefined")
+        return;
+    mark(element ?? null);
+    window.dispatchEvent(new Event(START_EVENT));
+}
+/** Backwards-compatible alias for the original name. */
+export const startRouteProgress = startNavigation;
+/**
+ * `useRouter`, with the navigation feedback attached to `push` and `replace`.
+ *
+ * A click that runs `router.push(href)` is invisible to the watcher above —
+ * there is no anchor and no popstate — so those navigations were the ones with
+ * no feedback at all. The worst case is the one right after a save: the
+ * button's own spinner stops when the write lands, and then nothing happens
+ * for as long as the next screen takes to render.
+ *
+ * Swapping the import is the whole change; no call site moves. `refresh`,
+ * `back`, `forward` and `prefetch` pass straight through — a refresh re-renders
+ * the screen you are already on, which needs no bar.
+ */
+export function useAppRouter() {
+    const router = useRouter();
+    return React.useMemo(() => ({
+        ...router,
+        // Forwarded by spread, not by naming the options: passing an explicit
+        // `undefined` is a different call from passing nothing.
+        push: (...args) => {
+            startNavigation();
+            router.push(...args);
+        },
+        replace: (...args) => {
+            startNavigation();
+            router.replace(...args);
+        },
+    }), [router]);
+}
+/**
+ * `router.push` with the feedback attached, and the control that caused it
+ * marked as busy. For a button that navigates rather than saves.
+ */
+export function useNavigate() {
+    const router = useRouter();
+    return React.useCallback((href, options) => {
+        startNavigation(options?.element ?? null);
+        if (options?.replace)
+            router.replace(href);
+        else
+            router.push(href);
+    }, [router]);
+}
+/**
+ * A click that means "take me there", rather than one the browser will handle
+ * itself — a new tab, a download, a context menu.
+ *
+ * Deliberately *not* a `defaultPrevented` check. This runs in the capture
+ * phase, and the reason is the whole point of this listener: Next's `Link`
+ * calls `preventDefault()` on its way to a client-side navigation, so by the
+ * time a bubble-phase listener sees the click, every in-app link looks
+ * cancelled. Guarding on `defaultPrevented` there means the bar fires for
+ * exactly the navigations that do not need it and stays silent for all the
+ * ones that do — which is what was happening here until this was measured in
+ * the browser.
+ */
+function isPlainLeftClick(event) {
+    return event.button === 0 && !event.metaKey && !event.ctrlKey && !event.shiftKey && !event.altKey;
+}
+function navigatesElsewhere(url) {
+    if (url.origin !== window.location.origin)
+        return false;
+    // API routes are downloads/exports, not page navigations.
+    if (url.pathname.startsWith("/api/"))
+        return false;
+    return url.pathname !== window.location.pathname || url.search !== window.location.search;
+}
+function NavigationProgressBar({ className }) {
+    const pathname = usePathname();
+    const search = useSearchParams().toString();
+    const [progress, setProgress] = React.useState(null);
+    const timers = React.useRef([]);
+    const active = React.useRef(false);
+    const clearTimers = React.useCallback(() => {
+        timers.current.forEach((id) => window.clearTimeout(id));
+        timers.current = [];
+    }, []);
+    const stop = React.useCallback(() => {
+        clearTimers();
+        active.current = false;
+        delete document.body.dataset.routePending;
+        unmark();
+        setProgress((value) => (value === null ? null : 100));
+        window.setTimeout(() => {
+            // A new navigation may have started in the meantime; leave its bar alone.
+            if (!active.current)
+                setProgress(null);
+        }, COMPLETE_MS);
+    }, [clearTimers]);
+    const start = React.useCallback(() => {
+        if (active.current)
+            return;
+        active.current = true;
+        document.body.dataset.routePending = "true";
+        const trickle = () => {
+            setProgress((value) => (value === null ? value : Math.min(value + Math.max(1, (90 - value) * 0.16), 90)));
+            timers.current.push(window.setTimeout(trickle, TRICKLE_MS));
+        };
+        timers.current.push(window.setTimeout(() => {
+            setProgress(8);
+            trickle();
+        }, START_DELAY_MS));
+        timers.current.push(window.setTimeout(stop, MAX_PENDING_MS));
+    }, [stop]);
+    // The navigation committed once the URL the router reports has changed.
+    const initialRender = React.useRef(true);
+    React.useEffect(() => {
+        if (initialRender.current) {
+            initialRender.current = false;
+            return;
+        }
+        stop();
+    }, [pathname, search, stop]);
+    React.useEffect(() => {
+        const onClick = (event) => {
+            if (!isPlainLeftClick(event))
+                return;
+            const target = event.target;
+            if (!(target instanceof Element))
+                return;
+            const anchor = target.closest("a");
+            if (!anchor?.href || anchor.hasAttribute("download"))
+                return;
+            if (anchor.target && anchor.target !== "_self")
+                return;
+            if (!navigatesElsewhere(new URL(anchor.href)))
+                return;
+            // Mark before `start`, which returns early when a navigation is already
+            // running: a second click during a slow load should still move the
+            // spinner to the link that was actually clicked.
+            mark(anchor);
+            start();
+        };
+        const onSubmit = (event) => {
+            if (event.defaultPrevented)
+                return;
+            const form = event.target;
+            if (!(form instanceof HTMLFormElement))
+                return;
+            if (form.method.toLowerCase() !== "get" || !form.action)
+                return;
+            if (new URL(form.action).origin !== window.location.origin)
+                return;
+            if (event.submitter)
+                mark(event.submitter);
+            start();
+        };
+        // Capture, so this runs before `Link` cancels the click (see above). The
+        // submit listener stays in the bubble phase on purpose: a form with an
+        // `onSubmit` that saves rather than navigates is the common case here, and
+        // `defaultPrevented` is exactly how to tell those apart.
+        document.addEventListener("click", onClick, true);
+        document.addEventListener("submit", onSubmit);
+        window.addEventListener("popstate", start);
+        window.addEventListener(START_EVENT, start);
+        return () => {
+            document.removeEventListener("click", onClick, true);
+            document.removeEventListener("submit", onSubmit);
+            window.removeEventListener("popstate", start);
+            window.removeEventListener(START_EVENT, start);
+            clearTimers();
+            unmark();
+            delete document.body.dataset.routePending;
+        };
+    }, [clearTimers, start]);
+    if (progress === null)
+        return null;
+    return (_jsx("div", { className: "pointer-events-none fixed inset-x-0 top-0 z-[100] h-0.5", role: "progressbar", "aria-label": "Loading page", "aria-busy": "true", children: _jsx("div", { className: className, style: { width: `${progress}%`, opacity: progress === 100 ? 0 : 1 } }) }));
+}
+/**
+ * Mount once, above everything else — including anything that suspends, or the
+ * bar disappears for exactly the navigations it is there for.
+ *
+ * `className` styles the filled part of the bar, so the host app picks its own
+ * colour without this module knowing any of its tokens.
+ */
+export function NavigationProgress({ className }) {
+    return (_jsx(React.Suspense, { fallback: null, children: _jsx(NavigationProgressBar, { className: className }) }));
+}
+//# sourceMappingURL=navigation-progress.js.map

package/dist/ux/navigation-progress.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"navigation-progress.js","sourceRoot":"","sources":["../../src/ux/navigation-progress.tsx"],"names":[],"mappings":"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"}

package/dist/ux/optimistic.d.ts

@@ -0,0 +1,139 @@
+/**
+ * The patch queue behind the optimistic hooks — no React, no transport, no
+ * framework. All of the thinking is here so it can be tested as a function.
+ *
+ * ## The shape of the problem
+ *
+ * A screen shows rows the server sent. Someone ticks one. Three things then
+ * have to be true at once:
+ *
+ * 1. The tick shows **now**, before any request goes out.
+ * 2. If the write fails, the tick goes away again and the person is told.
+ * 3. When the server's own rows arrive, they win — including when they say
+ *    something different from what was guessed.
+ *
+ * React's `useOptimistic` solves (1) and (2) for a server action, because the
+ * action *is* the transition and React knows when it ends. It does not solve
+ * (3) for an app that writes over `fetch` and then calls `router.refresh()`:
+ * `router.refresh()` is not awaitable, so the transition ends before the new
+ * rows land and the optimistic value snaps back to the stale one — a visible
+ * flash of the old answer on every single write. That is the reason this
+ * module exists rather than a wrapper around `useOptimistic`.
+ *
+ * ## How it works
+ *
+ * The server's rows are the *base*. Every optimistic change is a *patch* held
+ * beside the base, never merged into it. What the screen renders is the base
+ * with the patches applied, recomputed on each render.
+ *
+ * A patch is `pending` while its write is in flight, then either:
+ *
+ * - **dropped** — the write failed, so the base alone is the truth again; or
+ * - **settled** — the write landed. It keeps being applied, because the base
+ *   is still the *old* rows until a refresh arrives, and taking the patch away
+ *   at this point is precisely the flash we are avoiding.
+ *
+ * A settled patch is dropped when fresh rows arrive that account for it. That
+ * is the whole reconciliation rule, and it is deliberately evidence-based
+ * rather than timed: see `shouldDropSettled`.
+ */
+/** How a row is identified. Ids are strings here; numbers stringify fine. */
+export type RowKey = string;
+export type PatchKind = "insert" | "update" | "remove" | "move";
+export interface Patch<T> {
+    readonly id: string;
+    readonly kind: PatchKind;
+    /**
+     * The row this patch concerns. For an insert this starts as a made-up key
+     * and becomes the server's own key once the write lands.
+     */
+    readonly key: RowKey;
+    /** `insert`: the row to show. */
+    readonly row?: T;
+    /** `update`: the fields to lay over the row. */
+    readonly fields?: Partial<T>;
+    /** `insert`: which end of the list to show it at. */
+    readonly at?: "start" | "end";
+    /** `move`: the key this row now sits before; `null` means last. */
+    readonly before?: RowKey | null;
+    readonly settled: boolean;
+    /**
+     * What the base said about `key` at the moment the write landed. Fresh rows
+     * are recognised by disagreeing with it — see `shouldDropSettled`.
+     */
+    readonly witness?: T | null;
+}
+/** A patch id. Unique within a session; never stored or sent anywhere. */
+export declare function nextPatchId(): string;
+/**
+ * The rows to render: the server's, with every patch laid over them in the
+ * order they were made, so a later change to the same row wins.
+ */
+export declare function applyPatches<T>(base: readonly T[], patches: readonly Patch<T>[], keyOf: (row: T) => RowKey): readonly T[];
+/** Shallow, own-keys equality. Enough to tell "the same row" from "new data". */
+export declare function sameRow<T>(a: T | null | undefined, b: T | null | undefined): boolean;
+/**
+ * Does the base already say what this patch says? A redundant patch has
+ * nothing left to show and can go.
+ */
+export declare function isRedundant<T>(patch: Patch<T>, base: readonly T[], keyOf: (row: T) => RowKey): boolean;
+/**
+ * Whether a settled patch has been overtaken by fresh server rows.
+ *
+ * Two ways it can have been, and they cover the two endings the person cares
+ * about:
+ *
+ * - **The base agrees** — the refresh carried the change through. Dropping the
+ *   patch changes nothing on screen, which is exactly the point.
+ * - **The base disagrees with what it said when the write landed** — new data
+ *   for this row has arrived. It wins, whatever it says. This is the case
+ *   where the server did something other than what was guessed (clamped a
+ *   value, renamed on save, reordered), and the screen corrects itself.
+ *
+ * A base that has not changed at all leaves the patch applied, however long it
+ * has been there. There is no timeout on purpose: a screen that never refetches
+ * has no truth to fall back to, and snapping to stale rows after N seconds
+ * would be a bug that only shows up on slow connections.
+ *
+ * Only ever called when the base is a *different array* from the one the patch
+ * settled against, so a parent that rebuilds its rows on every render cannot
+ * shake patches loose.
+ */
+export declare function shouldDropSettled<T>(patch: Patch<T>, base: readonly T[], keyOf: (row: T) => RowKey): boolean;
+/**
+ * The queue after fresh rows arrived: pending writes are left alone, settled
+ * ones are dropped once the rows account for them.
+ */
+export declare function reconcile<T>(patches: readonly Patch<T>[], base: readonly T[], keyOf: (row: T) => RowKey): readonly Patch<T>[];
+/**
+ * Mark a landed write as settled, taking the server's own answer over the
+ * guess where it sent one — the correction in "confirm or correct" — and
+ * noting what the base said, so the next refresh can be recognised.
+ *
+ * What it takes from that answer is deliberately narrow. A write endpoint
+ * often returns a *thinner* record than the list endpoint does — no joined
+ * learner, no counts — because the caller did not need them. Laying that over
+ * the row wholesale would blank the columns beside the one that was edited,
+ * which looks exactly like data loss and is the reason this is a `pick` and a
+ * merge rather than an assignment.
+ */
+export declare function settlePatch<T>(patch: Patch<T>, serverRow: T | undefined, base: readonly T[], keyOf: (row: T) => RowKey): Patch<T>;
+/**
+ * Drop what a write that has just landed supersedes: earlier *settled* changes
+ * to the same rows. Writes still in flight stay — each has a request that can
+ * still come back refused and needs rolling back on its own.
+ *
+ * This happens on landing, never on queueing. A change that succeeded is still
+ * true while a later one is being attempted, and clearing it early means a
+ * failed second write rolls the first one back with it.
+ */
+export declare function supersede<T>(patches: readonly Patch<T>[], keys: ReadonlySet<RowKey>): readonly Patch<T>[];
+/**
+ * A stand-in key for a row that does not exist server-side yet. Distinctive on
+ * purpose: if one of these ever reaches a request body or a URL, the resulting
+ * 404 should say why at a glance.
+ */
+export declare function tempKey(prefix?: string): string;
+/** Whether a key came from `tempKey` — a row that is still being created. */
+export declare function isTempKey(key: RowKey): boolean;
+//# sourceMappingURL=optimistic.d.ts.map

package/dist/ux/optimistic.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"optimistic.d.ts","sourceRoot":"","sources":["../../src/ux/optimistic.ts"],"names":[],"mappings":"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"}

package/dist/ux/optimistic.js

@@ -0,0 +1,242 @@
+/**
+ * The patch queue behind the optimistic hooks — no React, no transport, no
+ * framework. All of the thinking is here so it can be tested as a function.
+ *
+ * ## The shape of the problem
+ *
+ * A screen shows rows the server sent. Someone ticks one. Three things then
+ * have to be true at once:
+ *
+ * 1. The tick shows **now**, before any request goes out.
+ * 2. If the write fails, the tick goes away again and the person is told.
+ * 3. When the server's own rows arrive, they win — including when they say
+ *    something different from what was guessed.
+ *
+ * React's `useOptimistic` solves (1) and (2) for a server action, because the
+ * action *is* the transition and React knows when it ends. It does not solve
+ * (3) for an app that writes over `fetch` and then calls `router.refresh()`:
+ * `router.refresh()` is not awaitable, so the transition ends before the new
+ * rows land and the optimistic value snaps back to the stale one — a visible
+ * flash of the old answer on every single write. That is the reason this
+ * module exists rather than a wrapper around `useOptimistic`.
+ *
+ * ## How it works
+ *
+ * The server's rows are the *base*. Every optimistic change is a *patch* held
+ * beside the base, never merged into it. What the screen renders is the base
+ * with the patches applied, recomputed on each render.
+ *
+ * A patch is `pending` while its write is in flight, then either:
+ *
+ * - **dropped** — the write failed, so the base alone is the truth again; or
+ * - **settled** — the write landed. It keeps being applied, because the base
+ *   is still the *old* rows until a refresh arrives, and taking the patch away
+ *   at this point is precisely the flash we are avoiding.
+ *
+ * A settled patch is dropped when fresh rows arrive that account for it. That
+ * is the whole reconciliation rule, and it is deliberately evidence-based
+ * rather than timed: see `shouldDropSettled`.
+ */
+let counter = 0;
+/** A patch id. Unique within a session; never stored or sent anywhere. */
+export function nextPatchId() {
+    counter += 1;
+    return `p${counter}`;
+}
+function find(rows, key, keyOf) {
+    for (const row of rows)
+        if (keyOf(row) === key)
+            return row;
+    return null;
+}
+/**
+ * The rows to render: the server's, with every patch laid over them in the
+ * order they were made, so a later change to the same row wins.
+ */
+export function applyPatches(base, patches, keyOf) {
+    if (patches.length === 0)
+        return base;
+    let rows = [...base];
+    for (const patch of patches) {
+        switch (patch.kind) {
+            case "insert": {
+                // The server's own copy has arrived under this key: show that one
+                // rather than two of the same thing.
+                if (patch.row === undefined || find(rows, patch.key, keyOf) !== null)
+                    break;
+                if (patch.at === "start")
+                    rows.unshift(patch.row);
+                else
+                    rows.push(patch.row);
+                break;
+            }
+            case "update": {
+                rows = rows.map((row) => (keyOf(row) === patch.key ? { ...row, ...patch.fields } : row));
+                break;
+            }
+            case "remove": {
+                rows = rows.filter((row) => keyOf(row) !== patch.key);
+                break;
+            }
+            case "move": {
+                const from = rows.findIndex((row) => keyOf(row) === patch.key);
+                if (from < 0)
+                    break;
+                const moved = rows.splice(from, 1);
+                // `splice` above removed exactly one row at a known index, so this is
+                // never empty; the check is for the type, not for the case.
+                if (moved.length === 0)
+                    break;
+                const to = patch.before == null ? -1 : rows.findIndex((other) => keyOf(other) === patch.before);
+                rows.splice(to < 0 ? rows.length : to, 0, ...moved);
+                break;
+            }
+        }
+    }
+    return rows;
+}
+/** The key that follows `key` in `rows`; `null` at the end. */
+function neighbourAfter(rows, key, keyOf) {
+    const index = rows.findIndex((row) => keyOf(row) === key);
+    if (index < 0)
+        return null;
+    const next = rows[index + 1];
+    return next === undefined ? null : keyOf(next);
+}
+/** Shallow, own-keys equality. Enough to tell "the same row" from "new data". */
+export function sameRow(a, b) {
+    if (a === b)
+        return true;
+    if (a == null || b == null)
+        return false;
+    if (typeof a !== "object" || typeof b !== "object")
+        return Object.is(a, b);
+    const left = a;
+    const right = b;
+    const keys = Object.keys(left);
+    if (keys.length !== Object.keys(right).length)
+        return false;
+    return keys.every((key) => Object.is(left[key], right[key]));
+}
+/**
+ * Does the base already say what this patch says? A redundant patch has
+ * nothing left to show and can go.
+ */
+export function isRedundant(patch, base, keyOf) {
+    const current = find(base, patch.key, keyOf);
+    switch (patch.kind) {
+        case "insert":
+            return current !== null;
+        case "remove":
+            return current === null;
+        case "update": {
+            // A row that is no longer there cannot be waiting for an edit.
+            if (current === null)
+                return true;
+            const fields = (patch.fields ?? {});
+            const row = current;
+            return Object.keys(fields).every((key) => Object.is(row[key], fields[key]));
+        }
+        case "move":
+            return find(base, patch.key, keyOf) !== null && neighbourAfter(base, patch.key, keyOf) === patch.before;
+    }
+}
+/**
+ * Whether a settled patch has been overtaken by fresh server rows.
+ *
+ * Two ways it can have been, and they cover the two endings the person cares
+ * about:
+ *
+ * - **The base agrees** — the refresh carried the change through. Dropping the
+ *   patch changes nothing on screen, which is exactly the point.
+ * - **The base disagrees with what it said when the write landed** — new data
+ *   for this row has arrived. It wins, whatever it says. This is the case
+ *   where the server did something other than what was guessed (clamped a
+ *   value, renamed on save, reordered), and the screen corrects itself.
+ *
+ * A base that has not changed at all leaves the patch applied, however long it
+ * has been there. There is no timeout on purpose: a screen that never refetches
+ * has no truth to fall back to, and snapping to stale rows after N seconds
+ * would be a bug that only shows up on slow connections.
+ *
+ * Only ever called when the base is a *different array* from the one the patch
+ * settled against, so a parent that rebuilds its rows on every render cannot
+ * shake patches loose.
+ */
+export function shouldDropSettled(patch, base, keyOf) {
+    if (isRedundant(patch, base, keyOf))
+        return true;
+    return !sameRow(find(base, patch.key, keyOf), patch.witness ?? null);
+}
+/**
+ * The queue after fresh rows arrived: pending writes are left alone, settled
+ * ones are dropped once the rows account for them.
+ */
+export function reconcile(patches, base, keyOf) {
+    if (patches.length === 0)
+        return patches;
+    const kept = patches.filter((patch) => !patch.settled || !shouldDropSettled(patch, base, keyOf));
+    return kept.length === patches.length ? patches : kept;
+}
+/**
+ * Mark a landed write as settled, taking the server's own answer over the
+ * guess where it sent one — the correction in "confirm or correct" — and
+ * noting what the base said, so the next refresh can be recognised.
+ *
+ * What it takes from that answer is deliberately narrow. A write endpoint
+ * often returns a *thinner* record than the list endpoint does — no joined
+ * learner, no counts — because the caller did not need them. Laying that over
+ * the row wholesale would blank the columns beside the one that was edited,
+ * which looks exactly like data loss and is the reason this is a `pick` and a
+ * merge rather than an assignment.
+ */
+export function settlePatch(patch, serverRow, base, keyOf) {
+    const settled = { ...patch, settled: true, witness: find(base, patch.key, keyOf) };
+    if (serverRow === null || serverRow === undefined || typeof serverRow !== "object")
+        return settled;
+    if (patch.kind === "insert" && patch.row !== undefined) {
+        // The guess fills in whatever the create did not answer with; the key
+        // comes from the server, because that is the one thing only it knows.
+        const row = { ...patch.row, ...serverRow };
+        const key = keyOf(row);
+        return { ...settled, key, row, witness: find(base, key, keyOf) };
+    }
+    if (patch.kind === "update" && patch.fields) {
+        // Only the fields this write set, and only those the answer carried: a
+        // price rounded on save, a title trimmed, a status the server chose.
+        const answer = serverRow;
+        const corrected = { ...patch.fields };
+        for (const field of Object.keys(corrected)) {
+            if (field in answer)
+                corrected[field] = answer[field];
+        }
+        return { ...settled, fields: corrected };
+    }
+    return settled;
+}
+/**
+ * Drop what a write that has just landed supersedes: earlier *settled* changes
+ * to the same rows. Writes still in flight stay — each has a request that can
+ * still come back refused and needs rolling back on its own.
+ *
+ * This happens on landing, never on queueing. A change that succeeded is still
+ * true while a later one is being attempted, and clearing it early means a
+ * failed second write rolls the first one back with it.
+ */
+export function supersede(patches, keys) {
+    return patches.filter((patch) => !(patch.settled && keys.has(patch.key)));
+}
+/**
+ * A stand-in key for a row that does not exist server-side yet. Distinctive on
+ * purpose: if one of these ever reaches a request body or a URL, the resulting
+ * 404 should say why at a glance.
+ */
+export function tempKey(prefix = "tmp") {
+    counter += 1;
+    return `${prefix}:${counter}:${Date.now().toString(36)}`;
+}
+/** Whether a key came from `tempKey` — a row that is still being created. */
+export function isTempKey(key) {
+    return key.startsWith("tmp:");
+}
+//# sourceMappingURL=optimistic.js.map

package/dist/ux/optimistic.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"optimistic.js","sourceRoot":"","sources":["../../src/ux/optimistic.ts"],"names":[],"mappings":"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"}