@designcrowd/library.brand-page 5.17.28 → 5.18.0

package/lib/src/metadata-builder/builders/rename-page-builder.js

@@ -0,0 +1,49 @@
+import {} from '../../brand-page/models';
+import { getPageSlugFromPageTitle } from '../../brand-page-maker/utils/slug.util';
+import { BaseMetadataBuilder, } from '../models';
+import { RENAME_PAGE_CHECKS, } from './section-rules/rename-page.rules';
+export class RenamePageBuilder extends BaseMetadataBuilder {
+    constructor(request, logger) {
+        super(request, logger);
+    }
+    async validateAsync() {
+        const errors = RENAME_PAGE_CHECKS.flatMap((check) => {
+            const err = check(this.request.payload);
+            return err ? [err] : [];
+        });
+        return { errors };
+    }
+    async buildAsync(model) {
+        this.log('Build called');
+        const validation = await this.validateAsync();
+        if (validation.errors.length) {
+            return { request: this.request, model, errors: validation.errors };
+        }
+        const { pageId, pageName } = this.request.payload;
+        const page = model.pages.find((p) => p.id === pageId);
+        if (!page) {
+            return {
+                request: this.request,
+                model,
+                errors: [`Page with ID "${pageId}" not found`],
+            };
+        }
+        const previousTitle = page.title;
+        page.title = pageName;
+        // Update the matching nav route's display name and recompute its slug.
+        // Slug uniqueness is computed against sibling routes (excluding the route
+        // being renamed) so we don't collide with our own previous slug.
+        const route = model.nav.routes.find((r) => r.pageId === pageId);
+        if (route) {
+            const siblingSlugs = model.nav.routes
+                .filter((r) => r.id !== route.id)
+                .map((r) => r.pageSlug);
+            route.displayName = pageName;
+            route.pageSlug = getPageSlugFromPageTitle(pageName, siblingSlugs);
+        }
+        this.log({
+            message: `Renamed page "${previousTitle}" → "${pageName}" (${pageId})`,
+        });
+        return { request: this.request, model };
+    }
+}

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

@@ -1,6 +1,8 @@
 import type { AboutSectionContent, BrandPageModel } from '../../../brand-page/models';
 import type { BuilderResult } from '../../models';
 import { BaseSectionBuilder } from './base-section-builder';
+import { validateAboutSection } from '../section-rules/about-section.rules';
 export declare class AboutSectionBuilder extends BaseSectionBuilder<AboutSectionContent> {
+    protected get sectionValidate(): typeof validateAboutSection;
     buildAsync(model: BrandPageModel): Promise<BuilderResult>;
 }

package/lib/src/metadata-builder/builders/section-builders/about-section-builder.js

@@ -1,18 +1,58 @@
-import { applyScalarFields, applyStyleFields } from '../section-field-utils';
+import { tiptapJsonToHtml } from '../../helpers/rte.helpers';
+import { isTiptapDocument, } from '../../parsers/section-tool-arguments';
+import { applyScalarFields, applyStyleFields, resolveGlobalPresetIntoStyle, } from '../section-field-utils';
+import { applyColorThemeToReplacements, resolveShapeColorReplacementsAsync, } from '../shape-color-utils';
 import { BaseSectionBuilder } from './base-section-builder';
