@designcrowd/library.brand-page 6.2.11 → 6.2.12

package/lib/src/{brand-page-maker/composables/rich-text-editor/extensions → shared/rte-extensions}/AutoLink.js

@@ -1,6 +1,10 @@
 import { Extension } from '@tiptap/core';
 import { Plugin, PluginKey } from 'prosemirror-state';
 import { DEFAULT_LINK_COLOR as LINK_COLOR } from '@src/constants/rich-text-editor.constants';
+/** A transaction carrying this meta skips the new-link styling pass below: a clipboard paste
+ * brings its own look (a copied link keeps its colour; a text-only paste brings no links), so
+ * neither wants AutoLink's "force blue + underline" treatment for a newly-created link. */
+export const AUTO_LINK_SKIP_STYLING_META = 'autoLinkSkipStyling';
 const isLinkMark = (mark) => mark.type.name === 'link';
 const isUnderlineMark = (mark) => mark.type.name === 'underline';
 const isTextStyleMark = (mark) => mark.type.name === 'textStyle';
@@ -38,6 +42,45 @@ const applyDefaultLinkStyling = (tr, schema, node, pos) => {
     }
     return modified;
 };
+/**
+ * The end-of-link detach a typed character gets right after a link's last position: the link
+ * mark (and its auto-blue colour, unless the user manually added an underline) drops from what
+ * comes next, so continuing to type doesn't extend the link. `null` when `pos` isn't at the end
+ * of a link — mid-link, or no link at all — so the caller keeps its own marks unchanged.
+ * Exported for `RteClipboard.ts`'s text-only paste, which takes the same detach a typed
+ * character would.
+ */
+export const linkDetachMarksAt = (state, pos) => {
+    const currentMarks = state.doc.resolve(pos).marks();
+    const linkMark = currentMarks.find(isLinkMark);
+    if (!linkMark)
+        return null;
+    const nextPos = pos + 1;
+    const hasLinkAfter = nextPos <= state.doc.content.size &&
+        state.doc
+            .resolve(Math.min(nextPos, state.doc.content.size))
+            .marks()
+            .some((mark) => isLinkMark(mark) && mark.eq(linkMark));
+    if (hasLinkAfter)
+        return null;
+    return currentMarks
+        .filter((mark) => {
+        if (isLinkMark(mark))
+            return false;
+        // Only preserve underlines if there's no blue color (manually added underlines)
+        // Remove underlines that were part of link styling (with blue color)
+        if (isUnderlineMark(mark)) {
+            const hasBlueColor = currentMarks.some(isBlueColorMark);
+            return !hasBlueColor;
+        }
+        // Remove blue color styling but preserve other text styles
+        if (isBlueColorMark(mark)) {
+            return createStylesWithoutColor(state.schema, mark);
+        }
+        return true;
+    })
+        .filter(Boolean);
+};
 const removeHyperlinkStyles = (tr, schema, node, pos) => {
     const range = { from: pos, to: pos + node.nodeSize };
     let modified = false;
@@ -70,52 +113,19 @@ export const AutoLink = Extension.create({
                 props: {
                     handleTextInput(view, from, to, text) {
                         const { state } = view;
-                        const { selection } = state;
-                        const { $anchor } = selection;
                         // Only handle when typing at a cursor position (from === to)
                         if (from !== to) {
                             return false;
                         }
-                        // Check if we have link marks at cursor position
-                        const currentMarks = $anchor.marks();
-                        const linkMark = currentMarks.find(isLinkMark);
-                        if (linkMark) {
-                            // Check if we're at the end of the link
-                            const currentPos = $anchor.pos;
-                            const nextPos = currentPos + 1;
-                            const hasLinkAfter = nextPos <= state.doc.content.size &&
-                                state.doc
-                                    .resolve(Math.min(nextPos, state.doc.content.size))
-                                    .marks()
-                                    .some((mark) => isLinkMark(mark) && mark.eq(linkMark));
-                            if (!hasLinkAfter) {
-                                // detach the link after the attached link mark
-                                const preservedMarks = currentMarks
-                                    .filter((mark) => {
-                                    if (isLinkMark(mark))
-                                        return false;
-                                    // Only preserve underlines if there's no blue color (manually added underlines)
-                                    // Remove underlines that were part of link styling (with blue color)
-                                    if (isUnderlineMark(mark)) {
-                                        const hasBlueColor = currentMarks.some(isBlueColorMark);
-                                        return !hasBlueColor; // Keep underline only if no blue color
-                                    }
-                                    // Remove blue color styling but preserve other text styles
-                                    if (isBlueColorMark(mark)) {
-                                        return createStylesWithoutColor(state.schema, mark);
-                                    }
-                                    return true;
-                                })
-                                    .filter(Boolean); // Insert text with only preserved marks
-                                let tr = state.tr;
-                                tr = tr.setStoredMarks(preservedMarks);
-                                tr = tr.insertText(text, from, to);
-                                tr = tr.setMeta('autoLinkDetached', true);
-                                view.dispatch(tr);
-                                return true;
-                            }
-                        }
-                        return false;
+                        const detached = linkDetachMarksAt(state, state.selection.$anchor.pos);
+                        if (!detached)
+                            return false;
+                        let tr = state.tr;
+                        tr = tr.setStoredMarks(detached);
+                        tr = tr.insertText(text, from, to);
+                        tr = tr.setMeta('autoLinkDetached', true);
+                        view.dispatch(tr);
+                        return true;
                     },
                 },
                 appendTransaction(transactions, oldState, newState) {
@@ -125,24 +135,30 @@ export const AutoLink = Extension.create({
                     if (!hasDocChanges)
                         return null;
                     const wasDetached = transactions.some((transaction) => transaction.getMeta('autoLinkDetached'));
-                    // Apply default styling to links (unless just detached)
-                    if (!wasDetached) {
+                    const skipsNewLinkStyling = transactions.some((transaction) => transaction.getMeta(AUTO_LINK_SKIP_STYLING_META));
+                    // Apply default styling to links (unless just detached, or the transaction brings its
+                    // own look — a clipboard paste)
+                    if (!wasDetached && !skipsNewLinkStyling) {
+                        // A link is new when its text wasn't a link before these transactions. Map each
+                        // position back through them: an edit earlier in the doc shifts every later link, so
+                        // the same raw position in the old doc lands on other text.
+                        const toOldPos = transactions
+                            .map((transaction) => transaction.mapping.invert())
+                            .reverse();
                         newState.doc.descendants((node, pos) => {
                             if (!node.isText || !node.text || !hasLinkMark(node.marks))
                                 return;
-                            // Check if this is a newly created link by comparing with old state
-                            const oldNode = pos < oldState.doc.nodeSize ? oldState.doc.nodeAt(pos) : null;
+                            const oldPos = toOldPos.reduce((mapped, mapping) => mapping.map(mapped, 1), pos);
+                            const oldNode = oldPos < oldState.doc.content.size
+                                ? oldState.doc.nodeAt(oldPos)
+                                : null;
                             const wasAlreadyLink = oldNode && hasLinkMark(oldNode.marks);
-                            // Only apply full styling (including underline) to newly created links
+                            // An existing link keeps the colour and underline it has now.
                             if (wasAlreadyLink === false) {
                                 if (applyDefaultLinkStyling(tr, newState.schema, node, pos)) {
                                     modified = true;
                                 }
                             }
-                            else {
-                                // For existing links, preserve their current color and underline choices
-                                // Don't override user customizations on existing links
-                            }
                         });
                     }
                     // Clean up hyperlink styling from text without link marks

package/lib/src/{brand-page-maker/composables/rich-text-editor/extensions → shared/rte-extensions}/MaxLength.js

@@ -18,7 +18,10 @@ export const MaxLength = Extension.create({
                         const { maxLength } = this.options;
                         const { state } = view;
                         const { from, to } = view.state.selection;
-                        const selectionSize = to - from;
+                        // The selected TEXT being replaced, not its position span: a selection crossing a
+                        // paragraph boundary spans 2 extra positions (the closing/opening block nodes) that
+                        // aren't characters.
+                        const selectionSize = state.doc.textBetween(from, to).length;
                         const currentTextLength = state.doc.textContent.length - selectionSize;
                         const incomingText = slice.content.textBetween(0, slice.content.size, '\n');
                         const allowed = maxLength - currentTextLength;

package/lib/src/shared/rte-extensions/TextEffects.d.ts

@@ -0,0 +1,28 @@
+import { Extension } from '@tiptap/core';
+export type TextEffectsOptions = {
+    types: string[];
+    renderTextDecorationClasses?: boolean;
+};
+declare module '@tiptap/core' {
+    interface Commands<ReturnType> {
+        textEffects: {
+            setFontWeight: (value: string) => ReturnType;
+            unsetFontWeight: () => ReturnType;
+            setFontStyle: (value: string) => ReturnType;
+            unsetFontStyle: () => ReturnType;
+            setTextDecoration: (value: string) => ReturnType;
+            unsetTextDecoration: () => ReturnType;
+        };
+    }
+}
+/**
+ * BP-5969 — weight / style / decoration as `textStyle` mark ATTRIBUTES, not semantic marks.
+ *
+ * Every typography property now lives on the run's `textStyle` mark, each defaulting to its role
+ * `var(--role-*)` (or a raw override) — identical to family/size/line-height/letter-spacing. So
+ * editing a role's font-weight / font-style / text-decoration changes one CSS custom-property
+ * declaration and repaints every linked run through the cascade, with no doc rewrite. (The
+ * container applies nothing, so a per-run `font-weight: normal` / `text-decoration: none` override
+ * cleanly wins — the reason these can leave the semantic `<strong>`/`<u>` model.)
+ */
+export declare const TextEffects: Extension<TextEffectsOptions, any>;

package/lib/src/shared/rte-extensions/TextEffects.js

@@ -0,0 +1,96 @@
+import { Extension } from '@tiptap/core';
+import { composeTextDecoration, roleVarRef, rteTextDecorationClassName, } from '@shared/text-role-typography.util';
+/**
+ * BP-5969 — weight / style / decoration as `textStyle` mark ATTRIBUTES, not semantic marks.
+ *
+ * Every typography property now lives on the run's `textStyle` mark, each defaulting to its role
+ * `var(--role-*)` (or a raw override) — identical to family/size/line-height/letter-spacing. So
+ * editing a role's font-weight / font-style / text-decoration changes one CSS custom-property
+ * declaration and repaints every linked run through the cascade, with no doc rewrite. (The
+ * container applies nothing, so a per-run `font-weight: normal` / `text-decoration: none` override
+ * cleanly wins — the reason these can leave the semantic `<strong>`/`<u>` model.)
+ */
+export const TextEffects = Extension.create({
+    name: 'textEffects',
+    addOptions() {
+        return {
+            types: ['textStyle'],
+            renderTextDecorationClasses: false,
+        };
+    },
+    addGlobalAttributes() {
+        return [
+            {
+                types: this.options.types,
+                attributes: {
+                    fontWeight: {
+                        default: null,
+                        parseHTML: (element) => element.style.fontWeight || null,
+                        renderHTML: (attributes) => attributes.fontWeight
+                            ? { style: `font-weight: ${attributes.fontWeight}` }
+                            : {},
+                    },
+                    fontStyle: {
+                        default: null,
+                        parseHTML: (element) => element.style.fontStyle || null,
+                        renderHTML: (attributes) => attributes.fontStyle
+                            ? { style: `font-style: ${attributes.fontStyle}` }
+                            : {},
+                    },
+                    textDecoration: {
+                        default: null,
+                        parseHTML: (element) => element.style.textDecoration || null,
+                        renderHTML: (attributes) => {
+                            if (!attributes.textDecoration)
+                                return {};
+                            const className = this.options.renderTextDecorationClasses
+                                ? rteTextDecorationClassName(attributes.textDecoration, attributes.textDecorationReset === true)
+                                : undefined;
+                            if (this.options.renderTextDecorationClasses)
+                                return className ? { class: className } : {};
+                            const value = attributes.textDecoration === roleVarRef('textDecoration')
+                                ? attributes.textDecoration
+                                : composeTextDecoration(undefined, attributes.textDecoration);
+                            return value ? { style: `text-decoration: ${value}` } : {};
+                        },
+                    },
+                    textDecorationReset: {
+                        default: null,
+                        parseHTML: (element) => element.getAttribute('data-bp-text-decoration-reset') === 'true'
+                            ? true
+                            : null,
+                        renderHTML: (attributes) => attributes.textDecorationReset
+                            ? { 'data-bp-text-decoration-reset': 'true' }
+                            : {},
+                    },
+                },
+            },
+        ];
+    },
+    addCommands() {
+        return {
+            setFontWeight: (fontWeight) => ({ chain }) => chain().setMark('textStyle', { fontWeight }).run(),
+            unsetFontWeight: () => ({ chain }) => chain()
+                .setMark('textStyle', { fontWeight: null })
+                .removeEmptyTextStyle()
+                .run(),
+            setFontStyle: (fontStyle) => ({ chain }) => chain().setMark('textStyle', { fontStyle }).run(),
+            unsetFontStyle: () => ({ chain }) => chain()
+                .setMark('textStyle', { fontStyle: null })
+                .removeEmptyTextStyle()
+                .run(),
+            // A reset marker qualifies only the value it was written with; setMark merges attrs, so a
+            // new value must clear it or the run would drop its role's lines.
+            setTextDecoration: (textDecoration) => ({ chain }) => chain()
+                .setMark('textStyle', { textDecoration, textDecorationReset: null })
+                .run(),
+            unsetTextDecoration: () => ({ chain }) => chain()
+                .setMark('textStyle', {
+                textDecoration: null,
+                textDecorationReset: null,
+            })
+                .removeEmptyTextStyle()
+                .run(),
+        };
+    },
+});

package/lib/src/shared/rte-extensions/ViewDomParser.d.ts

@@ -0,0 +1,2 @@
+import { Extension } from '@tiptap/core';
+export declare const ViewDomParser: Extension<any, any>;

package/lib/src/shared/rte-extensions/ViewDomParser.js

@@ -0,0 +1,21 @@
+import { Extension } from '@tiptap/core';
+import { DOMParser } from 'prosemirror-model';
+import { Plugin, PluginKey } from 'prosemirror-state';
+// The legacy bold/italic/underline/strike style rules misread the textStyle span's own styles on the
+// per-keystroke DOM read-back, so the whole run is retyped with the armed format — see
+// rich-text-editor.md. Paste keeps them: foreign HTML may carry bold only as a style.
+export const ViewDomParser = Extension.create({
+    name: 'viewDomParser',
+    addProseMirrorPlugins() {
+        const schemaParser = DOMParser.fromSchema(this.editor.schema);
+        return [
+            new Plugin({
+                key: new PluginKey('viewDomParser'),
+                props: {
+                    domParser: new DOMParser(this.editor.schema, schemaParser.rules.filter((rule) => 'tag' in rule)),
+                    clipboardParser: schemaParser,
+                },
+            }),
+        ];
+    },
+});

package/lib/src/shared/rte-extensions.util.d.ts

@@ -0,0 +1,25 @@
+import type { Extensions } from '@tiptap/vue-3';
+/**
+ * The schema generation a requested version resolves to: the highest change point at or below it
+ * (0 = the base schema). `undefined` = latest → the newest generation. So versions in the same
+ * range share one schema — asking for 5 or 20 both give the base — and callers cache one built
+ * schema per generation rather than per exact number.
+ */
+export declare const rteSchemaGeneration: (schemaVersion?: number) => number;
+export interface RteExtensionOptions {
+    /** Disable StarterKit nodes the editor doesn't use (lists, hr, code). */
+    restrictStarterKit?: boolean;
+    /** When present, add the live-editing-only plugins (Placeholder, MaxLength, ViewDomParser). */
+    editing?: {
+        placeholder?: string;
+        maxLength?: number;
+    };
+    /**
+     * Pin the schema to a model version's extension set. A migration passes its own version so the
+     * parse reproduces that era's schema (see `rteSchemaGeneration`); omit for the latest (runtime).
+     */
+    schemaVersion?: number;
+    /** Render text-decoration marks as role-aware classes instead of inline styles. */
+    renderTextDecorationClasses?: boolean;
+}
+export declare const getRteExtensions: (options?: RteExtensionOptions) => Extensions;

package/lib/src/{brand-page-maker/composables/rich-text-editor/getRteExtensions.js → shared/rte-extensions.util.js}

@@ -6,13 +6,55 @@ import ColorExtension from '@tiptap/extension-color';
 import Highlight from '@tiptap/extension-highlight';
 import Placeholder from '@tiptap/extension-placeholder';
 import Link from '@tiptap/extension-link';
-import { FontFamily } from './extensions/FontFamily';
-import { LetterSpacing } from './extensions/LetterSpacing';
-import { MaxLength } from './extensions/MaxLength';
-import { AutoLink } from './extensions/AutoLink';
-import { isHrefPageId } from './hyperlink';
+import { FontFamily } from './rte-extensions/FontFamily';
+import { LetterSpacing } from './rte-extensions/LetterSpacing';
+import { TextEffects } from './rte-extensions/TextEffects';
+import { MaxLength } from './rte-extensions/MaxLength';
+import { ViewDomParser } from './rte-extensions/ViewDomParser';
+import { AutoLink } from './rte-extensions/AutoLink';
+import { isHrefPageId } from './rte-link.util';
+/**
+ * Single source of truth for the Tiptap extension set (BP-5787).
+ *
+ * The live editor, the headless serialiser (useExternalRichTextEditor), and
+ * the upcoming render-from-JSON path must all use the SAME extensions, or
+ * rendered output drifts from what the user authored. This factory removes the
+ * previous duplication while preserving each consumer's exact configuration.
+ *
+ * Known, intentional differences are parameterised:
+ *  - `restrictStarterKit` — the live editor disables list/hr/code nodes.
+ *  - `editing` — only the live editor carries the Placeholder, MaxLength and
+ *    ViewDomParser plugins (none affects serialised output; they are editing-time only).
+ *
+ * Link target/rel are NOT parameterised: they are a pure function of the href
+ * applied in the Link mark's renderHTML (below), so every consumer — live
+ * editor, static renderer, schema check — emits identical link markup.
+ */
+/**
+ * The RTE schema is piecewise-constant across model-version ranges: it only changes when an
+ * extension is added, so every version between two change points shares one schema. Today the one
+ * change point is v22 — where `TextEffects` (weight/style/decoration on the `textStyle` mark) was
+ * added — giving two generations: below 22 is the pre-BP-5969 schema, 22-and-later (and the latest)
+ * carries TextEffects. Add the next version here if the schema grows.
+ *
+ * MIGRATION-22 SNAPSHOT DEPENDENCY: B1 parses v21 plain RTE strings with generation 22, so the
+ * extensions' `parseHTML` rules shape its output. Pinning the generation does not freeze those rules;
+ * after migration-22 releases, pin them in the migration before changing them.
+ */
+const RTE_SCHEMA_CHANGE_VERSIONS = [22];
+/**
+ * The schema generation a requested version resolves to: the highest change point at or below it
+ * (0 = the base schema). `undefined` = latest → the newest generation. So versions in the same
+ * range share one schema — asking for 5 or 20 both give the base — and callers cache one built
+ * schema per generation rather than per exact number.
+ */
+export const rteSchemaGeneration = (schemaVersion) => RTE_SCHEMA_CHANGE_VERSIONS.reduce((generation, changeVersion) => 
+// undefined = latest → reaches every change point → the newest generation.
+schemaVersion === undefined || schemaVersion >= changeVersion
+    ? changeVersion
+    : generation, 0);
 export const getRteExtensions = (options = {}) => {
-    const { restrictStarterKit = false, editing } = options;
+    const { restrictStarterKit = false, editing, schemaVersion, renderTextDecorationClasses = false, } = options;
     const extensions = [
         // v3 StarterKit bundles Link + Underline; we register both separately (with
         // custom Link config), so disable the bundled copies to avoid duplicate
@@ -61,6 +103,19 @@ export const getRteExtensions = (options = {}) => {
         FontSize.configure({ types: ['textStyle'] }),
         LetterSpacing,
         LineHeight.configure({ types: ['textStyle'] }),
+        // BP-5969: weight / style / decoration as textStyle attrs (role var or literal override), so a
+        // role edit to any of them repaints linked RTE via the cascade — like family/size already do.
+        // TextEffects entered at v22 (RTE_SCHEMA_CHANGE_VERSIONS). Gated in place — not appended — so the
+        // latest schema's extension order is byte-unchanged; a parse resolving below 22 omits it,
+        // reproducing the pre-BP-5969 schema.
+        ...(rteSchemaGeneration(schemaVersion) >= 22
+            ? [
+                TextEffects.configure({
+                    types: ['textStyle'],
+                    renderTextDecorationClasses,
+                }),
+            ]
+            : []),
         ColorExtension.configure({
             types: ['textStyle'],
         }),
@@ -70,7 +125,7 @@ export const getRteExtensions = (options = {}) => {
     ];
     // Live-editing-only plugins sit between Highlight and Link (original order).
     if (editing) {
-        extensions.push(Placeholder.configure({ placeholder: editing.placeholder }), MaxLength.configure({ maxLength: editing.maxLength }));
+        extensions.push(Placeholder.configure({ placeholder: editing.placeholder }), MaxLength.configure({ maxLength: editing.maxLength }), ViewDomParser);
     }
     extensions.push(Link.extend({
         // External-link policy lives at the serialisation boundary: target/rel are

package/lib/src/shared/rte-link.util.d.ts

@@ -0,0 +1 @@
+export declare const isHrefPageId: (href: string) => boolean;

package/lib/src/shared/rte-link.util.js

@@ -0,0 +1 @@
+export const isHrefPageId = (href) => !!href && href.startsWith('pageid:');

package/lib/src/shared/rte-render.util.d.ts

@@ -0,0 +1,112 @@
+import type { JSONContent } from '@tiptap/vue-3';
+import { isTiptapDocument, getRteJsonPlainText } from './rte-shape.util';
+export { isTiptapDocument, getRteJsonPlainText };
+/**
+ * BP-5787 — the boundary plumbing for storing RTE as Tiptap JSON.
+ *
+ * An RTE field is either a legacy inline-HTML string (pre-migration, or a
+ * not-yet-migrated published site) or a Tiptap JSON document (post-migration).
+ * These helpers let every consumer treat the two uniformly:
+ *
+ *   - isTiptapDocument — the canonical discriminator (object with type 'doc').
+ *   - renderRteToHtml  — render either form to final HTML for display.
+ *   - toRteJson        — normalise either form to JSON for storage.
+ *
+ * The schema-driven core of both directions is Tiptap/ProseMirror, fed by the
+ * single-source-of-truth extension set (getRteExtensions) — so the mapping lives
+ * in the extensions' schema, not a hand-maintained copy that drifts:
+ *
+ *   - renderRteToHtml uses @tiptap/static-renderer (renderToHTMLString). It is
+ *     DOM-less, so it runs on the server (SSR/publish/preview), not just the
+ *     browser, and needs no Editor instance.
+ *   - toRteJson turns an HTML string into a DOM node with an INJECTED parser and
+ *     feeds it to ProseMirror's schema-driven DOMParser. The HTML→DOM step needs
+ *     a DOM parser; rather than read the global `window.DOMParser` (as Tiptap's
+ *     `generateJSON` does — unusable on a pure-node server and fragile across SSR
+ *     execution contexts), the parser is supplied by the caller: the native
+ *     `DOMParser` in the browser, a jsdom `DOMParser` *instance* on the server
+ *     (see resolveHtmlParser). No global is ever mutated, so the conversion is
+ *     fully isomorphic regardless of how the SSR host bundles/executes this code.
+ */
+export type RichTextValue = string | JSONContent;
+/**
+ * A `DOMParser`-compatible object: turns an HTML string into a Document whose
+ * `body` is a DOM node ProseMirror can parse. The browser's native `DOMParser`
+ * and jsdom's `DOMParser` both satisfy this, so the DOM dependency is injected
+ * rather than read from a global.
+ */
+export interface HtmlParser {
+    parseFromString(html: string, type: 'text/html'): Document;
+}
+/**
+ * Render an RTE value to final HTML. Legacy HTML strings pass through untouched
+ * (they are already HTML); Tiptap JSON is serialised by @tiptap/static-renderer
+ * from the extension schema — no editor, no DOM — so it works on the server
+ * (SSR/publish), not just the browser.
+ *
+ * MIGRATION-22 SNAPSHOT DEPENDENCY: B1 uses this module's plain-text conversion and parser seam.
+ * Pin that v22 conversion before changing it after migration-22 releases.
+ */
+export declare const renderRteToHtml: (value: RichTextValue | null | undefined, options?: {
+    textDecorationClasses?: boolean;
+}) => string;
+/**
+ * Resolve an HtmlParser for the current runtime: the native `DOMParser` in the
+ * browser (and jsdom-based test envs), or a jsdom `DOMParser` INSTANCE on a
+ * pure-node server — created and returned directly, never assigned to a global,
+ * so it is immune to SSR execution-context differences. The jsdom specifier is
+ * assembled at runtime so no bundler follows it into a browser build. Memoised
+ * on the server (JSDOM construction is relatively expensive).
+ */
+export declare const resolveHtmlParser: () => Promise<HtmlParser>;
+/**
+ * Normalise an RTE value to a Tiptap JSON document. HTML strings are parsed with
+ * `parser` (defaults to the browser's native DOMParser); JSON documents pass
+ * through unchanged. Returns undefined for empty/blank input so callers can omit
+ * empty fields. `schemaVersion` pins the parse schema — a migration passes its own
+ * version so its output can't drift when the live schema gains an extension;
+ * everything else omits it and parses with the latest.
+ */
+export declare const toRteJson: (value: RichTextValue | null | undefined, parser?: HtmlParser, schemaVersion?: number) => JSONContent | undefined;
+/**
+ * Convert a PLAIN-TEXT field to a Tiptap JSON document. Plain-text fields persist
+ * newlines percent-encoded (`ESCAPED_NEWLINE_CHARACTER`, `%0A`); fed straight to the
+ * HTML parser those survive as a literal `"%0A"` run with the line structure lost, so
+ * we first turn them (and any raw `\n`) into `<br>` — the same shim the retired runtime
+ * rewrap applied via getRenderText before `setContent`. Guarded on `%0A` so a legacy
+ * RTE-HTML string (whose pretty-print `\n` must stay insignificant whitespace, stripped
+ * by `stripIndentationTextNodes`) is passed through untouched. JSON docs pass through.
+ */
+export declare const plainTextToRteJson: (value: RichTextValue | null | undefined, parser?: HtmlParser, schemaVersion?: number) => JSONContent | undefined;
+/**
+ * BP-5969 — build the Tiptap doc a factory stores for an RTE field: the RTE-JSON **source** that
+ * replaces the plain-string-then-convert seam. STRUCTURE only (paragraph + text + `textAlign`) —
+ * colour and role typography are baked afterwards by the init step (`applyTextContrast` +
+ * `authorContentRteFields`), since colour is contrast-derived and must not be duplicated per factory.
+ * Schema-built (never a hand-written literal), so it stays valid and matches migration output.
+ *
+ * Empty text → an empty paragraph (still a doc, never a string). A ProseMirror text node cannot be
+ * empty, so an empty field has no run: its colour then lives on the style object until the user types,
+ * when `buildInitialMarks` seeds the first run from it.
+ */
+export declare const rteDoc: (text: string, textAlign?: string, parser?: HtmlParser) => JSONContent;
+/**
+ * BP-5969 — inject `newText` into a template RTE doc while KEEPING the template's embedded style.
+ * Personalisation supplies only plain text; writing it raw drops the doc and its style (colour +
+ * typography live in the run marks). This lifts the template's **style skeleton** — the FIRST text
+ * run's `textStyle` mark (colour + role-var refs + any literal override) and the first block's
+ * alignment — and reflows the new text through it: a single paragraph whose lines join with hard
+ * breaks (matching how plain text is authored), every run carrying that mark. Per-word variation (a
+ * coloured word, an inline link) collapses to the base style — an accepted, documented loss; a
+ * uniformly-styled field comes out identical.
+ *
+ * The library owns schema handling: `Node.fromJSON` validates the template and hydrates real marks,
+ * `schema.text` applies them. No hand-written JSON and no `DOMParser`, so it is isomorphic — it runs
+ * on the server draft path where an editor or an HTML parse could not. The linked role lives on the
+ * sibling style object (`textStyleType`), untouched here, so the reflowed block still repaints on a
+ * role edit.
+ *
+ * A template that cannot be parsed, or that has no styled run, degrades to unstyled reflow rather than
+ * throwing — one bad field must not abort a whole personalisation pass.
+ */
+export declare const reflowRteDoc: (templateDoc: JSONContent, newText: string) => JSONContent;