canopycms 0.12.0 → 0.13.0

package/dist/editor/components/GetLatestChangesButton.js

@@ -0,0 +1,29 @@
+'use client';
+import { jsx as _jsx, jsxs as _jsxs } from "react/jsx-runtime";
+import { Button, Loader, Tooltip } from '@mantine/core';
+import { IconRefresh } from '@tabler/icons-react';
+import { EDITOR_ACTIONS } from '../copy.js';
+import { GETTING_LATEST_CHANGES, SLOW_NOTICE, WAITING_NOTICE, } from '../base-update-wait.js';
+const TOOLTIP_EVENTS = { hover: true, focus: true, touch: true };
+/** The Tooltip's text: why it waits, why it can't act, or what it does. */
+export function getLatestChangesReason(control) {
+    if (control.requesting || control.wait !== 'none') {
+        return control.wait === 'slow' ? SLOW_NOTICE : WAITING_NOTICE;
+    }
+    return control.blockedReason ?? control.tooltip;
+}
+/**
+ * "Get latest changes", or "Getting latest changes…" with a spinner while the request stands. It
+ * takes the wider label's width either way, so the bar never shifts. It can't act while it works
+ * or while something blocks it, and stays focusable (`aria-disabled`) with its Tooltip saying why.
+ * Only a block dims it: the working label is progress, read at full contrast.
+ */
+export function GetLatestChangesButton({ control, buttonRef, testId = 'get-latest-changes-button', }) {
+    const working = control.requesting || control.wait !== 'none';
+    const blocked = working || !!control.blockedReason;
+    const tooltip = getLatestChangesReason(control);
+    return (_jsx(Tooltip, { label: tooltip, events: TOOLTIP_EVENTS, multiline: true, maw: 320, children: _jsx(Button, { ref: buttonRef, size: "sm", variant: "default", style: { flexShrink: 0 }, leftSection: working ? (_jsx(Loader, { size: 14, "aria-hidden": "true" })) : (_jsx(IconRefresh, { size: 14, "aria-hidden": "true" })), onClick: () => {
+                if (!blocked)
+                    control.onRequest();
+            }, "data-disabled": blocked && !working ? true : undefined, "aria-disabled": blocked ? true : undefined, "data-working": working || undefined, "data-testid": testId, children: _jsxs("span", { style: { display: 'inline-grid' }, children: [_jsx("span", { style: { gridArea: '1 / 1', visibility: working ? 'hidden' : undefined }, children: EDITOR_ACTIONS.getLatestChanges }), _jsx("span", { style: { gridArea: '1 / 1', visibility: working ? undefined : 'hidden' }, children: GETTING_LATEST_CHANGES })] }) }) }));
+}

package/dist/editor/components/ReleaseHoldButton.d.ts

@@ -0,0 +1,20 @@
+/**
+ * What a release came to: released (or already gone), or refused with a message and its tone,
+ * `warning` where nothing is lost yet or the outcome is unknown.
+ */
+export type ReleaseOutcome = {
+    released: true;
+} | {
+    error: string;
+    tone: 'warning' | 'error';
+};
+/**
+ * An admin's way out of a branch held because its conflict record was set aside
+ * (api/merge-conflicts.ts `releaseHold`), behind a confirm that says what is lost. A refusal shows
+ * in the confirm, which stays open; a release closes it.
+ */
+export declare function ReleaseHoldButton({ branchLabel, onRelease, }: {
+    /** The branch as the bar names it, which the confirm names. */
+    branchLabel?: string;
+    onRelease: () => Promise<ReleaseOutcome>;
+}): import("react/jsx-runtime").JSX.Element;

package/dist/editor/components/ReleaseHoldButton.js

