canopycms 0.1.0-int.115 → 0.1.0

package/dist/editor/hooks/useDraftManager.js

@@ -11,10 +11,12 @@ import { ENTRY_CHANGED_MESSAGE } from '../../api/entries-constants.js';
 import { isUnanswered } from '../unanswered.js';
 import { withItemKeys } from '../../item-keys.js';
 import { RetryToastMessage } from '../components/RetryToastMessage.js';
+import { clearSaveAllResult, settleSaveAllEntry } from '../components/SaveAllResult.js';
+import { classifySaveAllError, invalidReason, SAVE_ALL_REASONS, } from './save-all.js';
 /** @internal Exported for tests. */
 export const SAVE_TIMED_OUT_MESSAGE = "Save didn't finish, and may not have gone through. Your changes are still here, so save again.";
 /** @internal Exported for tests. Shown when a save may already have landed, until a reload. */
-export const SAVE_MAY_HAVE_LANDED_MESSAGE = 'Your last save may already have gone through. Before saving again, choose "Reload entry" in the menu under the entry\'s name; your unsaved edits will be lost.';
+export const SAVE_MAY_HAVE_LANDED_MESSAGE = 'Your last save may already have gone through. Before saving again, choose "Refresh from server" in the entry\'s menu, on its name; your unsaved edits will be lost.';
 const saveMayHaveLandedToastId = (contentId) => `canopy-save-may-have-landed:${contentId}`;
 const saveTimedOutToastId = (contentId) => `canopy-save-timed-out:${contentId}`;
 /** @internal Exported for tests. A save refused because the entry was deleted. */
@@ -117,7 +119,20 @@ export function useDraftManager(options) {
     //             the behavior before base versions existed.
     const draftBaseVersionsRef = useRef({});
     const [draftStorageFailed, setDraftStorageFailed] = useState(false);
+    const [lastSaved, setLastSaved] = useState(null);
+    const [singleSaving, setSingleSaving] = useState(null);
     const [saveInFlight, setSaveInFlight] = useState(false);
+    const [saveAllProgress, setSaveAllProgress] = useState(null);
+    const saveAllRunningRef = useRef(false);
+    const mountedRef = useRef(true);
+    // Entries a Save, refresh or discard settled while Save all ran: its result no longer applies.
+    const settledDuringRunRef = useRef(new Set());
+    const settleEntry = (id) => {
+        if (saveAllRunningRef.current)
+            settledDuringRunRef.current.add(id);
+        settleSaveAllEntry(id);
+    };
+    const singleSaveRef = useRef(false);
     // contentId -> the token held when a save came back WRITE_OUTCOME_UNKNOWN, or when the retry of
     // a timed-out save was refused as a version conflict. That save may have landed, so re-sending
     // the token would bounce off the user's own write; held until re-read.
@@ -142,6 +157,8 @@ export function useDraftManager(options) {
     const storageKey = useMemo(() => `canopycms:drafts:${options.branchName}`, [options.branchName]);
     // Draft keys are now content IDs, not paths
     const currentId = options.currentEntry?.contentId;
+    const currentIdRef = useRef(currentId);
+    currentIdRef.current = currentId;
     const selectedValue = currentId ? drafts[currentId] : undefined;
     const loadedValue = currentId ? loadedValues[currentId] : undefined;
     const effectiveValue = selectedValue ?? loadedValue;
@@ -199,13 +216,23 @@ export function useDraftManager(options) {
         options.readEntryValue,
     ]);
     // Async callbacks outlive the render that created them; these give them current values.
-    const latestRef = useRef({ drafts, loadedValues, unresolvedCount: 0, modifiedCount, editedFiles });
+    const latestRef = useRef({
+        drafts,
+        loadedValues,
+        unresolvedCount: 0,
+        modifiedCount,
+        editedFiles,
+        dirtyIds,
+        entryById,
+    });
     latestRef.current = {
         drafts,
         loadedValues,
         unresolvedCount: unresolvedIds.length,
         modifiedCount,
         editedFiles,
+        dirtyIds,
+        entryById,
     };
     const latestOptionsRef = useRef(options);
     latestOptionsRef.current = options;
@@ -234,10 +261,20 @@ export function useDraftManager(options) {
             for (const id of goneEntriesRef.current)
                 notifications.hide(entryGoneToastId(id));
             goneEntriesRef.current.clear();
+            // Its entries, and their "Open" and "Save as new entry" buttons, are the old branch's.
+            clearSaveAllResult();
             reconciledDraftIdsRef.current = new Set();
         }
         prevBranchRef.current = options.branchName;
     }, [options.branchName]);
