canopycms 0.0.68-int.98 → 0.1.0

package/dist/editor/EditorAuthGate.d.ts

@@ -13,9 +13,13 @@
  *   different user the editor and its cache remount, because the SWRProvider is keyed by user id.
  * - A re-check that fails for a non-auth reason keeps the sign-in UI up with the error and Retry,
  *   so a provider that has already reported sign-in is never left waiting on nothing.
+ * - A response refusing the editor's mode (`EDITOR_MODE_MISMATCH`, see
+ *   operating-mode/editor-mode-check.ts) blocks for good, with no Retry: only a rebuild fixes it.
+ *   The server answers it before auth, so `whoami` meets it before any sign-in UI.
  */
 import React from 'react';
 import type { EditorSignInProps } from '../config/index.js';
+import type { OperatingMode } from '../operating-mode/types.js';
 import { type CanopyThemeOptions } from './theme.js';
 export interface EditorAuthGateProps {
     children: React.ReactNode;
@@ -23,5 +27,7 @@ export interface EditorAuthGateProps {
     SignInComponent?: React.ComponentType<EditorSignInProps>;
     /** The editor's theme, so the gate's own screens match it. */
     themeOptions?: CanopyThemeOptions;
+    /** The mode this bundle was built for, named by the mode-mismatch screen. */
+    editorMode?: OperatingMode;
 }
-export declare function EditorAuthGate({ children, SignInComponent, themeOptions }: EditorAuthGateProps): import("react/jsx-runtime").JSX.Element;
+export declare function EditorAuthGate({ children, SignInComponent, themeOptions, editorMode, }: EditorAuthGateProps): import("react/jsx-runtime").JSX.Element;

package/dist/editor/EditorAuthGate.js

@@ -15,14 +15,19 @@ import { jsx as _jsx, Fragment as _Fragment, jsxs as _jsxs } from "react/jsx-run
  *   different user the editor and its cache remount, because the SWRProvider is keyed by user id.
  * - A re-check that fails for a non-auth reason keeps the sign-in UI up with the error and Retry,
  *   so a provider that has already reported sign-in is never left waiting on nothing.
+ * - A response refusing the editor's mode (`EDITOR_MODE_MISMATCH`, see
+ *   operating-mode/editor-mode-check.ts) blocks for good, with no Retry: only a rebuild fixes it.
+ *   The server answers it before auth, so `whoami` meets it before any sign-in UI.
  */
 import { useCallback, useEffect, useMemo, useReducer, useRef } from 'react';
-import { Alert, Button, Center, Loader, Modal, Paper, Stack, Text, Title } from '@mantine/core';
+import { Alert, Box, Button, Center, Loader, Modal, Paper, Stack, Text, Title } from '@mantine/core';
 import { useSWRConfig } from 'swr';
 import { getErrorMessage } from '../utils/error.js';
-import { useApiClient, useOnUnauthorized } from './context/ApiClientContext.js';
+import { editorModeMismatchMessage } from '../operating-mode/editor-mode-check.js';
+import { useApiClient, useOnEditorModeMismatch, useOnUnauthorized, } from './context/ApiClientContext.js';
 import { EditorIdentityContext } from './context/EditorIdentityContext.js';
 import { SWRProvider } from './context/SWRProvider.js';