@@ -0,0 +1,36 @@
+'use client';
+import { jsx as _jsx, Fragment as _Fragment, jsxs as _jsxs } from "react/jsx-runtime";
+import { useState } from 'react';
+import { Button, Text } from '@mantine/core';
+import { EDITOR_ACTIONS } from '../copy.js';
+import { releaseHoldConsequences } from '../conflict-notice.js';
+import { ConfirmDeleteModal } from './ConfirmDeleteModal.js';
+/**
+ * An admin's way out of a branch held because its conflict record was set aside
+ * (api/merge-conflicts.ts `releaseHold`), behind a confirm that says what is lost. A refusal shows
+ * in the confirm, which stays open; a release closes it.
+ */
+export function ReleaseHoldButton({ branchLabel, onRelease, }) {
+    const [open, setOpen] = useState(false);
+    const [releasing, setReleasing] = useState(false);
+    const [refusal, setRefusal] = useState();
+    return (_jsxs(_Fragment, { children: [_jsx(Button, { size: "compact-sm", variant: "default", style: { flexShrink: 0 }, onClick: () => {
+                    setRefusal(undefined);
+                    setOpen(true);
+                }, "data-testid": "release-hold", children: EDITOR_ACTIONS.releaseHold }), _jsx(ConfirmDeleteModal, { isOpen: open, title: branchLabel ? `Release the hold on "${branchLabel}"?` : "Release this branch's hold?", message: releaseHoldConsequences, confirmLabel: EDITOR_ACTIONS.releaseHold, loading: releasing, onClose: () => setOpen(false), onConfirm: async () => {
+                    setReleasing(true);
+                    setRefusal(undefined);
+                    try {
+                        const outcome = await onRelease();
+                        if ('released' in outcome)
+                            setOpen(false);
+                        else
+                            setRefusal(outcome);
+                    }
+                    finally {
+                        setReleasing(false);
+                    }
+                }, children: refusal && (_jsx(Text, { size: "sm", role: "alert", c: refusal.tone === 'warning'
+                        ? 'var(--mantine-color-yellow-text)'
+                        : 'var(--mantine-color-red-text)', "data-testid": "release-hold-refusal", children: refusal.error })) })] }));
+}

package/dist/editor/components/RetryToastMessage.js

@@ -6,5 +6,5 @@ import { Anchor, Button, Code, Group, Stack, Text } from '@mantine/core';
 export function RetryToastMessage({ message, onRetry, actionLabel = 'Retry', details, }) {
     const [detailsOpen, setDetailsOpen] = useState(false);
     const detailsId = useId();
-    return (_jsxs(Stack, { gap: 4, children: [_jsxs(Group, { justify: "space-between", align: "center", gap: "sm", wrap: "nowrap", children: [_jsx(Text, { size: "sm", miw: 0, children: message }), _jsx(Button, { size: "compact-sm", variant: "subtle", onClick: onRetry, children: actionLabel })] }), details && (_jsxs(_Fragment, { children: [_jsx(Anchor, { component: "button", type: "button", size: "xs", style: { alignSelf: 'flex-start' }, "aria-expanded": detailsOpen, "aria-controls": detailsOpen ? detailsId : undefined, onClick: () => setDetailsOpen((open) => !open), children: "Details" }), detailsOpen && (_jsx(Code, { id: detailsId, block: true, style: { whiteSpace: 'pre-wrap', wordBreak: 'break-word' }, children: details }))] }))] }));
+    return (_jsxs(Stack, { gap: 4, children: [_jsxs(Group, { justify: "space-between", align: "center", gap: "sm", wrap: "nowrap", children: [_jsx(Text, { size: "sm", miw: 0, children: message }), _jsx(Button, { size: "compact-sm", variant: "subtle", onClick: onRetry, style: { flexShrink: 0 }, children: actionLabel })] }), details && (_jsxs(_Fragment, { children: [_jsx(Anchor, { component: "button", type: "button", size: "xs", style: { alignSelf: 'flex-start' }, "aria-expanded": detailsOpen, "aria-controls": detailsOpen ? detailsId : undefined, onClick: () => setDetailsOpen((open) => !open), children: "Details" }), detailsOpen && (_jsx(Code, { id: detailsId, block: true, style: { whiteSpace: 'pre-wrap', wordBreak: 'break-word' }, children: details }))] }))] }));
 }

package/dist/editor/components/change-parts.d.ts

