@simmalugnt-se/payload-editor-assistant 0.7.0 → 0.9.0

package/dist/endpoints/translation.d.ts

@@ -0,0 +1,11 @@
+import type { Endpoint } from "payload";
+import type { ValidatedEditorAssistantOptions } from "../config/validate.ts";
+/**
+ * Whether the open document has fields to translate, so the panel can offer it: the language they
+ * come from and how many, compared on the saved version. Read only, with the editor's access.
+ */
+export declare function createTranslationEndpoint(options: ValidatedEditorAssistantOptions): Endpoint;
+export type TranslationOffer = {
+    source?: string;
+    empty: number;
+};

package/dist/endpoints/translation.js

@@ -0,0 +1,56 @@
+import { hasCapability, resolveAllowlist } from "../domain/allowlist.js";
+import { findContentById } from "../domain/content.js";
+import { loadRichText } from "../form/rich-text.js";
+import { translationPaths } from "../form/translation.js";
+import { ENDPOINT_PREFIX } from "../package-name.js";
+import { sourceLocale } from "../runtime/translation-source.js";
+import { configuredDefaultLocale, configuredLocales, entityFields } from "../schema/discover.js";
+/**
+ * Whether the open document has fields to translate, so the panel can offer it: the language they
+ * come from and how many, compared on the saved version. Read only, with the editor's access.
+ */
+export function createTranslationEndpoint(options) {
+    return {
+        path: `${ENDPOINT_PREFIX}/translation`,
+        method: "get",
+        handler: async (req) => {
+            if (!req.user) {
+                return Response.json({ error: "unauthorized" }, { status: 401 });
+            }
+            if (options.enabled && !(await options.enabled({ userId: req.user.id }))) {
+                return Response.json({ error: "unavailable" }, { status: 403 });
+            }
+            const params = req.searchParams ?? new URL(req.url ?? "", "http://localhost").searchParams;
+            const target = {
+                collection: params.get("collection") ?? undefined,
+                global: params.get("global") ?? undefined,
+                documentId: params.get("id") ?? undefined,
+                locale: params.get("locale") ?? "",
+            };
+            return Response.json(await translationOffer(req, options, target));
+        },
+    };
+}
+async function translationOffer(req, options, target) {
+    const resolved = resolveAllowlist(options, target);
+    const source = sourceLocale({
+        open: target.locale,
+        locales: configuredLocales(req),
+        defaultLocale: configuredDefaultLocale(req),
+    });
+    if (!source ||
+        !resolved ||
+        !hasCapability(resolved.allowlist, "form.propose") ||
+        (target.collection && !target.documentId)) {
+        return { empty: 0 };
+    }
+    await loadRichText();
+    // One after the other: both reads share the request and its transaction.
+    const from = await findContentById(req, options, { ...target, locale: source });
+    const to = await findContentById(req, options, target);
+    if (!from.ok || !to.ok) {
+        return { empty: 0 };
+    }
+    const fields = entityFields(req, options, target);
+    return { source, empty: translationPaths(fields, to.data, from.data).empty.length };
+}

package/dist/form/diff.d.ts