+    // A result left up would act through this unmounted instance's callbacks.
+    useEffect(() => {
+        mountedRef.current = true;
+        return () => {
+            mountedRef.current = false;
+            clearSaveAllResult();
+        };
+    }, []);
     // Restore drafts from localStorage on mount or when storageKey changes
     useEffect(() => {
         if (typeof window === 'undefined')
@@ -611,6 +648,8 @@ export function useDraftManager(options) {
                     return equal(latest, value) ? rest : { ...rest, [created.contentId]: latest };
                 });
             }
+            if (created)
+                settleEntry(id);
             notifications.show({
                 message: created ? 'Saved as a new entry' : RECREATED_NOT_LISTED_MESSAGE,
                 color: 'green',
@@ -678,7 +717,7 @@ export function useDraftManager(options) {
             children: 'This draft was saved by an earlier version of the editor, which did not record ' +
                 'which version of the entry it was based on. Saving it will overwrite the copy ' +
                 'currently on the server, including any changes made by someone else since. ' +
-                'Choose "Reload entry" or "Discard changes" in the menu under the entry\'s title ' +
+                'Choose "Refresh from server" or "Discard changes" in the entry\'s menu, on its name, ' +
                 'instead if you would rather not risk that.',
             labels: { confirm: 'Save anyway', cancel: 'Cancel' },
             confirmProps: { color: 'red' },
@@ -691,6 +730,9 @@ export function useDraftManager(options) {
         });
     });
     const handleSave = async () => {
+        // Save all may be sending this entry with the same token; the loser's 409 would be a false conflict.
+        if (saveAllRunningRef.current)
+            return;
         const entry = options.currentEntry;
         const branch = options.branchName;
         if (!entry || !effectiveValue || !currentId)
@@ -704,7 +746,7 @@ export function useDraftManager(options) {
             notifications.hide(saveMayHaveLandedToastId(currentId));
         }
         // Conflict check first: a stale-based draft must not be schema-validated
-        // into a green "Saved" -- and nagging about field errors is noise when the
+        // into a "Saved" -- and nagging about field errors is noise when the
         // save is not going out at all.
         const baseState = draftBaseState();
         if (baseState === 'stale') {
@@ -723,10 +765,11 @@ export function useDraftManager(options) {
         }
         // Client-side pre-save validation (ED-H1): the same pure schema rules the
         // server enforces authoritatively at the write boundary. Blocks the save
-        // and surfaces per-field errors in the form instead of a green "Saved".
+        // and surfaces per-field errors in the form instead of a "Saved".
         const validationErrors = validateEntryFormValue(entry.schema, entry.format, effectiveValue);
         if (validationErrors.length > 0) {
             setErrorState({ entryId: currentId, errors: toFieldErrorMap(validationErrors) });
+            options.onSaveBlocked?.();
             notifications.show({
                 title: 'Cannot save yet',
                 message: `Fix ${validationErrors.length} validation ${validationErrors.length === 1 ? 'issue' : 'issues'} before saving`,
@@ -739,8 +782,12 @@ export function useDraftManager(options) {
         setErrorState(null);
         options.setBusy(true);
         setSaveInFlight(true);
+        setSingleSaving({ branch, contentId: currentId });
+        singleSaveRef.current = true;
         try {
             const saved = await options.saveEntry(entry, effectiveValue);
+            if (latestOptionsRef.current.branchName !== branch)
+                return;
             // Drop the draft now that it has been persisted, rather than
             // overwriting it with `saved`. `effectiveValue` is `drafts[currentId]
             // ?? loadedValues[currentId]`, and `loadedValues[currentId]` is about
@@ -761,16 +808,16 @@ export function useDraftManager(options) {
                 notifications.hide(saveTimedOutToastId(currentId));
             }
             hideEntryGone(currentId);
-            notifications.show({
-                message: 'Saved',
-                color: 'green',
-                autoClose: getNotificationDuration(4000),
-                withCloseButton: true,
-            });
+            settleEntry(currentId);
+            // Said on the Save button, not in a toast.
+            setLastSaved((prev) => ({ branch, contentId: currentId, seq: (prev?.seq ?? 0) + 1 }));
             options.onSaved?.();
         }
         catch (err) {
             console.error(err);
+            // Content ids repeat across branches: none of what follows belongs on the next one.
+            if (latestOptionsRef.current.branchName !== branch)
+                return;
             const isConflict = err instanceof SaveApiError && err.status === 409;
             // 422 = rejected by server-side schema validation or the adopter's
             // validateEntry hook; show its message and map per-field errors (e.g.
@@ -795,6 +842,7 @@ export function useDraftManager(options) {
                 err.fieldErrors &&
                 err.fieldErrors.length > 0) {
                 setErrorState({ entryId: currentId, errors: toFieldErrorMap(err.fieldErrors) });
+                options.onSaveBlocked?.();
             }
             if (isConflict && err.code === ENTRY_GONE_CODE) {
                 // Deleted or renamed since it was read, by someone else or by a delete or rename of this
@@ -879,6 +927,221 @@ export function useDraftManager(options) {
             }
         }
         finally {
+            singleSaveRef.current = false;
+            setSingleSaving(null);
+            setSaveInFlight(false);
+            options.setBusy(false);
+        }
+    };
+    /**
+     * A save that got no answer landed if the server now holds exactly what was sent. Only that
+     * answer settles it: a differing value may be the server's normalisation of a save that did
+     * land, so it leaves the token alone and the retry's 409 decides, as for `handleSave`.
+     */
+    const settleUnansweredSave = async (entry, sent) => {
+        const { readEntryValue, loadEntry } = latestOptionsRef.current;
+        try {
+            if (!readEntryValue || !equal(await readEntryValue(entry), sent))
+                return undefined;
+            const loaded = await loadEntry(entry);
+            return equal(loaded, sent) ? loaded : undefined;
+        }
+        catch (err) {
+            console.error(err);
+            return undefined;
+        }
+    };
+    /**
+     * One entry of Save all, through the same checks as `handleSave`: held saves, the draft's base
+     * version, schema validation, then the OCC-checked write. An entry not opened this session has
+     * no token yet, so it is loaded first, which also lets the base check see whether it moved on.
+     * Returns undefined when the draft went away or the branch changed meanwhile.
+     */
+    const saveOneOfAll = async (entry, branch) => {
+        const id = entry.contentId;
+        const sent = latestRef.current.drafts[id];
+        if (sent === undefined)
+            return undefined;
+        const onBranch = () => latestOptionsRef.current.branchName === branch;
+        const fail = (kind, reason, extra) => ({
+            saved: false,
+            failure: { contentId: id, label: entry.label, path: entry.path, kind, reason, ...extra },
+        });
+        const { getEntryVersion, loadEntry, saveEntry } = latestOptionsRef.current;
+        if (entry.unavailable)
+            return fail('blocked', SAVE_ALL_REASONS.unavailable);
+        if (entry.canEdit === false)
+            return fail('blocked', SAVE_ALL_REASONS.noEditAccess);
+        if (id in reloadRequiredRef.current) {
+            if (reloadRequiredRef.current[id] === getEntryVersion?.(id)) {
+                return fail('unanswered', SAVE_ALL_REASONS.earlierUnanswered);
+            }
+            delete reloadRequiredRef.current[id];
+            notifications.hide(saveMayHaveLandedToastId(id));
+        }
+        if (getEntryVersion?.(id) === undefined) {
+            try {
+                await loadEntry(entry);
+            }
+            catch (err) {
+                console.error(err);
+                return fail('error', SAVE_ALL_REASONS.loadFailed);
+            }
+            if (!onBranch())
+                return undefined;
+        }
+        const base = draftBaseVersionsRef.current[id];
+        if (base === null)
+            return fail('conflict', SAVE_ALL_REASONS.unknownBase);
+        if (base !== undefined && base !== getEntryVersion?.(id)) {
+            return fail('conflict', SAVE_ALL_REASONS.staleBase);
+        }
+        const validationErrors = validateEntryFormValue(entry.schema, entry.format, sent);
+        if (validationErrors.length > 0) {
+            if (id === currentIdRef.current) {
+                setErrorState({ entryId: id, errors: toFieldErrorMap(validationErrors) });
+                latestOptionsRef.current.onSaveBlocked?.();
+            }
+            return fail('invalid', invalidReason(validationErrors.length));
+        }
+        const commitSaved = (saved) => {
+            // Decided from `prev`, which holds an edit queued but not yet rendered.
+            setDrafts((prev) => {
+                if (!(id in prev))
+                    return prev;
+                if (!equal(prev[id], sent)) {
+                    // Edits typed while the save was out stay a draft, based on the version just written; a
+                    // new object, so that base is persisted. Idempotent, as a strict-mode rerun requires.
+                    const version = latestOptionsRef.current.getEntryVersion?.(id);
+                    if (version !== undefined)
+                        draftBaseVersionsRef.current[id] = version;
+                    return { ...prev };
+                }
+                const next = { ...prev };
+                delete next[id];
+                return next;
+            });
+            setLoadedValues((prev) => ({ ...prev, [id]: saved }));
+            if (timedOutSavesRef.current.delete(id))
+                notifications.hide(saveTimedOutToastId(id));
+            hideEntryGone(id);
+        };
+        try {
+            const saved = await saveEntry(entry, sent);
+            // Another branch's state now: its loaded values and draft bases are not this write's.
+            if (!onBranch())
+                return undefined;
+            commitSaved(saved);
+            return { saved: true };
+        }
+        catch (err) {
+            console.error(err);
+            if (!onBranch())
+                return undefined;
+            const outcome = classifySaveAllError(err, timedOutSavesRef.current.has(id));
+            switch (outcome.kind) {
+                case 'unanswered': {
+                    const landed = await settleUnansweredSave(entry, sent);
+                    if (!onBranch())
+                        return undefined;
+                    if (landed) {
+                        commitSaved(landed);
+                        return { saved: true };
+                    }
+                    timedOutSavesRef.current.add(id);
+                    return fail('unanswered', SAVE_ALL_REASONS.unanswered);
+                }
+                case 'landed?':
+                    reloadRequiredRef.current[id] = getEntryVersion?.(id);
+                    timedOutSavesRef.current.delete(id);
+                    notifications.hide(saveTimedOutToastId(id));
+                    return fail('unanswered', SAVE_ALL_REASONS.earlierUnanswered);
+                case 'gone': {
+                    if (timedOutSavesRef.current.delete(id))
+                        notifications.hide(saveTimedOutToastId(id));
+                    let moved;
+                    try {
+                        moved = await latestOptionsRef.current.followMovedEntry?.(entry);
+                    }
+                    catch (followErr) {
+                        console.error(followErr);
+                        return fail('conflict', SAVE_ALL_REASONS.goneUnchecked);
+                    }
+                    // "Open" in the result goes to where the changes moved.
+                    if (moved)
+                        return fail('conflict', SAVE_ALL_REASONS.renamed, { path: moved.path });
+                    return fail('conflict', SAVE_ALL_REASONS.deleted, {
+                        recreate: () => void recreateGoneEntry(entry, branch),
+                    });
+                }
+                default:
+                    if (outcome.kind === 'invalid' && id === currentIdRef.current) {
+                        const fieldErrors = err instanceof SaveApiError ? err.fieldErrors : undefined;
+                        if (fieldErrors?.length) {
+                            setErrorState({ entryId: id, errors: toFieldErrorMap(fieldErrors) });
+                            latestOptionsRef.current.onSaveBlocked?.();
+                        }
+                    }
+                    return fail(outcome.kind, outcome.reason, outcome.retryable ? { retryable: true } : undefined);
+            }
+        }
+    };
+    const handleSaveAll = async () => {
+        // A Save in flight would race this run's write of the same entry, with the same token.
+        if (saveAllRunningRef.current || singleSaveRef.current)
+            return undefined;
+        saveAllRunningRef.current = true;
+        settledDuringRunRef.current = new Set();
+        const branch = options.branchName;
+        // Busy from the first moment, so Save waits through the draft check too.
+        options.setBusy(true);
+        setSaveInFlight(true);
+        setSaveAllProgress({ done: 0, total: latestRef.current.modifiedCount });
+        try {
+            // A restored draft identical to the server is not a change, so it isn't saved.
+            await whenDraftsVerified();
+            if (latestOptionsRef.current.branchName !== branch)
+                return undefined;
+            const { dirtyIds: ids, entryById: byId } = latestRef.current;
+            const current = currentIdRef.current;
+            const queue = [...ids]
+                .sort((a, b) => Number(b === current) - Number(a === current))
+                .flatMap((id) => {
+                const entry = byId.get(id);
+                return entry ? [entry] : [];
+            });
+            const result = { branch, total: queue.length, saved: [], failed: [] };
+            if (queue.length === 0)
+                return result;
+            clearSaveAllResult();
+            setSaveAllProgress({ done: 0, total: queue.length });
+            for (const [index, entry] of queue.entries()) {
+                if (latestOptionsRef.current.branchName !== branch || !mountedRef.current)
+                    return undefined;
+                const outcome = await saveOneOfAll(entry, branch);
+                if (outcome?.saved) {
+                    result.saved.push({ contentId: entry.contentId, label: entry.label, path: entry.path });
+                }
+                else if (outcome) {
+                    result.failed.push(outcome.failure);
+                }
+                setSaveAllProgress({ done: index + 1, total: queue.length });
+            }
+            // Unmounted: a result would act through this gone instance's callbacks.
+            if (latestOptionsRef.current.branchName !== branch || !mountedRef.current)
+                return undefined;
+            // 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));
+            result.total = result.saved.length + result.failed.length;
+            if (result.saved.length > 0)
+                latestOptionsRef.current.onSaved?.();
+            return result;
+        }
+        finally {
+            saveAllRunningRef.current = false;
+            setSaveAllProgress(null);
             setSaveInFlight(false);
             options.setBusy(false);
         }
@@ -890,6 +1153,11 @@ export function useDraftManager(options) {
         for (const id of goneEntriesRef.current)
             notifications.hide(entryGoneToastId(id));
         goneEntriesRef.current.clear();
+        clearSaveAllResult();
+        if (saveAllRunningRef.current) {
+            for (const id of Object.keys(latestRef.current.drafts))
+                settledDuringRunRef.current.add(id);
+        }
         options.onDraftsReset?.();
         setDrafts({});
         setErrorState(null);
@@ -938,6 +1206,7 @@ export function useDraftManager(options) {
         }
         options.onDraftsReset?.(currentId);
         hideEntryGone(currentId);
+        settleEntry(currentId);
         setErrorState(null);
         setDrafts((prev) => {
             const next = { ...prev };
@@ -989,9 +1258,13 @@ export function useDraftManager(options) {
     const performReload = async () => {
         if (!options.currentEntry || !currentId)
             return;
+        const branch = options.branchName;
         options.setBusy(true);
         try {
             const loaded = await options.loadEntry(options.currentEntry);
+            // Content ids repeat across branches; the next branch's state is not this read's.
+            if (latestOptionsRef.current.branchName !== branch)
+                return;
             options.onDraftsReset?.(currentId);
             delete reloadRequiredRef.current[currentId];
             notifications.hide(saveMayHaveLandedToastId(currentId));
@@ -999,6 +1272,7 @@ export function useDraftManager(options) {
                 notifications.hide(saveTimedOutToastId(currentId));
             }
             hideEntryGone(currentId);
+            settleEntry(currentId);
             setLoadedValues((prev) => ({ ...prev, [currentId]: loaded }));
             // Drop the draft rather than seeding it with `loaded`. `effectiveValue`
             // falls back to `loadedValues`, so the rendered value is identical --
@@ -1013,13 +1287,15 @@ export function useDraftManager(options) {
                 return next;
             });
             notifications.show({
-                message: 'Reloaded',
+                message: 'Refreshed from server',
                 color: 'blue',
                 autoClose: getNotificationDuration(3000),
                 withCloseButton: true,
             });
         }
         catch (err) {
+            if (latestOptionsRef.current.branchName !== branch)
+                return;
             if (err instanceof EntrySchemaUnavailableError) {
                 notifications.show({
                     title: 'Not available yet',
@@ -1032,7 +1308,7 @@ export function useDraftManager(options) {
             }
             console.error(err);
             notifications.show({
-                message: 'Reload failed',
+                message: "Couldn't refresh from the server. Your changes are still here; try again.",
                 color: 'red',
                 autoClose: getNotificationDuration(6000),
                 withCloseButton: true,
@@ -1056,9 +1332,9 @@ export function useDraftManager(options) {
             return;
         }
         openConfirm({
-            title: 'Reload entry',
-            children: 'Reload this entry from the server? Unsaved changes to this entry will be lost.',
-            labels: { confirm: 'Reload', cancel: 'Cancel' },
+            title: 'Refresh from server',
+            children: "Replace this entry with the server's copy? Unsaved changes to this entry will be lost.",
+            labels: { confirm: 'Refresh', cancel: 'Cancel' },
             confirmProps: { color: 'red' },
             onConfirm: () => {
                 void performReload();
@@ -1164,6 +1440,11 @@ export function useDraftManager(options) {
         modifiedCount,
         editedFiles,
         handleSave,
+        singleSaving,
+        lastSaved,
+        handleSaveAll,
+        saveAllProgress,
+        isSaveAllRunning: () => saveAllRunningRef.current,
         handleDiscardDrafts,
         handleDiscardFileDraft,
         handleReload,

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

@@ -1,9 +1,12 @@
-import { type PaneLayout } from '../EditorPanes.js';
-/** @internal Consumed by the preview toolbar, which does not exist yet. */
+import { type PaneArrangement } from '../shell/PaneLayout.js';
+/** @internal The preview toolbar's width choice; see `preview-scale.ts`. */
 export type PreviewWidth = 'fit' | 'desktop' | 'tablet' | 'mobile';
+export declare const CONTENT_PANEL_WIDTH_MIN = 240;
+export declare const CONTENT_PANEL_WIDTH_MAX = 400;
 /** The persisted layout preferences: one JSON object under one storage key. */
 interface EditorLayoutPrefs {
-    layout: PaneLayout;
+    /** Unset until the user picks one, so it follows `defaultLayout`; JSON drops it while unset. */
+    layout?: PaneArrangement;
     highlightEnabled: boolean;
     sideSplitPercent: number;
     stackedSplitPercent: number;
@@ -27,29 +30,30 @@ export declare function parseEditorLayoutPrefs(raw: string | undefined): EditorL
 export interface UseEditorLayoutOptions {
     /** Where the preferences persist; defaults to `editorLayoutStorageKey()`. */
     storageKey?: string;
+    /** The layout until the user picks one; defaults to side by side. */
+    defaultLayout?: PaneArrangement;
 }
 export interface UseEditorLayoutReturn {
-    layout: PaneLayout;
-    setLayout: (layout: PaneLayout) => void;
+    /** The stored preferences have been read; until then every value is its default. */
+    loaded: boolean;
+    layout: PaneArrangement;
+    setLayout: (layout: PaneArrangement) => void;
     highlightEnabled: boolean;
     setHighlightEnabled: (enabled: boolean) => void;
     sideSplitPercent: number;
     stackedSplitPercent: number;
     /** Stores the clamped primary-pane size for one layout; a non-finite percent is ignored. */
-    setSplitPercent: (layout: PaneLayout, percent: number) => void;
+    setSplitPercent: (layout: PaneArrangement, percent: number) => void;
     previewWidth: PreviewWidth;
     setPreviewWidth: (width: PreviewWidth) => void;
     contentPanelOpen: boolean;
     setContentPanelOpen: (open: boolean) => void;
     contentPanelWidth: number;
     setContentPanelWidth: (width: number) => void;
-    headerRef: React.RefObject<HTMLDivElement>;
-    headerHeight: number;
 }
 /**
- * Editor layout: preferences persisted to localStorage (read after mount, so SSR renders the
- * defaults; a throwing storage keeps them in memory) plus the measured, unpersisted header height.
- * `previewWidth` and `contentPanel*` persist ahead of the toolbar and panel that will use them.
+ * Editor layout preferences, persisted to localStorage (read after mount, so SSR renders the
+ * defaults; a throwing storage keeps them in memory).
  */
 export declare function useEditorLayout(options?: UseEditorLayoutOptions): UseEditorLayoutReturn;
 export {};

package/dist/editor/hooks/useEditorLayout.js

@@ -1,17 +1,16 @@
-import { useCallback, useEffect, useRef, useState } from 'react';
-import { useLocalStorage } from '@mantine/hooks';
-import { DEFAULT_SIDE_SPLIT_PERCENT, DEFAULT_STACKED_SPLIT_PERCENT, SPLIT_PERCENT_MAX, SPLIT_PERCENT_MIN, } from '../EditorPanes.js';
+import { useCallback } from 'react';
+import { useLocalStorage, useMounted } from '@mantine/hooks';
+import { DEFAULT_SIDE_SPLIT_PERCENT, DEFAULT_STACKED_SPLIT_PERCENT, SPLIT_PERCENT_MAX, SPLIT_PERCENT_MIN, } from '../shell/PaneLayout.js';
 import { isPlainRecord } from '../../validation/field-traversal.js';
 const PREVIEW_WIDTHS = ['fit', 'desktop', 'tablet', 'mobile'];
 const PANE_LAYOUTS = ['side', 'stacked'];
-const CONTENT_PANEL_WIDTH_MIN = 240;
-const CONTENT_PANEL_WIDTH_MAX = 400;
+export const CONTENT_PANEL_WIDTH_MIN = 240;
+export const CONTENT_PANEL_WIDTH_MAX = 400;
 /**
  * @internal Exported for tests. Module-level so its identity is stable: Mantine memoises its
  * storage reader on the default value.
  */
 export const DEFAULT_EDITOR_LAYOUT_PREFS = {
-    layout: 'side',
     highlightEnabled: false,
     sideSplitPercent: DEFAULT_SIDE_SPLIT_PERCENT,
     stackedSplitPercent: DEFAULT_STACKED_SPLIT_PERCENT,
@@ -46,7 +45,7 @@ export function parseEditorLayoutPrefs(raw) {
     if (!isPlainRecord(parsed))
         return defaults;
     return {
-        layout: oneOf(PANE_LAYOUTS, parsed.layout, defaults.layout),
+        layout: PANE_LAYOUTS.find((layout) => layout === parsed.layout),
         highlightEnabled: boolOr(parsed.highlightEnabled, defaults.highlightEnabled),
         sideSplitPercent: numberOr(parsed.sideSplitPercent, defaults.sideSplitPercent, clampSplitPercent),
         stackedSplitPercent: numberOr(parsed.stackedSplitPercent, defaults.stackedSplitPercent, clampSplitPercent),
@@ -56,9 +55,8 @@ export function parseEditorLayoutPrefs(raw) {
     };
 }
 /**
- * Editor layout: preferences persisted to localStorage (read after mount, so SSR renders the
- * defaults; a throwing storage keeps them in memory) plus the measured, unpersisted header height.
- * `previewWidth` and `contentPanel*` persist ahead of the toolbar and panel that will use them.
+ * Editor layout preferences, persisted to localStorage (read after mount, so SSR renders the
+ * defaults; a throwing storage keeps them in memory).
  */
 export function useEditorLayout(options) {
     const [prefs, setPrefs] = useLocalStorage({
@@ -68,8 +66,9 @@ export function useEditorLayout(options) {
         // Each tab keeps its own layout; a change elsewhere reaches only tabs opened later.
         sync: false,
     });
-    const [headerHeight, setHeaderHeight] = useState(80);
-    const headerRef = useRef(null);
+    // Mounted in the same effect pass as the storage read above, and after it, so the render that
+    // first sees `loaded` also sees the stored values.
+    const loaded = useMounted();
     const setLayout = useCallback((layout) => setPrefs((prev) => ({ ...prev, layout })), [setPrefs]);
     const setHighlightEnabled = useCallback((highlightEnabled) => setPrefs((prev) => ({ ...prev, highlightEnabled })), [setPrefs]);
     const setSplitPercent = useCallback((layout, percent) => {
@@ -88,18 +87,9 @@ export function useEditorLayout(options) {
         const contentPanelWidth = clampContentPanelWidth(width);
         setPrefs((prev) => ({ ...prev, contentPanelWidth }));
     }, [setPrefs]);
-    useEffect(() => {
-        if (!headerRef.current)
-            return;
-        const node = headerRef.current;
-        const updateHeight = () => setHeaderHeight(node.getBoundingClientRect().height || 80);
-        updateHeight();
-        const observer = new ResizeObserver(updateHeight);
-        observer.observe(node);
-        return () => observer.disconnect();
-    }, []);
     return {
-        layout: prefs.layout,
+        loaded,
+        layout: prefs.layout ?? options?.defaultLayout ?? 'side',
         setLayout,
         highlightEnabled: prefs.highlightEnabled,
         setHighlightEnabled,
@@ -112,7 +102,5 @@ export function useEditorLayout(options) {
         setContentPanelOpen,
         contentPanelWidth: prefs.contentPanelWidth,
         setContentPanelWidth,
-        headerRef,
-        headerHeight,
     };
 }

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

@@ -39,6 +39,8 @@ export interface UseEntryManagerOptions {
 export interface UseEntryManagerReturn {
     selectedPath: string;
     setSelectedPath: (path: string) => void;
+    /** Leaves no entry open, as after deleting the open one, instead of opening the first. */
+    closeEntry: () => void;
     entries: EditorEntry[];
     setEntries: (entries: EditorEntry[]) => void;
     collections: EditorCollection[];
@@ -52,6 +54,8 @@ export interface UseEntryManagerReturn {
     availableSchemas: string[];
     /** True while the first entry load for the current branch is in flight (initial load, per branch). */
     entriesInitializing: boolean;
+    /** The branch's last entries fetch failed; its "Could not load content" toast offers Retry. */
+    entriesLoadFailed: boolean;
     navigatorOpen: boolean;
     setNavigatorOpen: (open: boolean) => void;
     refreshEntries: (branch?: string) => Promise<EditorEntry[]>;