@@ -0,0 +1,51 @@
+/**
+ * How the "Show changes" drawer shows a value and a text change, shared by its change cards and its
+ * conflict cards: marked text, values as the form would show them, and the drawer's reasoned button.
+ */
+import React from 'react';
+import type { DiffPart, DisplayValue, TextDiff } from '../entry-diff.js';
+export declare const TEXT_STYLE: React.CSSProperties;
+export declare const plural: (count: number, one: string, many: string) => string;
+export declare const ordinal: (n: number) => string;
+export type Side = 'before' | 'after';
+/**
+ * One side's text with its runs marked by a strike or an underline and by words, never colour
+ * alone. A line mostly changed says so once, up front, instead of run by run.
+ */
+export declare const MarkedText: React.FC<{
+    parts: readonly DiffPart[];
+    side: Side;
+    unit: 'line' | 'text';
+}>;
+/** A value as the form would show it: titles for references, file names for images. */
+export declare const Value: React.FC<{
+    value: DisplayValue;
+    alt?: {
+        text: TextDiff;
+        side: Side;
+    };
+}>;
+/**
+ * A date in full, in the viewer's time zone: a comparison needs the value, so this is the one
+ * place the editor shows a date absolute first and relative after. A day has no relative form: it
+ * may be a future event, and a past one is not hours ago.
+ */
+export declare const DateValue: React.FC<{
+    value: Extract<DisplayValue, {
+        kind: 'date';
+    }>;
+    text?: React.ReactNode;
+}>;
+/**
+ * A drawer control that, given a `reason`, stays focusable but doesn't act, its Tooltip saying
+ * why (`data-disabled` keeps the Tooltip working on focus and touch).
+ */
+export declare const ReasonedButton: React.FC<{
+    reason?: string;
+    onClick: () => void;
+    children: React.ReactNode;
+    danger?: boolean;
+    loading?: boolean;
+    'aria-label'?: string;
+    'data-testid'?: string;
+}>;

package/dist/editor/components/change-parts.js

