canopycms 0.11.1 → 0.12.0

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

@@ -99,9 +99,22 @@ export type DisplayValue = {
     kind: 'raw';
     text: string;
 };
+/**
+ * One step into a form value: a record's member, a list item by its item key, or a block item's
+ * data, which is its `value` record or, in the inline `_type` shape, the item itself.
+ */
+export type DataPathSegment = {
+    field: string;
+} | {
+    item: string;
+} | {
+    blockData: true;
+};
 export interface EntryChange {
     /** Stable among one diff's changes: its data path, list items named by key. */
     key: string;
+    /** Where the change is in the form value; absent for the entry type, which no field holds. */
+    dataPath?: DataPathSegment[];
     /** Human labels from the entry down to the change: "Page sections › Hero › Heading". */
     path: string[];
     kind: 'added' | 'removed' | 'changed' | 'moved';
@@ -127,6 +140,8 @@ export interface EntryDiffInput {
     after: EntryChangeSide | null;
     /** A referenced entry's title, from the entries the editor has listed. */
     referenceTitle?: (id: string) => string | undefined;
+    /** False when only which changes there are matters: no text is diffed for its marks. */
+    marks?: boolean;
 }
 /**
  * The difference between two texts. Short single-line text is diffed by word; anything else by
@@ -140,4 +155,4 @@ export interface EntryDiffInput {
  */
 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;
+export declare function computeEntryDiff({ fields, before, after, referenceTitle, marks, }: EntryDiffInput): EntryDiff;

package/dist/editor/entry-diff.js

@@ -59,14 +59,18 @@ const normalized = (value) => {
     return out;
 };
 const sameValue = (a, b) => (isEmpty(a) && isEmpty(b)) || equal(normalized(a), normalized(b));
-const at = (parent, label, key) => ({
+const at = (parent, label, key, segment) => ({
     path: [...parent.path, label],
     key: parent.key ? `${parent.key}.${key}` : key,
+    ...(parent.segments && segment && { segments: [...parent.segments, segment] }),
 });
+/** `where`'s data path as a change carries it. */
+const dataPathOf = (where) => where.segments ? { dataPath: where.segments } : {};
 /** A member the schema doesn't name, under an "Other fields" crumb. */
 const otherAt = (parent, name) => ({
     path: [...parent.path, OTHER_FIELDS_LABEL, humanizeName(name)],
     key: `${parent.key}?${name}`,
+    ...(parent.segments && { segments: [...parent.segments, { field: name }] }),
 });
 /** The file name of an image `src`, its query and fragment dropped. */
 const fileName = (src) => {
@@ -245,7 +249,7 @@ class Walker {
         const flat = flattenGroupFields(fields);
         const known = new Set(flat.map((f) => f.name));
         for (const field of flat) {
-            this.field(field, before?.[field.name], after?.[field.name], at(where, schemaLabel(field), field.name));
+            this.field(field, before?.[field.name], after?.[field.name], at(where, schemaLabel(field), field.name, { field: field.name }));
         }
         const others = new Set([...Object.keys(before ?? {}), ...Object.keys(after ?? {})]);
         for (const name of others) {
@@ -287,7 +291,7 @@ class Walker {
         if (sameValue(before, after) || sameInstant(field, before, after))
             return;
         const kind = isEmpty(before) ? 'added' : isEmpty(after) ? 'removed' : 'changed';
-        const change = { key: where.key, path: where.path, kind };
+        const change = { key: where.key, ...dataPathOf(where), path: where.path, kind };
         if (kind !== 'added')
             change.before = this.display(field, before);
         if (kind !== 'removed')
@@ -337,13 +341,15 @@ class Walker {
         const a = isPlainRecord(after) ? resolveBlockItem(field, after) : undefined;
         const sameTemplate = isPlainRecord(before) && isPlainRecord(after) && before.template === after.template;
         if (b && a && sameTemplate) {
-            this.fields(a.fields, b.data, a.data, where);
+            const data = where.segments && { segments: [...where.segments, { blockData: true }] };
+            this.fields(a.fields, b.data, a.data, { ...where, ...data });
             return;
         }
         if (sameValue(before, after))
             return;
         this.changes.push({
             key: where.key,
+            ...dataPathOf(where),
             path: where.path,
             kind: 'changed',
             before: this.blockRecord(field, before),
@@ -373,10 +379,11 @@ class Walker {
             const from = bIndex.get(key);
             // A matched item is named as it was at the base, so a change to its title doesn't rename
             // the path to it.
-            const itemAt = at(where, from === undefined ? item.heading(value, index) : item.heading(bItems[from], from), key);
+            const itemAt = at(where, from === undefined ? item.heading(value, index) : item.heading(bItems[from], from), key, { item: key });
             if (from === undefined) {
                 this.changes.push({
                     key: itemAt.key,
+                    ...dataPathOf(itemAt),
                     path: itemAt.path,
                     kind: 'added',
                     item: true,
@@ -387,6 +394,7 @@ class Walker {
             if (!stayed.has(key)) {
                 this.changes.push({
                     key: `${itemAt.key}#moved`,
+                    ...dataPathOf(itemAt),
                     path: itemAt.path,
                     kind: 'moved',
                     item: true,
@@ -400,9 +408,10 @@ class Walker {
             const key = bKeys[index];
             if (aSet.has(key))
                 return;
-            const itemAt = at(where, item.heading(value, index), key);
+            const itemAt = at(where, item.heading(value, index), key, { item: key });
             this.changes.push({
                 key: itemAt.key,
+                ...dataPathOf(itemAt),
                 path: itemAt.path,
                 kind: 'removed',
                 item: true,
@@ -585,11 +594,12 @@ const withContext = (lines) => {
     return out;
 };
 /** The entry's changes between `before` and `after`, in schema order. */
-export function computeEntryDiff({ fields, before, after, referenceTitle, }) {
-    // One budget for the whole entry: see DIFF_TIMEOUT_MS and SHORT_DIFF_TIMEOUT_MS.
-    const started = Date.now();
-    const walker = new Walker(referenceTitle, started + DIFF_TIMEOUT_MS, started + SHORT_DIFF_TIMEOUT_MS);
-    const root = { path: [], key: '' };
+export function computeEntryDiff({ fields, before, after, referenceTitle, marks = true, }) {
+    // One budget for the whole entry: see DIFF_TIMEOUT_MS and SHORT_DIFF_TIMEOUT_MS. Without
+    // marks, both deadlines have passed before the walk starts.
+    const started = marks ? Date.now() : 0;
+    const walker = new Walker(referenceTitle, started + (marks ? DIFF_TIMEOUT_MS : 0), started + (marks ? SHORT_DIFF_TIMEOUT_MS : 0));
+    const root = { path: [], key: '', segments: [] };
     if (before && after && before.entryType !== after.entryType) {
         walker.value(undefined, humanizeName(before.entryType), humanizeName(after.entryType), at(root, 'Entry type', '$entryType'));
     }

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

@@ -0,0 +1,45 @@
+/**
+ * "Undo change" in the "Show changes" drawer: one saved change of an entry set back, in its form
+ * value, to how `source` has it: the base's version to undo it, the branch's saved one to redo it.
+ * Pure; the editor puts the result in the entry's draft, so an undo is an unsaved edit until saved.
+ * List and block items are found by item key, so an undo lands on the item the change named
+ * wherever it now sits, and an item put back keeps its key, which its comment threads are anchored
+ * by (`resolveThreadPath` in item-keys.ts).
+ */
+import type { EntryChangeSide } from '../api/branch-entry-changes.js';
+import type { CanopyPathSegment } from './canopy-path.js';
+import type { EntryChange } from './entry-diff.js';
+type FormValue = Record<string, unknown>;
+/** A side as the editor's form holds it: an md/mdx body under `body` (`normalizeContentPayload`). */
+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;
+/**
+ * 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
+ * path, an added or removed item's whole content included.
+ */
+export declare function holdsAs(value: FormValue, side: FormValue, change: EntryChange, bodyField?: string): boolean;
+/** Whether a change has a place in the form value that an undo can set back. */
+export declare const canSetBack: (change: EntryChange) => boolean;
+/**
+ * `current` with `change` set to how `source` has it. A whole item added or removed is put in or
+ * taken out; a moved item goes back beside its neighbours in `source`; anything else takes
+ * `source`'s value at the change's path. Undefined when the change can't be placed in `current`,
+ * such as a field inside an item `current` no longer has. `bodyField` is the schema's body field
+ * on an md/mdx entry.
+ */
+export declare function setChangeBack(current: FormValue, source: FormValue, change: EntryChange, bodyField?: string): FormValue | undefined;
+/**
+ * The canopy path (`blocks[2].title`) of a change in `value`, which comment threads anchor to;
+ * undefined when an item on it isn't in `value`.
+ */
+export declare function canopyPathOf(value: FormValue, change: EntryChange, bodyField?: string): CanopyPathSegment[] | undefined;
+/**
+ * `current` with every one of `changes` set to how `source` has it, leaving anything else, such
+ * as an unsaved edit to an unchanged field, as it is. Items are placed in `source`'s order, so
+ * each lands beside a neighbour already back in place and the list ends in `source`'s order. A
+ * change that can't be placed is skipped.
+ */
+export declare function setAllBack(current: FormValue, source: FormValue, changes: readonly EntryChange[], bodyField?: string): FormValue;
+export {};

package/dist/editor/undo-change.js

@@ -0,0 +1,226 @@
+/**
+ * "Undo change" in the "Show changes" drawer: one saved change of an entry set back, in its form
+ * value, to how `source` has it: the base's version to undo it, the branch's saved one to redo it.
+ * Pure; the editor puts the result in the entry's draft, so an undo is an unsaved edit until saved.
+ * List and block items are found by item key, so an undo lands on the item the change named
+ * wherever it now sits, and an item put back keeps its key, which its comment threads are anchored
+ * by (`resolveThreadPath` in item-keys.ts).
+ */
+import equal from 'fast-deep-equal';
+import { ITEM_KEY } from '../item-keys.js';
+import { isPlainRecord } from '../validation/field-traversal.js';
+/** The form key of an md/mdx body, which the diff names by the schema's body field. */
+const FORM_BODY_KEY = 'body';
+/** A side as the editor's form holds it: an md/mdx body under `body` (`normalizeContentPayload`). */
+export const formValueOfSide = (side) => side.body === undefined ? { ...side.data } : { ...side.data, [FORM_BODY_KEY]: side.body };
+/** A form value as a side shaped like `like`, for comparing it with the base. */
+export const sideOfFormValue = (value, like) => {
+    if (like.body === undefined)
+        return { ...like, data: value };
+    const { [FORM_BODY_KEY]: body, ...data } = value;
+    return { ...like, data, body: typeof body === 'string' ? body : '' };
+};
+const indexOfKey = (list, key) => list.findIndex((item) => isPlainRecord(item) && item[ITEM_KEY] === key);
+/** A change's data path in form keys: the body field, when it heads the path, is `body`. */
+const formPath = (change, bodyField) => {
+    const path = change.dataPath ?? [];
+    const head = path[0];
+    return bodyField && head && 'field' in head && head.field === bodyField
+        ? [{ field: FORM_BODY_KEY }, ...path.slice(1)]
+        : path;
+};
+const step = (value, segment) => {
+    if ('field' in segment)
+        return isPlainRecord(value) ? value[segment.field] : undefined;
+    if ('item' in segment) {
+        if (!Array.isArray(value))
+            return undefined;
+        const index = indexOfKey(value, segment.item);
+        return index < 0 ? undefined : value[index];
+    }
+    return isPlainRecord(value) ? (isPlainRecord(value.value) ? value.value : value) : undefined;
+};
+const valueAt = (value, path) => path.reduce(step, value);
+/** What a `replace` returns when the change has nothing to act on, so it can't be placed. */
+const NOT_PLACED = Symbol('not-placed');
+/**
+ * `value` with what is at `path` replaced by `replace`'s result, copied on the way down; a
+ * record missing on the way is made, so a field comes back inside an object the branch cleared.
+ * Undefined when the path leads through an item or block the value no longer has. A record
+ * member replaced by undefined is dropped.
+ */
+const updateAt = (value, path, replace) => {
+    if (path.length === 0) {
+        const next = replace(value);
+        return next === NOT_PLACED ? undefined : { value: next };
+    }
+    const [segment, ...rest] = path;
+    if ('field' in segment) {
+        const record = isPlainRecord(value) ? value : value == null ? {} : undefined;
+        if (!record)
+            return undefined;
+        const next = updateAt(record[segment.field], rest, replace);
+        if (!next)
+            return undefined;
+        const out = { ...record };
+        if (next.value === undefined)
+            delete out[segment.field];
+        else
+            out[segment.field] = next.value;
+        return { value: out };
+    }
+    if ('item' in segment) {
+        if (!Array.isArray(value))
+            return undefined;
+        const index = indexOfKey(value, segment.item);
+        if (index < 0)
+            return undefined;
+        const next = updateAt(value[index], rest, replace);
+        if (!next)
+            return undefined;
+        const out = [...value];
+        out[index] = next.value;
+        return { value: out };
+    }
+    if (!isPlainRecord(value))
+        return undefined;
+    if (!isPlainRecord(value.value))
+        return updateAt(value, rest, replace);
+    const next = updateAt(value.value, rest, replace);
+    return next && { value: { ...value, value: next.value } };
+};
+/**
+ * `item` placed in `list` (which lacks it) where `order` has it: after the nearest item before it
+ * in `order` that `list` holds, else first.
+ */
+const placeLike = (list, item, key, order) => {
+    const at = indexOfKey(order, key);
+    for (let i = at - 1; i >= 0; i--) {
+        const before = order[i];
+        const index = isPlainRecord(before) ? indexOfKey(list, before[ITEM_KEY]) : -1;
+        if (index >= 0)
+            return [...list.slice(0, index + 1), item, ...list.slice(index + 1)];
+    }
+    return [item, ...list];
+};
+const isNothing = (value) => value === undefined || isEmptyContainer(value);
+/**
+ * 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
+ * path, an added or removed item's whole content included.
+ */
+export function holdsAs(value, side, change, bodyField) {
+    if (change.item && change.kind === 'moved') {
+        const placed = setChangeBack(value, side, change, bodyField);
+        return !!placed && equal(placed, value);
+    }
+    const path = formPath(change, bodyField);
+    const [mine, theirs] = [valueAt(value, path), valueAt(side, path)];
+    return (isNothing(mine) && isNothing(theirs)) || equal(mine, theirs);
+}
+/** Whether a change has a place in the form value that an undo can set back. */
+export const canSetBack = (change) => change.dataPath !== undefined;
+/**
+ * `current` with `change` set to how `source` has it. A whole item added or removed is put in or
+ * taken out; a moved item goes back beside its neighbours in `source`; anything else takes
+ * `source`'s value at the change's path. Undefined when the change can't be placed in `current`,
+ * such as a field inside an item `current` no longer has. `bodyField` is the schema's body field
+ * on an md/mdx entry.
+ */
+export function setChangeBack(current, source, change, bodyField) {
+    if (!canSetBack(change))
+        return undefined;
+    const path = formPath(change, bodyField);
+    const last = path[path.length - 1];
+    let next;
+    if (change.item && last && 'item' in last) {
+        const listPath = path.slice(0, -1);
+        const order = valueAt(source, listPath);
+        const sourceList = Array.isArray(order) ? order : [];
+        const wanted = valueAt(source, path);
+        next = updateAt(current, listPath, (old) => {
+            const list = Array.isArray(old) ? old : [];
+            const index = indexOfKey(list, last.item);
+            if (wanted === undefined)
+                return index < 0 ? old : list.filter((_, i) => i !== index);
+            if (change.kind === 'moved') {
+                if (index < 0)
+                    return NOT_PLACED;
+                const without = list.filter((_, i) => i !== index);
+                return placeLike(without, list[index], last.item, sourceList);
+            }
+            return index >= 0 ? old : placeLike(list, structuredClone(wanted), last.item, sourceList);
+        });
+    }
+    else {
+        const wanted = valueAt(source, path);
+        next = updateAt(current, path, () => wanted === undefined ? undefined : structuredClone(wanted));
+    }
+    const placed = next && isPlainRecord(next.value) ? next.value : undefined;
+    return placed && withoutEmptyContainers(placed, source, path);
+}
+const isEmptyContainer = (value) => Array.isArray(value)
+    ? value.length === 0
+    : isPlainRecord(value) && Object.keys(value).length === 0;
+/**
+ * `value` without the records and lists on `path` that setting a change back left empty where
+ * `source` has none, so a value set back matches `source` rather than holding `seo: {}`.
+ */
+const withoutEmptyContainers = (value, source, path) => {
+    let out = value;
+    for (let end = path.length; end > 0; end--) {
+        const at = path.slice(0, end);
+        if (!('field' in at[at.length - 1]))
+            continue;
+        if (valueAt(source, at) !== undefined || !isEmptyContainer(valueAt(out, at)))
+            continue;
+        const next = updateAt(out, at, () => undefined);
+        if (next && isPlainRecord(next.value))
+            out = next.value;
+    }
+    return out;
+};
+/**
+ * The canopy path (`blocks[2].title`) of a change in `value`, which comment threads anchor to;
+ * undefined when an item on it isn't in `value`.
+ */
+export function canopyPathOf(value, change, bodyField) {
+    const out = [];
+    let at = value;
+    for (const segment of formPath(change, bodyField)) {
+        if ('item' in segment) {
+            const index = Array.isArray(at) ? indexOfKey(at, segment.item) : -1;
+            if (index < 0)
+                return undefined;
+            out.push(index);
+        }
+        else if ('field' in segment) {
+            out.push(segment.field);
+        }
+        at = step(at, segment);
+    }
+    return out;
+}
+/** An item change's place in `source`'s list: -1 for an item `source` lacks; undefined otherwise. */
+const sourcePosition = (source, change, bodyField) => {
+    if (!change.item)
+        return undefined;
+    const path = formPath(change, bodyField);
+    const last = path[path.length - 1];
+    if (!last || !('item' in last))
+        return undefined;
+    const list = valueAt(source, path.slice(0, -1));
+    return Array.isArray(list) ? indexOfKey(list, last.item) : -1;
+};
+/**
+ * `current` with every one of `changes` set to how `source` has it, leaving anything else, such
+ * as an unsaved edit to an unchanged field, as it is. Items are placed in `source`'s order, so
+ * each lands beside a neighbour already back in place and the list ends in `source`'s order. A
+ * change that can't be placed is skipped.
+ */
+export function setAllBack(current, source, changes, bodyField) {
+    const ordered = changes
+        .map((change) => ({ change, position: sourcePosition(source, change, bodyField) }))
+        .sort((a, b) => (a.position ?? -2) - (b.position ?? -2));
+    return ordered.reduce((value, { change }) => setChangeBack(value, source, change, bodyField) ?? value, current);
+}

package/dist/version.d.ts

@@ -1 +1 @@
-export declare const CANOPYCMS_VERSION = "0.11.1";
+export declare const CANOPYCMS_VERSION = "0.12.0";

package/dist/version.js

@@ -1,3 +1,3 @@
 // Generated by scripts/bump-version.mjs, its only writer. The package builds with plain
 // tsc (rootDir: src), so src/ cannot import ../package.json; version.test.ts keeps the two equal.
-export const CANOPYCMS_VERSION = '0.11.1';
+export const CANOPYCMS_VERSION = '0.12.0';

package/package.json

@@ -1,7 +1,7 @@
 {
   "//": "@codemirror/language, @lezer/highlight: workaround — @mdxeditor/editor uses cm6-theme-basic-light which peer-requires these but mdxeditor doesn't declare them as dependencies",
   "name": "canopycms",
-  "version": "0.11.1",
+  "version": "0.12.0",
   "description": "CanopyCMS core package: schema-driven content, branch-aware editing, and editor UI for Next.js.",
   "license": "MIT",
   "repository": {