@designcrowd/library.brand-page 6.2.11 → 6.2.12

package/src/metadata-builder/builders/global-styles-builder.ts

@@ -9,17 +9,122 @@ import type {
   TextStyleOptionStyle,
 } from '../parsers/ai-toolcall-parser';
 import type { Logger } from '../logger';
-import type { GlobalTextStyleDeclaration } from '../../brand-page/models/styles.model';
+import {
+  CANONICAL_TEXT_STYLE_TYPES,
+  LEGACY_TEXT_STYLE_TYPES,
+  type CanonicalTextStyleType,
+  type GlobalTextStyleDeclaration,
+  type LegacyTextStyleType,
+  type TextStyleOptions,
+} from '../../brand-page/models/styles.model';
+import {
+  computeLegacyTargets,
+  HEADING_TIERS,
+  PARAGRAPH_TIERS,
+} from '../../brand-page/utils/text-role-reconnect.util';
+import {
+  TEXT_STYLE_CASCADE_PROPS,
+  type CascadeTypographyProp,
+} from '../../brand-page/utils/text-style.util';
+import { NEUTRAL_TYPOGRAPHY_VALUE } from '@shared/text-role-typography.util';
 import {
   GLOBAL_STYLE_CHECKS,
-  TEXT_STYLE_OPTION_KEYS,
+  normalizeGlobalTextStyleOption,
 } from './section-rules/global-styles.rules';
 import {
-  collectChangedFontFamilies,
-  propagateFontFamiliesToContents,
-} from './global-font-propagation';
+  collectChangedRoleProps,
+  propagateRolePropsToContents,
+} from './global-role-propagation';
 import { buttonStylePresetCss } from '../../shared/style-settings/button-style-preset';
 
