@designcrowd/library.brand-page 6.2.11 → 6.2.12

package/src/utils/minify-brand-page-metadata.ts

@@ -10,7 +10,20 @@ import {
 } from '../brand-page/models';
 import { resolveModelColorReferences } from '../brand-page/utils/color-palette.util';
 import type { Content, ContentType } from '../brand-page/models/content.model';
-import type { TextStyleDeclaration } from '../brand-page/models/styles.model';
+import type {
+  TextStyleDeclaration,
+  TextStyleOption,
+  TextStyles,
+} from '../brand-page/models/styles.model';
+import {
+  CANONICAL_TEXT_STYLE_TYPES,
+  LEGACY_TEXT_STYLE_TYPES,
+  type TextStyleType,
+} from '../brand-page/models/styles.model';
+import {
+  DEFAULT_FONT_FAMILY_KEY,
+  FONT_FAMILY_CONFIGS,
+} from '../brand-page/constants';
 import { hasRTEContent, isTiptapDocument } from '../brand-page-maker/utils';
 import { useExternalRichTextEditor } from '../brand-page-maker/composables/rich-text-editor/useRichTextEditor';
 import type { Editor, JSONContent } from '@tiptap/vue-3';
@@ -77,6 +90,16 @@ type MinifiedPage = {
   contents: MinifiedContent[];
 };
 
