@cosmicdrift/kumiko-bundled-features 0.374.0 → 0.378.0

package/dist/template-resolver/document-ops.d.ts

@@ -0,0 +1,167 @@
+import type { FieldIssue } from "@cosmicdrift/kumiko-framework/errors";
+import { type JSONContent } from "@tiptap/core";
+import * as z from "zod";
+import type { DocumentHtmlKind } from "./constants.ts";
+export declare const MAX_DOCUMENT_OPS = 50;
+export type DocumentBlockType = "paragraph" | "heading" | "list" | "table" | "repeat" | "image" | "button" | "divider" | "pageBreak" | "steps";
+export type DocumentBlock = {
+    readonly id: string;
+    readonly type: DocumentBlockType;
+    /** Inline content with `{{name}}` for placeholders; containers list one line per text block. */
+    readonly text?: string;
+    readonly level?: number;
+    readonly align?: string;
+    readonly showIf?: string;
+    readonly resource?: string;
+    readonly alt?: string;
+    readonly href?: string;
+    readonly each?: string;
+};
+export declare function documentBlockId(index: number): string;
+export declare function documentBlocksOf(doc: JSONContent): DocumentBlock[];
+declare const blockInputSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
+    type: z.ZodLiteral<"paragraph">;
+    text: z.ZodString;
+    align: z.ZodOptional<z.ZodEnum<{
+        center: "center";
+        justify: "justify";
+        left: "left";
+        right: "right";
+    }>>;
+}, z.core.$strip>, z.ZodObject<{
+    type: z.ZodLiteral<"heading">;
+    level: z.ZodNumber;
+    text: z.ZodString;
+}, z.core.$strip>, z.ZodObject<{
+    type: z.ZodLiteral<"image">;
+    resource: z.ZodString;
+    alt: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>, z.ZodObject<{
+    type: z.ZodLiteral<"button">;
+    text: z.ZodString;
+    href: z.ZodString;
+}, z.core.$strip>, z.ZodObject<{
+    type: z.ZodLiteral<"divider">;
+}, z.core.$strip>, z.ZodObject<{
+    type: z.ZodLiteral<"pageBreak">;
+}, z.core.$strip>], "type">;
+export type BlockInput = z.infer<typeof blockInputSchema>;
+export declare const documentOpSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
+    op: z.ZodLiteral<"insertBlock">;
+    after: z.ZodNullable<z.ZodString>;
+    block: z.ZodDiscriminatedUnion<[z.ZodObject<{
+        type: z.ZodLiteral<"paragraph">;
+        text: z.ZodString;
+        align: z.ZodOptional<z.ZodEnum<{
+            center: "center";
+            justify: "justify";
+            left: "left";
+            right: "right";
+        }>>;
+    }, z.core.$strip>, z.ZodObject<{
+        type: z.ZodLiteral<"heading">;
+        level: z.ZodNumber;
+        text: z.ZodString;
+    }, z.core.$strip>, z.ZodObject<{
+        type: z.ZodLiteral<"image">;
+        resource: z.ZodString;
+        alt: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>, z.ZodObject<{
+        type: z.ZodLiteral<"button">;
+        text: z.ZodString;
+        href: z.ZodString;
+    }, z.core.$strip>, z.ZodObject<{
+        type: z.ZodLiteral<"divider">;
+    }, z.core.$strip>, z.ZodObject<{
+        type: z.ZodLiteral<"pageBreak">;
+    }, z.core.$strip>], "type">;
+}, z.core.$strip>, z.ZodObject<{
+    op: z.ZodLiteral<"replaceText">;
+    blockId: z.ZodString;
+    find: z.ZodString;
+    replace: z.ZodString;
+}, z.core.$strip>, z.ZodObject<{
+    op: z.ZodLiteral<"removeBlock">;
+    blockId: z.ZodString;
+}, z.core.$strip>, z.ZodObject<{
+    op: z.ZodLiteral<"setResource">;
+    blockId: z.ZodString;
+    resource: z.ZodString;
+    alt: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+}, z.core.$strip>, z.ZodObject<{
+    op: z.ZodLiteral<"setMeta">;
+    meta: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+}, z.core.$strip>, z.ZodObject<{
+    op: z.ZodLiteral<"setVariable">;
+    name: z.ZodString;
+    definition: z.ZodNullable<z.ZodUnknown>;
+}, z.core.$strip>], "op">;
+export declare const documentOpsSchema: z.ZodArray<z.ZodDiscriminatedUnion<[z.ZodObject<{
+    op: z.ZodLiteral<"insertBlock">;
+    after: z.ZodNullable<z.ZodString>;
+    block: z.ZodDiscriminatedUnion<[z.ZodObject<{
+        type: z.ZodLiteral<"paragraph">;
+        text: z.ZodString;
+        align: z.ZodOptional<z.ZodEnum<{
+            center: "center";
+            justify: "justify";
+            left: "left";
+            right: "right";
+        }>>;
+    }, z.core.$strip>, z.ZodObject<{
+        type: z.ZodLiteral<"heading">;
+        level: z.ZodNumber;
+        text: z.ZodString;
+    }, z.core.$strip>, z.ZodObject<{
+        type: z.ZodLiteral<"image">;
+        resource: z.ZodString;
+        alt: z.ZodOptional<z.ZodString>;
+    }, z.core.$strip>, z.ZodObject<{
+        type: z.ZodLiteral<"button">;
+        text: z.ZodString;
+        href: z.ZodString;
+    }, z.core.$strip>, z.ZodObject<{
+        type: z.ZodLiteral<"divider">;
+    }, z.core.$strip>, z.ZodObject<{
+        type: z.ZodLiteral<"pageBreak">;
+    }, z.core.$strip>], "type">;
+}, z.core.$strip>, z.ZodObject<{
+    op: z.ZodLiteral<"replaceText">;
+    blockId: z.ZodString;
+    find: z.ZodString;
+    replace: z.ZodString;
+}, z.core.$strip>, z.ZodObject<{
+    op: z.ZodLiteral<"removeBlock">;
+    blockId: z.ZodString;
+}, z.core.$strip>, z.ZodObject<{
+    op: z.ZodLiteral<"setResource">;
+    blockId: z.ZodString;
+    resource: z.ZodString;
+    alt: z.ZodOptional<z.ZodNullable<z.ZodString>>;
+}, z.core.$strip>, z.ZodObject<{
+    op: z.ZodLiteral<"setMeta">;
+    meta: z.ZodRecord<z.ZodString, z.ZodUnknown>;
+}, z.core.$strip>, z.ZodObject<{
+    op: z.ZodLiteral<"setVariable">;
+    name: z.ZodString;
+    definition: z.ZodNullable<z.ZodUnknown>;
+}, z.core.$strip>], "op">>;
+export type DocumentOp = z.infer<typeof documentOpSchema>;
+export type DocumentOpsInput = {
+    readonly doc: JSONContent;
+    readonly meta: Readonly<Record<string, unknown>>;
+    readonly variableSchema: Readonly<Record<string, unknown>>;
+    readonly kind: DocumentHtmlKind;
+    readonly ops: readonly DocumentOp[];
+};
+export type DocumentOpsResult = {
+    readonly ok: true;
+    readonly doc: JSONContent;
+    readonly meta: Record<string, unknown>;
+    readonly variableSchema: Record<string, unknown>;
+} | {
+    readonly ok: false;
+    readonly issues: FieldIssue[];
+};
+export declare function applyDocumentOps(input: DocumentOpsInput): DocumentOpsResult;
+export {};