+type ResolvedTextStyleOptionArgs = {
+  style?: TextStyleOptionStyle;
+  isModified?: boolean;
+};
+
+const retiredKeyFamilyTiers = (
+  key: LegacyTextStyleType,
+): readonly CanonicalTextStyleType[] => {
+  switch (key) {
+    case 'headings':
+      return HEADING_TIERS.filter((tier) => tier !== 'heading1');
+    case 'paragraphs':
+      return PARAGRAPH_TIERS;
+    case 'titles':
+    case 'buttons':
+      return [];
+  }
+};
+
+const retiredKeySingleTarget = (
+  key: LegacyTextStyleType,
+  existingOptions: TextStyleOptions,
+): CanonicalTextStyleType => computeLegacyTargets(existingOptions)[key];
+
+const resolveCanonicalTextStyleOptions = (
+  textStyleOptions: NonNullable<
+    UpdateGlobalStylesArguments['textStyles']
+  >['textStyleOptions'],
+  existingOptions: TextStyleOptions,
+): Partial<Record<CanonicalTextStyleType, ResolvedTextStyleOptionArgs>> => {
+  const resolved: Partial<
+    Record<CanonicalTextStyleType, ResolvedTextStyleOptionArgs>
+  > = {};
+
+  if (!textStyleOptions) return resolved;
+
+  const mergeInto = (
+    role: CanonicalTextStyleType,
+    optionArgs: ResolvedTextStyleOptionArgs,
+  ): void => {
+    resolved[role] = {
+      style: {
+        ...resolved[role]?.style,
+        ...(optionArgs.style
+          ? normalizeGlobalTextStyleOption(optionArgs.style)
+          : undefined),
+      },
+      isModified: optionArgs.isModified ?? resolved[role]?.isModified,
+    };
+  };
+
+  for (const role of CANONICAL_TEXT_STYLE_TYPES) {
+    const optionArgs = textStyleOptions[role];
+
+    if (optionArgs) mergeInto(role, optionArgs);
+  }
+
+  for (const key of LEGACY_TEXT_STYLE_TYPES) {
+    const optionArgs = textStyleOptions[key];
+
+    if (!optionArgs) continue;
+
+    const singleTarget = retiredKeySingleTarget(key, existingOptions);
+    const familyTiers = retiredKeyFamilyTiers(key);
+    const style = (optionArgs.style ?? {}) as Record<string, unknown>;
+    const { fontFamily, ...rest } = style;
+    const hasRest = Object.keys(rest).length > 0;
+
+    if (hasRest || !familyTiers.length || optionArgs.isModified !== undefined) {
+      mergeInto(singleTarget, {
+        style: (familyTiers.length ? rest : style) as TextStyleOptionStyle,
+        isModified: optionArgs.isModified,
+      });
+    }
+
+    if (fontFamily !== undefined && familyTiers.length) {
+      familyTiers.forEach((role) =>
+        mergeInto(role, {
+          style: { fontFamily } as TextStyleOptionStyle,
+          isModified: optionArgs.isModified,
+        }),
+      );
+    }
+  }
+
+  return resolved;
+};
+
 export class GlobalStylesBuilder extends BaseMetadataBuilder<UpdateGlobalStylesArguments> {
   constructor(
     request: MetadataBuilderRequest<UpdateGlobalStylesArguments>,
@@ -40,38 +145,53 @@ export class GlobalStylesBuilder extends BaseMetadataBuilder<UpdateGlobalStylesA
 
       return { errors };
     } catch (error) {
+      // Fail closed: a throwing check must block the call, not pass it as clean with every
+      // check skipped.
       this.log({
-        message: 'Global styles validation failed unexpectedly — skipping',
+        message:
+          'Global styles validation failed unexpectedly — rejecting the call',
         error,
       });
 
-      return { errors: [] };
+      return { errors: ['Global styles validation failed unexpectedly'] };
     }
   }
 
   async buildAsync(model: BrandPageModel): Promise<BuilderResult> {
     this.log('Build called');
+
+    const validation = await this.validateAsync();
+
+    if (validation.errors.length) {
+      return { request: this.request, model, errors: validation.errors };
+    }
+
     const args = this.request.payload ?? {};
+    let builderWarnings: string[] | undefined;
 
     if (args.backgroundStyles) {
       this.applyBackgroundStyles(model, args.backgroundStyles);
     }
 
     if (args.textStyles) {
-      this.applyTextStyles(model, args.textStyles);
+      const { changedRoleProps, warnings } = this.applyTextStyles(
+        model,
+        args.textStyles,
+      );
 
-      // A category font change only reaches preset-bound content by itself;
-      // detached section styles and inline RTE font marks would still render
-      // the old family. Propagate so the change is actually visible (BP-5780).
-      const changedFamilies = collectChangedFontFamilies(args.textStyles);
+      builderWarnings = warnings.length ? warnings : undefined;
 
-      if (Object.keys(changedFamilies).length) {
+      if (Object.keys(changedRoleProps).length) {
         try {
-          propagateFontFamiliesToContents(model, changedFamilies);
+          propagateRolePropsToContents(
+            model,
+            changedRoleProps,
+            args.textStyles.keepRuns,
+          );
         } catch (error) {
           this.log({
             message:
-              'Global font propagation to existing contents failed — presets still updated',
+              'Global role propagation to existing contents failed — presets still updated',
             error,
           });
         }
@@ -82,45 +202,66 @@ export class GlobalStylesBuilder extends BaseMetadataBuilder<UpdateGlobalStylesA
       this.applyButtonStyles(model, args.buttonStyles);
     }
 
-    return { request: this.request, model };
+    return { request: this.request, model, warnings: builderWarnings };
   }
 
   private applyTextStyles(
     model: BrandPageModel,
     textStyles: NonNullable<UpdateGlobalStylesArguments['textStyles']>,
-  ): void {
+  ): {
+    changedRoleProps: ReturnType<typeof collectChangedRoleProps>;
+    warnings: string[];
+  } {
     const ts = model.styles.textStyles;
 
-    // A `textStyles.style` arg is ignored — the property is retired. Schema cleanup
-    // in service.ai-pipelines is a follow-up.
-
-    // Merge textFontFamily
-    if (textStyles.textFontFamily !== undefined) {
-      ts.textFontFamily = textStyles.textFontFamily as typeof ts.textFontFamily;
-    }
+    const resolved = resolveCanonicalTextStyleOptions(
+      textStyles.textStyleOptions,
+      ts.textStyleOptions,
+    );
+    const changedRoleProps = collectChangedRoleProps(
+      resolved,
+      ts.textStyleOptions,
+    );
 
-    // Deep-merge textStyleOptions per category
-    if (textStyles.textStyleOptions) {
-      for (const key of TEXT_STYLE_OPTION_KEYS) {
-        const optionArgs = textStyles.textStyleOptions[key];
+    for (const role of CANONICAL_TEXT_STYLE_TYPES) {
+      const optionArgs = resolved[role];
 
-        if (!optionArgs) continue;
+      if (!optionArgs) continue;
 
-        const existing = ts.textStyleOptions[key];
+      const existing = ts.textStyleOptions[role];
 
-        if (!existing) continue;
+      if (!existing) continue;
 
-        if (optionArgs.style) {
-          this.mergeStyleOptionStyle(existing.style, optionArgs.style);
-          // Mark as modified when style properties change
-          existing.isModified = true;
-        }
+      if (optionArgs.style) {
+        this.mergeStyleOptionStyle(existing.style, optionArgs.style);
+        existing.isModified = true;
+      }
 
-        if (optionArgs.isModified !== undefined) {
-          existing.isModified = optionArgs.isModified;
-        }
+      if (optionArgs.isModified !== undefined) {
+        existing.isModified = optionArgs.isModified;
       }
     }
+
+    return {
+      changedRoleProps,
+      warnings: this.applyTextStylesWarnings(textStyles),
+    };
+  }
+
+  private applyTextStylesWarnings(
+    textStyles: NonNullable<UpdateGlobalStylesArguments['textStyles']>,
+  ): string[] {
+    const droppedRoles = Object.entries(textStyles.textStyleOptions ?? {})
+      .filter(([, option]) => option?.style?.color)
+      .map(([role]) => role);
+
+    return droppedRoles.length
+      ? [
+          `Ignored role color for ${droppedRoles.join(
+            ', ',
+          )}; apply colour to the affected sections instead.`,
+        ]
+      : [];
   }
 
   private applyButtonStyles(
@@ -129,19 +270,14 @@ export class GlobalStylesBuilder extends BaseMetadataBuilder<UpdateGlobalStylesA
   ): void {
     const bs = model.styles.buttonStyles;
 
-    // Deep-merge style (color, borderColor, backgroundColor)
     if (buttonStyles.style) {
       bs.style = { ...bs.style, ...buttonStyles.style };
     }
 
-    // Deep-merge iconStyle (fill)
     if (buttonStyles.iconStyle) {
       bs.iconStyle = { ...bs.iconStyle, ...buttonStyles.iconStyle };
     }
 
-    // Merge selectedButtonStyleId and apply that preset's shape and shadow the way the
-    // editor's picker does: the site renders buttons from `style`, so the id alone is
-    // invisible (BP-6082). The preset owns the shape keys; colours from `style` stay.
     if (buttonStyles.selectedButtonStyleId !== undefined) {
       bs.selectedButtonStyleId = buttonStyles.selectedButtonStyleId;
 
@@ -198,14 +334,12 @@ export class GlobalStylesBuilder extends BaseMetadataBuilder<UpdateGlobalStylesA
       if (backgroundStyles.backgroundShapeUrl === '') {
         bs.backgroundShapes = [];
       } else if (bs.backgroundShapes?.length) {
-        // Only update when shapes already exist — never add shapes to a site that has none.
-        // Update ALL shapes so every positional instance switches to the new shape type.
+        // Retype only the shapes a site already has: a site with none never gains one.
         bs.backgroundShapes = bs.backgroundShapes.map((shape) => ({
           ...shape,
           name: backgroundStyles.backgroundShapeUrl!,
         }));
       }
-      // If backgroundShapes is empty/absent: intentional no-op
     }
   }
 
@@ -214,8 +348,20 @@ export class GlobalStylesBuilder extends BaseMetadataBuilder<UpdateGlobalStylesA
     incoming: TextStyleOptionStyle,
   ): void {
     for (const [key, value] of Object.entries(incoming)) {
-      if (value !== undefined) {
+      if (!TEXT_STYLE_CASCADE_PROPS.includes(key as CascadeTypographyProp)) {
+        continue;
+      }
+
+      if (value !== undefined && value !== null && value !== '') {
         (existing as unknown as Record<string, unknown>)[key] = value;
+      } else if (
+        (value === null || value === '') &&
+        Object.prototype.hasOwnProperty.call(NEUTRAL_TYPOGRAPHY_VALUE, key)
+      ) {
+        (existing as unknown as Record<string, unknown>)[key] =
+          NEUTRAL_TYPOGRAPHY_VALUE[
+            key as keyof typeof NEUTRAL_TYPOGRAPHY_VALUE
+          ];
       }
     }
   }

package/src/metadata-builder/builders/header-builder.test.ts

@@ -1,41 +1,36 @@
 import { describe, it, expect } from 'vitest';
-import type { BrandPageModel } from '../../brand-page/models';
+import type {
+  BrandPageModel,
+  TextStyleDeclaration,
+} from '../../brand-page/models';
+import { TextStyles } from '../../brand-page/models';
 import type { TextStyleOptions } from '../../brand-page/models/styles.model';
+import {
+  resolveTextStyle,
+  TEXT_STYLE_CASCADE_PROPS,
+} from '../../brand-page/utils/text-style.util';
 import type { UpdateHeaderArguments } from '../parsers/ai-toolcall-parser';
 import { BUILDER_TYPES } from '../models';
 import { HeaderBuilder } from './header-builder';
 
 /**
- * BP-5420: changing the nav menu font had no effect when the nav button style
- * was bound to the global `buttons` preset (`textStyleType: 'buttons'`). The
- * renderer (`getTextStyleByContentTextStyle`) overlays the preset font over the
- * per-element style, discarding the font the builder wrote.
- *
- * The fix routes nav button style writes through `applyDetachedStyleOverride`,
- * which resolves the preset in and clears `textStyleType`.
+ * BP-5420: changing the nav menu font had no effect when the nav button style was bound to a
+ * global preset, because the renderer overlaid the preset font. With per-property resolution the
+ * nav keeps its role and the font is stored as a sparse override, which wins over the role.
  */
 
-const textStyleOptions = {
-  titles: { type: 'titles', title: 'Titles', style: { fontFamily: 'Poppins' } },
-  headings: {
-    type: 'headings',
-    title: 'Headings',
-    style: { fontFamily: 'Poppins' },
-  },
-  paragraphs: {
-    type: 'paragraphs',
-    title: 'Paragraphs',
-    style: { fontFamily: 'Inter' },
-  },
-  buttons: {
-    type: 'buttons',
-    title: 'Buttons',
-    style: { fontFamily: 'Poppins', fontSize: '1em', color: '#ffffff' },
-  },
-} as unknown as TextStyleOptions;
+const makeOptions = (): TextStyleOptions => {
+  const options = TextStyles.GetDefaultTextStyle().textStyleOptions;
+
+  options.paragraph1.style.fontFamily = 'Poppins';
+  options.button.style.fontFamily = 'Poppins';
+
+  return options;
+};
 
 const makeModel = (
   defaultButtonStyle: Record<string, unknown>,
+  textStyleOptions: TextStyleOptions = makeOptions(),
 ): BrandPageModel =>
   ({
     styles: { textStyles: { textStyleOptions } },
@@ -54,9 +49,17 @@ const run = (args: UpdateHeaderArguments, model: BrandPageModel) =>
     payload: args,
   }).buildAsync(model);
 
+// Only the font is stored; every other typography property is left to the role.
+const expectOnlyFontOverride = (style: Record<string, unknown>): void => {
+  for (const prop of TEXT_STYLE_CASCADE_PROPS) {
+    if (prop !== 'fontFamily') expect(style[prop]).toBeUndefined();
+  }
+};
+
 describe('HeaderBuilder — nav menu font vs global style', () => {
-  it('clears textStyleType so the new menu font sticks when bound to a preset', async () => {
-    const model = makeModel({ textStyleType: 'buttons' });
+  it('link_text_font keeps the nav tabs on their role; the font is a sparse override that sticks', async () => {
+    const options = makeOptions();
+    const model = makeModel({ textStyleType: 'paragraph1' }, options);
 
     const { model: out, errors } = await run(
       { desktop: { link_text_font: 'Oswald' } },
@@ -67,11 +70,28 @@ describe('HeaderBuilder — nav menu font vs global style', () => {
       .defaultButtonStyle as Record<string, unknown>;
 
     expect(errors ?? []).toEqual([]);
+    expect(style.textStyleType).toBe('paragraph1');
+    expect(style.fontFamily).toBe('Oswald');
+    expectOnlyFontOverride(style);
+    expect(
+      resolveTextStyle(style as TextStyleDeclaration, options.paragraph1.style)
+        .fontFamily,
+    ).toBe('Oswald');
+  });
+
+  it('link_text_font reconnects nav tabs on a retired role to their starting role, Paragraph 1', async () => {
+    const model = makeModel({ textStyleType: 'buttons' });
+
+    const { model: out } = await run(
+      { desktop: { link_text_font: 'Oswald' } },
+      model,
+    );
+
+    const style = out.pageHeaderDesktop!.navigation
+      .defaultButtonStyle as Record<string, unknown>;
+
+    expect(style.textStyleType).toBe('paragraph1');
     expect(style.fontFamily).toBe('Oswald');
-    expect(style.textStyleType).toBeUndefined();
-    // preset values resolved in; only the font is overridden
-    expect(style.fontSize).toBe('1em');
-    expect(style.color).toBe('#ffffff');
   });
 
   it('applies the override to the targeted viewport only', async () => {
@@ -106,20 +126,71 @@ describe('HeaderBuilder — nav menu font vs global style', () => {
 });
 
 describe('HeaderBuilder — nav menu font reaches the hamburger overlay (BP-6079)', () => {
-  it('applies link_text_font to the hamburger default and selected button styles', async () => {
-    const model = makeModel({ textStyleType: 'buttons' });
+  it.each([[{ textStyleType: 'button' }], [{}]])(
+    'applies link_text_font to the hamburger default (%j → Button text); the selected link follows it (BP-5969 R12)',
+    async (hamburgerRole) => {
+      const options = makeOptions();
+      const model = makeModel({ textStyleType: 'paragraph1' }, options);
+      const nav = model.pageHeaderMobile!.navigation as unknown as Record<
+        string,
+        unknown
+      >;
+
+      nav.hamburgerMenuStyle = {
+        defaultButtonStyle: { ...hamburgerRole, color: '#111111' },
+        selectedButtonStyle: { color: '#222222' },
+      };
+
+      const { model: out, errors } = await run(
+        { mobile: { link_text_font: 'Oswald' } },
+        model,
+      );
+
+      const menu = (
+        out.pageHeaderMobile!.navigation as unknown as Record<string, unknown>
+      ).hamburgerMenuStyle as Record<string, Record<string, unknown>>;
+
+      expect(errors ?? []).toEqual([]);
+      expect(menu.defaultButtonStyle.textStyleType).toBe('button');
+      expect(menu.defaultButtonStyle.fontFamily).toBe('Oswald');
+      expect(menu.defaultButtonStyle.color).toBe('#111111');
+      expect(
+        resolveTextStyle(
+          menu.defaultButtonStyle as TextStyleDeclaration,
+          options.button.style,
+        ).fontFamily,
+      ).toBe('Oswald');
+      // The selected style mirrors the default's RESULTING sparse typography (B4; R12, R20)
+      // instead of being independently reconnected onto its own role — it carries no role of
+      // its own (no maker path sets one, no migration adds one; global-role-propagation's
+      // sibling drop is what reaches it on a later site-wide change, not a textStyleType match).
+      expect(menu.selectedButtonStyle.textStyleType).toBeUndefined();
+      expect(menu.selectedButtonStyle.fontFamily).toBe('Oswald');
+      expect(menu.selectedButtonStyle.color).toBe('#222222');
+      expect(
+        resolveTextStyle(
+          menu.selectedButtonStyle as TextStyleDeclaration,
+          options.button.style,
+        ).fontFamily,
+      ).toBe('Oswald');
+    },
+  );
+
+  it('selected link follows its default sibling: a family equal to the menu role is sparse on both', async () => {
+    const options = makeOptions(); // options.button.style.fontFamily === 'Poppins'
+    const model = makeModel({ textStyleType: 'paragraph1' }, options);
     const nav = model.pageHeaderMobile!.navigation as unknown as Record<
       string,
       unknown
     >;
 
     nav.hamburgerMenuStyle = {
-      defaultButtonStyle: { fontFamily: 'Lato', color: '#111111' },
-      selectedButtonStyle: { textStyleType: 'buttons' },
+      defaultButtonStyle: { textStyleType: 'button', color: '#111111' },
+      selectedButtonStyle: { color: '#222222' },
     };
 
     const { model: out, errors } = await run(
-      { mobile: { link_text_font: 'Oswald' } },
+      { mobile: { link_text_font: 'Poppins' } },
       model,
     );
 
@@ -128,10 +199,11 @@ describe('HeaderBuilder — nav menu font reaches the hamburger overlay (BP-6079
     ).hamburgerMenuStyle as Record<string, Record<string, unknown>>;
 
     expect(errors ?? []).toEqual([]);
-    expect(menu.defaultButtonStyle.fontFamily).toBe('Oswald');
-    expect(menu.defaultButtonStyle.color).toBe('#111111');
-    expect(menu.selectedButtonStyle.fontFamily).toBe('Oswald');
+    expect(menu.defaultButtonStyle.fontFamily).toBeUndefined();
+    expect(menu.selectedButtonStyle.fontFamily).toBeUndefined();
     expect(menu.selectedButtonStyle.textStyleType).toBeUndefined();
+    expect(menu.defaultButtonStyle.color).toBe('#111111');
+    expect(menu.selectedButtonStyle.color).toBe('#222222');
   });
 
   it('a header without a hamburger menu style is left alone', async () => {

package/src/metadata-builder/builders/header-builder.ts

@@ -16,7 +16,11 @@ import type { Logger } from '../logger';
 import type { TextStyleOptions } from '../../brand-page/models/styles.model';
 import { getPageSlugFromPageTitle } from '../../brand-page-maker/utils/slug.util';
 import { HEADER_CHECKS } from './section-rules/header.rules';
-import { applyDetachedStyleOverride } from './section-field-utils';
+import { applyAiStyle } from './section-field-utils';
+import {
+  omitTypography,
+  pickTypography,
+} from '../../brand-page/utils/text-style.util';
 
 const applyViewportHeaderChanges = (
   header: AbstractPageHeaderStyles,
@@ -58,10 +62,11 @@ const applyViewportHeaderChanges = (
   }
 
   if (overrides.link_text_font !== undefined && header.navigation) {
-    header.navigation.defaultButtonStyle = applyDetachedStyleOverride(
+    header.navigation.defaultButtonStyle = applyAiStyle(
       header.navigation.defaultButtonStyle,
       { fontFamily: overrides.link_text_font },
       textStyleOptions,
+      { startingRole: 'paragraph1' },
     );
   }
 
@@ -73,16 +78,21 @@ const applyViewportHeaderChanges = (
   ) {
     const menu = header.navigation.hamburgerMenuStyle;
 
-    menu.defaultButtonStyle = applyDetachedStyleOverride(
+    menu.defaultButtonStyle = applyAiStyle(
       menu.defaultButtonStyle,
       { fontFamily: overrides.link_text_font },
       textStyleOptions,
+      { startingRole: 'button' },
     );
-    menu.selectedButtonStyle = applyDetachedStyleOverride(
-      menu.selectedButtonStyle,
-      { fontFamily: overrides.link_text_font },
-      textStyleOptions,
-    );
+    // The selected style mirrors the default's RESULTING sparse typography rather than being
+    // independently reconnected: it carries no role of its own (no maker path
+    // sets one, no migration adds one), so reconnecting it on its own path could resolve a
+    // different override shape than its sibling for the same ask. `global-role-propagation.ts`
+    // mirrors a later site-wide change onto it the same way (the default/selected sibling drop).
+    menu.selectedButtonStyle = {
+      ...omitTypography(menu.selectedButtonStyle ?? {}),
+      ...pickTypography(menu.defaultButtonStyle),
+    };
   }
 
   if (overrides.link_bg_color !== undefined && header.navigation) {

package/src/metadata-builder/builders/section-builders/about-section-builder.ts

@@ -11,7 +11,7 @@ import {
 import {
   applyScalarFields,
   applyStyleFields,
-  resolveGlobalPresetIntoStyle,
+  applyAiStyle,
 } from '../section-field-utils';
 import {
   applyColorThemeToReplacements,
@@ -54,8 +54,9 @@ export class AboutSectionBuilder extends BaseSectionBuilder<AboutSectionContent>
     if (aboutArgs.title !== undefined) {
       if (isTiptapDocument(aboutArgs.title)) {
         resolved.content.title = aboutArgs.title;
-        resolved.content.titleStyle = resolveGlobalPresetIntoStyle(
+        resolved.content.titleStyle = applyAiStyle(
           resolved.content.titleStyle,
+          {},
           textStyleOptions,
         ) as TextStyleDeclaration;
       } else {
@@ -66,8 +67,9 @@ export class AboutSectionBuilder extends BaseSectionBuilder<AboutSectionContent>
     if (aboutArgs.paragraph !== undefined) {
       if (isTiptapDocument(aboutArgs.paragraph)) {
         resolved.content.paragraph = aboutArgs.paragraph;
-        resolved.content.paragraphStyle = resolveGlobalPresetIntoStyle(
+        resolved.content.paragraphStyle = applyAiStyle(
           resolved.content.paragraphStyle,
+          {},
           textStyleOptions,
         ) as TextStyleDeclaration;
       } else {

package/src/metadata-builder/builders/section-builders/banner-section-builder.ts

@@ -12,7 +12,7 @@ import {
   applyButtonLink,
   applyScalarFields,
   applyStyleFields,
-  resolveGlobalPresetIntoStyle,
+  applyAiStyle,
 } from '../section-field-utils';
 import {
   applyColorThemeToReplacements,
@@ -91,8 +91,9 @@ export class BannerSectionBuilder extends BaseSectionBuilder<BannerSectionConten
     if (bannerArgs.title !== undefined) {
       if (isTiptapDocument(bannerArgs.title)) {
         resolved.content.title = bannerArgs.title;
-        resolved.content.titleStyle = resolveGlobalPresetIntoStyle(
+        resolved.content.titleStyle = applyAiStyle(
           resolved.content.titleStyle,
+          {},
           textStyleOptions,
         ) as TextStyleDeclaration;
       } else {
@@ -103,8 +104,9 @@ export class BannerSectionBuilder extends BaseSectionBuilder<BannerSectionConten
     if (bannerArgs.description !== undefined) {
       if (isTiptapDocument(bannerArgs.description)) {
         resolved.content.description = bannerArgs.description;
-        resolved.content.descriptionStyle = resolveGlobalPresetIntoStyle(
+        resolved.content.descriptionStyle = applyAiStyle(
           resolved.content.descriptionStyle,
+          {},
           textStyleOptions,
         ) as TextStyleDeclaration;
       } else {