canopycms 0.11.1 → 0.12.1

package/dist/editor/hooks/useBaseUpdate.js

@@ -0,0 +1,269 @@
+'use client';
+import { jsx as _jsx } from "react/jsx-runtime";
+import { useCallback, useEffect, useRef, useState } from 'react';
+import { useSWRConfig } from 'swr';
+import { notifications } from '@mantine/notifications';
+import { clientOperatingStrategy } from '../../operating-mode/client.js';
+import { isBaseUpdatePending } from '../../base-update.js';
+import { useApiClient } from '../context/index.js';
+import { getErrorMessage } from '../../utils/error.js';
+import { BRANCHES_KEY } from './useBranchesData.js';
+import { RetryToastMessage } from '../components/RetryToastMessage.js';
+import { EDITOR_ACTIONS } from '../copy.js';
+import { GAVE_UP_MESSAGE, REQUEST_FAILED_MESSAGE, SAVE_FIRST_REASON, UNANSWERED_MESSAGE, baseUpdatePollMs, baseUpdateResultMessage, baseUpdateWait, nextBaseUpdateWaitChange, } from '../base-update-wait.js';
+import { serverNow } from '../server-clock.js';
+import { UnansweredError, isGatewayFailure, isUnanswered } from '../unanswered.js';
+const RESULT_TOAST_ID = 'canopy-base-update-result';
+/** Writes the branch a request answered into the listing, so its wait shows at once. */
+function withBranch(data, branch) {
+    if (!data)
+        return data;
+    return { ...data, branches: data.branches.map((b) => (b.name === branch.name ? branch : b)) };
+}
+/** Whether `a` is a later request time than `b`, an absent one being earliest. */
+const laterThan = (a, b) => b === undefined || Date.parse(a) > Date.parse(b);
+const sameBranch = (branch, record) => record?.name === branch.name && record.createdAt === branch.createdAt;
+/** The listed branch, carrying this tab's newer request. */
+function withAsked(branch, asked) {
+    if (!branch || !sameBranch(branch, asked))
+        return branch;
+    return laterThan(asked.requestedAt, branch.baseUpdateRequestedAt)
+        ? { ...branch, baseUpdateRequestedAt: asked.requestedAt }
+        : branch;
+}
+/** The branch, carrying the answer this tab already reported when the listing hasn't caught up. */
+function withSettled(branch, settled) {
+    if (!branch || !sameBranch(branch, settled) || !isBaseUpdatePending(branch))
+        return branch;
+    return laterThan(branch.baseUpdateRequestedAt ?? '', settled.requestedAt) &&
+        branch.baseUpdateRequestedAt !== undefined
+        ? branch
+        : {
+            ...branch,
+            baseUpdateRequestedAt: settled.requestedAt,
+            lastBaseUpdate: settled.lastBaseUpdate,
+        };
+}
+/**
+ * A toast in the one slot this hook uses, replacing what it showed before. `onAction` offers
+ * Retry, or `actionLabel`.
+ */
+function showResult(color, message, onAction, actionLabel) {
+    notifications.hide(RESULT_TOAST_ID);
+    notifications.show({
+        id: RESULT_TOAST_ID,
+        color,
+        autoClose: color === 'green' ? undefined : false,
+        message: onAction ? (_jsx(RetryToastMessage, { message: message, onRetry: onAction, actionLabel: actionLabel })) : (message),
+    });
+}
+/**
+ * "Get latest changes" for the open branch: asks, then re-reads the branch list while the branch
+ * waits, and reports the worker's answer in a toast once it lands. Only a wait this tab saw end
+ * reports, so a reload onto an answered request stays quiet. The wait is timed by the server's
+ * clock (server-clock.ts), and a request this tab made counts even when a listing fetched before
+ * it lands after it.
+ */
+export function useBaseUpdate(options) {
+    const { operatingMode, permitted, unsavedCount, onUpdated } = options;
+    const apiClient = useApiClient();
+    const { mutate } = useSWRConfig();
+    const [requestingFor, setRequestingFor] = useState(null);
+    // The last request this tab made, by branch, which a listing that predates it can't undo.
+    const [asked, setAsked] = useState(null);
+    // The last answer this tab reported, by branch, which a listing that predates it can't undo:
+    // another host can serve the branch list from an older snapshot.
+    const [settled, setSettled] = useState(null);
+    const [, setTick] = useState(0);
+    const listed = options.branch;
+    const name = listed?.name;
+    const branch = withSettled(withAsked(listed, asked), settled);
+    const available = !!branch &&
+        clientOperatingStrategy(operatingMode).syncsBranchesWithBase() &&
+        branch.status === 'editing' &&
+        branch.isProtected === false &&
+        permitted;
+    const wait = baseUpdateWait(branch, serverNow());
+    const requestedAt = branch?.baseUpdateRequestedAt;
+    const answer = branch?.lastBaseUpdate;
+    const status = branch?.status;
+    const createdAt = branch?.createdAt;
+    // The wait changes on its own at the slow and give-up marks; nothing else would re-render then.
+    const changeAt = nextBaseUpdateWaitChange(branch, serverNow());
+    useEffect(() => {
+        if (changeAt === undefined)
+            return;
+        const timer = setTimeout(() => setTick((n) => n + 1), Math.max(0, changeAt - serverNow()) + 50);
+        return () => clearTimeout(timer);
+    }, [changeAt]);
+    // Re-read the listing while the branch waits, on a timer of its own: SWR stops polling a key
+    // whose last fetch failed, and one failed read must not end the wait. Each read starts only once
+    // the last has settled, since SWR drops an in-flight read's result when another starts.
+    const pollMs = baseUpdatePollMs(wait);
+    useEffect(() => {
+        if (pollMs === 0)
+            return;
+        let stopped = false;
+        let timer;
+        const next = () => {
+            timer = setTimeout(async () => {
+                if (typeof document === 'undefined' || document.visibilityState !== 'hidden') {
+                    await mutate(BRANCHES_KEY).catch(() => undefined);
+                }
+                if (!stopped)
+                    next();
+            }, pollMs);
+        };
+        next();
+        return () => {
+            stopped = true;
+            clearTimeout(timer);
+        };
+    }, [pollMs, mutate]);
+    const latest = useRef({ name, unsavedCount, available });
+    latest.current = { name, unsavedCount, available };
+    const onUpdatedRef = useRef(onUpdated);
+    onUpdatedRef.current = onUpdated;
+    const onShowConflictsRef = useRef(options.onShowConflicts);
+    onShowConflictsRef.current = options.onShowConflicts;
+    const requestRef = useRef(async () => { });
+    // Stable, and reads only refs, so the toasts that carry it keep working.
+    const retry = useCallback(() => {
+        notifications.hide(RESULT_TOAST_ID);
+        void requestRef.current();
+    }, []);
+    const report = useCallback((on, result) => {
+        setSettled({ ...on, lastBaseUpdate: result });
+        if (result.outcome !== 'failed')
+            onUpdatedRef.current();
+        if (result.outcome === 'conflicts') {
+            // The toast counts the choices left, which the branch's conflicts hold.
+            void apiClient.conflicts
+                .list({ branch: on.name })
+                .then((answer) => (answer.ok ? answer.data?.openCount : undefined))
+                .catch(() => undefined)
+                .then((count) => {
+                if (latest.current.name !== on.name)
+                    return;
+                const { color, message } = baseUpdateResultMessage(result, count);
+                const show = () => {
+                    notifications.hide(RESULT_TOAST_ID);
+                    onShowConflictsRef.current?.();
+                };
+                showResult(color, message, onShowConflictsRef.current && count !== 0 ? show : undefined, EDITOR_ACTIONS.showChanges);
+            });
+            return;
+        }
+        const { color, message } = baseUpdateResultMessage(result);
+        // Retry only for someone who may ask; another viewer just learns how it went.
+        const canRetry = result.outcome === 'failed' && latest.current.available;
+        showResult(color, message, canRetry ? retry : undefined);
+    }, [apiClient, retry]);
+    // A result is about the branch it came from: switching away closes it.
+    useEffect(() => () => {
+        notifications.hide(RESULT_TOAST_ID);
+    }, [name]);
+    // A wait this tab saw, by branch and request, reports when its answer lands, even after the
+    // editor stopped waiting on it; giving up says so, once.
+    const watched = useRef(undefined);
+    useEffect(() => {
+        if (!name || !requestedAt)
+            return;
+        const seen = watched.current;
+        const same = seen?.name === name && seen.requestedAt === requestedAt;
+        if (wait !== 'none') {
+            if (!same)
+                watched.current = { name, requestedAt, gaveUp: false };
+            return;
+        }
+        if (!seen || !same)
+            return;
+        if (answer &&
+            !isBaseUpdatePending({ baseUpdateRequestedAt: requestedAt, lastBaseUpdate: answer })) {
+            watched.current = undefined;
+            report({ name, createdAt: createdAt ?? '', requestedAt }, answer);
+        }
+        else if (!seen.gaveUp && status === 'editing') {
+            seen.gaveUp = true;
+            showResult('yellow', GAVE_UP_MESSAGE);
+        }
+    }, [name, createdAt, requestedAt, answer, wait, status, report]);
+    const request = useCallback(async () => {
+        const target = latest.current.name;
+        if (!target)
+            return;
+        if (latest.current.unsavedCount > 0) {
+            showResult('yellow', SAVE_FIRST_REASON);
+            return;
+        }
+        // What lands after the user moved to another branch is about that one, not this.
+        const stillOpen = () => latest.current.name === target;
+        setRequestingFor(target);
+        try {
+            try {
+                const result = await apiClient.workflow.updateFromBase({ branch: target });
+                if (isGatewayFailure(result))
+                    throw new UnansweredError();
+                if (result.ok && result.data) {
+                    const { branch: answered, requestedAt: at } = result.data;
+                    await mutate(BRANCHES_KEY, (data) => withBranch(data, answered), {
+                        revalidate: false,
+                    });
+                    if (!stillOpen())
+                        return;
+                    const on = { name: target, createdAt: answered.createdAt, requestedAt: at };
+                    setAsked(on);
+                    if (!isBaseUpdatePending(answered) && answered.lastBaseUpdate) {
+                        report(on, answered.lastBaseUpdate);
+                    }
+                    else {
+                        watched.current = { name: target, requestedAt: at, gaveUp: false };
+                    }
+                    return;
+                }
+                // A refusal can mean the branch moved on (submitted meanwhile): re-read it, and offer Retry
+                // only if it can still ask.
+                const fresh = await mutate(BRANCHES_KEY);
+                if (!stillOpen())
+                    return;
+                const now = fresh?.branches.find((b) => b.name === target);
+                const canRetry = now === undefined || now.status === 'editing';
+                showResult('red', result.error ?? REQUEST_FAILED_MESSAGE, canRetry ? retry : undefined);
+            }
+            catch (err) {
+                if (!isUnanswered(err))
+                    throw err;
+                // It may have gone through, and a reload that shows the wait settles it.
+                const fresh = await mutate(BRANCHES_KEY);
+                if (!stillOpen())
+                    return;
+                const reloaded = fresh?.branches.find((b) => b.name === target);
+                if (baseUpdateWait(reloaded, serverNow()) === 'none') {
+                    showResult('yellow', UNANSWERED_MESSAGE, retry);
+                }
+            }
+        }
+        catch (err) {
+            if (!stillOpen())
+                return;
+            notifications.hide(RESULT_TOAST_ID);
+            notifications.show({
+                id: RESULT_TOAST_ID,
+                color: 'red',
+                autoClose: false,
+                message: (_jsx(RetryToastMessage, { message: REQUEST_FAILED_MESSAGE, onRetry: retry, details: getErrorMessage(err) })),
+            });
+        }
+        finally {
+            setRequestingFor((current) => (current === target ? null : current));
+        }
+    }, [apiClient, mutate, report, retry]);
+    requestRef.current = request;
+    return {
+        available,
+        wait,
+        requesting: !!name && requestingFor === name,
+        blockedReason: unsavedCount > 0 ? SAVE_FIRST_REASON : undefined,
+        request,
+    };
+}

