canopycms 0.7.0 → 0.8.0

package/dist/editor/components/ReviewDialogs.js

@@ -9,8 +9,8 @@ const NOTE_ANNOUNCE_FROM = REQUEST_CHANGES_NOTE_MAX_LENGTH - 100;
 /** What the Approve dialog says; the pull request clause needs a pull request to be true. */
 export function approveMessage(branchName, hasPullRequest) {
     return hasPullRequest
-        ? `Approve "${branchName}"? Its pull request stays open on GitHub for someone with access to merge it.`
-        : `Approve "${branchName}"? It stays locked until it is withdrawn or changes are requested.`;
+        ? `Approve “${branchName}”? Its pull request stays open on GitHub for someone with access to merge it.`
+        : `Approve “${branchName}”? It stays locked until it is withdrawn or changes are requested.`;
 }
 /** The Request changes dialog's body: what happens, and an optional note for the editor. */
 export function RequestChangesForm({ branchName, hasPullRequest, initialNote = '', onNoteChange, }) {
@@ -18,7 +18,7 @@ export function RequestChangesForm({ branchName, hasPullRequest, initialNote = '
     // The first focus, which the dialog's focus trap gives, puts the caret after a prefilled note so
     // typing carries on from it; later focus keeps wherever the caret was left.
     const caretPlaced = useRef(false);
-    return (_jsxs(Stack, { gap: "sm", children: [_jsx(Text, { size: "sm", children: `Send "${branchName}" back to its editor? It goes back to editing${hasPullRequest ? ', and its pull request becomes a draft' : ''}.` }), _jsxs(Stack, { gap: 4, children: [_jsx(Textarea, { label: "Note to the editor", description: "Saved as a comment on the branch.", value: note, onChange: (event) => {
+    return (_jsxs(Stack, { gap: "sm", children: [_jsx(Text, { size: "sm", children: `Send “${branchName}” back to its editor? It goes back to editing${hasPullRequest ? ', and its pull request becomes a draft' : ''}.` }), _jsxs(Stack, { gap: 4, children: [_jsx(Textarea, { label: "Note to the editor", description: "Saved as a comment on the branch.", value: note, onChange: (event) => {
                             setNote(event.currentTarget.value);
                             onNoteChange(event.currentTarget.value);
                         }, maxLength: REQUEST_CHANGES_NOTE_MAX_LENGTH, autosize: true, minRows: 3, maxRows: 8, onFocus: (event) => {

package/dist/editor/context/ApiClientContext.d.ts

@@ -7,6 +7,7 @@ import React from 'react';
 import { createApiClient } from '../../api/index.js';
 import type { OperatingMode } from '../../operating-mode/types.js';
 export type ApiClient = ReturnType<typeof createApiClient>;
+type BranchSegments = ReadonlyMap<string, string>;
 export interface ApiClientProviderProps {
     children: React.ReactNode;
     /** Optional custom client for testing */
@@ -34,6 +35,13 @@ export declare function ApiClientProvider({ children, client, basePath, editorMo
 export declare function useOnUnauthorized(listener: () => void): void;
 /** As {@link useOnUnauthorized}, for responses refusing the editor's mode (`EDITOR_MODE_MISMATCH`). */
 export declare function useOnEditorModeMismatch(listener: () => void): void;
+/**
+ * Tells the provider's own client the `/:branch` segment each listed branch's requests carry
+ * (name to segment); a name not in `segments` goes as `unlistedSegment` sends it. Set during
+ * render, not in an effect: a data hook fetches in a layout effect, before any effect here would
+ * run. Outside a provider it does nothing, and an injected `client` never reads the table.
+ */
+export declare function useBranchSegments(segments: BranchSegments): void;
 /**
  * Hook to access the API client.
  * Must be used within an ApiClientProvider.
@@ -44,3 +52,4 @@ export declare function useApiClient(): ApiClient;
  * Useful for conditional usage or graceful degradation.
  */
 export declare function useOptionalApiClient(): ApiClient | null;
+export {};

package/dist/editor/context/ApiClientContext.js

@@ -8,6 +8,7 @@ import { jsx as _jsx } from "react/jsx-runtime";
 import { createContext, useContext, useEffect, useMemo, useState } from 'react';
 import { createApiClient } from '../../api/index.js';
 import { joinUrlPrefix } from '../../utils/url-prefix.js';
+import { unlistedSegment } from '../branch-names.js';
 const ApiClientContext = createContext(null);
 function createClientSignal() {
     const listeners = new Set();
@@ -24,6 +25,17 @@ function createClientSignal() {
         },
     };
 }
+/** The branch-name to `/:branch`-segment lookup the provider's client reads, replaced as listings arrive. */
+function createSegmentTable() {
+    let segments = new Map();
+    return {
+        lookup: (branch) => segments.get(branch) ?? unlistedSegment(branch),
+        replace: (next) => {
+            segments = next;
+        },
+    };
+}
+const BranchSegmentsContext = createContext(null);
 const UnauthorizedSignalContext = createContext(null);
 const EditorModeMismatchSignalContext = createContext(null);
 /**
@@ -41,6 +53,7 @@ export function ApiClientProvider({ children, client, basePath, editorMode, }) {
     // Only a client built HERE reports to `useOnUnauthorized` and `useOnEditorModeMismatch`; an
     // injected `client` is used as-is, so its 401s and mode mismatches reach the auth gate only
     // through the gate's own whoami result.
+    const [segmentTable] = useState(createSegmentTable);
     const apiClient = useMemo(() => {
         return (client ??
             createApiClient({
@@ -48,9 +61,10 @@ export function ApiClientProvider({ children, client, basePath, editorMode, }) {
                 onUnauthorized: unauthorized.emit,
                 editorMode,
                 onEditorModeMismatch: modeMismatch.emit,
+                branchSegment: segmentTable.lookup,
             }));
-    }, [client, basePath, editorMode, unauthorized, modeMismatch]);
-    return (_jsx(UnauthorizedSignalContext.Provider, { value: unauthorized, children: _jsx(EditorModeMismatchSignalContext.Provider, { value: modeMismatch, children: _jsx(ApiClientContext.Provider, { value: apiClient, children: children }) }) }));
+    }, [client, basePath, editorMode, unauthorized, modeMismatch, segmentTable]);
+    return (_jsx(UnauthorizedSignalContext.Provider, { value: unauthorized, children: _jsx(EditorModeMismatchSignalContext.Provider, { value: modeMismatch, children: _jsx(BranchSegmentsContext.Provider, { value: segmentTable.replace, children: _jsx(ApiClientContext.Provider, { value: apiClient, children: children }) }) }) }));
 }
 /**
  * Subscribe to every unauthenticated response (`ApiClientOptions.onUnauthorized`) the provider's
@@ -66,6 +80,16 @@ export function useOnEditorModeMismatch(listener) {
     const signal = useContext(EditorModeMismatchSignalContext);
     useEffect(() => signal?.subscribe(listener), [signal, listener]);
 }
+/**
+ * Tells the provider's own client the `/:branch` segment each listed branch's requests carry
+ * (name to segment); a name not in `segments` goes as `unlistedSegment` sends it. Set during
+ * render, not in an effect: a data hook fetches in a layout effect, before any effect here would
+ * run. Outside a provider it does nothing, and an injected `client` never reads the table.
+ */
+export function useBranchSegments(segments) {
+    const set = useContext(BranchSegmentsContext);
+    set?.(segments);
+}
 /**
  * Hook to access the API client.
  * Must be used within an ApiClientProvider.

package/dist/editor/context/index.d.ts

@@ -1,4 +1,4 @@
-export { ApiClientProvider, useApiClient, useOptionalApiClient, type ApiClient, type ApiClientProviderProps, } from './ApiClientContext.js';
+export { ApiClientProvider, useApiClient, useBranchSegments, useOptionalApiClient, type ApiClient, type ApiClientProviderProps, } from './ApiClientContext.js';
 export { AssetContextProvider, authenticatedAssetBase, useAssetContext, type AssetContextValue, type AssetContextProviderProps, } from './AssetContext.js';
 export { SWRProvider, type SWRProviderProps } from './SWRProvider.js';
 export { useEditorLoading, useEditorModals, useEditorPreview } from './EditorStateContext.js';

package/dist/editor/context/index.js

@@ -1,4 +1,4 @@
-export { ApiClientProvider, useApiClient, useOptionalApiClient, } from './ApiClientContext.js';
+export { ApiClientProvider, useApiClient, useBranchSegments, useOptionalApiClient, } from './ApiClientContext.js';
 export { AssetContextProvider, authenticatedAssetBase, useAssetContext, } from './AssetContext.js';
 export { SWRProvider } from './SWRProvider.js';
 export { useEditorLoading, useEditorModals, useEditorPreview } from './EditorStateContext.js';

package/dist/editor/copy.d.ts

@@ -20,6 +20,7 @@ export declare const EDITOR_ACTIONS: {
     readonly undoClear: "Undo clear";
     readonly changeUrl: "Change URL";
     readonly changeSlug: "Change slug";
+    readonly showChanges: "Show changes";
 };
 /**
  * Why a list at its `maxItems` adds nothing more, as a disabled Add's Tooltip or an input's hint.

package/dist/editor/copy.js

@@ -20,6 +20,7 @@ export const EDITOR_ACTIONS = {
     undoClear: 'Undo clear',
     changeUrl: 'Change URL',
     changeSlug: 'Change slug',
+    showChanges: 'Show changes',
 };
 /**
  * Why a list at its `maxItems` adds nothing more, as a disabled Add's Tooltip or an input's hint.

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

@@ -17,6 +17,8 @@ type PreviewEntry = {
     itemType?: string;
     previewSrc?: string;
 };
+/** `src` with its last `?branch=` value set to `branchName`; a `src` without one is returned as is. */
+export declare const withPreviewBranch: (src: string, branchName: string) => string;
 /**
  * The entry's route on the host site, or `undefined` when it has no page. The first
  * `previewBaseByCollection` key present decides: for a root entry its own path

package/dist/editor/editor-utils.js

@@ -31,6 +31,21 @@ const appendBranch = (url, branchName) => {
     const separator = beforeHash.includes('?') ? '&' : '?';
     return `${beforeHash}${separator}branch=${encodeURIComponent(branchName)}${hash}`;
 };
+/** `src` with its last `?branch=` value set to `branchName`; a `src` without one is returned as is. */
+export const withPreviewBranch = (src, branchName) => {
+    const hashIndex = src.indexOf('#');
+    const beforeHash = hashIndex === -1 ? src : src.slice(0, hashIndex);
+    const queryIndex = beforeHash.indexOf('?');
+    if (queryIndex === -1)
+        return src;
+    const params = beforeHash.slice(queryIndex + 1).split('&');
+    const keys = params.map((param) => param.split('=', 1)[0]);
+    const at = keys.lastIndexOf('branch');
+    if (at === -1)
+        return src;
+    params[at] = `branch=${encodeURIComponent(branchName)}`;
+    return `${beforeHash.slice(0, queryIndex + 1)}${params.join('&')}${src.slice(beforeHash.length)}`;
+};
 /**
  * The `previewBase` value under `key`, or `undefined` for none. An empty value counts as none, and
  * so does anything `Object.prototype` supplies.

package/dist/editor/entry-diff.d.ts

@@ -0,0 +1,143 @@
+/**
+ * What changed in one entry between two saved states, field by field, for the "Show changes"
+ * drawer. Pure and client-safe: it walks the entry type's schema, so each change carries the
+ * labels the form shows, and lists and blocks match their items by item key (`item-keys.ts`),
+ * so a reordered item reads as moved, not as one removed and one added.
+ */
+import type { FieldConfig } from '../config/index.js';
+import type { EntryChangeSide } from '../api/branch-entry-changes.js';
+/** A run of text on one side of a text change; `added` and `removed` runs are the difference. */
+export interface DiffPart {
+    value: string;
+    added?: true;
+    removed?: true;
+}
+/**
+ * One row of a line diff, its Before and After lines side by side: an unchanged line on both, a
+ * changed pair, or a line on one side only (the other side's cell is empty). `skipped` stands
+ * for unchanged lines left out between changes.
+ */
+export type DiffRow = {
+    kind: 'same';
+    text: string;
+} | {
+    kind: 'change';
+    before?: DiffPart[];
+    after?: DiffPart[];
+} | {
+    kind: 'skipped';
+    count: number;
+};
+/**
+ * A text change: word by word for a short value, row by row with word marks for long text, or a
+ * line break added or removed at the very end, the only difference.
+ */
+export type TextDiff = {
+    mode: 'words';
+    parts: DiffPart[];
+} | {
+    mode: 'lines';
+    rows: DiffRow[];
+} | {
+    mode: 'endLineBreak';
+    added: boolean;
+};
+/** A value as the drawer shows it. */
+export type DisplayValue = {
+    kind: 'empty';
+} | {
+    kind: 'text';
+    text: string;
+    long?: true;
+} | {
+    kind: 'number';
+    value: number;
+} | {
+    kind: 'boolean';
+    value: boolean;
+}
+/** `text`, its absolute local form; `dateOnly`: a calendar date, read as local midnight. */
+ | {
+    kind: 'date';
+    iso: string;
+    text: string;
+    dateOnly?: true;
+} | {
+    kind: 'select';
+    label: string;
+}
+/** No `title` when the editor's entry list has no entry with this id. */
+ | {
+    kind: 'reference';
+    id: string;
+    title?: string;
+} | {
+    kind: 'image';
+    src: string;
+    name: string;
+    alt?: string;
+}
+/** A list item's place, 1-based, among `of` items, for a move. */
+ | {
+    kind: 'position';
+    position: number;
+    of: number;
+} | {
+    kind: 'list';
+    items: DisplayValue[];
+}
+/** A whole object, list item or block, as its labelled fields. */
+ | {
+    kind: 'fields';
+    fields: Array<{
+        label: string;
+        value: DisplayValue;
+    }>;
+}
+/** A value of a shape the schema doesn't describe, as JSON. */
+ | {
+    kind: 'raw';
+    text: string;
+};
+export interface EntryChange {
+    /** Stable among one diff's changes: its data path, list items named by key. */
+    key: string;
+    /** Human labels from the entry down to the change: "Page sections › Hero › Heading". */
+    path: string[];
+    kind: 'added' | 'removed' | 'changed' | 'moved';
+    /** A whole list item or block added, removed or moved, rather than a field's value. */
+    item?: true;
+    before?: DisplayValue;
+    after?: DisplayValue;
+    text?: TextDiff;
+    /** Both sides' images' alt texts, diffed by word. */
+    altText?: TextDiff;
+    /** The text differs too much to mark within the time allowed: show both sides whole. */
+    tooLargeToMark?: true;
+}
+export interface EntryDiff {
+    changes: EntryChange[];
+    /** Both sides exist and hold equal values: only the file's formatting differs. */
+    formattingOnly: boolean;
+}
+export interface EntryDiffInput {
+    /** The entry type's fields. */
+    fields: readonly FieldConfig[];
+    before: EntryChangeSide | null;
+    after: EntryChangeSide | null;
+    /** A referenced entry's title, from the entries the editor has listed. */
+    referenceTitle?: (id: string) => string | undefined;
+}
+/**
+ * The difference between two texts. Short single-line text is diffed by word; anything else by
+ * line, a removed line paired with the added line in its place diffed by word inside, and runs
+ * of unchanged lines cut to {@link CONTEXT_LINES} beside each change. Words are diffed with
+ * whitespace as tokens (`diffWordsWithSpace`): `diffWords` gives an unchanged run the new
+ * text's spacing, so one side read back from its parts would not be the text it was.
+ * Undefined once `deadline` (a `Date.now()`) passes: no line diff starts after it. A short word
+ * diff runs until the later `wordDeadline`.
+ * @internal Exported for tests.
+ */
+export declare function textDiff(before: string, after: string, long?: boolean, deadline?: number, wordDeadline?: number): TextDiff | undefined;
+/** The entry's changes between `before` and `after`, in schema order. */
+export declare function computeEntryDiff({ fields, before, after, referenceTitle, }: EntryDiffInput): EntryDiff;