+import { validateAboutSection } from '../section-rules/about-section.rules';
 export class AboutSectionBuilder extends BaseSectionBuilder {
+    get sectionValidate() {
+        return validateAboutSection;
+    }
     async buildAsync(model) {
         this.log('Build called');
         const validation = await this.validateAsync();
         if (validation.errors.length) {
             return { request: this.request, model, errors: validation.errors };
         }
-        const resolved = this.resolveContent(model);
+        const resolved = this.resolveAndRepositionContent(model);
         if ('error' in resolved)
             return resolved.error;
-        applyScalarFields(resolved.content, this.args, this.sectionType);
-        applyStyleFields(resolved.content, this.args, this.sectionType);
         const aboutArgs = this.args;
+        const prevImageUrl = resolved.content.imageUrl;
+        applyScalarFields(resolved.content, this.args, this.sectionType);
+        applyStyleFields(resolved.content, this.args, this.sectionType, this.getGlobalTextStyles(model));
+        const textStyleOptions = model.styles?.textStyles?.textStyleOptions;
+        if (aboutArgs.title !== undefined) {
+            if (isTiptapDocument(aboutArgs.title)) {
+                resolved.content.title = tiptapJsonToHtml(aboutArgs.title);
+                resolved.content.titleStyle = resolveGlobalPresetIntoStyle(resolved.content.titleStyle, textStyleOptions);
+            }
+            else {
+                resolved.content.title = aboutArgs.title;
+            }
+        }
+        if (aboutArgs.paragraph !== undefined) {
+            if (isTiptapDocument(aboutArgs.paragraph)) {
+                resolved.content.paragraph = tiptapJsonToHtml(aboutArgs.paragraph);
+                resolved.content.paragraphStyle = resolveGlobalPresetIntoStyle(resolved.content.paragraphStyle, textStyleOptions);
+            }
+            else {
+                resolved.content.paragraph = aboutArgs.paragraph;
+            }
+        }
+        if (aboutArgs.about_shape_url) {
+            resolved.content.mediaType = 'shape';
+            if (aboutArgs.about_shape_url !== prevImageUrl) {
+                resolved.content.colorReplacements =
+                    await resolveShapeColorReplacementsAsync(aboutArgs.about_shape_url);
+            }
+        }
+        else if (aboutArgs.about_image_url) {
+            resolved.content.mediaType = 'image';
+        }
+        if (aboutArgs.color_theme) {
+            resolved.content.colorReplacements = applyColorThemeToReplacements(resolved.content.colorReplacements ?? [], aboutArgs.color_theme);
+        }
         if (aboutArgs.background_color !== undefined) {
             resolved.content.backgroundStyle = {
                 ...resolved.content.backgroundStyle,

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

@@ -1,6 +1,8 @@
 import type { BannerSectionContent, BrandPageModel } from '../../../brand-page/models';
 import type { BuilderResult } from '../../models';
 import { BaseSectionBuilder } from './base-section-builder';
+import { validateBannerSection } from '../section-rules/banner-section.rules';
 export declare class BannerSectionBuilder extends BaseSectionBuilder<BannerSectionContent> {
+    protected get sectionValidate(): typeof validateBannerSection;
     buildAsync(model: BrandPageModel): Promise<BuilderResult>;
 }

package/lib/src/metadata-builder/builders/section-builders/banner-section-builder.js

@@ -1,32 +1,96 @@
-import { applyScalarFields, applyStyleFields, applyRTEStyles, } from '../section-field-utils';
+import { tiptapJsonToHtml } from '../../helpers/rte.helpers';
+import { isTiptapDocument, } from '../../parsers/section-tool-arguments';
+import { applyButtonLink, applyScalarFields, applyStyleFields, resolveGlobalPresetIntoStyle, } from '../section-field-utils';
+import { applyColorThemeToReplacements, resolveShapeColorReplacementsAsync, } from '../shape-color-utils';
 import { BaseSectionBuilder } from './base-section-builder';
+import { validateBannerSection } from '../section-rules/banner-section.rules';
 const applyBackgroundImage = (content, args) => {
     if (args.background_image_url) {
         content.media = undefined;
         content.mediaType = 'image';
     }
 };
+const applyBackgroundShapeAsync = async (content, args, prevImageUrl) => {
+    if (args.background_shape_url) {
+        content.media = undefined;
+        content.mediaType = 'shape';
+        content.size = '100%';
+        if (args.background_shape_url !== prevImageUrl) {
+            content.colorReplacements = await resolveShapeColorReplacementsAsync(args.background_shape_url);
+        }
+    }
+    if (args.color_theme) {
+        content.colorReplacements = applyColorThemeToReplacements(content.colorReplacements ?? [], args.color_theme);
+    }
+};
 export class BannerSectionBuilder extends BaseSectionBuilder {
+    get sectionValidate() {
+        return validateBannerSection;
+    }
     async buildAsync(model) {
         this.log('Build called');
         const validation = await this.validateAsync();
         if (validation.errors.length) {
             return { request: this.request, model, errors: validation.errors };
         }
-        const resolved = this.resolveContent(model);
+        const resolved = this.resolveAndRepositionContent(model);
         if ('error' in resolved)
             return resolved.error;
-        applyScalarFields(resolved.content, this.args, this.sectionType);
-        applyStyleFields(resolved.content, this.args, this.sectionType);
-        applyRTEStyles(resolved.content, this.args, this.sectionType);
-        applyBackgroundImage(resolved.content, this.args);
+        // FOR TESTING PURPOSE: If the generated content contains "@test", return an error message to replace it with "@dev-test"
+        // LETS KEEP THIS FOR NOW TO TEST THE EVEN LOOPING OF THE BUILD PROCESS, SINCE WE HAVE SEEN SOME ISSUES WITH IT DURING TESTING
+        const strrr = JSON.stringify((this.request.payload?.arguments).title?.content || {});
+        if (strrr.includes('@test')) {
+            return {
+                request: this.request,
+                model,
+                errors: [
+                    'When there is generated text contain "@test", should return as "@dev-test" instead',
+                ],
+            };
+        }
+        // TEST END
         const bannerArgs = this.args;
+        const prevImageUrl = resolved.content.imageUrl;
+        applyScalarFields(resolved.content, this.args, this.sectionType);
+        applyButtonLink(resolved.content, bannerArgs);
+        applyStyleFields(resolved.content, this.args, this.sectionType, this.getGlobalTextStyles(model));
+        const textStyleOptions = model.styles?.textStyles?.textStyleOptions;
+        if (bannerArgs.title !== undefined) {
+            if (isTiptapDocument(bannerArgs.title)) {
+                resolved.content.title = tiptapJsonToHtml(bannerArgs.title);
+                resolved.content.titleStyle = resolveGlobalPresetIntoStyle(resolved.content.titleStyle, textStyleOptions);
+            }
+            else {
+                resolved.content.title = bannerArgs.title;
+            }
+        }
+        if (bannerArgs.description !== undefined) {
+            if (isTiptapDocument(bannerArgs.description)) {
+                resolved.content.description = tiptapJsonToHtml(bannerArgs.description);
+                resolved.content.descriptionStyle = resolveGlobalPresetIntoStyle(resolved.content.descriptionStyle, textStyleOptions);
+            }
+            else {
+                resolved.content.description = bannerArgs.description;
+            }
+        }
+        applyBackgroundImage(resolved.content, bannerArgs);
+        await applyBackgroundShapeAsync(resolved.content, bannerArgs, prevImageUrl);
         if (bannerArgs.background_color !== undefined) {
             resolved.content.backgroundStyle = {
                 ...resolved.content.backgroundStyle,
                 backgroundColor: bannerArgs.background_color ?? '',
             };
         }
+        if (bannerArgs.card_style && typeof bannerArgs.card_style === 'object') {
+            const existing = resolved.content.cardStyle || {};
+            resolved.content.cardStyle = {
+                ...existing,
+                ...Object.fromEntries(Object.entries(bannerArgs.card_style).map(([k, v]) => [
+                    k,
+                    v === null ? '' : v,
+                ])),
+            };
+        }
         return { request: this.request, model };
     }
 }

package/lib/src/metadata-builder/builders/section-builders/base-section-builder.d.ts

@@ -1,7 +1,10 @@
 import { type BrandPageModel, type Content } from '../../../brand-page/models';
+import type { TextStyleOptions } from '../../../brand-page/models/styles.model';
+import { type EventTracker } from '../../../brand-page-maker/composables/useEventTracker';
 import type { Logger } from '../../logger';
 import { BaseMetadataBuilder, type BuilderResult, type MetadataBuilderRequest } from '../../models';
 import type { SectionToolArguments, SectionType } from '../../parsers/section-tool-arguments';
+import type { ValidationContext } from '../../sanitizers/section-args-validator';
 export interface SectionBuilderPayload {
     sectionType: SectionType;
     arguments: SectionToolArguments;
@@ -9,19 +12,47 @@ export interface SectionBuilderPayload {
     contentId?: string;
     /** Target page ID — used for create operations to place the new section on the correct page. */
     pageId?: string;
+    /** Insert/move before this existing content ID (create: position on insert; update: reposition). */
+    moveBeforeContentId?: string;
 }
 /**
  * Abstract base for per-section builders.
  *
  * Concrete builders implement `buildAsync` directly, using
- * `resolveContent()` to obtain the content object to mutate.
+ * `resolveAndRepositionContent()` to obtain the content object to mutate.
  */
 export declare abstract class BaseSectionBuilder<C extends Content = Content> extends BaseMetadataBuilder<SectionBuilderPayload> {
-    constructor(request: MetadataBuilderRequest<SectionBuilderPayload>, logger?: Logger);
+    /**
+     * Content ID resolved during `resolveAndRepositionContent` (CREATE: the
+     * id of the freshly-created content; UPDATE: the id of the located target).
+     * `MetadataExecutor` reads this via `getResolvedContentId()` to surface it
+     * on the returned BuilderResult, so callers can anchor follow-up operations
+     * (notably the AI retry vacant-slot tracker) to the section we just touched.
+     */
+    protected resolvedContentId?: string;
+    constructor(request: MetadataBuilderRequest<SectionBuilderPayload>, logger?: Logger, eventTracker?: EventTracker);
+    getResolvedContentId(): string | undefined;
     protected get sectionType(): SectionType;
     protected get mode(): 'create' | 'update';
     protected get args(): SectionToolArguments;
-    /** Override in subclasses for per-section validation. */
+    /**
+     * Returns the explicit validate function for this section's AI arguments.
+     * Override in concrete builders to return the colocated validate function.
+     * Return undefined (default) to skip validation — used by structural
+     * builders (delete, move) that have no argument constraints.
+     */
+    protected get sectionValidate(): ((args: Record<string, unknown>, ctx: ValidationContext) => string[]) | undefined;
+    /**
+     * Returns the model's global text style options. Used by `applyStyleFields`
+     * to resolve an existing style's `textStyleType` preset into concrete
+     * values before clearing the preset reference when applying an AI override.
+     */
+    protected getGlobalTextStyles(model: BrandPageModel): TextStyleOptions | undefined;
+    /**
+     * Returns validation errors for the section's AI arguments.
+     * Override in subclasses to add section-specific checks — call super.validateSection()
+     * to inherit the base rule enforcement.
+     */
     protected validateSection(): string[];
     validateAsync(): Promise<{
         errors: string[];
@@ -30,11 +61,12 @@ export declare abstract class BaseSectionBuilder<C extends Content = Content> ex
      * Validates the request, then creates or finds the target content.
      * Returns `{ content }` on success, or `{ error }` with a BuilderResult on failure.
      */
-    protected resolveContent(model: BrandPageModel): {
+    protected resolveAndRepositionContent(model: BrandPageModel): {
         content: C;
     } | {
         error: BuilderResult;
     };
     private createContent;
+    private moveContent;
     private findContent;
 }

package/lib/src/metadata-builder/builders/section-builders/base-section-builder.js

@@ -1,15 +1,27 @@
-import {} from '../../../brand-page/models';
+import { BRAND_PAGE_TYPES, } from '../../../brand-page/models';
+import { TRIGGER_TYPE, } from '../../../brand-page-maker/composables/useEventTracker';
 import { BaseMetadataBuilder, } from '../../models';
 import { createDefaultSectionContent } from '../section-content-factory';
 /**
  * Abstract base for per-section builders.
  *
  * Concrete builders implement `buildAsync` directly, using
- * `resolveContent()` to obtain the content object to mutate.
+ * `resolveAndRepositionContent()` to obtain the content object to mutate.
  */
 export class BaseSectionBuilder extends BaseMetadataBuilder {
-    constructor(request, logger) {
-        super(request, logger);
+    /**
+     * Content ID resolved during `resolveAndRepositionContent` (CREATE: the
+     * id of the freshly-created content; UPDATE: the id of the located target).
+     * `MetadataExecutor` reads this via `getResolvedContentId()` to surface it
+     * on the returned BuilderResult, so callers can anchor follow-up operations
+     * (notably the AI retry vacant-slot tracker) to the section we just touched.
+     */
+    resolvedContentId;
+    constructor(request, logger, eventTracker) {
+        super(request, logger, eventTracker);
+    }
+    getResolvedContentId() {
+        return this.resolvedContentId;
     }
     get sectionType() {
         return this.request.payload.sectionType;
@@ -20,9 +32,37 @@ export class BaseSectionBuilder extends BaseMetadataBuilder {
     get args() {
         return this.request.payload.arguments;
     }
-    /** Override in subclasses for per-section validation. */
+    /**
+     * Returns the explicit validate function for this section's AI arguments.
+     * Override in concrete builders to return the colocated validate function.
+     * Return undefined (default) to skip validation — used by structural
+     * builders (delete, move) that have no argument constraints.
+     */
+    get sectionValidate() {
+        return undefined;
+    }
+    /**
+     * Returns the model's global text style options. Used by `applyStyleFields`
+     * to resolve an existing style's `textStyleType` preset into concrete
+     * values before clearing the preset reference when applying an AI override.
+     */
+    getGlobalTextStyles(model) {
+        return model.styles?.textStyles?.textStyleOptions;
+    }
+    /**
+     * Returns validation errors for the section's AI arguments.
+     * Override in subclasses to add section-specific checks — call super.validateSection()
+     * to inherit the base rule enforcement.
+     */
     validateSection() {
-        return [];
+        const validate = this.sectionValidate;
+        if (!validate)
+            return [];
+        // TODO(KP): Pass brandPageType from the request when available, to enforce item caps correctly.
+        return validate(this.args, {
+            brandPageType: BRAND_PAGE_TYPES.brandSite,
+            mode: this.mode,
+        });
     }
     async validateAsync() {
         const errors = [];
@@ -37,23 +77,44 @@ export class BaseSectionBuilder extends BaseMetadataBuilder {
                 errors.push('contentId is required for update operations');
             }
         }
-        errors.push(...this.validateSection());
+        try {
+            errors.push(...this.validateSection());
+        }
+        catch (error) {
+            // Validation is a background concern — never let a validator bug break the build.
+            this.log({
+                message: 'validateSection failed unexpectedly — skipping arg validation',
+                error,
+            });
+        }
         return { errors };
     }
     /**
      * Validates the request, then creates or finds the target content.
      * Returns `{ content }` on success, or `{ error }` with a BuilderResult on failure.
      */
-    resolveContent(model) {
+    resolveAndRepositionContent(model) {
         if (this.mode === 'create') {
-            return this.createContent(model);
+            const created = this.createContent(model);
+            if ('content' in created) {
+                this.resolvedContentId = created.content.id;
+            }
+            return created;
+        }
+        const result = this.findContent(model);
+        if ('error' in result)
+            return result;
+        this.resolvedContentId = result.content.id;
+        const { moveBeforeContentId } = this.request.payload;
+        if (moveBeforeContentId) {
+            this.moveContent(model, result.content, moveBeforeContentId);
         }
-        return this.findContent(model);
+        return result;
     }
     createContent(model) {
         const payload = this.request.payload;
         const { pageId } = payload;
-        const content = createDefaultSectionContent(this.sectionType);
+        const content = createDefaultSectionContent(this.sectionType, model.brandPageType);
         if (!content) {
             return {
                 error: {
@@ -81,13 +142,42 @@ export class BaseSectionBuilder extends BaseMetadataBuilder {
                 },
             };
         }
-        targetPage.contents.push(content);
+        const { moveBeforeContentId } = payload;
+        if (moveBeforeContentId) {
+            const anchorIndex = targetPage.contents.findIndex((c) => c.id === moveBeforeContentId);
+            if (anchorIndex !== -1) {
+                targetPage.contents.splice(anchorIndex, 0, content);
+            }
+            else {
+                targetPage.contents.push(content);
+            }
+        }
+        else {
+            targetPage.contents.push(content);
+        }
+        this.eventTracker?.sendAddContentEvent(this.sectionType, undefined, undefined, TRIGGER_TYPE.AI_BUILDER);
         this.log({
             message: `Created ${this.sectionType} section on page ${targetPage.id}`,
             contentId: content.id,
         });
         return { content: content };
     }
+    moveContent(model, content, beforeContentId) {
+        for (const page of model.pages) {
+            const currentIndex = page.contents.findIndex((c) => c.id === content.id);
+            if (currentIndex === -1)
+                continue;
+            page.contents.splice(currentIndex, 1);
+            const anchorIndex = page.contents.findIndex((c) => c.id === beforeContentId);
+            if (anchorIndex !== -1) {
+                page.contents.splice(anchorIndex, 0, content);
+            }
+            else {
+                page.contents.push(content);
+            }
+            return;
+        }
+    }
     findContent(model) {
         const { contentId } = this.request.payload;
         for (const page of model.pages) {

package/lib/src/metadata-builder/builders/section-builders/booking-section-builder.d.ts

@@ -0,0 +1,8 @@
+import type { BookingSectionContent, BrandPageModel } from '../../../brand-page/models';
+import type { BuilderResult } from '../../models';
+import { BaseSectionBuilder } from './base-section-builder';
+import { validateBookingSection } from '../section-rules/booking-section.rules';
+export declare class BookingSectionBuilder extends BaseSectionBuilder<BookingSectionContent> {
+    protected get sectionValidate(): typeof validateBookingSection;
+    buildAsync(model: BrandPageModel): Promise<BuilderResult>;
+}

package/lib/src/metadata-builder/builders/section-builders/booking-section-builder.js

@@ -0,0 +1,50 @@
+import { tiptapJsonToHtml } from '../../helpers/rte.helpers';
+import { isTiptapDocument, } from '../../parsers/section-tool-arguments';
+import { applyButtonLink, applyScalarFields, applyStyleFields, resolveGlobalPresetIntoStyle, } from '../section-field-utils';
+import { BaseSectionBuilder } from './base-section-builder';
+import { validateBookingSection } from '../section-rules/booking-section.rules';
+export class BookingSectionBuilder extends BaseSectionBuilder {
+    get sectionValidate() {
+        return validateBookingSection;
+    }
+    async buildAsync(model) {
+        this.log('Build called');
+        const validation = await this.validateAsync();
+        if (validation.errors.length) {
+            return { request: this.request, model, errors: validation.errors };
+        }
+        const resolved = this.resolveAndRepositionContent(model);
+        if ('error' in resolved)
+            return resolved.error;
+        const bookingArgs = this.args;
+        applyScalarFields(resolved.content, this.args, this.sectionType);
+        applyButtonLink(resolved.content, bookingArgs);
+        applyStyleFields(resolved.content, this.args, this.sectionType, this.getGlobalTextStyles(model));
+        const textStyleOptions = model.styles?.textStyles?.textStyleOptions;
+        if (bookingArgs.title !== undefined) {
+            if (isTiptapDocument(bookingArgs.title)) {
+                resolved.content.title = tiptapJsonToHtml(bookingArgs.title);
+                resolved.content.titleStyle = resolveGlobalPresetIntoStyle(resolved.content.titleStyle, textStyleOptions);
+            }
+            else {
+                resolved.content.title = bookingArgs.title;
+            }
+        }
+        if (bookingArgs.description !== undefined) {
+            if (isTiptapDocument(bookingArgs.description)) {
+                resolved.content.description = tiptapJsonToHtml(bookingArgs.description);
+                resolved.content.descriptionStyle = resolveGlobalPresetIntoStyle(resolved.content.descriptionStyle, textStyleOptions);
+            }
+            else {
+                resolved.content.description = bookingArgs.description;
+            }
+        }
+        if (bookingArgs.background_color !== undefined) {
+            resolved.content.backgroundStyle = {
+                ...resolved.content.backgroundStyle,
+                backgroundColor: bookingArgs.background_color ?? '',
+            };
+        }
+        return { request: this.request, model };
+    }
+}

package/lib/src/metadata-builder/builders/section-builders/button-section-builder.d.ts

@@ -1,6 +1,8 @@
 import type { ButtonContent, BrandPageModel } from '../../../brand-page/models';
 import type { BuilderResult } from '../../models';
 import { BaseSectionBuilder } from './base-section-builder';
+import { validateButtonSection } from '../section-rules/button-section.rules';
 export declare class ButtonSectionBuilder extends BaseSectionBuilder<ButtonContent> {
+    protected get sectionValidate(): typeof validateButtonSection;
     buildAsync(model: BrandPageModel): Promise<BuilderResult>;
 }

package/lib/src/metadata-builder/builders/section-builders/button-section-builder.js

@@ -1,13 +1,17 @@
 import { applyScalarFields } from '../section-field-utils';
 import { BaseSectionBuilder } from './base-section-builder';
+import { validateButtonSection } from '../section-rules/button-section.rules';
 export class ButtonSectionBuilder extends BaseSectionBuilder {
+    get sectionValidate() {
+        return validateButtonSection;
+    }
     async buildAsync(model) {
         this.log('Build called');
         const validation = await this.validateAsync();
         if (validation.errors.length) {
             return { request: this.request, model, errors: validation.errors };
         }
-        const resolved = this.resolveContent(model);
+        const resolved = this.resolveAndRepositionContent(model);
         if ('error' in resolved)
             return resolved.error;
         applyScalarFields(resolved.content, this.args, this.sectionType);

package/lib/src/metadata-builder/builders/section-builders/contact-form-builder.d.ts

@@ -1,6 +1,8 @@
 import type { ContactFormContent, BrandPageModel } from '../../../brand-page/models';
 import type { BuilderResult } from '../../models';
 import { BaseSectionBuilder } from './base-section-builder';
+import { validateContactForm } from '../section-rules/contact-form.rules';
 export declare class ContactFormBuilder extends BaseSectionBuilder<ContactFormContent> {
+    protected get sectionValidate(): typeof validateContactForm;
     buildAsync(model: BrandPageModel): Promise<BuilderResult>;
 }

package/lib/src/metadata-builder/builders/section-builders/contact-form-builder.js

@@ -1,19 +1,53 @@
-import { applyScalarFields, applyStyleFields } from '../section-field-utils';
+import { tiptapJsonToHtml } from '../../helpers/rte.helpers';
+import { isTiptapDocument, } from '../../parsers/section-tool-arguments';
+import { applyScalarFields, applyStyleFields, resolveGlobalPresetIntoStyle, } from '../section-field-utils';
 import { BaseSectionBuilder } from './base-section-builder';
+import { validateContactForm } from '../section-rules/contact-form.rules';
 export class ContactFormBuilder extends BaseSectionBuilder {
+    get sectionValidate() {
+        return validateContactForm;
+    }
     async buildAsync(model) {
         this.log('Build called');
         const validation = await this.validateAsync();
         if (validation.errors.length) {
             return { request: this.request, model, errors: validation.errors };
         }
-        const resolved = this.resolveContent(model);
+        const resolved = this.resolveAndRepositionContent(model);
         if ('error' in resolved)
             return resolved.error;
         const content = resolved.content;
         applyScalarFields(content, this.args, this.sectionType);
-        applyStyleFields(content, this.args, this.sectionType);
+        applyStyleFields(content, this.args, this.sectionType, this.getGlobalTextStyles(model));
         const args = this.args;
+        const textStyleOptions = model.styles?.textStyles?.textStyleOptions;
+        if (args.title !== undefined) {
+            if (isTiptapDocument(args.title)) {
+                content.title = tiptapJsonToHtml(args.title);
+                content.titleStyle = resolveGlobalPresetIntoStyle(content.titleStyle, textStyleOptions);
+            }
+            else {
+                content.title = args.title;
+            }
+        }
+        if (args.description !== undefined) {
+            if (isTiptapDocument(args.description)) {
+                content.description = tiptapJsonToHtml(args.description);
+                content.descriptionStyle = resolveGlobalPresetIntoStyle(content.descriptionStyle, textStyleOptions);
+            }
+            else {
+                content.description = args.description;
+            }
+        }
+        if (args.success_message !== undefined) {
+            if (isTiptapDocument(args.success_message)) {
+                content.successMessage = tiptapJsonToHtml(args.success_message);
+                content.successMessageStyle = resolveGlobalPresetIntoStyle(content.successMessageStyle, textStyleOptions);
+            }
+            else {
+                content.successMessage = args.success_message;
+            }
+        }
         if (args.fields && Array.isArray(args.fields) && content.fields) {
             for (const toggle of args.fields) {
                 const field = content.fields.find((f) => f.id === toggle.field_id);
@@ -28,6 +62,16 @@ export class ContactFormBuilder extends BaseSectionBuilder {
                 backgroundColor: args.background_color ?? '',
             };
         }
+        if (args.card_style && typeof args.card_style === 'object') {
+            const existing = content.cardStyle || {};
+            content.cardStyle = {
+                ...existing,
+                ...Object.fromEntries(Object.entries(args.card_style).map(([k, v]) => [
+                    k,
+                    v === null ? '' : v,
+                ])),
+            };
+        }
         return { request: this.request, model };
     }
 }