package/dist/editor/hooks/useBranchManager.d.ts

@@ -51,7 +51,7 @@ interface BranchSummary {
     syncFailureReason?: string;
     /** Whether this branch has unresolved merge conflicts with the base branch */
     conflictStatus?: ConflictStatus;
-    /** ContentIds of entries where --theirs was applied during rebase; cleared on clean rebase */
+    /** ContentIds of entries with a merge conflict a person has yet to resolve */
     conflictFiles?: string[];
     /** What is stuck and needs a person (api/branch.ts). */
     hold?: BranchHold;
@@ -92,6 +92,11 @@ export interface UseBranchManagerOptions {
     onStamped?: (stamped: StampedEntry[]) => void;
     /** A request for changes went through; the branch may now carry the reviewer's note as a comment. */
     onChangesRequested?: (branchName: string) => void;
+    /**
+     * How to ask for the latest changes on `branchName` once it is withdrawn, or undefined where
+     * that can't apply. With it, withdrawing a branch that conflicts with its base asks right after.
+     */
+    latestChangesAfterWithdraw?: (branchName: string) => (() => Promise<void>) | undefined;
 }
 export interface UseBranchManagerReturn {
     /**

package/dist/editor/hooks/useBranchManager.js

@@ -6,7 +6,8 @@ import { Alert, Stack, Text } from '@mantine/core';
 import { IconAlertTriangle } from '@tabler/icons-react';
 import { openConfirm } from '../utils/confirm-modal.js';
 import { focusReturnProps } from '../utils/focus-return.js';
-import { EDITOR_ACTIONS } from '../copy.js';
+import { EDITOR_ACTIONS, WITHDRAW_AND_GET_LATEST } from '../copy.js';
+import { clientOperatingStrategy } from '../../operating-mode/client.js';
 import { notifications } from '@mantine/notifications';
 import { useApiClient, useBranchSegments } from '../context/index.js';
 import { BRANCHES_KEY, fetchBranches, useBranchesData } from './useBranchesData.js';
@@ -50,7 +51,11 @@ function actionError(result, fallback, staleIsConflict = false) {
     const message = result.error || fallback;
     if (result.ok)
         return new Error(message);
-    return staleIsConflict && result.status === 409 && !isNonApiResponse(result)
+    // Open conflicts refuse the action where the branch still is, so they are no stale status.
+    return staleIsConflict &&
+        result.status === 409 &&
+        result.code !== 'OPEN_CONFLICTS' &&
+        !isNonApiResponse(result)
         ? new StaleStatusError(message)
         : new RefusedError(message, result.status);
 }
@@ -142,16 +147,22 @@ export function withdrawPullRequestBullet(pr) {
         return `Leave the merged ${label} as it is`;
     return `Convert ${label} to a draft`;
 }
-const showWithdrawConfirmation = (branchName, pr, onConfirm, onDismiss, returnFocusTo) => {
+const showWithdrawConfirmation = (branchName, pr, onConfirm, onDismiss, returnFocusTo, 
+/** The branch conflicts with its base, so withdrawing also gets the latest changes. */
+thenGetLatest = false) => {
     const bullets = [
         withdrawPullRequestBullet(pr),
         'Change the branch status back to “editing”',
         'Remove from review queue',
+        thenGetLatest ? 'Bring in the latest changes made on the site' : undefined,
     ].filter((b) => b !== undefined);
     openConfirm({
         title: EDITOR_ACTIONS.withdrawFromReview,
         children: (_jsx(Text, { size: "sm", style: { whiteSpace: 'pre-line' }, children: `Withdraw “${branchName}” from review?\n\nThis will:\n${bullets.map((b) => `• ${b}`).join('\n')}` })),
-        labels: { confirm: EDITOR_ACTIONS.withdrawFromReview, cancel: 'Cancel' },
+        labels: {
+            confirm: thenGetLatest ? WITHDRAW_AND_GET_LATEST : EDITOR_ACTIONS.withdrawFromReview,
+            cancel: 'Cancel',
+        },
         confirmProps: { color: 'orange', 'data-testid': 'confirm-withdraw-branch' },
         ...confirmModalHandlers(onConfirm, onDismiss),
         ...focusReturnProps(returnFocusTo),
@@ -609,8 +620,9 @@ export function useBranchManager(options) {
             notifications.show({
                 id,
                 message: details.note ? (_jsx(NoteNotSavedMessage, { message: message, note: details.note, hint: "Copy it to keep it." })) : (message),
-                color: 'red',
-                ...(details.note ? { autoClose: false } : {}),
+                // A 409, such as open conflicts, loses nothing and says what to do: yellow, until read.
+                color: err.status === 409 ? 'yellow' : 'red',
+                ...(details.note || err.status === 409 ? { autoClose: false, withCloseButton: true } : {}),
             });
             await loadBranches();
             return;
@@ -719,6 +731,12 @@ export function useBranchManager(options) {
     const handleWithdraw = (requested, returnFocusTo) => {
         const branchNameToWithdraw = listedName(requested);
         return singleFlight('withdraw', branchNameToWithdraw, () => new Promise((resolve, reject) => {
+            // The conflict that held it in review is what the latest changes settle.
+            const requestLatest = clientOperatingStrategy(options.operatingMode).syncsBranchesWithBase() &&
+                listedBranch(branchNameToWithdraw)?.hold?.kind === 'conflicts'
+                ? options.latestChangesAfterWithdraw?.(branchNameToWithdraw)
+                : undefined;
+            const thenGetLatest = !!requestLatest;
             showWithdrawConfirmation(shownName(branchNameToWithdraw), pullRequestOf(branchNameToWithdraw), async () => {
                 options.setBusy(true);
                 try {
@@ -731,6 +749,9 @@ export function useBranchManager(options) {
                     updateCreatedBranch(branchNameToWithdraw, result.data?.branch);
                     await loadBranches();
                     resolve();
+                    // Reports its own outcome, so a failure here never reads as a failed withdraw.
+                    if (requestLatest)
+                        void requestLatest();
                 }
                 catch (err) {
                     await reportActionFailure(err, 'Failed to withdraw branch', EDITOR_ACTIONS.withdrawFromReview);
@@ -739,7 +760,7 @@ export function useBranchManager(options) {
                 finally {
                     options.setBusy(false);
                 }
-            }, () => resolve(), returnFocusTo);
+            }, () => resolve(), returnFocusTo, thenGetLatest);
         }));
     };
     const handleArchive = (requested) => {

package/dist/editor/hooks/useBranchesData.js

@@ -15,6 +15,7 @@
 import useSWR, { useSWRConfig } from 'swr';
 import { isNonApiResponse } from '../../api/client.js';
 import { seedUserProfiles } from './useUserMetadata.js';
+import { noteServerTime } from '../server-clock.js';
 /** Cache key for the branches list. */
 export const BRANCHES_KEY = 'canopy:branches';
 /**
@@ -33,6 +34,8 @@ export async function fetchBranches(apiClient, swr) {
     if (!result.ok) {
         throw new Error(result.error ?? `Failed to load branches: ${result.status}`);
     }
+    if (result.data?.serverTime !== undefined)
+        noteServerTime(result.data.serverTime);
     const users = result.data?.users ?? [];
     await seedUserProfiles(swr, users);
     return {

package/dist/editor/hooks/useConflictChoices.d.ts

@@ -0,0 +1,24 @@
+import type { ResolvedFieldConflict } from '../../merge-conflicts.js';
+import type { EntryChoices, FieldChoice } from '../conflict-choices.js';
+export interface UseConflictChoicesReturn {
+    /** The open branch's choices for an entry, by conflict key. */
+    choicesFor: (contentId: string) => EntryChoices;
+    /** Records a choice, or clears it with undefined. */
+    choose: (contentId: string, key: string, mergeSha: string, choice: FieldChoice | undefined, decided: boolean) => void;
+    /** Entries with a decided choice no save has sent. */
+    pendingIds: ReadonlySet<string>;
+    /** What a save of an entry on `branch` resolves; nothing for another branch. */
+    pending: (branch: string, contentId: string) => ResolvedFieldConflict[];
+    /** Drops the choices a save sent: resolved, or no longer open. */
+    sent: (branch: string, contentId: string, resolved: readonly ResolvedFieldConflict[]) => void;
+    /** Drops an entry's choices, or every entry's when `contentId` is undefined. */
+    clear: (contentId?: string) => void;
+    /** Keeps only the choices of the entries `open` names, which have conflicts open. */
+    keepEntries: (open: ReadonlySet<string>) => void;
+    /** Keeps only an entry's choices for the conflicts `open` names, each on its merge. */
+    retain: (contentId: string, open: ReadonlyArray<{
+        key: string;
+        mergeSha: string;
+    }>) => void;
+}
+export declare function useConflictChoices(branch: string): UseConflictChoicesReturn;

package/dist/editor/hooks/useConflictChoices.js

@@ -0,0 +1,75 @@
+'use client';
+/**
+ * The choices made on conflict cards that no save has sent yet, per entry of the open branch
+ * (conflict-choices.ts). A decided choice makes its entry count as unsaved, so a save writes it,
+ * and that save sends the conflict's key in `resolvedConflicts`. Choices belong to the branch they
+ * were made on, and go with a discard of the entry's drafts.
+ */
+import { useCallback, useMemo, useRef, useState } from 'react';
+const NONE = {};
+export function useConflictChoices(branch) {
+    const [state, setState] = useState({
+        branch,
+        choices: {},
+    });
+    const choices = state.branch === branch ? state.choices : {};
+    const latest = useRef({ branch, choices });
+    latest.current = { branch, choices };
+    // Choices are held for the open branch only: one made after a switch starts its branch afresh,
+    // and a late answer about another branch leaves them alone.
+    const update = useCallback((forBranch, change, starts = false) => setState((prev) => {
+        if (prev.branch !== forBranch) {
+            return starts ? { branch: forBranch, choices: change({}) } : prev;
+        }
+        const next = change(prev.choices);
+        return next === prev.choices ? prev : { branch: forBranch, choices: next };
+    }), []);
+    const choose = useCallback((contentId, key, mergeSha, choice, decided) => update(latest.current.branch, (current) => {
+        const { [key]: _old, ...rest } = current[contentId] ?? {};
+        const entry = choice ? { ...rest, [key]: { mergeSha, choice, decided } } : rest;
+        const { [contentId]: _entry, ...others } = current;
+        return Object.keys(entry).length > 0 ? { ...others, [contentId]: entry } : others;
+    }, true), [update]);
+    const pendingIds = useMemo(() => new Set(Object.entries(choices)
+        .filter(([, entry]) => Object.values(entry).some((c) => c.decided))
+        .map(([id]) => id)), [choices]);
+    const pending = useCallback((forBranch, contentId) => {
+        if (forBranch !== latest.current.branch)
+            return [];
+        return Object.entries(latest.current.choices[contentId] ?? {})
+            .filter(([, c]) => c.decided)
+            .map(([key, c]) => ({ mergeSha: c.mergeSha, key }));
+    }, []);
+    const sent = useCallback((forBranch, contentId, resolved) => update(forBranch, (current) => {
+        const entry = current[contentId];
+        if (!entry)
+            return current;
+        const left = Object.fromEntries(Object.entries(entry).filter(([key, c]) => !resolved.some((r) => r.key === key && r.mergeSha === c.mergeSha)));
+        const { [contentId]: _sent, ...others } = current;
+        return Object.keys(left).length > 0 ? { ...others, [contentId]: left } : others;
+    }), [update]);
+    const clear = useCallback((contentId) => update(latest.current.branch, (current) => {
+        if (contentId === undefined)
+            return Object.keys(current).length > 0 ? {} : current;
+        if (!(contentId in current))
+            return current;
+        const { [contentId]: _cleared, ...others } = current;
+        return others;
+    }), [update]);
+    const retain = useCallback((contentId, open) => update(latest.current.branch, (current) => {
+        const entry = current[contentId];
+        if (!entry)
+            return current;
+        const kept = Object.entries(entry).filter(([key, c]) => open.some((o) => o.key === key && o.mergeSha === c.mergeSha));
+        if (kept.length === Object.keys(entry).length)
+            return current;
+        const { [contentId]: _stale, ...others } = current;
+        return kept.length > 0 ? { ...others, [contentId]: Object.fromEntries(kept) } : others;
+    }), [update]);
+    const keepEntries = useCallback((open) => update(latest.current.branch, (current) => {
+        const kept = Object.entries(current).filter(([id]) => open.has(id));
+        return kept.length === Object.keys(current).length ? current : Object.fromEntries(kept);
+    }), [update]);
+    const choicesFor = useCallback((contentId) => choices[contentId] ?? NONE, [choices]);
+    return { choicesFor, choose, pendingIds, pending, sent, clear, retain, keepEntries };
+}

package/dist/editor/hooks/useConflictsData.d.ts

@@ -0,0 +1,26 @@
+import type { ApiClient } from '../context/index.js';
+import type { EntryConflictData, MergeConflictsData } from '../../api/merge-conflicts.js';
+export interface EntryConflictTarget {
+    logicalPath: string;
+    /** The entry's content id, which tells it from a collection at the same path. */
+    id?: string;
+}
+export interface ConflictsState<T> {
+    data: T | undefined;
+    /** Why the last read failed, in the server's words where it gave some. */
+    error: string | undefined;
+    isValidating: boolean;
+    reload: () => Promise<void>;
+}
+/**
+ * The branch's open conflicts, read while its listing names any (`conflictFiles`); undefined
+ * otherwise, which means none.
+ */
+export declare function useBranchConflictsData(apiClient: Pick<ApiClient, 'conflicts'>, branch: string, conflictFiles: readonly string[] | undefined, 
+/** Read even with no entry named, as the editor does to learn of a hold on the branch. */
+always?: boolean): ConflictsState<MergeConflictsData>;
+/**
+ * One entry's conflicts, read while `target` is set (its drawer is open): null when it has none,
+ * which the API answers with a 404.
+ */
+export declare function useEntryConflictData(apiClient: Pick<ApiClient, 'conflicts'>, branch: string, target: EntryConflictTarget | undefined): ConflictsState<EntryConflictData | null>;

package/dist/editor/hooks/useConflictsData.js

@@ -0,0 +1,89 @@
+'use client';
+/**
+ * SWR-backed reads of the conflicts a merge left on a branch (api/merge-conflicts.ts): the list,
+ * for Submit's reason, the bar's badge and an entry's notice, and one entry's conflicts for its
+ * "Show changes" drawer. A null key fetches nothing.
+ */
+import { useCallback, useEffect, useRef } from 'react';
+import useSWR, { useSWRConfig } from 'swr';
+const KEY_PREFIX = 'canopy:conflicts:';
+/**
+ * The list's key, one per branch, so a re-read keeps the last answer showing until it lands: a
+ * branch's hold must not blink off while its list is read again.
+ */
+const listKey = (branch) => `${KEY_PREFIX}${branch}|`;
+/** An entry's key, under its branch's prefix and a `:`, which no branch name holds. */
+const entryKey = (branch, target) => `${KEY_PREFIX}${branch}:${target.logicalPath}${target.id ? `#${target.id}` : ''}`;
+class ConflictsLoadError extends Error {
+}
+/**
+ * The branch's open conflicts, read while its listing names any (`conflictFiles`); undefined
+ * otherwise, which means none.
+ */
+export function useBranchConflictsData(apiClient, branch, conflictFiles, 
+/** Read even with no entry named, as the editor does to learn of a hold on the branch. */
+always = false) {
+    const key = branch && (always || conflictFiles?.length) ? listKey(branch) : null;
+    const swr = useSWR(key, async () => {
+        const result = await apiClient.conflicts.list({ branch });
+        if (result.ok && result.data && Array.isArray(result.data.conflicts))
+            return result.data;
+        throw new ConflictsLoadError(result.error ?? `HTTP ${result.status}`);
+    });
+    const { mutate } = swr;
+    // A listing that changes what is open (`conflictFiles`) reads the list again.
+    const open = (conflictFiles ?? []).join(',');
+    const lastOpen = useRef(open);
+    useEffect(() => {
+        if (lastOpen.current === open)
+            return;
+        lastOpen.current = open;
+        if (key)
+            void mutate();
+    }, [open, key, mutate]);
+    const { mutate: mutateKeys } = useSWRConfig();
+    const reload = useCallback(async () => {
+        const prefix = `${KEY_PREFIX}${branch}`;
+        await Promise.all([
+            mutate(),
+            mutateKeys((k) => typeof k === 'string' && (k.startsWith(`${prefix}:`) || k.startsWith(`${prefix}|`))),
+        ]);
+    }, [mutate, mutateKeys, branch]);
+    return {
+        data: key ? swr.data : undefined,
+        error: key && swr.error instanceof Error ? swr.error.message : undefined,
+        isValidating: swr.isValidating,
+        reload,
+    };
+}
+/**
+ * One entry's conflicts, read while `target` is set (its drawer is open): null when it has none,
+ * which the API answers with a 404.
+ */
+export function useEntryConflictData(apiClient, branch, target) {
+    const key = branch && target ? entryKey(branch, target) : null;
+    const swr = useSWR(key, async () => {
+        if (!target)
+            return null;
+        const result = await apiClient.conflicts.entry({
+            branch,
+            entryPath: target.logicalPath,
+            ...(target.id && { id: target.id }),
+        });
+        if (result.ok && result.data && Array.isArray(result.data.fields))
+            return result.data;
+        if (result.status === 404)
+            return null;
+        throw new ConflictsLoadError(result.error ?? `HTTP ${result.status}`);
+    });
+    const { mutate } = swr;
+    const reload = useCallback(async () => {
+        await mutate();
+    }, [mutate]);
+    return {
+        data: key ? swr.data : undefined,
+        error: key && swr.error instanceof Error ? swr.error.message : undefined,
+        isValidating: swr.isValidating,
+        reload,
+    };
+}

package/dist/editor/hooks/useDraftManager.d.ts

@@ -63,6 +63,11 @@ export interface UseDraftManagerOptions {
     followMovedEntry?: (entry: EditorEntry) => Promise<EditorEntry | undefined>;
     /** Creates a deleted entry again from its draft (useEntryManager's `recreateEntry`). */
     recreateEntry?: (entry: EditorEntry, value: FormValue) => Promise<EditorEntry | undefined>;
+    /**
+     * Entries with a conflict choice a save has yet to send (useConflictChoices.ts): unsaved even
+     * when the choice left the value as it was, such as "Keep your version".
+     */
+    pendingIds?: ReadonlySet<string>;
 }
 /** The unsaved work a branch-level action would leave behind. `labels` names the entries (it may be shorter than `count`). */
 export interface UnsavedSummary {