@@ -0,0 +1,171 @@
+'use client';
+import { jsx as _jsx, Fragment as _Fragment, jsxs as _jsxs } from "react/jsx-runtime";
+/**
+ * How the "Show changes" drawer shows a value and a text change, shared by its change cards and its
+ * conflict cards: marked text, values as the form would show them, and the drawer's reasoned button.
+ */
+import React, { useEffect, useRef, useState } from 'react';
+import { Button, Group, List, Stack, Text, Tooltip, VisuallyHidden } from '@mantine/core';
+import { IconPhotoOff } from '@tabler/icons-react';
+import { EDITOR_THUMBNAIL_WIDTHS } from '../../assets/editor-thumbnail-widths.js';
+import { useAssetContext } from '../context/index.js';
+import { editorImageSrc } from '../media/editor-image-src.js';
+import { formatRelativeTime } from '../relative-time.js';
+/**
+ * Struck on a tint at least 1.3:1 from the card in either scheme, with text kept at 4.5:1 on it:
+ * `red.2` in light, `red.6` at 30% over the dark card.
+ */
+const REMOVED_STYLE = {
+    background: 'light-dark(var(--mantine-color-red-2), color-mix(in srgb, var(--mantine-color-red-6) 30%, transparent))',
+    color: 'inherit',
+    textDecoration: 'line-through',
+    textDecorationThickness: 2,
+};
+/** Underlined on a tint, measured as REMOVED_STYLE's: `green.3`, or `green.6` at 30%. */
+const ADDED_STYLE = {
+    background: 'light-dark(var(--mantine-color-green-3), color-mix(in srgb, var(--mantine-color-green-6) 30%, transparent))',
+    color: 'inherit',
+    textDecoration: 'underline',
+    textDecorationThickness: 2,
+};
+export const TEXT_STYLE = { whiteSpace: 'pre-wrap', overflowWrap: 'anywhere' };
+/** Long text on one side only is cut to this many lines once it has more than LONG_TEXT_LINES. */
+const COLLAPSED_LINES = 50;
+const LONG_TEXT_LINES = 200;
+/** Above this share of a line's text changed, one prefix names the whole line instead of each run. */
+const WHOLE_LINE_SHARE = 0.6;
+export const plural = (count, one, many) => `${count} ${count === 1 ? one : many}`;
+export const ordinal = (n) => {
+    const tens = n % 100;
+    const suffix = tens >= 11 && tens <= 13 ? 'th' : ({ 1: 'st', 2: 'nd', 3: 'rd' }[n % 10] ?? 'th');
+    return `${n}${suffix}`;
+};
+/**
+ * `side`'s runs of `parts`, a marked run joined to the next of its mark across whitespace alone,
+ * so a screen reader hears one removal, not one per word.
+ */
+const sideRuns = (parts, side) => {
+    const runs = [];
+    for (const part of parts) {
+        if (side === 'before' ? part.added : part.removed)
+            continue;
+        const mark = part.removed ? 'removed' : part.added ? 'added' : undefined;
+        const last = runs[runs.length - 1];
+        const gap = runs[runs.length - 2];
+        if (mark && last && last.mark === mark) {
+            last.value += part.value;
+        }
+        else if (mark && last && !last.mark && /^\s+$/.test(last.value) && gap?.mark === mark) {
+            runs.pop();
+            gap.value += last.value + part.value;
+        }
+        else {
+            runs.push({ value: part.value, ...(mark && { mark }) });
+        }
+    }
+    return runs;
+};
+const WHITESPACE_MARKS = {
+    ' ': { shown: '·', said: 'space' },
+    '\t': { shown: '→', said: 'tab' },
+    '\n': { shown: '⏎', said: 'line break' },
+};
+/** A run's text; whitespace alone shows a mark for each character, said in words. */
+const RunText = ({ value }) => {
+    if (value === '')
+        return _jsx("em", { children: "(blank line)" });
+    if (!/^\s+$/.test(value))
+        return _jsx(_Fragment, { children: value });
+    const chars = [...value];
+    return (_jsxs(_Fragment, { children: [_jsx("span", { "aria-hidden": true, children: chars.map((c) => WHITESPACE_MARKS[c]?.shown ?? c).join('') }), _jsx(VisuallyHidden, { component: "span", children: chars.map((c) => WHITESPACE_MARKS[c]?.said ?? 'space').join(', ') })] }));
+};
+const MARK_WORDS = {
+    removed: { start: 'Removed: ', end: ', end of removal', line: 'Removed line: ' },
+    added: { start: 'Added: ', end: ', end of addition', line: 'Added line: ' },
+};
+/**
+ * One side's text with its runs marked by a strike or an underline and by words, never colour
+ * alone. A line mostly changed says so once, up front, instead of run by run.
+ */
+export const MarkedText = ({ parts, side, unit }) => {
+    const runs = sideRuns(parts, side);
+    const total = runs.reduce((n, run) => n + run.value.length, 0);
+    const marked = runs.reduce((n, run) => n + (run.mark ? run.value.length : 0), 0);
+    const mark = side === 'before' ? 'removed' : 'added';
+    const whole = runs.some((run) => run.mark) && (total === 0 || marked / total > WHOLE_LINE_SHARE);
+    return (_jsxs(_Fragment, { children: [whole && (_jsx(VisuallyHidden, { component: "span", children: unit === 'line' ? MARK_WORDS[mark].line : MARK_WORDS[mark].start })), runs.map((run, i) => {
+                if (!run.mark)
+                    return _jsx(React.Fragment, { children: run.value }, i);
+                const Tag = run.mark === 'removed' ? 'del' : 'ins';
+                const style = run.mark === 'removed' ? REMOVED_STYLE : ADDED_STYLE;
+                // Whitespace alone, or a blank line's label, has nothing for a line to cross.
+                const shown = /^\s*$/.test(run.value) ? { ...style, textDecoration: 'none' } : style;
+                return (_jsxs(Tag, { style: shown, children: [!whole && (_jsx(VisuallyHidden, { component: "span", children: MARK_WORDS[run.mark].start })), _jsx(RunText, { value: run.value }), !whole && _jsx(VisuallyHidden, { component: "span", children: MARK_WORDS[run.mark].end })] }, i));
+            })] }));
+};
+const THUMBNAIL_SIZE = EDITOR_THUMBNAIL_WIDTHS.listRow / 2;
+/** An image's thumbnail beside its name, which says what it is; an icon if it won't load. */
+const Thumbnail = ({ src }) => {
+    const { baseUrl } = useAssetContext();
+    const [failed, setFailed] = useState(false);
+    if (failed) {
+        return (_jsx(IconPhotoOff, { size: THUMBNAIL_SIZE, stroke: 1.5, "aria-hidden": true, style: { flexShrink: 0, color: 'var(--mantine-color-dimmed)' } }));
+    }
+    return (_jsx("img", { src: editorImageSrc(src, baseUrl, { width: EDITOR_THUMBNAIL_WIDTHS.listRow }), alt: "", width: THUMBNAIL_SIZE, height: THUMBNAIL_SIZE, onError: () => setFailed(true), style: { objectFit: 'cover', borderRadius: 4, flexShrink: 0 } }));
+};
+/** Text on one side only; more than LONG_TEXT_LINES lines show COLLAPSED_LINES until asked. */
+const LongText = ({ text }) => {
+    const [expanded, setExpanded] = useState(false);
+    const firstNew = useRef(null);
+    useEffect(() => {
+        if (expanded)
+            firstNew.current?.focus();
+    }, [expanded]);
+    const lines = text.split('\n');
+    const long = lines.length > LONG_TEXT_LINES;
+    const collapsed = !expanded && long;
+    return (_jsxs(Stack, { gap: 4, align: "flex-start", children: [_jsx(Text, { size: "sm", style: TEXT_STYLE, children: !long ? (text) : (_jsxs(_Fragment, { children: [lines.slice(0, COLLAPSED_LINES).join('\n'), expanded && (_jsxs(_Fragment, { children: ['\n', _jsx("span", { ref: firstNew, tabIndex: -1, children: lines.slice(COLLAPSED_LINES).join('\n') })] }))] })) }), collapsed && (_jsxs(Button, { size: "compact-sm", variant: "subtle", onClick: () => setExpanded(true), children: ["Show all ", lines.length, " lines"] }))] }));
+};
+/** A value as the form would show it: titles for references, file names for images. */
+export const Value = ({ value, alt, }) => {
+    switch (value.kind) {
+        case 'empty':
+            return (_jsx(Text, { size: "sm", c: "dimmed", children: "Not set" }));
+        case 'text':
+            return _jsx(LongText, { text: value.text });
+        case 'number':
+            return _jsx(Text, { size: "sm", children: value.value.toLocaleString() });
+        case 'boolean':
+            return _jsx(Text, { size: "sm", children: value.value ? 'Yes' : 'No' });
+        case 'date':
+            return _jsx(DateValue, { value: value });
+        case 'select':
+            return _jsx(Text, { size: "sm", children: value.label });
+        case 'reference':
+            return value.title !== undefined ? (_jsx(Text, { size: "sm", children: value.title })) : (_jsx(Text, { size: "sm", c: "dimmed", children: "Entry unavailable" }));
+        case 'image':
+            return (_jsxs(Group, { gap: "xs", wrap: "nowrap", align: "flex-start", children: [_jsx(Thumbnail, { src: value.src }, value.src), _jsxs(Stack, { gap: 0, miw: 0, children: [_jsx(Text, { size: "sm", style: TEXT_STYLE, children: value.name }), value.alt && (_jsxs(Text, { size: "xs", style: TEXT_STYLE, children: [_jsxs(Text, { span: true, size: "xs", c: "dimmed", children: ["Alt text:", ' '] }), alt?.text.mode === 'words' ? (_jsx(MarkedText, { parts: alt.text.parts, side: alt.side, unit: "text" })) : (value.alt)] }))] })] }));
+        case 'position':
+            return (_jsxs(Text, { size: "sm", children: [ordinal(value.position), " of ", value.of] }));
+        case 'list':
+            return (_jsx(List, { size: "sm", spacing: 4, children: value.items.map((item, i) => (_jsx(List.Item, { children: _jsx(Value, { value: item }) }, i))) }));
+        case 'fields':
+            return (_jsx(Stack, { gap: 6, children: value.fields.map((field, i) => (_jsxs("div", { children: [_jsx(Text, { size: "xs", fw: 500, children: field.label }), _jsx(Value, { value: field.value })] }, i))) }));
+        case 'raw':
+            return (_jsx(Text, { size: "xs", ff: "monospace", style: TEXT_STYLE, children: value.text }));
+    }
+};
+/**
+ * A date in full, in the viewer's time zone: a comparison needs the value, so this is the one
+ * place the editor shows a date absolute first and relative after. A day has no relative form: it
+ * may be a future event, and a past one is not hours ago.
+ */
+export const DateValue = ({ value, text }) => (_jsxs(Stack, { gap: 0, children: [_jsx(Text, { size: "sm", style: TEXT_STYLE, children: text ?? value.text }), !value.dateOnly && (_jsx(Text, { size: "xs", c: "dimmed", children: formatRelativeTime(value.iso) }))] }));
+/**
+ * A drawer control that, given a `reason`, stays focusable but doesn't act, its Tooltip saying
+ * why (`data-disabled` keeps the Tooltip working on focus and touch).
+ */
+export const ReasonedButton = ({ reason, onClick, danger, ...props }) => (_jsx(Tooltip, { label: reason, disabled: !reason, multiline: true, maw: 280, position: "bottom-start", children: _jsx(Button, { size: "compact-sm", variant: "subtle", ...(danger && { color: 'red', c: 'var(--canopy-danger-text)' }), ...props, onClick: () => {
+            if (!reason)
+                onClick();
+        }, "data-disabled": reason ? true : undefined, "aria-disabled": reason ? true : undefined }) }));