+/**
+ * The canonical roles are the source of truth. The four legacy options and the retired root text
+ * colour remain in the outbound payload temporarily because the deployed AI pipeline still reads
+ * them for contrast repair. Remove this compatibility shape only after pipeline PR #664 ships.
+ */
+type MinifiedTextStyles = {
+  textStyleOptions: Partial<Record<TextStyleType, TextStyleOption>>;
+  style?: { color?: string };
+};
+
 export interface MinifiedBrandPageMetadata {
   brandPageType: BrandPageType;
   v: number;
@@ -85,7 +108,9 @@ export interface MinifiedBrandPageMetadata {
    * a concrete value, so the lookup table only costs tokens and invites the LLM
    * echoing a `palette-…` id back at us.
    */
-  styles: Omit<PageStyles, 'colors'>;
+  styles: Omit<PageStyles, 'colors' | 'textStyles'> & {
+    textStyles: MinifiedTextStyles;
+  };
   pages: MinifiedPage[];
   nav: NavModel;
   footer?: {
@@ -601,11 +626,22 @@ const minifyHeaderBackgroundStyle = (
 
 const minifyHeader = (
   header: AbstractPageHeaderStyles | undefined | null,
+  textStyles: TextStyles | undefined,
   logoAssetKey?: string,
 ): MinifiedHeader | undefined => {
   if (!header) return undefined;
 
   const nav = header.navigation;
+  const navStyle = nav?.defaultButtonStyle;
+  // A linked nav stores only what differs from its role, so its font may be the role's, else the
+  // page root's Lato.
+  const navFontFamily =
+    navStyle?.fontFamily ||
+    (navStyle?.textStyleType
+      ? textStyles?.textStyleOptions?.[navStyle.textStyleType]?.style
+          ?.fontFamily
+      : undefined) ||
+    FONT_FAMILY_CONFIGS[DEFAULT_FONT_FAMILY_KEY].name;
 
   return {
     displayStyle: header.displayStyle || undefined,
@@ -617,11 +653,8 @@ const minifyHeader = (
     navigation: nav
       ? {
           displayType: nav.displayType || undefined,
-          defaultButtonStyle: nav.defaultButtonStyle
-            ? {
-                color: nav.defaultButtonStyle.color,
-                fontFamily: nav.defaultButtonStyle.fontFamily,
-              }
+          defaultButtonStyle: navStyle
+            ? { color: navStyle.color, fontFamily: navFontFamily }
             : undefined,
           selectedButtonStyle: nav.selectedButtonStyle || undefined,
           hamburgerMenuStyle: nav.hamburgerMenuStyle
@@ -632,6 +665,22 @@ const minifyHeader = (
   };
 };
 
+/**
+ * A fresh copy, never the source model. The deployed pipeline still uses the legacy role/root-colour
+ * shape for contrast repair, so preserve it in the outbound payload until #664 is deployed.
+ */
+const minifyTextStyles = (
+  textStyles: TextStyles | undefined,
+): MinifiedTextStyles => ({
+  textStyleOptions: Object.fromEntries(
+    [...CANONICAL_TEXT_STYLE_TYPES, ...LEGACY_TEXT_STYLE_TYPES]
+      .map((role) => [role, textStyles?.textStyleOptions?.[role]])
+      .filter(([, option]) => option !== undefined),
+  ) as Partial<Record<TextStyleType, TextStyleOption>>,
+  style: (textStyles as unknown as { style?: { color?: string } } | undefined)
+    ?.style,
+});
+
 const minifyPage = (
   page: PageModel,
   nav: NavModel,
@@ -661,7 +710,10 @@ export const minifyBrandPageMetadata = (
   const result: MinifiedBrandPageMetadata = {
     brandPageType: model.brandPageType || BRAND_PAGE_TYPES.default,
     v: model.v,
-    styles: stylesWithoutPalette,
+    styles: {
+      ...stylesWithoutPalette,
+      textStyles: minifyTextStyles(stylesWithoutPalette.textStyles),
+    },
     pages: model.pages.map((p) =>
       minifyPage(p, model.nav, externalEditor, assets),
     ),
@@ -690,6 +742,7 @@ export const minifyBrandPageMetadata = (
     },
     pageHeaderDesktop: minifyHeader(
       model.pageHeaderDesktop,
+      model.styles?.textStyles,
       findAssetKey(
         assets,
         resolveLogoData(
@@ -700,6 +753,7 @@ export const minifyBrandPageMetadata = (
     ),
     pageHeaderMobile: minifyHeader(
       model.pageHeaderMobile,
+      model.styles?.textStyles,
       findAssetKey(
         assets,
         resolveLogoData(

package/lib/src/brand-page-maker/composables/rich-text-editor/extensions/AutoLink.d.ts

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

package/lib/src/brand-page-maker/composables/rich-text-editor/getRteExtensions.d.ts

@@ -1,28 +0,0 @@
-import type { Extensions } from '@tiptap/vue-3';
-/**
- * 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 plugins
- *    (neither 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.
- */
-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). */
-    editing?: {
-        placeholder?: string;
-        maxLength?: number;
-    };
-}
-export declare const getRteExtensions: (options?: RteExtensionOptions) => Extensions;

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

@@ -1,63 +0,0 @@
-import type { JSONContent } from '@tiptap/vue-3';
-import { isTiptapDocument, getRteJsonPlainText } from './rich-text-editor.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.
- */
-export declare const renderRteToHtml: (value: RichTextValue | null | undefined) => 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.
- */
-export declare const toRteJson: (value: RichTextValue | null | undefined, parser?: HtmlParser) => JSONContent | undefined;

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

@@ -1,106 +0,0 @@
-import { getSchema } from '@tiptap/core';
-import { DOMParser as ProseMirrorDOMParser } from '@tiptap/pm/model';
-import { renderToHTMLString } from '@tiptap/static-renderer/pm/html-string';
-import { getRteExtensions } from '../composables/rich-text-editor/getRteExtensions';
-import { isTiptapDocument, getRteJsonPlainText } from './rich-text-editor.util';
-export { isTiptapDocument, getRteJsonPlainText };
-// One extension set shared by both directions (render + parse). Schema knowledge
-// lives here, once — Tiptap/extension upgrades propagate to both automatically.
-const RTE_EXTENSIONS = getRteExtensions();
-// ProseMirror schema derived once from the shared extension set. This is the
-// schema-driven heart of HTML→JSON (no drift); only the HTML→DOM step is injected.
-const RTE_SCHEMA = getSchema(RTE_EXTENSIONS);
-/**
- * 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.
- */
-export const renderRteToHtml = (value) => {
-    if (value == null || value === '')
-        return '';
-    if (typeof value === 'string')
-        return value;
-    try {
-        return renderToHTMLString({ content: value, extensions: RTE_EXTENSIONS });
-    }
-    catch (error) {
-        // renderToHTMLString throws on a node/mark type this renderer's schema
-        // doesn't know. The realistic trigger is version skew — the library ships to
-        // multiple apps, so a maker on a newer schema can persist a node an older
-        // deployed renderer can't render. Degrade to visible text rather than let
-        // one field throw out of its (unguarded) computed and 500 the whole page.
-        console.error('renderRteToHtml: unrenderable doc, falling back to plain text', error);
-        return getRteJsonPlainText(value);
-    }
-};
-// Tiptap's elementFromString strips whitespace-only text nodes (pretty-print
-// indentation between tags) before parsing; replicate it so injected-parser
-// output stays identical to the previous generateJSON-based conversion.
-const stripIndentationTextNodes = (node) => {
-    const children = node.childNodes;
-    for (let i = children.length - 1; i >= 0; i -= 1) {
-        const child = children[i];
-        if (child.nodeType === 3 &&
-            child.nodeValue &&
-            /^(\n\s\s|\n)$/.test(child.nodeValue)) {
-            node.removeChild(child);
-        }
-        else if (child.nodeType === 1) {
-            stripIndentationTextNodes(child);
-        }
-    }
-    return node;
-};
-const htmlToRteJson = (html, parser) => {
-    const body = parser.parseFromString(`<body>${html}</body>`, 'text/html').body;
-    const dom = stripIndentationTextNodes(body);
-    return ProseMirrorDOMParser.fromSchema(RTE_SCHEMA).parse(dom).toJSON();
-};
-let serverParserPromise = null;
-/**
- * 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 const resolveHtmlParser = async () => {
-    if (typeof DOMParser !== 'undefined')
-        return new DOMParser();
-    if (!serverParserPromise) {
-        const jsdomModuleId = ['js', 'dom'].join('');
-        serverParserPromise = import(/* @vite-ignore */ jsdomModuleId)
-            .then((mod) => {
-            const { JSDOM } = mod;
-            const { DOMParser: JsdomDOMParser } = new JSDOM('').window;
-            return new JsdomDOMParser();
-        })
-            .catch((error) => {
-            // Don't cache the failure — let a later call retry the import.
-            serverParserPromise = null;
-            throw error;
-        });
-    }
-    return serverParserPromise;
-};
-const getDefaultParser = () => {
-    if (typeof DOMParser !== 'undefined')
-        return new DOMParser();
-    throw new Error('toRteJson: no global DOMParser in this environment. On the server, pass an ' +
-        'explicit parser as the second argument (see resolveHtmlParser).');
-};
-/**
- * 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.
- */
-export const toRteJson = (value, parser) => {
-    if (value == null || value === '')
-        return undefined;
-    if (isTiptapDocument(value))
-        return value;
-    return htmlToRteJson(value, parser ?? getDefaultParser());
-};

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

@@ -1,18 +0,0 @@
-import type { JSONContent } from '@tiptap/vue-3';
-/**
- * Is this value RTE content, and in which shape?
- *
- * Pure predicates with NO runtime imports, kept out of `rich-text-editor.util.ts`
- * (which pulls `dompurify` and the render helpers) so a pure consumer — the Color
- * Matches panel, which must tell a plain string from legacy RTE HTML — doesn't drag
- * in the editor toolchain. That module re-exports both, so callers are unchanged.
- */
-/** Canonical discriminator for the JSON RTE model: an object with `type: 'doc'`. */
-export declare const isTiptapDocument: (value: unknown) => value is JSONContent;
-/**
- * A legacy inline-HTML RTE string: opens with a tag and closes with one. It does
- * NOT match plain strings (`Price < 10`), CSS values, or text with merely embedded
- * HTML, because genuine RTE always begins with a block tag. Legacy shape only —
- * post-migration use isTiptapDocument, or hasRTEContent for either shape.
- */
-export declare const isRteHtmlString: (value: unknown) => value is string;

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

@@ -1,21 +0,0 @@
-/**
- * Is this value RTE content, and in which shape?
- *
- * Pure predicates with NO runtime imports, kept out of `rich-text-editor.util.ts`
- * (which pulls `dompurify` and the render helpers) so a pure consumer — the Color
- * Matches panel, which must tell a plain string from legacy RTE HTML — doesn't drag
- * in the editor toolchain. That module re-exports both, so callers are unchanged.
- */
-/** Canonical discriminator for the JSON RTE model: an object with `type: 'doc'`. */
-export const isTiptapDocument = (value) => typeof value === 'object' &&
-    value !== null &&
-    value.type === 'doc';
-/**
- * A legacy inline-HTML RTE string: opens with a tag and closes with one. It does
- * NOT match plain strings (`Price < 10`), CSS values, or text with merely embedded
- * HTML, because genuine RTE always begins with a block tag. Legacy shape only —
- * post-migration use isTiptapDocument, or hasRTEContent for either shape.
- */
-export const isRteHtmlString = (value) => typeof value === 'string' &&
-    value.length > 0 &&
-    /^<[A-Za-z][A-Za-z0-9-]*\b[^>]*>[\s\S]*<\/[A-Za-z][A-Za-z0-9-]*>$/.test(value.trim());

package/lib/src/metadata-builder/builders/global-font-propagation.d.ts

@@ -1,41 +0,0 @@
-import type { JSONContent } from '@tiptap/vue-3';
-import type { BrandPageModel } from '../../brand-page/models';
-import type { UpdateGlobalStylesArguments } from '../parsers/ai-toolcall-parser';
-/**
- * Propagation of AI global font-family changes into existing section content.
- *
- * A `tool_update_global_styles` call merges new per-category font families into
- * `styles.textStyles.textStyleOptions` — but only content whose style is still
- * bound to a preset (`textStyleType`) follows that change. Template-authored
- * content carries detached `*Style` objects AND inline `font-family` marks in
- * its RTE HTML, both of which override the preset at render time, so a global
- * font change was invisible on most templates (BP-5780 ISSUE-01).
- *
- * This module walks every page's contents and, for each text field whose
- * resolved category received a new family, aligns the detached style object and
- * rewrites the RTE field's inline font-family marks. Preset-bound styles are NOT
- * detached — they already follow the preset; only their RTE inline marks are
- * rewritten (the marks would otherwise still win over the preset).
- *
- * RTE fields come in two shapes: legacy inline HTML strings (rewritten through
- * the headless Tiptap editor) and the migrated Tiptap JSON document (rewritten
- * in place — `textStyle` mark attrs). Missing the JSON shape left every mark on
- * the old family while the `*Style` objects moved (BP-6079).
- */
-export type GlobalFontCategory = 'titles' | 'headings' | 'paragraphs' | 'buttons';
-/** Extract the per-category families this AI call actually changes. */
-export declare const collectChangedFontFamilies: (textStyles: UpdateGlobalStylesArguments["textStyles"]) => Partial<Record<GlobalFontCategory, string>>;
-export type ApplyFontToRTE = (text: string, fontFamily: string) => string;
-/**
- * Rewrite the `fontFamily` attr of every `textStyle` mark in a Tiptap document.
- * Only marks that already carry a family are touched: a run without one inherits
- * the (already updated) `*Style` / preset at render, so adding a mark would pin
- * it needlessly.
- */
-export declare const applyFontToTiptapDoc: (doc: JSONContent, fontFamily: string) => JSONContent;
-/**
- * Walk every page's contents and propagate the changed families.
- * `applyFont` is injectable for tests; the default rewrites inline marks via
- * the external Tiptap editor.
- */
-export declare const propagateFontFamiliesToContents: (model: BrandPageModel, changed: Partial<Record<GlobalFontCategory, string>>, applyFont?: ApplyFontToRTE) => void;

package/lib/src/metadata-builder/builders/global-font-propagation.js

@@ -1,146 +0,0 @@
-import { hasRTEContent } from '../../brand-page-maker/utils';
-import { useExternalRichTextEditor } from '../../brand-page-maker/composables/rich-text-editor/useRichTextEditor';
-import { applyStyleToRTEText } from '../helpers/rte.helpers';
-import { isTiptapDocument } from '../parsers/section-tool-arguments';
-/**
- * Default category per text field when its style is detached (no `textStyleType`).
- * Mirrors the AI service's slot→category stamping (titles←h1, headings←h2-h4,
- * paragraphs←body, buttons←button). `title` upgrades to `titles` on banner
- * sections (the hero headline) via `resolveFieldCategory`.
- */
-const FIELD_DEFAULT_CATEGORY = {
-    title: 'headings',
-    heading: 'headings',
-    name: 'headings',
-    description: 'paragraphs',
-    paragraph: 'paragraphs',
-    text: 'paragraphs',
-    testimonial: 'paragraphs',
-    position: 'paragraphs',
-    question: 'headings',
-    answer: 'paragraphs',
-    buttonText: 'buttons',
-    successMessage: 'paragraphs',
-};
-const CATEGORIES = [
-    'titles',
-    'headings',
-    'paragraphs',
-    'buttons',
-];
-const isPlainObject = (v) => !!v && typeof v === 'object' && !Array.isArray(v);
-/** Extract the per-category families this AI call actually changes. */
-export const collectChangedFontFamilies = (textStyles) => {
-    const changed = {};
-    if (!textStyles)
-        return changed;
-    for (const category of CATEGORIES) {
-        const family = textStyles.textStyleOptions?.[category]?.style?.fontFamily;
-        if (typeof family === 'string' && family.trim()) {
-            changed[category] = family;
-        }
-    }
-    // Base text family covers paragraphs when no explicit paragraphs entry came in.
-    if (!changed.paragraphs &&
-        typeof textStyles.textFontFamily === 'string' &&
-        textStyles.textFontFamily.trim()) {
-        changed.paragraphs = textStyles.textFontFamily;
-    }
-    return changed;
-};
-const resolveFieldCategory = (fieldName, style, content) => {
-    const preset = isPlainObject(style)
-        ? style.textStyleType
-        : undefined;
-    if (preset && CATEGORIES.includes(preset))
-        return preset;
-    if (fieldName === 'title' && content.type === 'banner-section') {
-        return 'titles';
-    }
-    return FIELD_DEFAULT_CATEGORY[fieldName];
-};
-/** `testimonialsStyle` → `testimonial`, `titleStyle` → `title`. */
-const styleKeyToFieldName = (styleKey) => {
-    const base = styleKey.slice(0, -'Style'.length);
-    return base.endsWith('s') && !(base in FIELD_DEFAULT_CATEGORY)
-        ? base.slice(0, -1)
-        : base;
-};
-/**
- * Rewrite the `fontFamily` attr of every `textStyle` mark in a Tiptap document.
- * Only marks that already carry a family are touched: a run without one inherits
- * the (already updated) `*Style` / preset at render, so adding a mark would pin
- * it needlessly.
- */
-export const applyFontToTiptapDoc = (doc, fontFamily) => {
-    const visit = (node) => {
-        const marks = node.marks?.map((mark) => mark.type === 'textStyle' && mark.attrs?.fontFamily
-            ? { ...mark, attrs: { ...mark.attrs, fontFamily } }
-            : mark);
-        const content = node.content?.map(visit);
-        return {
-            ...node,
-            ...(marks ? { marks } : {}),
-            ...(content ? { content } : {}),
-        };
-    };
-    return visit(doc);
-};
-const walkRecord = (record, content, changed, applyFont) => {
-    for (const [key, value] of Object.entries(record)) {
-        if (key.endsWith('Style') && isPlainObject(value)) {
-            // Detached style objects carry their own fontFamily override — align it.
-            // Preset-bound styles keep following the preset (never detach here).
-            const category = resolveFieldCategory(styleKeyToFieldName(key), value, content);
-            const family = category ? changed[category] : undefined;
-            if (family && !value.textStyleType) {
-                value.fontFamily =
-                    family;
-            }
-        }
-        else if (key in FIELD_DEFAULT_CATEGORY && hasRTEContent(value)) {
-            // Inline RTE marks override every style layer at render — rewrite them.
-            const category = resolveFieldCategory(key, record[`${key}Style`], content);
-            const family = category ? changed[category] : undefined;
-            if (family) {
-                record[key] = isTiptapDocument(value)
-                    ? applyFontToTiptapDoc(value, family)
-                    : applyFont(value, family);
-            }
-        }
-        else if (Array.isArray(value)) {
-            for (const item of value) {
-                if (isPlainObject(item)) {
-                    walkRecord(item, content, changed, applyFont);
-                }
-            }
-        }
-    }
-};
-/**
- * Walk every page's contents and propagate the changed families.
- * `applyFont` is injectable for tests; the default rewrites inline marks via
- * the external Tiptap editor.
- */
-export const propagateFontFamiliesToContents = (model, changed, applyFont) => {
-    if (!Object.keys(changed).length)
-        return;
-    let editor;
-    const apply = applyFont ??
-        ((text, fontFamily) => {
-            editor = editor ?? useExternalRichTextEditor().externalEditor;
-            return applyStyleToRTEText(editor, text, {
-                fontFamily,
-            });
-        });
-    try {
-        for (const page of model.pages) {
-            for (const content of page.contents) {
-                walkRecord(content, content, changed, apply);
-            }
-        }
-    }
-    finally {
-        editor?.destroy();
-    }
-};