@@ -6,8 +6,13 @@ export type HumanDiffLine = {
 export type DiffLanguage = "sv" | "en";
 /**
  * `labels` names related documents by id (see `labelRelations`), so a chosen image reads as its
- * filename or alt text instead of an id.
+ * filename or alt text instead of an id. Rich text is listed by `richTextLines` instead.
  */
 export declare function humanDiff(current: Record<string, unknown>, operations: FormOperation[], language?: DiffLanguage, labels?: Map<string, string>): HumanDiffLine[];
+/**
+ * The parts of a rich text field that changed: `before` as the model read it (Markdown blocks),
+ * `after` as compiled, where `{ keep: i }` is block `i` unchanged.
+ */
+export declare function richTextLines(path: string, before: unknown[], after: unknown[], language?: DiffLanguage): HumanDiffLine[];
 /** Sub-lines are indented two spaces; the approval panel nests them under the header. */
 export declare const DIFF_SUBLINE_INDENT = "  ";

package/dist/form/diff.js

@@ -1,5 +1,6 @@
 import { isLexical, lexicalPlaintext } from "./lexical.js";
 import { getAtPath, parseFieldPath } from "./path.js";
+import { richTextDiff } from "./rich-text.js";
 const COPY = {
     en: {
         empty: "empty",
@@ -12,6 +13,9 @@ const COPY = {
         removeBlock: (n, field) => `Remove block ${n} from ${field}`,
         moveBlock: (from, to) => `Move block ${from} to ${to}`,
         replaceBlock: (n, block) => `Replace block ${n} with ${block}`,
+        part: (field, n) => `${field}, part ${n}`,
+        addPart: (field, n) => `${field}, new part ${n}`,
+        removePart: (field, n) => `${field}, part ${n} removed`,
         unknown: "Unknown change",
     },
     sv: {
@@ -25,6 +29,9 @@ const COPY = {
         removeBlock: (n, field) => `Ta bort block ${n} från ${field}`,
         moveBlock: (from, to) => `Flytta block ${from} till ${to}`,
         replaceBlock: (n, block) => `Ersätt block ${n} med ${block}`,
+        part: (field, n) => `${field}, del ${n}`,
+        addPart: (field, n) => `${field}, ny del ${n}`,
+        removePart: (field, n) => `${field}, del ${n} tas bort`,
         unknown: "Okänd ändring",
     },
 };
@@ -32,7 +39,7 @@ const HEADER_PREVIEW = 80;
 const FIELD_PREVIEW = 300;
 /**
  * `labels` names related documents by id (see `labelRelations`), so a chosen image reads as its
- * filename or alt text instead of an id.
+ * filename or alt text instead of an id. Rich text is listed by `richTextLines` instead.
  */
 export function humanDiff(current, operations, language = "en", labels) {
     const copy = COPY[language];
@@ -93,6 +100,33 @@ export function humanDiff(current, operations, language = "en", labels) {
         }
     });
 }
+/**
+ * The parts of a rich text field that changed: `before` as the model read it (Markdown blocks),
+ * `after` as compiled, where `{ keep: i }` is block `i` unchanged.
+ */
+export function richTextLines(path, before, after, language = "en") {
+    const copy = COPY[language];
+    const field = label(path);
+    const part = (block) => typeof block === "string"
+        ? preview(block, copy, FIELD_PREVIEW)
+        : `[${block.type ?? "?"}]`;
+    return richTextDiff(before, after).map((change) => {
+        switch (change.kind) {
+            case "changed":
+                return {
+                    path,
+                    text: `${copy.part(field, change.index + 1)}: ${part(change.before)} → ${part(change.after)}`,
+                };
+            case "added":
+                return { path, text: `${copy.addPart(field, change.index + 1)}: ${part(change.after)}` };
+            default:
+                return {
+                    path,
+                    text: `${copy.removePart(field, change.index + 1)}: ${part(change.before)}`,
+                };
+        }
+    });
+}
 /** Sub-lines are indented two spaces; the approval panel nests them under the header. */
 export const DIFF_SUBLINE_INDENT = "  ";
 function withFields(header, value, copy) {

package/dist/form/empty.d.ts

@@ -1,2 +1 @@
 export declare function listEmptyTextPaths(data: Record<string, unknown>): string[];
-export declare function previewAtPath(data: Record<string, unknown>, path: string): string | undefined;

package/dist/form/empty.js

@@ -1,6 +1,5 @@
 import { isDeniedFieldName } from "../config/denied-fields.js";
 import { lexicalPlaintext } from "./lexical.js";
-import { getAtPath, parseFieldPath } from "./path.js";
 const SKIP = new Set(["id", "slug", "blockType", "_status", "parent"]);
 const MAX_PATHS = 12;
 export function listEmptyTextPaths(data) {
@@ -8,22 +7,6 @@ export function listEmptyTextPaths(data) {
     walk(data, "", paths);
     return paths;
 }
-export function previewAtPath(data, path) {
-    try {
-        const value = getAtPath(data, parseFieldPath(path));
-        if (typeof value === "string" && value.trim()) {
-            return truncate(value.trim());
-        }
-        if (value && typeof value === "object" && "root" in value) {
-            const text = lexicalPlaintext(value);
-            return text ? truncate(text) : undefined;
-        }
-    }
-    catch {
-        return undefined;
-    }
-    return undefined;
-}
 function walk(value, path, into) {
     if (into.length >= MAX_PATHS) {
         return;
@@ -56,6 +39,3 @@ function walk(value, path, into) {
         }
     }
 }
-function truncate(value) {
-    return value.length > 80 ? `${value.slice(0, 77)}…` : value;
-}

package/dist/form/rich-text.d.ts

@@ -0,0 +1,72 @@
+/**
+ * Rich text for the model: Lexical editor state becomes a list of Markdown blocks, one per top-level
+ * node, and back. Payload's own converters do the work, with each field's own editor config, so the
+ * model can only write what the field allows. `{ keep: i }` stands for stored block `i` as it is:
+ * the model sends it for every block it leaves alone, and gets it for what Markdown cannot say
+ * (uploads, relationships, custom blocks), which it may move or drop but never create or change.
+ * A kept block, or one sent back unchanged, reuses the stored node exactly, keeping alignment,
+ * indent and styles.
+ *
+ * `@payloadcms/richtext-lexical` is an optional peer: without it, rich text stays as it was (plain
+ * text in, paragraphs out). Call `loadRichText` before converting.
+ */
+export type KeptBlock = {
+    keep: number;
+    type?: string;
+};
+export type RichTextBlock = string | KeptBlock;
+export type RichTextLink = {
+    collection: string;
+    id: string;
+};
+type LexicalNode = Record<string, unknown> & {
+    type?: unknown;
+    children?: unknown;
+};
+type LexicalState = {
+    root: Record<string, unknown> & {
+        children: LexicalNode[];
+    };
+};
+/** Loads Payload's converters once; false when `@payloadcms/richtext-lexical` is not installed. */
+export declare function loadRichText(): Promise<boolean>;
+export declare function isLexicalState(value: unknown): value is LexicalState;
+export declare function isRichTextBlocks(value: unknown): value is RichTextBlock[];
+/**
+ * The model's view of stored rich text, or null when it cannot be converted (no converters, no
+ * editor config). An empty field is `""`, so it reads as an empty text to fill.
+ */
+export declare function toBlocks(value: unknown, editor: unknown): RichTextBlock[] | "" | null;
+/**
+ * Rich text from what the model sent: blocks (see `toBlocks`) or a Markdown string. `original` is
+ * the stored value the blocks were made from. `links` are the internal links in rebuilt blocks, to
+ * check against the editor's access; links in reused blocks were there already.
+ */
+export declare function fromBlocks(value: RichTextBlock[] | string, original: unknown, editor: unknown): {
+    ok: true;
+    state: LexicalState;
+    links: RichTextLink[];
+} | {
+    ok: false;
+    error: string;
+};
+export type BlockChange = {
+    kind: "changed";
+    index: number;
+    before: RichTextBlock;
+    after: RichTextBlock;
+} | {
+    kind: "added";
+    index: number;
+    after: RichTextBlock;
+} | {
+    kind: "removed";
+    index: number;
+    before: RichTextBlock;
+};
+/**
+ * Which blocks changed between two block lists, by position in the new list for added and changed
+ * blocks and in the old list for removed ones. A removal next to an addition reads as a change.
+ */
+export declare function richTextDiff(before: unknown[], sent: unknown[]): BlockChange[];
+export {};

package/dist/form/rich-text.js

@@ -0,0 +1,254 @@
+/**
+ * Rich text for the model: Lexical editor state becomes a list of Markdown blocks, one per top-level
+ * node, and back. Payload's own converters do the work, with each field's own editor config, so the
+ * model can only write what the field allows. `{ keep: i }` stands for stored block `i` as it is:
+ * the model sends it for every block it leaves alone, and gets it for what Markdown cannot say
+ * (uploads, relationships, custom blocks), which it may move or drop but never create or change.
+ * A kept block, or one sent back unchanged, reuses the stored node exactly, keeping alignment,
+ * indent and styles.
+ *
+ * `@payloadcms/richtext-lexical` is an optional peer: without it, rich text stays as it was (plain
+ * text in, paragraphs out). Call `loadRichText` before converting.
+ */
+/** Top-level nodes whose Markdown round trip keeps them as they are. */
+const MARKDOWN_NODES = new Set(["paragraph", "heading", "list", "quote", "horizontalrule"]);
+/** Inline nodes Markdown can carry; a block holding anything else is kept whole. */
+const MARKDOWN_INLINE = new Set(["text", "link", "autolink", "linebreak", "tab", "listitem"]);
+/** How the model writes an internal link: `[text](doc:pages/12)`. */
+const DOC_LINK = /^doc:([\w-]+)\/(.+)$/;
+/**
+ * Payload's Markdown export drops unknown URL schemes, so internal links leave as this address and
+ * become `doc:` in the Markdown. Its import keeps `doc:` as written.
+ */
+const DOC_EXPORT = "https://doc.invalid/";
+let converters;
+/** Loads Payload's converters once; false when `@payloadcms/richtext-lexical` is not installed. */
+export async function loadRichText() {
+    if (converters === undefined) {
+        try {
+            const lexical = await import("@payloadcms/richtext-lexical");
+            converters = {
+                toMarkdown: lexical.convertLexicalToMarkdown,
+                toLexical: lexical.convertMarkdownToLexical,
+            };
+        }
+        catch {
+            converters = null;
+        }
+    }
+    return converters !== null;
+}
+export function isLexicalState(value) {
+    const root = value?.root;
+    return Boolean(root && typeof root === "object" && Array.isArray(root.children));
+}
+export function isRichTextBlocks(value) {
+    return Array.isArray(value) && value.every((item) => typeof item === "string" || isKept(item));
+}
+/**
+ * The model's view of stored rich text, or null when it cannot be converted (no converters, no
+ * editor config). An empty field is `""`, so it reads as an empty text to fill.
+ */
+export function toBlocks(value, editor) {
+    const editorConfig = editorConfigOf(editor);
+    if (!converters || !editorConfig || !isLexicalState(value)) {
+        return null;
+    }
+    const blocks = value.root.children.map((node, index) => canWrite(node)
+        ? nodeMarkdown(node, value.root, editorConfig)
+        : { keep: index, type: String(node.type ?? "node") });
+    const empty = blocks.every((block) => block === "");
+    return empty ? "" : blocks;
+}
+/**
+ * Rich text from what the model sent: blocks (see `toBlocks`) or a Markdown string. `original` is
+ * the stored value the blocks were made from. `links` are the internal links in rebuilt blocks, to
+ * check against the editor's access; links in reused blocks were there already.
+ */
+export function fromBlocks(value, original, editor) {
+    const editorConfig = editorConfigOf(editor);
+    if (!converters || !editorConfig) {
+        return { ok: false, error: "Rich text cannot be converted here." };
+    }
+    const stored = isLexicalState(original) ? original : undefined;
+    const storedBlocks = stored ? (toBlocks(stored, editor) ?? []) : [];
+    const blocks = typeof value === "string" ? [value] : value;
+    if (typeof value === "string" && Array.isArray(storedBlocks) && storedBlocks.some(isKept)) {
+        return {
+            ok: false,
+            error: "This rich text holds parts plain text would drop. Send it as a list of blocks, with { keep: i } for each block you leave as it is.",
+        };
+    }
+    const children = [];
+    const used = new Set();
+    const links = [];
+    const allowed = linkCollections(editorConfig);
+    for (const block of blocks) {
+        if (isKept(block)) {
+            const node = stored?.root.children[block.keep];
+            if (!node || used.has(block.keep)) {
+                return {
+                    ok: false,
+                    error: `{ keep: ${block.keep} } is not a block of this rich text, or appears twice.`,
+                };
+            }
+            used.add(block.keep);
+            children.push(node);
+            continue;
+        }
+        const reused = Array.isArray(storedBlocks)
+            ? storedBlocks.findIndex((entry, index) => entry === block && !used.has(index))
+            : -1;
+        const storedNode = reused >= 0 ? stored?.root.children[reused] : undefined;
+        if (storedNode) {
+            used.add(reused);
+            children.push(storedNode);
+            continue;
+        }
+        if (!block.trim()) {
+            continue;
+        }
+        const converted = converters.toLexical({ markdown: block, editorConfig });
+        const nodes = isLexicalState(converted) ? converted.root.children : [];
+        for (const node of nodes) {
+            const error = internalLinks(node, allowed, links);
+            if (error) {
+                return { ok: false, error };
+            }
+            children.push(node);
+        }
+    }
+    const root = stored?.root ?? {
+        type: "root",
+        format: "",
+        indent: 0,
+        version: 1,
+        direction: "ltr",
+    };
+    return { ok: true, state: { root: { ...root, children } }, links };
+}
+/**
+ * Which blocks changed between two block lists, by position in the new list for added and changed
+ * blocks and in the old list for removed ones. A removal next to an addition reads as a change.
+ */
+export function richTextDiff(before, sent) {
+    // { keep: i } in what the model sent stands for block i as it was.
+    const after = sent.map((block) => (isKept(block) ? (before[block.keep] ?? block) : block));
+    const key = (block) => (typeof block === "string" ? block : JSON.stringify(block));
+    const a = before.map(key);
+    const b = after.map(key);
+    // Longest common subsequence, small enough for the blocks of one field.
+    const lengths = Array.from({ length: a.length + 1 }, () => new Array(b.length + 1).fill(0));
+    for (let i = a.length - 1; i >= 0; i--) {
+        for (let j = b.length - 1; j >= 0; j--) {
+            lengths[i][j] =
+                a[i] === b[j] ? lengths[i + 1][j + 1] + 1 : Math.max(lengths[i + 1][j], lengths[i][j + 1]);
+        }
+    }
+    const changes = [];
+    let i = 0;
+    let j = 0;
+    while (i < a.length || j < b.length) {
+        if (i < a.length && j < b.length && a[i] === b[j]) {
+            i++;
+            j++;
+        }
+        else if (i < a.length &&
+            j < b.length &&
+            lengths[i + 1][j] === lengths[i][j + 1] &&
+            lengths[i + 1][j + 1] === lengths[i][j]) {
+            changes.push({
+                kind: "changed",
+                index: j,
+                before: before[i],
+                after: after[j],
+            });
+            i++;
+            j++;
+        }
+        else if (j < b.length && (i >= a.length || lengths[i][j + 1] >= lengths[i + 1][j])) {
+            changes.push({ kind: "added", index: j, after: after[j] });
+            j++;
+        }
+        else {
+            changes.push({ kind: "removed", index: i, before: before[i] });
+            i++;
+        }
+    }
+    return changes;
+}
+function canWrite(node) {
+    if (!MARKDOWN_NODES.has(String(node.type))) {
+        return false;
+    }
+    const inline = (child) => {
+        const record = child;
+        return (MARKDOWN_INLINE.has(String(record?.type)) &&
+            (!Array.isArray(record.children) || record.children.every(inline)));
+    };
+    return !Array.isArray(node.children) || node.children.every(inline);
+}
+/** One top-level node as Markdown, with internal links written as `doc:` links. */
+function nodeMarkdown(node, root, editorConfig) {
+    const data = { root: { ...root, children: [withDocLinks(node)] } };
+    const markdown = converters?.toMarkdown({ data, editorConfig }).trim() ?? "";
+    return markdown.replaceAll(`](${DOC_EXPORT}`, "](doc:");
+}
+function withDocLinks(node) {
+    const fields = node.fields;
+    const next = { ...node };
+    if (node.type === "link" && fields?.linkType === "internal") {
+        const doc = fields.doc;
+        const id = doc?.value && typeof doc.value === "object" ? doc.value.id : doc?.value;
+        next.fields = {
+            ...fields,
+            linkType: "custom",
+            url: `${DOC_EXPORT}${String(doc?.relationTo)}/${String(id)}`,
+        };
+    }
+    if (Array.isArray(node.children)) {
+        next.children = node.children.map((child) => withDocLinks(child));
+    }
+    return next;
+}
+/** Turns `doc:` links into Payload's internal links, collecting them; an error names the rule. */
+function internalLinks(node, allowed, into) {
+    const fields = node.fields;
+    const match = node.type === "link" && typeof fields?.url === "string" ? DOC_LINK.exec(fields.url) : null;
+    if (match) {
+        const [, collection = "", id = ""] = match;
+        // Without enabledCollections, Payload lets links point at any collection; access decides.
+        if (allowed && !allowed.includes(collection)) {
+            return allowed.length
+                ? `Links in this text can only point at ${allowed.join(", ")}.`
+                : "Links in this text cannot point at documents.";
+        }
+        node.fields = {
+            linkType: "internal",
+            doc: { relationTo: collection, value: /^\d+$/.test(id) ? Number(id) : id },
+            newTab: fields?.newTab === true,
+        };
+        into.push({ collection, id });
+    }
+    for (const child of Array.isArray(node.children) ? node.children : []) {
+        const error = internalLinks(child, allowed, into);
+        if (error) {
+            return error;
+        }
+    }
+    return undefined;
+}
+function linkCollections(editorConfig) {
+    const features = editorConfig
+        .resolvedFeatureMap;
+    const link = features?.get("link");
+    const enabled = link?.sanitizedServerFeatureProps?.enabledCollections;
+    return Array.isArray(enabled) ? enabled.filter((slug) => typeof slug === "string") : undefined;
+}
+function editorConfigOf(editor) {
+    return editor?.editorConfig;
+}
+function isKept(value) {
+    const record = value;
+    return Boolean(record && typeof record === "object" && Number.isInteger(record.keep));
+}

package/dist/form/shape.d.ts

@@ -1,11 +1,20 @@
 import type { FieldNode } from "../schema/fields.ts";
+import { type RichTextLink } from "./rich-text.ts";
 /**
- * Make compiled data safe to store: plain text in rich text fields becomes editor state,
- * then every block must be typed. Mutates `data`.
+ * A copy of `data` where each rich text field the converters can read is a list of `{ keep: i }`,
+ * one per stored block, so operations can set, insert or remove single blocks (`layout.1.content.2`)
+ * while every other block stays exactly as it was. `finalizeCompiled` turns the lists back.
  */
-export declare function finalizeCompiled(data: Record<string, unknown>, fields: FieldNode[]): {
+export declare function openRichText(data: Record<string, unknown>, fields: FieldNode[]): Record<string, unknown>;
+/**
+ * Make compiled data safe to store: rich text written as Markdown blocks or text becomes editor
+ * state, reusing what `original` (the form before the change) held, then every block must be
+ * typed. Mutates `data`. `links` are internal links in rewritten rich text, to check for access.
+ */
+export declare function finalizeCompiled(data: Record<string, unknown>, fields: FieldNode[], original?: Record<string, unknown>): {
     ok: true;
     data: Record<string, unknown>;
+    links: RichTextLink[];
 } | {
     ok: false;
     error: string;