+import { EditorShell } from './shell/EditorShell.js';
 import { CanopyCMSProvider } from './theme.js';
 const initialGateState = {
     phase: 'checking',
@@ -30,11 +35,15 @@ const initialGateState = {
     sessionRejected: false,
     error: undefined,
     reauthCount: 0,
+    modeMismatch: false,
 };
 function gateReducer(state, action) {
     switch (action.type) {
+        case 'modeMismatch':
+            return state.modeMismatch ? state : { ...state, modeMismatch: true };
         case 'accepted':
             return {
+                ...state,
                 phase: 'signed-in',
                 user: action.user,
                 sessionRejected: false,
@@ -64,17 +73,24 @@ function gateReducer(state, action) {
             return state.phase === 'error' ? { ...state, phase: 'checking', error: undefined } : state;
     }
 }
-export function EditorAuthGate({ children, SignInComponent, themeOptions }) {
+export function EditorAuthGate({ children, SignInComponent, themeOptions, editorMode, }) {
     const apiClient = useApiClient();
     const [state, dispatch] = useReducer(gateReducer, initialGateState);
     const handleUnauthorized = useCallback(() => {
         dispatch({ type: 'unauthorized', afterSignIn: false });
     }, []);
     useOnUnauthorized(handleUnauthorized);
+    const handleModeMismatch = useCallback(() => {
+        dispatch({ type: 'modeMismatch' });
+    }, []);
+    useOnEditorModeMismatch(handleModeMismatch);
     const check = useCallback(async (afterSignIn) => {
         try {
             const result = await apiClient.user.whoami();
-            if (result.ok && result.data) {
+            if (result.code === 'EDITOR_MODE_MISMATCH') {
+                dispatch({ type: 'modeMismatch' });
+            }
+            else if (result.ok && result.data) {
                 dispatch({
                     type: 'accepted',
                     user: { userId: result.data.userId, groups: result.data.groups },
@@ -104,16 +120,32 @@ export function EditorAuthGate({ children, SignInComponent, themeOptions }) {
     }, [check]);
     const identity = useMemo(() => (state.user ? { user: state.user } : null), [state.user]);
     const signIn = (_jsxs(_Fragment, { children: [state.phase === 'signed-out' && state.error && (_jsx(RetryNotice, { title: "Couldn't confirm your sign-in", error: state.error, onRetry: onSignedIn })), SignInComponent ? (_jsx(SignInComponent, { onSignedIn: onSignedIn, sessionRejected: state.sessionRejected })) : (_jsx(DefaultSignedOutNotice, { onSignedIn: onSignedIn, sessionRejected: state.sessionRejected }))] }));
+    const modeMismatchNotice = state.modeMismatch && _jsx(ModeMismatchNotice, { editorMode: editorMode });
     if (!state.user || !identity) {
-        return (_jsx(CanopyCMSProvider, { ...themeOptions, withNotifications: false, children: _jsx(Center, { mih: "100vh", p: "md", children: state.phase === 'signed-out' ? (_jsx(Stack, { align: "center", gap: "md", "data-testid": "canopy-sign-in-screen", children: signIn })) : state.phase === 'error' ? (_jsx(RetryNotice, { title: "Couldn't load the editor", error: state.error ?? 'Unknown error', onRetry: retryInitial })) : (_jsxs(Stack, { align: "center", gap: "xs", "data-testid": "canopy-auth-checking", children: [_jsx(Loader, {}), _jsx(Text, { size: "sm", c: "dimmed", children: "Checking sign-in\u2026" })] })) }) }));
+        if (modeMismatchNotice) {
+            return (_jsx(CanopyCMSProvider, { ...themeOptions, withNotifications: false, children: _jsx(GateScreen, { children: modeMismatchNotice }) }));
+        }
+        return (_jsx(CanopyCMSProvider, { ...themeOptions, withNotifications: false, children: _jsx(GateScreen, { children: state.phase === 'signed-out' ? (_jsx(Stack, { align: "center", gap: "md", "data-testid": "canopy-sign-in-screen", children: signIn })) : state.phase === 'error' ? (_jsx(RetryNotice, { title: "Couldn't load the editor", error: state.error ?? 'Unknown error', onRetry: retryInitial })) : (_jsxs(Stack, { align: "center", gap: "xs", "data-testid": "canopy-auth-checking", children: [_jsx(Loader, {}), _jsx(Text, { size: "sm", c: "dimmed", children: "Checking sign-in\u2026" })] })) }) }));
     }
-    return (_jsxs(EditorIdentityContext.Provider, { value: identity, children: [_jsxs(SWRProvider, { children: [_jsx(RevalidateOnReauth, { reauthCount: state.reauthCount }), children] }, state.user.userId), state.phase === 'signed-out' && (
+    return (_jsxs(EditorIdentityContext.Provider, { value: identity, children: [_jsxs(SWRProvider, { children: [_jsx(RevalidateOnReauth, { reauthCount: state.reauthCount }), children] }, state.user.userId), modeMismatchNotice && (_jsx(CanopyCMSProvider, { ...themeOptions, withNotifications: false, children: _jsx(Modal, { opened: true, onClose: keepOpen, withCloseButton: false, closeOnClickOutside: false, closeOnEscape: false, centered: true, size: "lg", children: modeMismatchNotice }) })), !modeMismatchNotice && state.phase === 'signed-out' && (
             // The editor's own MantineProvider is inside <Editor>, so the overlay brings its own.
             // Notifications stay with the editor's provider; a second container would duplicate them.
             _jsx(CanopyCMSProvider, { ...themeOptions, withNotifications: false, children: _jsx(Modal, { opened: true, onClose: keepOpen, withCloseButton: false, closeOnClickOutside: false, closeOnEscape: false, centered: true, title: "Sign in to continue", children: _jsxs(Stack, { gap: "md", "data-testid": "canopy-sign-in-overlay", children: [_jsx(Text, { size: "sm", children: "Your session has ended. Unsaved edits stay in place if you sign back in as the same user." }), signIn] }) }) }))] }));
 }
-/** The overlay closes only when the server accepts a session again. */
+/** A screen shown in the editor's place, scrolling when it is taller than the window. */
+function GateScreen({ children }) {
+    return (_jsx(EditorShell, { main: _jsx(Box, { h: "100%", style: { overflowY: 'auto' }, children: _jsx(Center, { mih: "100%", p: "md", style: { justifyContent: 'safe center', alignItems: 'safe center' }, children: children }) }) }));
+}
+/** The sign-in overlay closes only when the server accepts a session again; the mode one never. */
 function keepOpen() { }
+/** Blocking, with no Retry: the editor bundle itself is wrong, so only a rebuild helps. */
+function ModeMismatchNotice({ editorMode }) {
+    return (_jsx(Alert, { color: "red", title: "This editor doesn't match its CMS server", maw: 560, "data-testid": "canopy-mode-mismatch", children: _jsx(Text, { size: "sm", children: editorMode
+                ? editorModeMismatchMessage(editorMode)
+                : 'This editor was built for a different mode than the CMS server runs, so signing in ' +
+                    'cannot work. Whoever deploys this site needs to rebuild the editor with ' +
+                    'NEXT_PUBLIC_CANOPY_MODE set to the server mode at build time.' }) }));
+}
 /**
  * Revalidates every SWR key when the same identity is re-accepted. `revalidateOnFocus` is off
  * (see SWRProvider), so without this the data that 401'd behind the overlay would stay stale.
@@ -132,9 +164,9 @@ function RevalidateOnReauth({ reauthCount }) {
     return null;
 }
 function RetryNotice(props) {
-    return (_jsx(Alert, { color: "red", title: props.title, maw: 480, "data-testid": "canopy-auth-error", children: _jsxs(Stack, { gap: "xs", align: "flex-start", children: [_jsx(Text, { size: "sm", children: props.error }), _jsx(Button, { size: "xs", variant: "light", onClick: props.onRetry, children: "Retry" })] }) }));
+    return (_jsx(Alert, { color: "red", title: props.title, maw: 480, "data-testid": "canopy-auth-error", children: _jsxs(Stack, { gap: "xs", align: "flex-start", children: [_jsx(Text, { size: "sm", children: props.error }), _jsx(Button, { variant: "light", onClick: props.onRetry, children: "Retry" })] }) }));
 }
 /** Re-checks rather than reloading: in the overlay, a reload would discard the unsaved edits. */
 function DefaultSignedOutNotice({ onSignedIn, sessionRejected }) {
-    return (_jsx(Paper, { withBorder: true, p: "xl", radius: "md", maw: 420, children: _jsxs(Stack, { gap: "sm", children: [_jsx(Title, { order: 3, children: "Sign in required" }), _jsx(Text, { size: "sm", children: "You are not signed in to the CMS. Sign in through this site's auth provider, then continue." }), sessionRejected && (_jsx(Text, { size: "sm", c: "red", children: "Still not signed in." })), _jsx(Button, { onClick: onSignedIn, children: "Continue" })] }) }));
+    return (_jsx(Paper, { withBorder: true, p: "xl", maw: 420, children: _jsxs(Stack, { gap: "sm", children: [_jsx(Title, { order: 3, children: "Sign in required" }), _jsx(Text, { size: "sm", children: "You are not signed in to the CMS. Sign in through this site's auth provider, then continue." }), sessionRejected && (_jsx(Text, { size: "sm", c: "var(--canopy-danger-text)", children: "Still not signed in." })), _jsx(Button, { size: "sm", onClick: onSignedIn, children: "Continue" })] }) }));
 }

package/dist/editor/EntryNavigator.d.ts

@@ -5,11 +5,17 @@ type TreeController = ReturnType<typeof useTree>;
 export interface EntryNavItem {
     path: LogicalPath;
     label: string;
+    /** Matched by the filter; the last segment of `path` when absent. */
+    slug?: string;
     status?: string;
     collectionPath?: LogicalPath;
     contentId?: ContentId;
     /** True when this entry's file conflicted during rebase */
     conflictNotice?: boolean;
+    /** True when the entry's type is unavailable; it shows no menu, since every item in it writes. */
+    unavailable?: boolean;
+    /** True when this user cannot edit the entry: it shows a lock and no menu, since every item writes. */
+    readOnly?: boolean;
 }
 export interface EntryNavCollection {
     path: LogicalPath;
@@ -21,6 +27,10 @@ export interface EntryNavCollection {
     children?: EntryNavCollection[];
     /** True when this collection's .collection.json conflicted during rebase */
     conflictNotice?: boolean;
+    /** Registry keys of this collection's unavailable entry types; non-empty shows the message once. */
+    unavailableSchemaRefs?: readonly string[];
+    /** True when this user's path rules refuse a new entry here: the collection says so once. */
+    addRefused?: boolean;
     onAdd?: () => void;
     onEdit?: () => void;
     onAddSubCollection?: () => void;
@@ -51,6 +61,18 @@ export interface EntryNavigatorProps {
      * would only 403 after the fact. Default false.
      */
     readOnly?: boolean;
+    /** Entry paths with unsaved changes; each shows a dot, and so does every collection holding one. */
+    dirtyPaths?: ReadonlySet<string>;
+    /**
+     * A collection to bring into view: any filter clears, its ancestors and itself expand, and its
+     * row takes focus. `seq` makes a repeat ask for the same collection a new one.
+     */
+    revealCollection?: {
+        path: string;
+        seq: number;
+    };
+    /** The reveal is done, or its collection is not in the tree. */
+    onRevealed?: () => void;
 }
 export declare const EntryNavigator: React.FC<EntryNavigatorProps>;
 export default EntryNavigator;