canopycms 0.12.0 → 0.12.1

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 {

package/dist/editor/hooks/useDraftManager.js

@@ -187,12 +187,19 @@ export function useDraftManager(options) {
     //
     // 3. The comparison is `fast-deep-equal`, so key insertion order of a
     //    rehydrated draft does not make it dirty.
-    const dirtyIds = useMemo(() => Object.keys(drafts).filter((id) => {
-        if (entriesKnown && !entryById.has(id))
-            return false;
-        const baseline = loadedValues[id] ?? verifiedBaselines[id];
-        return baseline === undefined || !equal(drafts[id], baseline);
-    }), [drafts, loadedValues, verifiedBaselines, entriesKnown, entryById]);
+    //
+    // 4. An entry with a conflict choice to send counts, draft or not (`pendingIds`).
+    const pendingIds = options.pendingIds;
+    const dirtyIds = useMemo(() => {
+        const dirty = Object.keys(drafts).filter((id) => {
+            if (entriesKnown && !entryById.has(id))
+                return false;
+            const baseline = loadedValues[id] ?? verifiedBaselines[id];
+            return baseline === undefined || !equal(drafts[id], baseline);
+        });
+        const pending = [...(pendingIds ?? [])].filter((id) => !dirty.includes(id) && (!entriesKnown || entryById.has(id)));
+        return pending.length > 0 ? [...dirty, ...pending] : dirty;
+    }, [drafts, loadedValues, verifiedBaselines, entriesKnown, entryById, pendingIds]);
     const modifiedCount = dirtyIds.length;
     const editedFiles = useMemo(() => dirtyIds
         .map((id) => {
@@ -963,7 +970,10 @@ export function useDraftManager(options) {
      */
     const saveOneOfAll = async (entry, branch) => {
         const id = entry.contentId;
-        const sent = latestRef.current.drafts[id];
+        const sent = latestRef.current.drafts[id] ??
+            (latestOptionsRef.current.pendingIds?.has(id)
+                ? latestRef.current.loadedValues[id]
+                : undefined);
         if (sent === undefined)
             return undefined;
         const onBranch = () => latestOptionsRef.current.branchName === branch;
@@ -1137,7 +1147,9 @@ export function useDraftManager(options) {
             // Discarded, refreshed or saved mid-run, so neither saved nor failed by this run.
             const { drafts: remaining } = latestRef.current;
             const settled = settledDuringRunRef.current;
-            result.failed = result.failed.filter((failure) => failure.contentId in remaining && !settled.has(failure.contentId));
+            const pendingNow = latestOptionsRef.current.pendingIds;
+            result.failed = result.failed.filter((failure) => (failure.contentId in remaining || !!pendingNow?.has(failure.contentId)) &&
+                !settled.has(failure.contentId));
             result.total = result.saved.length + result.failed.length;
             if (result.saved.length > 0)
                 latestOptionsRef.current.onSaved?.();
@@ -1351,6 +1363,8 @@ export function useDraftManager(options) {
         if (!entry)
             return false;
         const id = entry.contentId;
+        if (pendingIds?.has(id))
+            return true;
         if (!drafts[id])
             return false;
         const baseline = loadedValues[id] ?? verifiedBaselines[id];
@@ -1359,6 +1373,8 @@ export function useDraftManager(options) {
     const isSelectedDirty = () => {
         if (!currentId)
             return false;
+        if (pendingIds?.has(currentId))
+            return true;
         if (!drafts[currentId])
             return false;
         return !loadedValues[currentId] || !equal(drafts[currentId], loadedValues[currentId]);

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

@@ -1,3 +1,4 @@
+import type { ResolvedFieldConflict } from '../../merge-conflicts.js';
 import type { ApiErrorCode } from '../../api/types.js';
 import type { EditorEntry, EditorCollection } from '../Editor.js';
 import type { LogicalPath } from '../../paths/types.js';
@@ -62,6 +63,14 @@ export interface UseEntryManagerOptions {
      * refreshes the entries, so what reads the same branch state reloads here.
      */
     onContentRefresh?: (branch: string) => void;
+    /**
+     * The conflicts a save of an entry resolves (useConflictChoices.ts): `pending` names them as the
+     * save sends them, and `onSaved` hears which the save sent and which the server cleared.
+     */
+    conflictResolutions?: {
+        pending: (branch: string, contentId: string) => ResolvedFieldConflict[];
+        onSaved: (branch: string, contentId: string, sent: ResolvedFieldConflict[], cleared: ResolvedFieldConflict[]) => void;
+    };
 }
 export interface UseEntryManagerReturn {
     selectedPath: string;

package/dist/editor/hooks/useEntryManager.js

@@ -339,15 +339,20 @@ export function useEntryManager(options) {
         if (expectedVersion === undefined) {
             throw new SaveApiError(409, "This entry hasn't finished loading, so it can't be saved yet. Reload it and try again (your unsaved edits will be lost).");
         }
+        const resolving = options.conflictResolutions?.pending(requestBranch, entry.contentId) ?? [];
         const writeBody = {
             ...payload,
             expectedVersion,
+            ...(resolving.length > 0 && { resolvedConflicts: resolving }),
         };
         const result = await apiClient.content.write(writeParams, writeBody);
         if (isGatewayFailure(result))
             throw new UnansweredError();
         if (!result.ok)
             throw new SaveApiError(result.status, result.error, result.fieldErrors, result.code);
+        if (resolving.length > 0) {
+            options.conflictResolutions?.onSaved(requestBranch, entry.contentId, resolving, result.data?.resolvedConflicts ?? []);
+        }
         // Update stored version token from write response
         if (typeof result.data?.version === 'number') {
             entryVersionsRef.current.set(versionKey(requestBranch, entry.contentId), result.data.version);

package/dist/editor/release-hold.d.ts

@@ -0,0 +1,12 @@
+/**
+ * An admin's release of a branch held as its record of conflicts was set aside
+ * (api/merge-conflicts.ts `releaseHold`). An unanswered request is settled by reading the record
+ * again, as the release may have landed.
+ */
+import type { ApiClient } from './context/index.js';
+import type { ReleaseOutcome } from './components/ReleaseHoldButton.js';
+/** A release's outcome, and on release whether it found the branch held, when that is known. */
+export type ReleaseResult = ReleaseOutcome & {
+    wasHeld?: boolean;
+};
+export declare function releaseConflictsHold(apiClient: Pick<ApiClient, 'conflicts'>, branch: string): Promise<ReleaseResult>;

package/dist/editor/release-hold.js

@@ -0,0 +1,39 @@
+/**
+ * An admin's release of a branch held as its record of conflicts was set aside
+ * (api/merge-conflicts.ts `releaseHold`). An unanswered request is settled by reading the record
+ * again, as the release may have landed.
+ */
+import { isGatewayFailure, isUnanswered } from './unanswered.js';
+import { getErrorMessage } from '../utils/error.js';
+const UNKNOWN = {
+    error: "The release may have gone through even though the server didn't answer. Reload the page to see whether the branch is still on hold.",
+    tone: 'warning',
+};
+const STILL_HELD = {
+    error: "The server didn't answer, and the branch is still on hold. Try again in a moment.",
+    tone: 'warning',
+};
+export async function releaseConflictsHold(apiClient, branch) {
+    const settle = async () => {
+        const now = await apiClient.conflicts.list({ branch }).catch(() => undefined);
+        if (!now?.ok || !now.data)
+            return UNKNOWN;
+        // Not held now, but this read can't say whose release that was.
+        return now.data.held ? STILL_HELD : { released: true };
+    };
+    let result;
+    try {
+        result = await apiClient.conflicts.releaseHold({ branch });
+    }
+    catch (err) {
+        return isUnanswered(err) ? settle() : { error: getErrorMessage(err), tone: 'error' };
+    }
+    if (result.ok)
+        return { released: true, wasHeld: result.data?.released !== false };
+    if (isGatewayFailure(result))
+        return settle();
+    return {
+        error: result.error ?? "Couldn't release the hold. Try again in a moment.",
+        tone: result.status === 409 ? 'warning' : 'error',
+    };
+}

package/dist/editor/server-clock.d.ts

@@ -0,0 +1,4 @@
+/** Record a time the server reported, as of when its answer arrived. */
+export declare function noteServerTime(serverTime: number, receivedAt?: number): void;
+/** Now, by the server's clock as last heard; the browser's until then. */
+export declare function serverNow(): number;

package/dist/editor/server-clock.js

@@ -0,0 +1,15 @@
+/**
+ * The server's clock as the editor last heard it, so a wait timed against a server timestamp
+ * (base-update-wait.ts) doesn't depend on the browser's clock being right. One offset per page:
+ * the editor talks to one server.
+ */
+let offsetMs = 0;
+/** Record a time the server reported, as of when its answer arrived. */
+export function noteServerTime(serverTime, receivedAt = Date.now()) {
+    if (Number.isFinite(serverTime))
+        offsetMs = serverTime - receivedAt;
+}
+/** Now, by the server's clock as last heard; the browser's until then. */
+export function serverNow() {
+    return Date.now() + offsetMs;
+}

package/dist/editor/undo-change.d.ts

@@ -14,6 +14,13 @@ type FormValue = Record<string, unknown>;
 export declare const formValueOfSide: (side: EntryChangeSide) => FormValue;
 /** A form value as a side shaped like `like`, for comparing it with the base. */
 export declare const sideOfFormValue: (value: FormValue, like: EntryChangeSide) => EntryChangeSide;
+/**
+ * `value` with `next` at a change's place, records on the way made as needed; undefined when the
+ * place is inside an item `value` no longer has.
+ */
+export declare const withValueAt: (value: FormValue, change: Pick<EntryChange, "dataPath">, next: unknown, bodyField?: string) => FormValue | undefined;
+/** What `value` holds at a change's place; undefined where it has nothing there. */
+export declare const valueAtChange: (value: FormValue, change: Pick<EntryChange, "dataPath">, bodyField?: string) => unknown;
 /**
  * Whether `value` holds `change` as `side` has it, so setting the change to `side` would change
  * nothing: a moved item placed as `side` places it, anything else the same value at the change's

package/dist/editor/undo-change.js

@@ -41,6 +41,16 @@ const step = (value, segment) => {
     return isPlainRecord(value) ? (isPlainRecord(value.value) ? value.value : value) : undefined;
 };
 const valueAt = (value, path) => path.reduce(step, value);
+/**
+ * `value` with `next` at a change's place, records on the way made as needed; undefined when the
+ * place is inside an item `value` no longer has.
+ */
+export const withValueAt = (value, change, next, bodyField) => {
+    const placed = updateAt(value, formPath(change, bodyField), () => next);
+    return placed && isPlainRecord(placed.value) ? placed.value : undefined;
+};
+/** What `value` holds at a change's place; undefined where it has nothing there. */
+export const valueAtChange = (value, change, bodyField) => valueAt(value, formPath(change, bodyField));
 /** What a `replace` returns when the change has nothing to act on, so it can't be placed. */
 const NOT_PLACED = Symbol('not-placed');
 /**
@@ -91,17 +101,22 @@ const updateAt = (value, path, replace) => {
 };
 /**
  * `item` placed in `list` (which lacks it) where `order` has it: after the nearest item before it
- * in `order` that `list` holds, else first.
+ * in `order` that `list` holds, else before the nearest one after it, else at its place in `order`.
  */
 const placeLike = (list, item, key, order) => {
     const at = indexOfKey(order, key);
+    const indexIn = (other) => isPlainRecord(other) ? indexOfKey(list, other[ITEM_KEY]) : -1;
     for (let i = at - 1; i >= 0; i--) {
-        const before = order[i];
-        const index = isPlainRecord(before) ? indexOfKey(list, before[ITEM_KEY]) : -1;
+        const index = indexIn(order[i]);
         if (index >= 0)
             return [...list.slice(0, index + 1), item, ...list.slice(index + 1)];
     }
-    return [item, ...list];
+    for (let i = at + 1; at > 0 && i < order.length; i++) {
+        const index = indexIn(order[i]);
+        if (index >= 0)
+            return [...list.slice(0, index), item, ...list.slice(index)];
+    }
+    return at > 0 ? [...list.slice(0, at), item, ...list.slice(at)] : [item, ...list];
 };
 const isNothing = (value) => value === undefined || isEmptyContainer(value);
 /**

package/dist/git-manager.d.ts

@@ -560,6 +560,11 @@ export declare class GitManager {
      * path. Any other failure, such as an unknown `rev`, throws.
      */
     showFile(rev: string, filePath: string): Promise<string | undefined>;
+    /**
+     * The text of the blob `sha`, `'too-large'` when it is over `maxBytes`, or `undefined` when this
+     * clone has no such blob. Any other failure throws.
+     */
+    readBlob(sha: string, maxBytes: number): Promise<string | 'too-large' | undefined>;
     ensureAuthor(author: {
         name: string;
         email: string;