@designcrowd/library.brand-page 6.2.11 → 6.2.12

package/lib/src/brand-page-maker/utils/rte-authoring.util.d.ts

@@ -0,0 +1,4 @@
+import type { JSONContent } from '@tiptap/vue-3';
+import type { Content, TextStyleOptions } from '@brand-page';
+export declare const docHasTextRun: (doc: JSONContent) => boolean;
+export declare const authorContentRteFields: (content: Content, textStyleOptions?: TextStyleOptions) => void;

package/lib/src/brand-page-maker/utils/rte-authoring.util.js

@@ -0,0 +1,101 @@
+import { rteStyleFieldsFor, pairedRteTextField, } from '@shared/color-strategies/rte-field-pairs';
+import { setRteTextColor } from '@shared/color-strategies/rte-color';
+import { plainTextToRteJson, isTiptapDocument, } from '@shared/rte-render.util';
+import { isCanonicalLinked } from './rich-text-editor.util';
+import { roleVarRef, ROLE_VAR_ATTRS } from '@shared/text-role-typography.util';
+/** The linked role's style for a field's `textStyleType`, for the defined-attr check below. */
+const roleStyleFor = (options, textStyleType) => textStyleType && options
+    ? options[textStyleType]?.style
+    : undefined;
+/**
+ * BP-5969 — reference the role's typography on every run of a canonical-linked authored doc, so
+ * new content matches migration output: the mark names the reference (self-describing, and the
+ * editor reads it without reaching into the store), and it follows role edits via the cascade.
+ * A ref is emitted ONLY for an attr the role actually defines — mirroring `buildInitialMarks` and
+ * migration `stripLiftRteDoc`, so authored and migrated runs share one shape (no reference to a
+ * `--role-*` var the role class never emits). No role style (options absent) → no refs.
+ */
+const applyRoleTypographyVars = (doc, roleStyle) => {
+    const refs = ROLE_VAR_ATTRS.flatMap(({ markAttr }) => {
+        const ref = roleVarRef(markAttr);
+        return ref && roleStyle?.[markAttr]
+            ? [[markAttr, ref]]
+            : [];
+    });
+    if (!refs.length)
+        return;
+    const walk = (node) => {
+        if (node.type === 'text') {
+            const marks = (node.marks ??= []);
+            let textStyle = marks.find((mark) => mark.type === 'textStyle');
+            if (!textStyle) {
+                textStyle = { type: 'textStyle', attrs: {} };
+                marks.push(textStyle);
+            }
+            textStyle.attrs = { ...(textStyle.attrs ?? {}) };
+            for (const [attr, ref] of refs)
+                textStyle.attrs[attr] = ref;
+        }
+        node.content?.forEach(walk);
+    };
+    walk(doc);
+};
+// True when the doc has at least one text run — i.e. somewhere for a run mark (colour) to live.
+export const docHasTextRun = (doc) => {
+    const walk = (node) => node.type === 'text' ? true : (node.content ?? []).some(walk);
+    return walk(doc);
+};
+/**
+ * Author (or enrich) one RTE field into its final doc: bake the resolved element colour into the run
+ * mark and reference the role's typography on every run, matching migration output.
+ *
+ * The field's value is either an already-authored doc — the BP-5969 factory source (`rteDoc`) — or a
+ * plain string (legacy / AI callers); both normalise to a doc here. `undefined` for empty/absent
+ * input so callers can leave the field alone.
+ */
+const authorRteDoc = (value, style, roleStyle) => {
+    let doc = isTiptapDocument(value)
+        ? value
+        : plainTextToRteJson(value);
+    if (!doc)
+        return undefined;
+    // Colour rides the run mark — but ONLY when there is a run. An empty doc (empty field) has no text
+    // node to hold a mark, so its colour stays on `style.color` until the user types (the editor's
+    // `buildInitialMarks` seeds the first run from it); stripping it here would strand it.
+    if (style?.color && docHasTextRun(doc)) {
+        doc = setRteTextColor(doc, style.color) ?? doc;
+        delete style.color; // colour now lives in the mark (matches migration step G)
+    }
+    if (style?.textAlign) {
+        for (const block of doc.content ?? []) {
+            block.attrs = { ...(block.attrs ?? {}), textAlign: style.textAlign };
+        }
+    }
+    // Canonical-linked: reference the role's (defined) typography on every run.
+    if (isCanonicalLinked(style))
+        applyRoleTypographyVars(doc, roleStyle);
+    return doc;
+};
+export const authorContentRteFields = (content, 
+// Role definitions, so a run references only the attrs its role actually defines (matches
+// migration output). Absent → no typography refs (colour/textAlign still authored).
+textStyleOptions) => {
+    const fields = content;
+    for (const styleField of rteStyleFieldsFor(content.type)) {
+        const textField = pairedRteTextField(content.type, styleField);
+        if (!textField)
+            continue;
+        const style = fields[styleField];
+        const doc = authorRteDoc(fields[textField], style, roleStyleFor(textStyleOptions, style?.textStyleType));
+        if (doc)
+            fields[textField] = doc;
+    }
+    const textItems = fields.textItems;
+    if (Array.isArray(textItems)) {
+        for (const item of textItems) {
+            const doc = authorRteDoc(item.text, item.textStyle, roleStyleFor(textStyleOptions, item.textStyle?.textStyleType));
+            if (doc)
+                item.text = doc;
+        }
+    }
+};