package/dist/template-resolver/document-ops.js

@@ -0,0 +1,390 @@
+import { getSchema } from "@tiptap/core";
+import * as z from "zod";
+import { documentBlocksForKind } from "./document-blocks.js";
+import { DOCUMENT_TEXT_ALIGNMENTS, documentExtensions, isDocumentPlaceholderHref, isDocumentReferenceName, isDocumentResourceKey, } from "./document-schema.js";
+import { contentToLine, lineToContent, singleLine } from "./placeholder-text.js";
+import { toVariableDef } from "./template-validation.js";
+export const MAX_DOCUMENT_OPS = 50;
+// Assigning these keys would reach the prototype of the meta object.
+const FORBIDDEN_META_KEYS = new Set(["__proto__", "prototype", "constructor"]);
+const TEXT_BLOCK_TYPES = new Set(["paragraph", "heading", "button"]);
+function blockTypeOf(node) {
+    switch (node.type) {
+        case "paragraph":
+        case "heading":
+        case "button":
+        case "divider":
+        case "pageBreak":
+        case "steps":
+            return node.type;
+        case "bulletList":
+        case "orderedList":
+            return "list";
+        case "table":
+            return eachOf(node) === undefined ? "table" : "repeat";
+        case "resource":
+            return "image";
+        default:
+            return null;
+    }
+}
+function stringAttr(node, name) {
+    const value = node.attrs?.[name];
+    return typeof value === "string" && value !== "" ? value : undefined;
+}
+function eachOf(table) {
+    for (const row of table.content ?? []) {
+        const each = stringAttr(row, "each");
+        if (each !== undefined)
+            return each;
+    }
+    return undefined;
+}
+function textLinesOf(node) {
+    if (TEXT_BLOCK_TYPES.has(node.type ?? ""))
+        return [contentToLine(node.content)];
+    return (node.content ?? []).flatMap(textLinesOf);
+}
+const NON_TEXT_BLOCK_TYPES = new Set([
+    "image",
+    "divider",
+    "pageBreak",
+    "steps",
+]);
+function setOptionalAttrs(block, node) {
+    const align = stringAttr(node, "textAlign");
+    if (align !== undefined)
+        block.align = align;
+    const showIf = stringAttr(node, "showIf");
+    if (showIf !== undefined)
+        block.showIf = showIf;
+}
+function setTypeSpecificAttrs(block, node) {
+    const level = node.attrs?.["level"];
+    if (block.type === "heading" && typeof level === "number")
+        block.level = level;
+    const resource = stringAttr(node, "resource");
+    if (block.type === "image" && resource !== undefined)
+        block.resource = resource;
+    const alt = stringAttr(node, "alt");
+    if (block.type === "image" && alt !== undefined)
+        block.alt = alt;
+    const href = stringAttr(node, "href");
+    if (block.type === "button" && href !== undefined)
+        block.href = href;
+    const each = eachOf(node);
+    if (block.type === "repeat" && each !== undefined)
+        block.each = each;
+}
+function blockOf(node, id) {
+    const type = blockTypeOf(node);
+    if (type === null)
+        return null;
+    const block = { id, type };
+    if (!NON_TEXT_BLOCK_TYPES.has(type))
+        block.text = textLinesOf(node).join("\n");
+    setOptionalAttrs(block, node);
+    setTypeSpecificAttrs(block, node);
+    return block;
+}
+export function documentBlockId(index) {
+    return `b${index}`;
+}
+export function documentBlocksOf(doc) {
+    return (doc.content ?? []).flatMap((node, index) => blockOf(node, documentBlockId(index)) ?? []);
+}
+const blockIdSchema = z.string().min(1).max(20);
+const singleLineText = z.string().max(2000);
+const blockInputSchema = z.discriminatedUnion("type", [
+    z.object({
+        type: z.literal("paragraph"),
+        text: singleLineText,
+        align: z.enum(DOCUMENT_TEXT_ALIGNMENTS).optional(),
+    }),
+    z.object({
+        type: z.literal("heading"),
+        level: z.number().int().min(1).max(3),
+        text: singleLineText,
+    }),
+    z.object({
+        type: z.literal("image"),
+        resource: z.string().min(1).max(200),
+        alt: z.string().max(500).optional(),
+    }),
+    z.object({ type: z.literal("button"), text: singleLineText, href: z.string().max(300) }),
+    z.object({ type: z.literal("divider") }),
+    z.object({ type: z.literal("pageBreak") }),
+]);
+export const documentOpSchema = z.discriminatedUnion("op", [
+    z.object({
+        op: z.literal("insertBlock"),
+        after: blockIdSchema.nullable(),
+        block: blockInputSchema,
+    }),
+    z.object({
+        op: z.literal("replaceText"),
+        blockId: blockIdSchema,
+        find: z.string().min(1).max(2000),
+        replace: z.string().max(2000),
+    }),
+    z.object({ op: z.literal("removeBlock"), blockId: blockIdSchema }),
+    z.object({
+        op: z.literal("setResource"),
+        blockId: blockIdSchema,
+        resource: z.string().min(1).max(200),
+        alt: z.string().max(500).nullable().optional(),
+    }),
+    z.object({ op: z.literal("setMeta"), meta: z.record(z.string(), z.unknown()) }),
+    z.object({
+        op: z.literal("setVariable"),
+        name: z.string().min(1).max(100),
+        definition: z.unknown().nullable(),
+    }),
+]);
+export const documentOpsSchema = z.array(documentOpSchema).min(1).max(MAX_DOCUMENT_OPS);
+function patchIssue(path, code, params) {
+    const camel = code.replace(/_([a-z])/g, (_match, letter) => letter.toUpperCase());
+    return {
+        path,
+        code,
+        i18nKey: `templateResolver.errors.patch.${camel}`,
+        ...(params === undefined ? {} : { params }),
+    };
+}
+function textNodesIn(nodes) {
+    return nodes.flatMap((node) => (node.type === "text" ? [node] : textNodesIn(node.content ?? [])));
+}
+function occurrencesOf(text, find) {
+    return text.split(find).length - 1;
+}
+function replacementNodes(textNode, find, replace) {
+    const text = textNode.text ?? "";
+    const at = text.indexOf(find);
+    const withMarks = (node) => node.type === "text" && textNode.marks !== undefined
+        ? { ...node, marks: textNode.marks }
+        : node;
+    const before = text.slice(0, at);
+    const after = text.slice(at + find.length);
+    return [
+        ...(before === "" ? [] : [{ ...textNode, text: before }]),
+        ...lineToContent(singleLine(replace)).map(withMarks),
+        ...(after === "" ? [] : [{ ...textNode, text: after }]),
+    ];
+}
+function replaceInContent(content, find, replace) {
+    return content.flatMap((node) => {
+        if (node.type === "text") {
+            return (node.text ?? "").includes(find) ? replacementNodes(node, find, replace) : [node];
+        }
+        return [
+            node.content === undefined
+                ? node
+                : { ...node, content: replaceInContent(node.content, find, replace) },
+        ];
+    });
+}
+function nodeOfInput(input) {
+    switch (input.type) {
+        case "paragraph":
+            return {
+                type: "paragraph",
+                ...(input.align === undefined ? {} : { attrs: { textAlign: input.align } }),
+                content: lineToContent(singleLine(input.text)),
+            };
+        case "heading":
+            return {
+                type: "heading",
+                attrs: { level: input.level },
+                content: lineToContent(singleLine(input.text)),
+            };
+        case "image":
+            return { type: "resource", attrs: { resource: input.resource, alt: input.alt ?? null } };
+        case "button":
+            return {
+                type: "button",
+                attrs: { href: input.href },
+                content: lineToContent(singleLine(input.text)),
+            };
+        case "divider":
+        case "pageBreak":
+            return { type: input.type };
+    }
+}
+const TOOLBAR_BLOCK_OF_INPUT = {
+    image: "image",
+    button: "button",
+    divider: "divider",
+    pageBreak: "pageBreak",
+};
+function isBlockAllowed(input, kind) {
+    if (input.type === "paragraph" || input.type === "heading")
+        return true;
+    return documentBlocksForKind(kind).includes(TOOLBAR_BLOCK_OF_INPUT[input.type]);
+}
+function inputIssue(input, path) {
+    if (input.type === "image" && !isDocumentResourceKey(input.resource)) {
+        return patchIssue(`${path}.block.resource`, "invalid_resource_key", {
+            resource: input.resource,
+        });
+    }
+    if (input.type === "button" && !isDocumentPlaceholderHref(input.href)) {
+        return patchIssue(`${path}.block.href`, "invalid_button_href", { href: input.href });
+    }
+    return null;
+}
+let cachedSchema = null;
+function documentSchema() {
+    cachedSchema ??= getSchema(documentExtensions);
+    return cachedSchema;
+}
+function isValidDocument(doc) {
+    try {
+        documentSchema().nodeFromJSON(doc).check();
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+function lookupEntry(state, blockId, fieldPath) {
+    const entry = state.entries.get(blockId);
+    if (entry === undefined)
+        return { issue: patchIssue(fieldPath, "unknown_block", { blockId }) };
+    if (entry.removed)
+        return { issue: patchIssue(fieldPath, "block_removed", { blockId }) };
+    return { entry };
+}
+function blockInputIssue(op, path, kind) {
+    if (!isBlockAllowed(op.block, kind)) {
+        return patchIssue(`${path}.block.type`, "block_not_allowed", { type: op.block.type, kind });
+    }
+    if (op.block.type === "paragraph" &&
+        op.block.align !== undefined &&
+        !documentBlocksForKind(kind).includes("align")) {
+        return patchIssue(`${path}.block.align`, "block_not_allowed", { type: "align", kind });
+    }
+    return inputIssue(op.block, path);
+}
+function insertBlockOp(state, op, path) {
+    const anchor = op.after === null ? null : lookupEntry(state, op.after, `${path}.after`);
+    if (anchor !== null && "issue" in anchor)
+        return anchor.issue;
+    const invalid = blockInputIssue(op, path, state.kind);
+    if (invalid !== null)
+        return invalid;
+    const target = anchor === null ? state.insertedAtStart : anchor.entry.insertedAfter;
+    target.push(nodeOfInput(op.block));
+    return null;
+}
+function removeBlockOp(state, op, path) {
+    const found = lookupEntry(state, op.blockId, `${path}.blockId`);
+    if ("issue" in found)
+        return found.issue;
+    found.entry.removed = true;
+    return null;
+}
+function replaceTextOp(state, op, path) {
+    const found = lookupEntry(state, op.blockId, `${path}.blockId`);
+    if ("issue" in found)
+        return found.issue;
+    const { entry } = found;
+    const count = textNodesIn([entry.node]).reduce((sum, node) => sum + occurrencesOf(node.text ?? "", op.find), 0);
+    if (count === 0)
+        return patchIssue(`${path}.find`, "text_not_found", { find: op.find });
+    if (count > 1)
+        return patchIssue(`${path}.find`, "text_ambiguous", { find: op.find, count });
+    entry.node = replaceInContent([entry.node], op.find, op.replace)[0] ?? entry.node;
+    return null;
+}
+function setResourceOp(state, op, path) {
+    const found = lookupEntry(state, op.blockId, `${path}.blockId`);
+    if ("issue" in found)
+        return found.issue;
+    const { entry } = found;
+    if (entry.node.type !== "resource") {
+        return patchIssue(`${path}.blockId`, "block_type_mismatch", {
+            expected: "image",
+            actual: entry.node.type ?? "unknown",
+        });
+    }
+    if (!isDocumentResourceKey(op.resource)) {
+        return patchIssue(`${path}.resource`, "invalid_resource_key", { resource: op.resource });
+    }
+    const alt = op.alt === undefined ? (entry.node.attrs?.["alt"] ?? null) : op.alt;
+    entry.node = { ...entry.node, attrs: { resource: op.resource, alt } };
+    return null;
+}
+function setMetaOp(state, op, path) {
+    const forbidden = Object.keys(op.meta).find((key) => FORBIDDEN_META_KEYS.has(key));
+    if (forbidden !== undefined) {
+        return patchIssue(`${path}.meta`, "invalid_meta_key", { key: forbidden });
+    }
+    for (const [key, value] of Object.entries(op.meta)) {
+        if (value === null)
+            delete state.meta[key];
+        else
+            state.meta[key] = value;
+    }
+    return null;
+}
+function setVariableOp(state, op, path) {
+    if (!isDocumentReferenceName(op.name)) {
+        return patchIssue(`${path}.name`, "invalid_variable_name", { name: op.name });
+    }
+    if (op.definition === null) {
+        delete state.variableSchema[op.name];
+        return null;
+    }
+    const definition = toVariableDef(op.definition);
+    if (definition === null) {
+        return patchIssue(`${path}.definition`, "invalid_variable_definition", { name: op.name });
+    }
+    state.variableSchema[op.name] = definition;
+    return null;
+}
+function applyOp(state, op, path) {
+    switch (op.op) {
+        case "insertBlock":
+            return insertBlockOp(state, op, path);
+        case "removeBlock":
+            return removeBlockOp(state, op, path);
+        case "replaceText":
+            return replaceTextOp(state, op, path);
+        case "setResource":
+            return setResourceOp(state, op, path);
+        case "setMeta":
+            return setMetaOp(state, op, path);
+        case "setVariable":
+            return setVariableOp(state, op, path);
+    }
+}
+// Ops address blocks by the ids of the document as it was read, so inserted blocks are
+// collected per anchor and the list is assembled once at the end.
+export function applyDocumentOps(input) {
+    const entries = new Map();
+    (input.doc.content ?? []).forEach((node, index) => {
+        entries.set(documentBlockId(index), {
+            node: structuredClone(node),
+            removed: false,
+            insertedAfter: [],
+        });
+    });
+    const state = {
+        kind: input.kind,
+        entries,
+        insertedAtStart: [],
+        meta: { ...input.meta },
+        variableSchema: { ...input.variableSchema },
+    };
+    const issues = input.ops.flatMap((op, index) => applyOp(state, op, `ops.${index}`) ?? []);
+    if (issues.length > 0)
+        return { ok: false, issues };
+    const content = [
+        ...state.insertedAtStart,
+        ...[...entries.values()].flatMap((entry) => entry.removed ? entry.insertedAfter : [entry.node, ...entry.insertedAfter]),
+    ];
+    const doc = { ...input.doc, content };
+    if (!isValidDocument(doc))
+        return { ok: false, issues: [patchIssue("ops", "invalid_document")] };
+    return { ok: true, doc, meta: state.meta, variableSchema: state.variableSchema };
+}

package/dist/template-resolver/document-sanitizer.d.ts

@@ -1,7 +1,8 @@
 import type { FieldIssue } from "@cosmicdrift/kumiko-framework/errors";
+import type { JSONContent } from "@tiptap/core";
 import { type Element as ScanElement } from "happy-dom";
 import type { ContentFormat } from "./constants.ts";
-export type DocumentViolationCode = "script_element" | "event_handler_attribute" | "disallowed_link_href" | "external_image_source" | "image_without_resource" | "invalid_reference_name" | "embedded_content" | "unsafe_attribute_value" | "button_href_not_placeholder" | "document_requires_html_format" | "layout_requires_mjml_format" | "layout_invalid_structure" | "layout_missing_content_slot" | "layout_source_system_only";
+export type DocumentViolationCode = "script_element" | "event_handler_attribute" | "disallowed_link_href" | "external_image_source" | "image_without_resource" | "invalid_reference_name" | "embedded_content" | "unsafe_attribute_value" | "images_block_pdf_only" | "button_href_not_placeholder" | "document_requires_html_format" | "layout_requires_mjml_format" | "layout_invalid_structure" | "layout_missing_content_slot" | "layout_source_system_only";
 export type DocumentViolation = {
     readonly code: DocumentViolationCode;
     readonly detail: string;
@@ -24,6 +25,8 @@ export type SanitizeBodyResult = {
 export declare function violation(code: DocumentViolationCode, detail: string, message: string): DocumentViolation;
 export declare function withParsedDocument<T>(html: string, read: (body: ScanElement) => T): T;
 export declare function sanitizeDocumentHtml(html: string): SanitizeHtmlResult;
+export declare function parseDocumentJson(html: string): JSONContent;
+export declare function serializeDocumentJson(doc: JSONContent): string;
 export declare function flattenParagraphsToLineBreaks(sanitizedHtml: string): string;
 export declare function sanitizeTemplateBody(input: {
     readonly kind: string;

package/dist/template-resolver/document-sanitizer.js

@@ -59,6 +59,7 @@ const REFERENCE_ATTRIBUTES = [
     [DOCUMENT_CONDITION_ATTRIBUTE, isDocumentReferenceName],
     ["data-resource", isDocumentResourceKey],
     ["data-steps", isDocumentReferenceName],
+    ["data-images", isDocumentReferenceName],
     ["data-step", isDocumentStepKey],
 ];
 function scanReferences(tag, element, out) {
@@ -156,6 +157,12 @@ export function sanitizeDocumentHtml(html) {
         html: generateHTML(generateJSON(html, documentExtensions), documentExtensions),
     };
 }
+export function parseDocumentJson(html) {
+    return generateJSON(html, documentExtensions);
+}
+export function serializeDocumentJson(doc) {
+    return generateHTML(doc, documentExtensions);
+}
 // For a sanitized value placed inside a line of text: paragraphs become line
 // breaks. Other blocks (lists, headings) cannot be made inline and stay as they are.
 export function flattenParagraphsToLineBreaks(sanitizedHtml) {
@@ -176,10 +183,28 @@ function requiredFormatViolation(kind, contentFormat) {
     }
     return null;
 }
+const IMAGES_BLOCK_KIND = "document-pdf";
+// The node is part of the shared document model, so a mail body would keep it after the
+// rebuild; only a PDF resolves the record's images.
+function imagesBlockViolation(input) {
+    if (input.kind === IMAGES_BLOCK_KIND ||
+        !isSanitizedHtmlKind(input.kind) ||
+        input.contentFormat !== "html" ||
+        input.content === null) {
+        return null;
+    }
+    const hasImagesBlock = withParsedDocument(input.content, (body) => body.querySelector("div[data-images]") !== null);
+    return hasImagesBlock
+        ? violation("images_block_pdf_only", input.kind, `Record images blocks are only allowed in templates of kind ${IMAGES_BLOCK_KIND}`)
+        : null;
+}
 export function sanitizeTemplateBody(input) {
     const formatViolation = requiredFormatViolation(input.kind, input.contentFormat);
     if (formatViolation !== null)
         return { ok: false, violations: [formatViolation] };
+    const imagesViolation = imagesBlockViolation(input);
+    if (imagesViolation !== null)
+        return { ok: false, violations: [imagesViolation] };
     if (!isSanitizedHtmlKind(input.kind) ||
         input.contentFormat !== "html" ||
         input.content === null) {
@@ -197,6 +222,7 @@ const VIOLATION_I18N_KEYS = {
     invalid_reference_name: "templateResolver.errors.document.invalidReferenceName",
     embedded_content: "templateResolver.errors.document.embeddedContent",
     unsafe_attribute_value: "templateResolver.errors.document.unsafeAttributeValue",
+    images_block_pdf_only: "templateResolver.errors.document.imagesBlockPdfOnly",
     button_href_not_placeholder: "templateResolver.errors.document.buttonHrefNotPlaceholder",
     document_requires_html_format: "templateResolver.errors.document.documentRequiresHtmlFormat",
     layout_requires_mjml_format: "templateResolver.errors.document.layoutRequiresMjmlFormat",

package/dist/template-resolver/document-schema.d.ts

@@ -3,13 +3,14 @@ export declare function isDocumentPlaceholderHref(href: string): boolean;
 export declare function isAllowedDocumentLinkHref(href: string): boolean;
 export declare function isDocumentReferenceName(value: string): boolean;
 export declare function isDocumentResourceKey(value: string): boolean;
-export declare const DOCUMENT_NODE_NAMES: readonly ["variable", "resource", "button", "divider", "pageBreak", "steps"];
+export declare const DOCUMENT_NODE_NAMES: readonly ["variable", "resource", "button", "divider", "pageBreak", "steps", "images"];
 export declare const DocumentVariable: Node<any, any>;
 export declare const DocumentResource: Node<any, any>;
 export declare const DocumentButton: Node<any, any>;
 export declare const DocumentDivider: Node<any, any>;
 export declare const DocumentPageBreak: Node<any, any>;
 export declare const DocumentSteps: Node<any, any>;
+export declare const DocumentImages: Node<any, any>;
 export declare const DocumentTableRow: Node<import("@tiptap/extension-table").TableRowOptions, any>;
 export declare const DocumentTable: Node<import("@tiptap/extension-table").TableOptions, any>;
 export declare const DocumentTableCell: Node<import("@tiptap/extension-table").TableCellOptions, any>;

package/dist/template-resolver/document-schema.js

@@ -8,6 +8,7 @@ import { Extension, Node } from "@tiptap/core";
 import { Link } from "@tiptap/extension-link";
 import { Table, TableCell, TableHeader, TableRow } from "@tiptap/extension-table";
 import StarterKit from "@tiptap/starter-kit";
+import { createDocumentImagesNode } from "./document-images.js";
 import { createDocumentStepsNode } from "./document-steps.js";
 const PLACEHOLDER_HREF = /^\{\{(.+)\}\}$/;
 const REFERENCE_NAME = /^[A-Za-z_][A-Za-z0-9_]*(\.[A-Za-z_][A-Za-z0-9_]*)*$/;
@@ -65,6 +66,7 @@ export const DOCUMENT_NODE_NAMES = [
     "divider",
     "pageBreak",
     "steps",
+    "images",
 ];
 export const DocumentVariable = Node.create({
     name: "variable",
@@ -170,6 +172,7 @@ export const DocumentPageBreak = Node.create({
     },
 });
 export const DocumentSteps = createDocumentStepsNode(isDocumentReferenceName);
+export const DocumentImages = createDocumentImagesNode(isDocumentReferenceName);
 // A repeat row is a table row carrying `each`: prosemirror-tables requires
 // the tableRow node type, so a separate node type is not an option.
 export const DocumentTableRow = TableRow.extend({
@@ -346,6 +349,7 @@ export const documentExtensions = [
     DocumentDivider,
     DocumentPageBreak,
     DocumentSteps,
+    DocumentImages,
     DocumentTextAlign,
     DocumentTextSize,
     DocumentCondition,