canopycms 0.1.0-int.115 → 0.1.0

package/dist/editor/copy.d.ts

@@ -5,6 +5,8 @@
  */
 export declare const EDITOR_ACTIONS: {
     readonly save: "Save";
+    readonly saveAll: "Save all";
+    readonly refreshFromServer: "Refresh from server";
     readonly submitForReview: "Submit for review";
     readonly withdrawFromReview: "Withdraw from review";
     readonly requestChanges: "Request changes";
@@ -12,4 +14,5 @@ export declare const EDITOR_ACTIONS: {
     readonly newBranch: "New branch";
     readonly remove: "Remove";
     readonly clear: "Clear";
+    readonly openEntry: "Open entry";
 };

package/dist/editor/copy.js

@@ -5,6 +5,8 @@
  */
 export const EDITOR_ACTIONS = {
     save: 'Save',
+    saveAll: 'Save all',
+    refreshFromServer: 'Refresh from server',
     submitForReview: 'Submit for review',
     withdrawFromReview: 'Withdraw from review',
     requestChanges: 'Request changes',
@@ -12,4 +14,5 @@ export const EDITOR_ACTIONS = {
     newBranch: 'New branch',
     remove: 'Remove',
     clear: 'Clear',
+    openEntry: 'Open entry',
 };

package/dist/editor/editor-utils.d.ts

@@ -69,14 +69,19 @@ export declare const buildCollectionLabels: (collections?: EditorCollection[]) =
 export declare const entryTypeLabel: (collections: EditorCollection[] | undefined, entry: Pick<EditorEntry, "collectionPath" | "entryType">) => string | undefined;
 /** An entry's navigator badge: "Missing" when its file is gone, else its type's label or name. */
 export declare const entryStatusLabel: (collections: EditorCollection[] | undefined, entry: Pick<EditorEntry, "status" | "collectionPath" | "entryType">) => string | undefined;
+/** One crumb before the entry's own: "All content", a collection, or a folder of a nested slug. */
+export interface BreadcrumbSegment {
+    label: string;
+    /** The collection the crumb opens in the content panel; absent on "All content" and slug folders. */
+    collectionPath?: string;
+    /** A slug folder, which is not a node of the content tree, so it navigates nowhere. */
+    folder?: true;
+}
 /**
- * Builds breadcrumb segments for an entry based on its collection hierarchy.
- *
- * @param currentEntry - The entry to build breadcrumbs for (or undefined for root)
- * @param collectionLabels - Map of collection IDs to labels
- * @returns Array of breadcrumb segment strings, starting with 'All content'
+ * Builds breadcrumb segments for an entry based on its collection hierarchy, starting with
+ * "All content". The first path part is skipped as the content root, which the tree does not show.
  */
-export declare const buildBreadcrumbSegments: (currentEntry: EditorEntry | undefined, collectionLabels: Map<string, string>) => string[];
+export declare const buildBreadcrumbSegments: (currentEntry: EditorEntry | undefined, collectionLabels: Map<string, string>) => BreadcrumbSegment[];
 /**
  * Calculates which collection nodes need to be expanded to show the path to a specific entry.
  * Recursively walks the tree to find the target entry and marks all ancestor collections as expanded.

package/dist/editor/editor-utils.js

@@ -204,34 +204,25 @@ export const entryStatusLabel = (collections, entry) => {
     return entryTypeLabel(collections, entry) ?? (entry.status && humanizeName(entry.status));
 };
 /**
- * Builds breadcrumb segments for an entry based on its collection hierarchy.
- *
- * @param currentEntry - The entry to build breadcrumbs for (or undefined for root)
- * @param collectionLabels - Map of collection IDs to labels
- * @returns Array of breadcrumb segment strings, starting with 'All content'
+ * Builds breadcrumb segments for an entry based on its collection hierarchy, starting with
+ * "All content". The first path part is skipped as the content root, which the tree does not show.
  */
 export const buildBreadcrumbSegments = (currentEntry, collectionLabels) => {
+    const segments = [{ label: 'All content' }];
     if (!currentEntry)
-        return ['All content'];
-    const segments = ['All content'];
-    // Show collection hierarchy for entries that belong to a collection
+        return segments;
     if (currentEntry.collectionPath) {
-        // Split the collectionPath into path parts and build cumulative paths
-        // e.g., "content/documentation/guides" -> ["content/documentation", "content/documentation/guides"]
         const parts = currentEntry.collectionPath.split('/').filter(Boolean);
         for (let i = 1; i < parts.length; i++) {
             const pathUpToHere = parts.slice(0, i + 1).join('/');
             const label = collectionLabels.get(pathUpToHere);
-            if (label) {
-                segments.push(label);
-            }
+            if (label)
+                segments.push({ label, collectionPath: pathUpToHere });
         }
     }
-    // Add slug path segments (for nested slugs like "folder/file")
     const slugSegments = (currentEntry.slug ?? '').split('/').filter(Boolean);
-    if (slugSegments.length > 1) {
-        segments.push(...slugSegments.slice(0, -1));
-    }
+    for (const folder of slugSegments.slice(0, -1))
+        segments.push({ label: folder, folder: true });
     return segments;
 };
 /**

package/dist/editor/fields/MarkdownField.js

@@ -157,12 +157,15 @@ const editorWrapperStyle = {
  * rather than scrolling sideways (`toolbar-wrap.ts` hides a separator left at a row's edge).
  * MDXEditor's dark theme leaves its page background white, so editor and popups take tokens; in
  * dark mode its drop shadow vanishes over a subtle panel, so popups take a dropdown's border.
+ * Its popups portal into `<body>` at z-index 2, under the editor shell; they take the layer between
+ * the shell and Mantine's drawers and modals, so a drawer or modal still covers them.
  */
 const EditorContentStyles = () => (_jsx("style", { children: `
     .canopy-mdx-content { min-height: 120px; padding: 8px 12px; }
     .mdxeditor .canopy-mdx-toolbar { flex-wrap: wrap; overflow-x: visible; }
     .mdxeditor { --basePageBg: var(--mantine-color-body); }
     .mdxeditor-popup-container { --basePageBg: var(--canopy-surface-subtle); }
+    body > .mdxeditor-popup-container { z-index: calc(var(--mantine-z-index-modal) - 1); }
     [data-mantine-color-scheme='dark'] .mdxeditor-popup-container :is([data-radix-popper-content-wrapper] > *, [role='dialog']) {
       border: 1px solid var(--mantine-color-default-border);
     }

package/dist/editor/hooks/save-all.d.ts

@@ -0,0 +1,68 @@
+import type { LogicalPath } from '../../paths/types.js';
+/**
+ * Why one entry of a Save all was not saved. `unanswered` and `conflict` lose nothing yet, so
+ * they warn (yellow); the rest are errors (red).
+ */
+export type SaveAllFailureKind = 'unanswered' | 'conflict' | 'invalid' | 'blocked' | 'error';
+export interface SaveAllFailure {
+    contentId: string;
+    label: string;
+    path: LogicalPath;
+    kind: SaveAllFailureKind;
+    /** A full sentence for the result's list, after the entry's name. */
+    reason: string;
+    /** "Save as new entry", for an entry deleted since its edits started. */
+    recreate?: () => void;
+    /** Refused for now only, so the result's "Try again" can pass it. */
+    retryable?: true;
+}
+export interface SaveAllResult {
+    branch: string;
+    /** The entries Save all set out to save. */
+    total: number;
+    saved: Array<{
+        contentId: string;
+        label: string;
+        path: LogicalPath;
+    }>;
+    failed: SaveAllFailure[];
+}
+export interface SaveAllProgress {
+    /** Entries settled so far, saved or not. */
+    done: number;
+    total: number;
+}
+/** One result toast at a time: a new run replaces it, and leaving its branch takes a partly failed one down. */
+export declare const SAVE_ALL_RESULT_TOAST_ID = "canopy-save-all-result";
+export declare const SAVE_ALL_REASONS: {
+    readonly unanswered: "Saving it may have gone through even though the server didn't answer. Open it and choose \"Refresh from server\" to check before saving again.";
+    readonly earlierUnanswered: "An earlier save of it may have gone through even though the server didn't answer. Open it and choose \"Refresh from server\" to check before saving again.";
+    readonly staleBase: "It changed on the server since your edits started, so saving would overwrite someone else's changes. Open it and choose \"Refresh from server\" to see the latest version (your unsaved edits will be lost).";
+    readonly unknownBase: "Its unsaved changes come from an older version of the editor. Open it and save it on its own to confirm the overwrite.";
+    readonly unavailable: "Its entry type isn't available in this version of the site, so it can't be saved.";
+    readonly noEditAccess: "You don't have edit access to it.";
+    readonly forbidden: "You don't have permission to save it. Ask a CanopyCMS admin for access.";
+    readonly loadFailed: "It couldn't be loaded from the server, so it wasn't saved. Try Save all again.";
+    readonly renamed: "It was renamed since your edits started, so it wasn't saved. Your changes moved with it: save again.";
+    readonly deleted: "It was deleted since your edits started, so it wasn't saved. Choose \"Save as new entry\" to keep your changes.";
+    readonly goneUnchecked: "It was deleted or renamed since your edits started, so it wasn't saved, and the editor couldn't check which. Choose \"Refresh branch\" in the branch menu: if it was renamed, your changes moved with it.";
+    readonly failed: "Save failed. Try again.";
+};
+export declare const invalidReason: (count: number) => string;
+/**
+ * Classifies a refused or unanswered save the way `handleSave` does, minus its toasts: Save all
+ * reports every entry in one result. `ENTRY_GONE`, a may-have-landed 409 and an unanswered write
+ * need the caller's follow-up, so they come back as `gone`, `landed?` and `unanswered`.
+ */
+export declare function classifySaveAllError(err: unknown, retryOfUnanswered: boolean): {
+    kind: 'gone';
+} | {
+    kind: 'landed?';
+} | {
+    kind: 'unanswered';
+} | {
+    kind: Exclude<SaveAllFailureKind, 'unanswered'>;
+    reason: string;
+    fieldErrors?: boolean;
+    retryable?: true;
+};

package/dist/editor/hooks/save-all.js

@@ -0,0 +1,61 @@
+import { ENTRY_CHANGED_MESSAGE } from '../../api/entries-constants.js';
+import { SCHEMA_UNAVAILABLE_CODE } from '../unavailable-entry-type.js';
+import { isUnanswered } from '../unanswered.js';
+import { EDITOR_ACTIONS } from '../copy.js';
+import { SaveApiError } from './useEntryManager.js';
+/** One result toast at a time: a new run replaces it, and leaving its branch takes a partly failed one down. */
+export const SAVE_ALL_RESULT_TOAST_ID = 'canopy-save-all-result';
+const ENTRY_GONE_CODE = 'ENTRY_GONE';
+const BRANCH_SYNCING_CODE = 'BRANCH_SYNCING';
+export const SAVE_ALL_REASONS = {
+    unanswered: `Saving it may have gone through even though the server didn't answer. Open it and choose "${EDITOR_ACTIONS.refreshFromServer}" to check before saving again.`,
+    earlierUnanswered: `An earlier save of it may have gone through even though the server didn't answer. Open it and choose "${EDITOR_ACTIONS.refreshFromServer}" to check before saving again.`,
+    staleBase: `It changed on the server since your edits started, so saving would overwrite someone else's changes. Open it and choose "${EDITOR_ACTIONS.refreshFromServer}" to see the latest version (your unsaved edits will be lost).`,
+    unknownBase: 'Its unsaved changes come from an older version of the editor. Open it and save it on its own to confirm the overwrite.',
+    unavailable: "Its entry type isn't available in this version of the site, so it can't be saved.",
+    noEditAccess: "You don't have edit access to it.",
+    forbidden: "You don't have permission to save it. Ask a CanopyCMS admin for access.",
+    loadFailed: "It couldn't be loaded from the server, so it wasn't saved. Try Save all again.",
+    renamed: "It was renamed since your edits started, so it wasn't saved. Your changes moved with it: save again.",
+    deleted: 'It was deleted since your edits started, so it wasn\'t saved. Choose "Save as new entry" to keep your changes.',
+    goneUnchecked: 'It was deleted or renamed since your edits started, so it wasn\'t saved, and the editor couldn\'t check which. Choose "Refresh branch" in the branch menu: if it was renamed, your changes moved with it.',
+    failed: 'Save failed. Try again.',
+};
+export const invalidReason = (count) => `${count} ${count === 1 ? 'field needs' : 'fields need'} fixing. Open it to see which.`;
+/**
+ * Classifies a refused or unanswered save the way `handleSave` does, minus its toasts: Save all
+ * reports every entry in one result. `ENTRY_GONE`, a may-have-landed 409 and an unanswered write
+ * need the caller's follow-up, so they come back as `gone`, `landed?` and `unanswered`.
+ */
+export function classifySaveAllError(err, retryOfUnanswered) {
+    if (isUnanswered(err))
+        return { kind: 'unanswered' };
+    if (!(err instanceof SaveApiError))
+        return { kind: 'error', reason: SAVE_ALL_REASONS.failed };
+    if (err.status === 409) {
+        if (err.code === ENTRY_GONE_CODE)
+            return { kind: 'gone' };
+        // The retry of a save that got no answer, refused as changed, most likely bounced off itself.
+        if (err.code === 'WRITE_OUTCOME_UNKNOWN' ||
+            (retryOfUnanswered && err.serverMessage === ENTRY_CHANGED_MESSAGE)) {
+            return { kind: 'landed?' };
+        }
+        if (err.code === BRANCH_SYNCING_CODE) {
+            return { kind: 'conflict', reason: err.message, retryable: true };
+        }
+        // The version check's own wording names the single-entry recovery, so Save all says it its way.
+        const changed = !err.serverMessage || err.serverMessage === ENTRY_CHANGED_MESSAGE;
+        return { kind: 'conflict', reason: changed ? SAVE_ALL_REASONS.staleBase : err.serverMessage };
+    }
+    if (err.code === SCHEMA_UNAVAILABLE_CODE)
+        return { kind: 'blocked', reason: err.message };
+    if (err.status === 422) {
+        return { kind: 'invalid', reason: err.message, fieldErrors: !!err.fieldErrors?.length };
+    }
+    // A path rule's refusal says only "Forbidden"; the guards' own refusals explain themselves.
+    if (err.status === 403) {
+        const bare = !err.serverMessage || err.serverMessage === 'Forbidden';
+        return { kind: 'blocked', reason: bare ? SAVE_ALL_REASONS.forbidden : err.serverMessage };
+    }
+    return { kind: 'error', reason: SAVE_ALL_REASONS.failed };
+}

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

@@ -9,6 +9,8 @@ export interface UseCommentSystemOptions {
     canResolveComments: boolean;
     setSelectedPath: (id: string) => void;
     setBranchManagerOpen: (open: boolean) => void;
+    /** Uncovers the form before anything here focuses one of its fields. */
+    onRevealForm?: () => void;
     onCommentsChange?: (comments: CommentThread[]) => void;
 }
 export interface UseCommentSystemReturn {

package/dist/editor/hooks/useCommentSystem.js

@@ -172,6 +172,7 @@ export function useCommentSystem(options) {
                 later(() => {
                     target.style.boxShadow = previous;
                 }, 1200);
+                options.onRevealForm?.();
                 // Cleared shortly after, once FieldWrapper has seen it and scrolled to the field.
                 setFocusedFieldPath(found.path);
                 later(() => setFocusedFieldPath(undefined), 100);
@@ -196,6 +197,7 @@ export function useCommentSystem(options) {
             if (target) {
                 whenRevealed(target, () => target.scrollIntoView({ behavior: 'smooth', block: 'center' }));
             }
+            options.onRevealForm?.();
             setFocusedFieldPath(canopyPath);
             setHighlightThreadId(threadId);
             window.setTimeout(() => {
@@ -214,6 +216,7 @@ export function useCommentSystem(options) {
             if (formElement) {
                 formElement.scrollIntoView({ behavior: 'smooth', block: 'start' });
             }
+            options.onRevealForm?.();
             setHighlightThreadId(threadId);
             window.setTimeout(() => {
                 setHighlightThreadId(undefined);

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

@@ -2,10 +2,11 @@ import type { EditorEntry } from '../Editor.js';
 import type { LogicalPath } from '../../paths/types.js';
 import type { FormValue } from '../FormRenderer.js';
 import type { StampedEntry } from '../../stamp-on-publish.js';
+import { type SaveAllProgress, type SaveAllResult } from './save-all.js';
 /** @internal Exported for tests. */
 export declare 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 declare 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 declare 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.";
 /** @internal Exported for tests. A save refused because the entry was deleted. */
 export declare const ENTRY_DELETED_MESSAGE = "This entry was deleted since you opened it, so it was not saved. Your changes are still in the form until the content list next refreshes and closes it: choose \"Save as new entry\" to keep them.";
 /** @internal Exported for tests. A save refused because the entry was renamed; the editor has opened it. */
@@ -50,6 +51,8 @@ export interface UseDraftManagerOptions {
      * instead of the stale label from the last entries fetch.
      */
     onSaved?: () => void;
+    /** A save was refused for field errors, which the form now shows. */
+    onSaveBlocked?: () => void;
     /**
      * Fired when drafts are thrown away for the server's copy: Discard (one entry, or every entry
      * when `contentId` is undefined) and Reload. Anything built on the discarded draft, such as an
@@ -80,6 +83,26 @@ export interface UseDraftManagerReturn {
         label: string;
     }>;
     handleSave: () => Promise<void>;
+    /** The entry a single Save is writing, while it is in flight. */
+    singleSaving: {
+        branch: string;
+        contentId: string;
+    } | null;
+    /** The last Save that landed; its `seq` rises with each, and the Save button says "Saved". */
+    lastSaved: {
+        branch: string;
+        contentId: string;
+        seq: number;
+    } | null;
+    /**
+     * Saves every entry with unsaved changes on the branch, one at a time. Undefined when a run or
+     * a single Save is already in flight, or the branch changed or the editor unmounted meanwhile.
+     */
+    handleSaveAll: () => Promise<SaveAllResult | undefined>;
+    /** Set while Save all runs. */
+    saveAllProgress: SaveAllProgress | null;
+    /** Whether Save all is running now, read at the moment of a click rather than a render. */
+    isSaveAllRunning: () => boolean;
     handleDiscardDrafts: (returnFocusTo?: () => HTMLElement | null) => void;
     /** `announce` toasts the discard, for a draft the form isn't showing (a read-only branch's). */
     handleDiscardFileDraft: (returnFocusTo?: () => HTMLElement | null, options?: {