package/lib/src/brand-page-maker/utils/rte-clipboard.util.d.ts

@@ -0,0 +1,126 @@
+import type { JSONContent } from '@tiptap/vue-3';
+import type { ColorItem, GlobalTextStyleDeclaration, TextStyleDeclaration } from '@brand-page';
+import { type RoleVarMarkAttr } from '@shared/text-role-typography.util';
+/**
+ * Pure transforms for the maker RTE's copy, cut and paste. No editor, no DOM: every
+ * function here takes and returns Tiptap JSON (or a bare value), so `RteClipboard.ts`
+ * can call them from real clipboard events without this module knowing ProseMirror's
+ * live `Node`/`Mark` instances exist. Kept off the `brand-page-maker/utils` barrel
+ * (imported by path) — see `rich-text-editor.md` *Entry points* for why it stays out
+ * of `getRteExtensions`.
+ */
+export declare const RTE_CLIPBOARD_MIME_TYPE = "application/x-rte-slice";
+export declare const RTE_CLIPBOARD_VERSION: 1;
+export interface RteClipboardContext {
+    /** The field's canonical role style, or undefined for a legacy/unlinked field. */
+    role: GlobalTextStyleDeclaration | undefined;
+    /** The field's own style object (whole-field overrides, colour, alignment). */
+    block: TextStyleDeclaration | undefined;
+    /** The site palette, for resolving and relinking colour references. */
+    colors: ColorItem[];
+}
+export type ResolvedRunStyle = Partial<Record<RoleVarMarkAttr, string>> & {
+    color?: string;
+};
+export interface RteClipboardSliceJSON {
+    content: JSONContent[];
+    openStart?: number;
+    openEnd?: number;
+}
+export interface RteClipboardPayload {
+    v: typeof RTE_CLIPBOARD_VERSION;
+    slice: RteClipboardSliceJSON;
+}
+type RteRunMark = {
+    type: string;
+    attrs?: Record<string, unknown>;
+};
+type RteRunNode = {
+    marks?: RteRunMark[];
+};
+/**
+ * Resolve a colour value (text or highlight) to what the canvas shows, in one
+ * normalised form: a legacy `logo-*` token maps to its palette role first; a
+ * `var(--id)` reference resolves against `colors` (a blank role reads as its default);
+ * a resolvable solid canonicalises to lowercase `#rrggbb`/`#rrggbbaa`. A reference the
+ * palette doesn't hold stays exactly as written (D3) — copy never invents a look the
+ * canvas doesn't have.
+ */
+export declare const resolveRunColorForCopy: (value: string | undefined, colors: ColorItem[]) => string | undefined;
+/**
+ * A run's typography and colour, resolved to what the canvas shows (A5): every role
+ * reference becomes a literal value, so the slice carries "what it looks like" rather
+ * than "what it's linked to" — the destination decides what re-links (see
+ * `relinkRunTypographyToRole`). An uncoloured run stays uncoloured (ADR-0020: no base
+ * coat) — colour has no whole-field fallback, unlike typography.
+ */
+export declare const resolveRunStyleForCopy: (node: RteRunNode, context: RteClipboardContext) => ResolvedRunStyle;
+/**
+ * The external (`text/html`, other apps) reading of a run: the same resolved look, with
+ * `fontSize` converted from em to px at the 16px root (the toolbar's own readout) so an
+ * app with no `--role-*`/em context still shows the right size, and the run's link href
+ * (if any) carried through untouched.
+ */
+export declare const resolveRunStyleForExternal: (node: RteRunNode, context: RteClipboardContext) => ResolvedRunStyle & {
+    href?: string;
+};
+/**
+ * "Same value written differently" (A6): family ignores quoting, weight/style/
+ * decoration/spacing treat their CSS-neutral keyword as equal to unset, and — local to
+ * this comparator, so the asterisk and relink paths don't widen — `fontSize` compares
+ * as px at the 16px root, so `1.375em` and `22px` are one size.
+ */
+export declare const isSameTypographyValue: (attr: RoleVarMarkAttr, a: string | undefined, b: string | undefined) => boolean;
+/**
+ * Relink a resolved run to the destination role (A5 step 2, R2): a value equal to the
+ * destination's (or its neutral) becomes the role var, so it keeps following that role;
+ * any other value stays the run's own literal. With no canonical role at the
+ * destination, every value stays literal — `roleVarOrLiteral`'s rule, applied per run
+ * instead of at the mutation point. An attr the copy left absent stays absent.
+ */
+export declare const relinkRunTypographyToRole: (resolved: ResolvedRunStyle, destinationRole: GlobalTextStyleDeclaration | undefined) => ResolvedRunStyle;
+/**
+ * Relink a resolved colour to the destination palette (A5 step 3, R3, D3). On a link
+ * run, the fixed link colour is never remapped, so a coincidental match doesn't mint a
+ * spurious reference. Otherwise (including a non-link run that happens to equal the
+ * fixed link colour): a destination palette ROLE holding the same canonical value wins
+ * first (lowest index — `roleIdsByCanonicalValue`'s tie-break), then a custom in stored
+ * order (blanks skipped); with no match, the canonical hex stays fixed and nothing is
+ * added to the palette.
+ */
+export declare const relinkColorToPalette: (canonicalHex: string, colors: ColorItem[], isLinkColor?: boolean) => string;
+/**
+ * Every paragraph/heading a paste touches takes the destination's alignment (Reading
+ * 14) — overriding whatever the source paragraphs carried. With no destination
+ * alignment resolved, the source's own alignment is cleared rather than left in place:
+ * an open-ended LAST paragraph merges into the following text using the SLICE's own
+ * attrs, so a leftover source alignment would repaint the destination's own trailing
+ * text — the open-ended FIRST paragraph merges the other way, keeping the destination
+ * paragraph's own attrs untouched.
+ */
+export declare const alignPastedParagraphs: (content: JSONContent[], destinationAlign: string | undefined) => JSONContent[];
+/**
+ * A plain-text (no valid own-editor form) paste's paragraphs (Approach step 4): split on
+ * runs of line breaks — prosemirror-view's own rule — dropping empty pieces, each line
+ * becomes a paragraph carrying the caller's marks (the seed a first type, or the
+ * paste-point's marks, would take) and the destination's alignment. Open at both ends,
+ * so the first and last line join the surrounding text. `null` for text with no visible
+ * line (nothing to insert).
+ */
+export declare const plainTextToParagraphSlice: (text: string, marks: RteRunMark[], textAlign: string | undefined) => RteClipboardSliceJSON | null;
+/**
+ * Validate a clipboard string as our own, un-tampered `x-rte-slice` payload (R13): it
+ * parses, its version is ours, and it is byte-for-byte its own `sanitizeRteJson` form —
+ * an unsafe link or CSS value, an unknown mark, or even a key reordered from the
+ * sanitised form changes it and fails this. It must also build against the live editor
+ * schema — catching a node/mark `sanitizeRteJson`'s broader allowlist accepts but this
+ * editor's restricted schema doesn't (lists, code). `Slice.fromJSON` alone only checks
+ * that node/mark types exist; it neither validates a node's content against its type's
+ * content expression nor its mark set, and it accepts any `openStart`/`openEnd` number —
+ * fractional included — regardless of the content's actual depth — so every top-level node
+ * is also `check()`ed, and the open depths must be integers bounded by `Slice.maxOpen`. Any
+ * failure returns `null`, so the caller falls back to the text-only path instead of
+ * inserting a malformed slice.
+ */
+export declare const parseOwnRteClipboardPayload: (raw: string) => RteClipboardPayload | null;
+export {};