package/dist/editor/conflict-cards.d.ts

@@ -0,0 +1,93 @@
+/**
+ * The cards "Show changes" shows for an entry's open conflicts, built from what
+ * `GET /:branch/conflicts/...entryPath` answers (api/merge-conflicts.ts): each place's three
+ * versions as the drawer shows values, and long text split into the regions both sides changed.
+ * Pure. Where a choice lands in the form value is `conflict-choices.ts`.
+ */
+import type { EntryConflictData } from '../api/merge-conflicts.js';
+import type { FieldConfig } from '../config/index.js';
+import type { FieldConflictKind } from '../merge/entry-merge.js';
+import { type TextConflictRegion } from '../merge/text-merge.js';
+import { type DataPathSegment, type DisplayValue, type TextDiff } from './entry-diff.js';
+type FormValue = Record<string, unknown>;
+interface CardBase {
+    /** Unique among the entry's cards: the conflict's key, and a region's number within it. */
+    id: string;
+    /** The record's key, which a save's `resolvedConflicts` sends back. */
+    key: string;
+    mergeSha: string;
+    /** Human labels from the entry down to the place: "Page sections › Hero › Heading". */
+    path: string[];
+}
+/** A value both sides changed: a field, a whole list item, or a value the drawer shows whole. */
+interface ValueConflictCard extends CardBase {
+    type: 'value';
+    conflict: FieldConflictKind;
+    /** A whole list item or block, which the choice keeps or removes. */
+    item: boolean;
+    before: DisplayValue;
+    latest: DisplayValue;
+    yours: DisplayValue;
+    /** Word or line marks from Before to the latest version, and from Before to yours. */
+    latestText?: TextDiff;
+    yoursText?: TextDiff;
+    /** The latest version's value here can't be found ({@link FieldConflict.latestPlaceable}). */
+    latestUnavailable?: true;
+}
+/** Lines of long text both sides changed, one card per region of a field. */
+interface RegionConflictCard extends CardBase {
+    type: 'region';
+    /** 0-based, among the field's regions. */
+    index: number;
+    count: number;
+    before: string;
+    latest: string;
+    yours: string;
+    latestText?: TextDiff;
+    yoursText?: TextDiff;
+}
+/** The entry was moved to different places on each side; the branch's place stands. */
+interface LocationConflictCard extends CardBase {
+    type: 'location';
+}
+export type ConflictCard = ValueConflictCard | RegionConflictCard | LocationConflictCard;
+/** One recorded conflict and what its choices act on. */
+export interface FieldConflict {
+    key: string;
+    mergeSha: string;
+    dataPath: DataPathSegment[];
+    item: boolean;
+    cards: ConflictCard[];
+    /** The latest version as a form value, which "Use latest version" takes from. */
+    latest?: FormValue;
+    /**
+     * The latest version was read and holds every list item on the place's path, other than the item
+     * a removal on its side took out, so its value there can be found and placed. It is keyed as the
+     * merge named the place along the base's own path ({@link alignedTo}), so this fails only where
+     * the record gives no such path, one that runs another way, or one whose merged key another of
+     * its items holds; and where your saved value holds another item at the key of one your version
+     * lacks.
+     */
+    latestPlaceable: boolean;
+    /** Your saved value holds another item at the key of the one your version lacks here. */
+    otherItemHere?: true;
+    /**
+     * Long text found again by region from its three versions: the text the merge left, and its
+     * regions, each holding your lines there. Absent when the text is one whole value.
+     */
+    text?: {
+        merged: string;
+        regions: TextConflictRegion[];
+    };
+}
+export interface EntryConflicts {
+    fields: FieldConflict[];
+    /** Versions the API couldn't show, so a field's cards may show less. */
+    incomplete: boolean;
+}
+/**
+ * The cards for one entry's open field conflicts. `bodyField` is the schema's body field on an
+ * md/mdx entry. Each version the cards compare is diffed once per pair, however many fields share it.
+ */
+export declare function buildEntryConflicts(data: EntryConflictData, fields: readonly FieldConfig[], bodyField: string | undefined, referenceTitle?: (id: string) => string | undefined, saved?: FormValue): EntryConflicts;
+export {};