package/lib/src/brand-page-maker/utils/rte-clipboard.util.js

@@ -0,0 +1,307 @@
+import { getSchema } from '@tiptap/core';
+import { Slice } from 'prosemirror-model';
+import { canonicalSolidHex, isBlankColorValue, isPaletteRoleId, paletteRoleIdForToken, resolveColorReference, roleIdsByCanonicalValue, toColorVarReference, } from '@brand-page/utils/color-palette.util';
+import { ROLE_VAR_ATTRS, roleVarRef, runTypographyFillValue, NEUTRAL_TYPOGRAPHY_VALUE, } from '@shared/text-role-typography.util';
+import { DEFAULT_LINK_COLOR } from '@src/constants/rich-text-editor.constants';
+import { isRoleVarRef, normTypographyValue } from './rich-text-editor.util';
+import { sanitizeRteJson } from './rte-sanitize.util';
+import { emToPx } from './text.util';
+import { getRteExtensions } from '@shared/rte-extensions.util';
+/**
+ * Pure transforms for the maker RTE's copy, cut and paste. No editor, no DOM: every
+ * function here takes and returns Tiptap JSON (or a bare value), so `RteClipboard.ts`
+ * can call them from real clipboard events without this module knowing ProseMirror's
+ * live `Node`/`Mark` instances exist. Kept off the `brand-page-maker/utils` barrel
+ * (imported by path) — see `rich-text-editor.md` *Entry points* for why it stays out
+ * of `getRteExtensions`.
+ */
+export const RTE_CLIPBOARD_MIME_TYPE = 'application/x-rte-slice';
+export const RTE_CLIPBOARD_VERSION = 1;
+/**
+ * The JSON-node twin of `runTypography` (`rich-text-editor.util.ts`): a run's own
+ * typography, falling back to a legacy semantic mark for un-migrated/pasted runs. Works
+ * on a Tiptap JSON node directly (no schema needed), because a copy/paste payload is
+ * JSON — never a live ProseMirror `Node` — end to end.
+ */
+const runTypographyFromJson = (node) => {
+    const marks = node.marks ?? [];
+    const textStyle = marks.find((mark) => mark.type === 'textStyle');
+    const attrOf = (attr) => {
+        const value = textStyle?.attrs?.[attr];
+        return typeof value === 'string' && value !== '' ? value : undefined;
+    };
+    const has = (markType) => marks.some((mark) => mark.type === markType);
+    const legacyDecoration = [has('underline') && 'underline', has('strike') && 'line-through']
+        .filter(Boolean)
+        .join(' ') || undefined;
+    return {
+        fontFamily: attrOf('fontFamily'),
+        fontSize: attrOf('fontSize'),
+        lineHeight: attrOf('lineHeight'),
+        letterSpacing: attrOf('letterSpacing'),
+        fontWeight: attrOf('fontWeight') ?? (has('bold') ? 'bold' : undefined),
+        fontStyle: attrOf('fontStyle') ?? (has('italic') ? 'italic' : undefined),
+        textDecoration: attrOf('textDecoration') ?? legacyDecoration,
+    };
+};
+/**
+ * Resolve one typography attr the way the canvas renders it: the run's own value
+ * (a role ref resolved to the source role's value, or its neutral; a literal — including
+ * a legacy bold/italic/underline/strike mark — kept as written), else, for an attr the
+ * run doesn't carry, `runTypographyFillValue`'s whole-field fill, resolved the same way.
+ * Never invents a value the canvas wouldn't show (D2).
+ */
+const resolveTypographyAttrForCopy = (attr, own, role, block) => {
+    const value = own !== undefined
+        ? own
+        : runTypographyFillValue(attr, role, block);
+    if (value === undefined)
+        return undefined;
+    const resolved = isRoleVarRef(value)
+        ? (role?.[attr] ?? NEUTRAL_TYPOGRAPHY_VALUE[attr])
+        : value;
+    // A quoted family (`"Playfair Display"`, or a stack like `"Playfair Display", serif`)
+    // fails sanitizeRteJson's safe-CSS-value check and is dropped outright, not kept
+    // quoted — so strip every quote, not just an outer pair, rather than lose it.
+    return attr === 'fontFamily' ? resolved?.replace(/['"]+/g, '') : resolved;
+};
+/**
+ * Resolve a colour value (text or highlight) to what the canvas shows, in one
+ * normalised form: a legacy `logo-*` token maps to its palette role first; a
+ * `var(--id)` reference resolves against `colors` (a blank role reads as its default);
+ * a resolvable solid canonicalises to lowercase `#rrggbb`/`#rrggbbaa`. A reference the
+ * palette doesn't hold stays exactly as written (D3) — copy never invents a look the
+ * canvas doesn't have.
+ */
+export const resolveRunColorForCopy = (value, colors) => {
+    if (!value)
+        return undefined;
+    const roleId = paletteRoleIdForToken(value);
+    const ref = roleId ? toColorVarReference(roleId) : value;
+    const resolved = resolveColorReference(ref, colors, {
+        withRoleDefaults: true,
+    });
+    return canonicalSolidHex(resolved) ?? resolved;
+};
+/**
+ * A run's typography and colour, resolved to what the canvas shows (A5): every role
+ * reference becomes a literal value, so the slice carries "what it looks like" rather
+ * than "what it's linked to" — the destination decides what re-links (see
+ * `relinkRunTypographyToRole`). An uncoloured run stays uncoloured (ADR-0020: no base
+ * coat) — colour has no whole-field fallback, unlike typography.
+ */
+export const resolveRunStyleForCopy = (node, context) => {
+    const own = runTypographyFromJson(node);
+    const style = {};
+    for (const { markAttr } of ROLE_VAR_ATTRS) {
+        const value = resolveTypographyAttrForCopy(markAttr, own[markAttr], context.role, context.block);
+        if (value !== undefined)
+            style[markAttr] = value;
+    }
+    const textStyle = node.marks?.find((mark) => mark.type === 'textStyle');
+    const color = resolveRunColorForCopy(textStyle?.attrs?.color, context.colors);
+    if (color !== undefined)
+        style.color = color;
+    return style;
+};
+/**
+ * The external (`text/html`, other apps) reading of a run: the same resolved look, with
+ * `fontSize` converted from em to px at the 16px root (the toolbar's own readout) so an
+ * app with no `--role-*`/em context still shows the right size, and the run's link href
+ * (if any) carried through untouched.
+ */
+export const resolveRunStyleForExternal = (node, context) => {
+    const style = resolveRunStyleForCopy(node, context);
+    const link = (node.marks ?? []).find((mark) => mark.type === 'link');
+    const href = link?.attrs?.href;
+    const fontSizePx = sizeToPx(style.fontSize);
+    return {
+        ...style,
+        ...(fontSizePx !== undefined ? { fontSize: `${fontSizePx}px` } : {}),
+        ...(href ? { href } : {}),
+    };
+};
+const SIZE_UNIT = /^(-?[\d.]+)(px|em)$/;
+/** A typography value's px size at the 16px root, or undefined for anything else. */
+const sizeToPx = (value) => {
+    const match = value?.trim().match(SIZE_UNIT);
+    if (!match)
+        return undefined;
+    const [, amount, unit] = match;
+    return unit === 'px' ? parseFloat(amount) : parseFloat(emToPx(`${amount}em`));
+};
+/**
+ * "Same value written differently" (A6): family ignores quoting, weight/style/
+ * decoration/spacing treat their CSS-neutral keyword as equal to unset, and — local to
+ * this comparator, so the asterisk and relink paths don't widen — `fontSize` compares
+ * as px at the 16px root, so `1.375em` and `22px` are one size.
+ */
+export const isSameTypographyValue = (attr, a, b) => {
+    if (attr === 'fontSize') {
+        const pxA = sizeToPx(a);
+        return pxA !== undefined && pxA === sizeToPx(b);
+    }
+    return normTypographyValue(attr, a) === normTypographyValue(attr, b);
+};
+/**
+ * Relink a resolved run to the destination role (A5 step 2, R2): a value equal to the
+ * destination's (or its neutral) becomes the role var, so it keeps following that role;
+ * any other value stays the run's own literal. With no canonical role at the
+ * destination, every value stays literal — `roleVarOrLiteral`'s rule, applied per run
+ * instead of at the mutation point. An attr the copy left absent stays absent.
+ */
+export const relinkRunTypographyToRole = (resolved, destinationRole) => {
+    const relinked = { ...resolved };
+    if (!destinationRole)
+        return relinked;
+    for (const { markAttr } of ROLE_VAR_ATTRS) {
+        const value = resolved[markAttr];
+        if (value === undefined)
+            continue;
+        relinked[markAttr] = isSameTypographyValue(markAttr, value, destinationRole[markAttr])
+            ? roleVarRef(markAttr)
+            : value;
+    }
+    return relinked;
+};
+/**
+ * Relink a resolved colour to the destination palette (A5 step 3, R3, D3). On a link
+ * run, the fixed link colour is never remapped, so a coincidental match doesn't mint a
+ * spurious reference. Otherwise (including a non-link run that happens to equal the
+ * fixed link colour): a destination palette ROLE holding the same canonical value wins
+ * first (lowest index — `roleIdsByCanonicalValue`'s tie-break), then a custom in stored
+ * order (blanks skipped); with no match, the canonical hex stays fixed and nothing is
+ * added to the palette.
+ */
+export const relinkColorToPalette = (canonicalHex, colors, isLinkColor = false) => {
+    if (isLinkColor && canonicalHex === DEFAULT_LINK_COLOR)
+        return canonicalHex;
+    const roleId = roleIdsByCanonicalValue(colors).get(canonicalHex);
+    if (roleId)
+        return toColorVarReference(roleId);
+    const custom = colors.find((color) => !isPaletteRoleId(color.id) &&
+        !isBlankColorValue(color.value) &&
+        canonicalSolidHex(color.value) === canonicalHex);
+    return custom ? toColorVarReference(custom.id) : canonicalHex;
+};
+/**
+ * Every paragraph/heading a paste touches takes the destination's alignment (Reading
+ * 14) — overriding whatever the source paragraphs carried. With no destination
+ * alignment resolved, the source's own alignment is cleared rather than left in place:
+ * an open-ended LAST paragraph merges into the following text using the SLICE's own
+ * attrs, so a leftover source alignment would repaint the destination's own trailing
+ * text — the open-ended FIRST paragraph merges the other way, keeping the destination
+ * paragraph's own attrs untouched.
+ */
+export const alignPastedParagraphs = (content, destinationAlign) => content.map((node) => {
+    if (node.type !== 'paragraph' && node.type !== 'heading')
+        return node;
+    const { textAlign: _sourceAlign, ...attrs } = (node.attrs ?? {});
+    return {
+        ...node,
+        attrs: destinationAlign
+            ? { ...attrs, textAlign: destinationAlign }
+            : attrs,
+    };
+});
+const LINE_BREAK_RUN = /(?:\r\n?|\n)+/;
+/**
+ * A plain-text (no valid own-editor form) paste's paragraphs (Approach step 4): split on
+ * runs of line breaks — prosemirror-view's own rule — dropping empty pieces, each line
+ * becomes a paragraph carrying the caller's marks (the seed a first type, or the
+ * paste-point's marks, would take) and the destination's alignment. Open at both ends,
+ * so the first and last line join the surrounding text. `null` for text with no visible
+ * line (nothing to insert).
+ */
+export const plainTextToParagraphSlice = (text, marks, textAlign) => {
+    const lines = text.split(LINE_BREAK_RUN).filter((line) => line !== '');
+    if (!lines.length)
+        return null;
+    return {
+        content: lines.map((line) => ({
+            type: 'paragraph',
+            ...(textAlign ? { attrs: { textAlign } } : {}),
+            content: [
+                {
+                    type: 'text',
+                    text: line,
+                    ...(marks.length ? { marks } : {}),
+                },
+            ],
+        })),
+        openStart: 1,
+        openEnd: 1,
+    };
+};
+// The ProseMirror schema a paste is validated against: the SAME extension set the live
+// maker editor mounts (`restrictStarterKit`), so a node/mark the editor lacks — lists,
+// code — fails here exactly as it would fail reaching the real editor. `getSchema` is
+// DOM-less (mirrors `rte-schema-check.ts`), so this stays a pure check; built once and
+// cached.
+let cachedRteClipboardSchema;
+const getRteClipboardSchema = () => (cachedRteClipboardSchema ??= getSchema(getRteExtensions({ restrictStarterKit: true })));
+const canonicalSliceJSON = (sliceJson) => {
+    const sanitized = sanitizeRteJson({
+        type: 'doc',
+        content: sliceJson.content,
+    });
+    return {
+        content: sanitized.content ?? [],
+        ...(sliceJson.openStart ? { openStart: sliceJson.openStart } : {}),
+        ...(sliceJson.openEnd ? { openEnd: sliceJson.openEnd } : {}),
+    };
+};
+/**
+ * Validate a clipboard string as our own, un-tampered `x-rte-slice` payload (R13): it
+ * parses, its version is ours, and it is byte-for-byte its own `sanitizeRteJson` form —
+ * an unsafe link or CSS value, an unknown mark, or even a key reordered from the
+ * sanitised form changes it and fails this. It must also build against the live editor
+ * schema — catching a node/mark `sanitizeRteJson`'s broader allowlist accepts but this
+ * editor's restricted schema doesn't (lists, code). `Slice.fromJSON` alone only checks
+ * that node/mark types exist; it neither validates a node's content against its type's
+ * content expression nor its mark set, and it accepts any `openStart`/`openEnd` number —
+ * fractional included — regardless of the content's actual depth — so every top-level node
+ * is also `check()`ed, and the open depths must be integers bounded by `Slice.maxOpen`. Any
+ * failure returns `null`, so the caller falls back to the text-only path instead of
+ * inserting a malformed slice.
+ */
+export const parseOwnRteClipboardPayload = (raw) => {
+    let candidate;
+    try {
+        candidate = JSON.parse(raw);
+    }
+    catch {
+        return null;
+    }
+    if (!candidate ||
+        typeof candidate !== 'object' ||
+        candidate.v !== RTE_CLIPBOARD_VERSION) {
+        return null;
+    }
+    const slice = candidate.slice;
+    if (!slice || typeof slice !== 'object')
+        return null;
+    const canonical = {
+        v: RTE_CLIPBOARD_VERSION,
+        slice: canonicalSliceJSON(slice),
+    };
+    if (JSON.stringify(candidate) !== JSON.stringify(canonical))
+        return null;
+    try {
+        const parsed = Slice.fromJSON(getRteClipboardSchema(), slice);
+        parsed.content.forEach((node) => node.check());
+        const maxOpen = Slice.maxOpen(parsed.content);
+        if (!Number.isInteger(parsed.openStart) ||
+            !Number.isInteger(parsed.openEnd) ||
+            parsed.openStart < 0 ||
+            parsed.openEnd < 0 ||
+            parsed.openStart > maxOpen.openStart ||
+            parsed.openEnd > maxOpen.openEnd) {
+            return null;
+        }
+    }
+    catch {
+        return null;
+    }
+    return canonical;
+};

package/lib/src/brand-page-maker/utils/rte-sanitize.util.js

@@ -42,15 +42,20 @@ const ALLOWED_MARK_TYPES = new Set([
     'highlight',
     'link',
 ]);
-// textStyle attrs map to the allow-listed CSS properties (font-weight →
-// bold mark, text-decoration → underline/strike, text-align → node attr,
-// background-color → highlight, so they are intentionally not here).
+// textStyle attrs map to the allow-listed CSS properties. BP-5969: font-weight / font-style /
+// text-decoration are now textStyle attrs (role var or literal), NOT semantic <strong>/<u>/<s>
+// marks, so a role edit propagates via the cascade. text-align → node attr and background-color →
+// highlight are still intentionally not here.
 const ALLOWED_TEXT_STYLE_ATTRS = new Set([
     'color',
     'fontFamily',
     'fontSize',
     'letterSpacing',
     'lineHeight',
+    'fontWeight',
+    'fontStyle',
+    'textDecoration',
+    'textDecorationReset',
 ]);
 /**
  * A safe CSS value is a short string free of characters that could inject an
@@ -70,6 +75,11 @@ const sanitizeTextStyleAttrs = (attrs) => {
         if (!ALLOWED_TEXT_STYLE_ATTRS.has(key))
             continue;
         const value = attrs[key];
+        if (key === 'textDecorationReset') {
+            if (value === true)
+                clean[key] = true;
+            continue;
+        }
         // Tiptap emits '' for unset textStyle slots — preserve them.
         if (value === '' || value == null) {
             clean[key] = '';