@designcrowd/library.brand-page 5.17.6 → 5.17.7

package/lib/src/lib.js

@@ -25,6 +25,7 @@ export { default as CookieConsent } from './brand-page/components/cookie-consent
 export { default as SensitiveContentModal } from './brand-page/components/sensitive-content/SensitiveContentModal.vue';
 // functions
 export { getBrandPageViewModelFromBrandPageModel, migrateBrandPageModel, } from './brand-page/utils';
+export { minifyBrandPageMetadata, } from './utils/minify-brand-page-metadata';
 export * as brandPageUtils from './brand-page/utils';
 export { getOptimalLogoSize, calculateOptimizedLogoDimensions, applyLogoImageBase64UrlToBrandPageTemplateModel, recalculateLogoContentDimensions, recalculateHeaderLogoSizes, } from './brand-page/utils/logo.util';
 export { sanitizeRTEHtml } from './brand-page-maker/utils';

package/lib/src/metadata-builder/ai-metadata-executor.d.ts

@@ -2,7 +2,7 @@ import { type BrandPageModel } from '../brand-page/models';
 import type { Logger } from './logger';
 import { type MetadataExecutorResult } from './models';
 import { type ParsedToolCall } from './parsers/ai-toolcall-parser';
-export declare const executeAiToolUseAsync: (metadata: BrandPageModel, toolcalls: ParsedToolCall[], options: {
+export declare const executeToolCallsAsync: (metadata: BrandPageModel, toolcalls: ParsedToolCall[], options: {
     logger?: Logger;
     maxCharacters?: number;
 }) => Promise<MetadataExecutorResult>;

package/lib/src/metadata-builder/ai-metadata-executor.js

@@ -2,10 +2,11 @@ import {} from '../brand-page/models';
 import { buildUpdateTextRequest } from './builders/update-content-text-builder';
 import { buildUpdateTextStyleRequest } from './builders/update-content-text-style-builder';
 import { MetadataExecutor } from './metadata-executor';
-import {} from './models';
-import { AI_ASSISTANT_TOOL_NAMES, } from './parsers/ai-toolcall-parser';
-export const executeAiToolUseAsync = async (metadata, toolcalls, options) => {
-    const requests = toolcalls.map((toolcall) => {
+import { BUILDER_TYPES, } from './models';
+import { AI_ASSISTANT_TOOL_NAMES, SECTION_TOOL_MAP, } from './parsers/ai-toolcall-parser';
+export const executeToolCallsAsync = async (metadata, toolcalls, options) => {
+    const requests = toolcalls
+        .map((toolcall) => {
         switch (toolcall.function) {
             case AI_ASSISTANT_TOOL_NAMES.UPDATE_TEXT: {
                 const arg = toolcall.arguments;
@@ -24,12 +25,72 @@ export const executeAiToolUseAsync = async (metadata, toolcalls, options) => {
                     newStyles: arg.metadata.style,
                 });
             }
+            case AI_ASSISTANT_TOOL_NAMES.DELETE_SECTION: {
+                const arg = toolcall.arguments;
+                return {
+                    id: toolcall.toolId,
+                    type: BUILDER_TYPES.DELETE_SECTION,
+                    payload: {
+                        contentId: arg.content_id,
+                    },
+                };
+            }
+            case AI_ASSISTANT_TOOL_NAMES.MOVE_SECTION: {
+                const arg = toolcall.arguments;
+                return {
+                    id: toolcall.toolId,
+                    type: BUILDER_TYPES.MOVE_SECTION,
+                    payload: {
+                        contentId: arg.content_id,
+                        position: arg.position,
+                        targetPageId: arg.target_page_id,
+                    },
+                };
+            }
+            case AI_ASSISTANT_TOOL_NAMES.ADD_PAGE: {
+                const arg = toolcall.arguments;
+                return {
+                    id: toolcall.toolId,
+                    type: BUILDER_TYPES.ADD_PAGE,
+                    payload: {
+                        pageId: arg.page_id,
+                        pageName: arg.page_name,
+                    },
+                };
+            }
+            case AI_ASSISTANT_TOOL_NAMES.REMOVE_PAGE: {
+                const arg = toolcall.arguments;
+                return {
+                    id: toolcall.toolId,
+                    type: BUILDER_TYPES.REMOVE_PAGE,
+                    payload: {
+                        pageId: arg.page_id,
+                    },
+                };
+            }
             default: {
-                throw new Error(`Unsupported tool call: ${toolcall.function}`);
+                const sectionTool = SECTION_TOOL_MAP[toolcall.function];
+                if (!sectionTool) {
+                    console.warn(`[executeToolCallsAsync] Skipping unsupported tool call: ${toolcall.function}`);
+                    return null;
+                }
+                const { mode, content_id: contentId, page_id: pageId, arguments: sectionArgs, } = toolcall.arguments;
+                const builderType = `${mode}-${sectionTool.sectionType}`;
+                return {
+                    id: toolcall.toolId,
+                    type: builderType,
+                    payload: {
+                        sectionType: sectionTool.sectionType,
+                        contentId: contentId,
+                        arguments: sectionArgs,
+                        pageId: pageId,
+                    },
+                };
             }
         }
-    });
-    options.logger?.log('executeAiToolUseAsync', { requests });
+    })
+        .filter((r) => r !== null);
+    options.logger?.log('executeToolCallsAsync', { requests });
     const executor = new MetadataExecutor();
     return await executor.executeAsync(metadata, requests, options.logger);
 };

package/lib/src/metadata-builder/builders/add-page-builder.d.ts

@@ -0,0 +1,14 @@
+import { type BrandPageModel } from '../../brand-page/models';
+import { BaseMetadataBuilder, type BuilderResult, type MetadataBuilderRequest } from '../models';
+import type { Logger } from '../logger';
+export interface AddPagePayload {
+    pageId: string;
+    pageName: string;
+}
+export declare class AddPageBuilder extends BaseMetadataBuilder<AddPagePayload> {
+    constructor(request: MetadataBuilderRequest<AddPagePayload>, logger?: Logger);
+    validateAsync(): Promise<{
+        errors: string[];
+    }>;
+    buildAsync(model: BrandPageModel): Promise<BuilderResult>;
+}

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

@@ -0,0 +1,66 @@
+import { PageModel } from '../../brand-page/models';
+import { getPageSlugFromPageTitle } from '../../brand-page-maker/utils/slug.util';
+import { BaseMetadataBuilder, } from '../models';
+export class AddPageBuilder extends BaseMetadataBuilder {
+    constructor(request, logger) {
+        super(request, logger);
+    }
+    async validateAsync() {
+        const errors = [];
+        const payload = this.request.payload;
+        if (!payload?.pageId) {
+            errors.push('page_id is required for add_page');
+        }
+        if (!payload?.pageName) {
+            errors.push('page_name is required for add_page');
+        }
+        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;
+        // Check if page with this ID already exists
+        if (model.pages.some((p) => p.id === pageId)) {
+            return {
+                request: this.request,
+                model,
+                errors: [`Page with ID "${pageId}" already exists`],
+            };
+        }
+        // Create the new page
+        const newPage = new PageModel({
+            id: pageId,
+            title: pageName,
+            contents: [],
+            isHidden: false,
+        });
+        // Insert the new page before any hidden pages
+        const visiblePages = model.pages.filter((page) => !page.isHidden);
+        const hiddenPages = model.pages.filter((page) => page.isHidden);
+        model.pages = [...visiblePages, newPage, ...hiddenPages];
+        // Construct slug from page name, ensuring uniqueness against existing routes
+        const existingSlugs = model.nav.routes.map((r) => r.pageSlug);
+        const slug = getPageSlugFromPageTitle(pageName, existingSlugs);
+        // Add nav route and order entry
+        const routeId = `route-${pageId}`;
+        model.nav.routes.push({
+            id: routeId,
+            pageId,
+            pageSlug: slug,
+            isHidden: false,
+            displayName: pageName,
+        });
+        model.nav.orders.push({
+            routeId,
+            subRoutes: [],
+        });
+        this.log({
+            message: `Added page "${pageName}" (${pageId}) with slug "/${slug}"`,
+        });
+        return { request: this.request, model };
+    }
+}

package/lib/src/metadata-builder/builders/remove-page-builder.d.ts

@@ -0,0 +1,13 @@
+import { type BrandPageModel } from '../../brand-page/models';
+import { BaseMetadataBuilder, type BuilderResult, type MetadataBuilderRequest } from '../models';
+import type { Logger } from '../logger';
+export interface RemovePagePayload {
+    pageId: string;
+}
+export declare class RemovePageBuilder extends BaseMetadataBuilder<RemovePagePayload> {
+    constructor(request: MetadataBuilderRequest<RemovePagePayload>, logger?: Logger);
+    validateAsync(): Promise<{
+        errors: string[];
+    }>;
+    buildAsync(model: BrandPageModel): Promise<BuilderResult>;
+}

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

@@ -0,0 +1,50 @@
+import {} from '../../brand-page/models';
+import { BaseMetadataBuilder, } from '../models';
+export class RemovePageBuilder extends BaseMetadataBuilder {
+    constructor(request, logger) {
+        super(request, logger);
+    }
+    async validateAsync() {
+        const errors = [];
+        const payload = this.request.payload;
+        if (!payload?.pageId) {
+            errors.push('page_id is required for remove_page');
+        }
+        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 } = this.request.payload;
+        // Check if page exists
+        const pageIndex = model.pages.findIndex((p) => p.id === pageId);
+        if (pageIndex === -1) {
+            return {
+                request: this.request,
+                model,
+                errors: [`Page with ID "${pageId}" not found`],
+            };
+        }
+        const page = model.pages[pageIndex];
+        // Remove the page
+        model.pages.splice(pageIndex, 1);
+        // Remove matching nav route(s)
+        const removedRouteIds = new Set();
+        model.nav.routes = model.nav.routes.filter((route) => {
+            if (route.pageId === pageId) {
+                removedRouteIds.add(route.id);
+                return false;
+            }
+            return true;
+        });
+        // Remove matching nav order entries
+        model.nav.orders = model.nav.orders.filter((order) => !removedRouteIds.has(order.routeId));
+        this.log({
+            message: `Removed page "${page.title}" (${pageId})`,
+        });
+        return { request: this.request, model };
+    }
+}

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

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

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

@@ -0,0 +1,17 @@
+import { applyScalarFields, applyStyleFields } from '../section-field-utils';
+import { BaseSectionBuilder } from './base-section-builder';
+export class AboutSectionBuilder extends BaseSectionBuilder {
+    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);
+        if ('error' in resolved)
+            return resolved.error;
+        applyScalarFields(resolved.content, this.args, this.sectionType);
+        applyStyleFields(resolved.content, this.args, this.sectionType);
+        return { request: this.request, model };
+    }
+}

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

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

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

@@ -0,0 +1,25 @@
+import { applyScalarFields, applyStyleFields, applyRTEStyles, } from '../section-field-utils';
+import { BaseSectionBuilder } from './base-section-builder';
+const applyBackgroundImage = (content, args) => {
+    if (args.background_image_url) {
+        content.media = undefined;
+        content.mediaType = 'image';
+    }
+};
+export class BannerSectionBuilder extends BaseSectionBuilder {
+    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);
+        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);
+        return { request: this.request, model };
+    }
+}

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

@@ -0,0 +1,40 @@
+import { type BrandPageModel, type Content } from '../../../brand-page/models';
+import type { Logger } from '../../logger';
+import { BaseMetadataBuilder, type BuilderResult, type MetadataBuilderRequest } from '../../models';
+import type { SectionToolArguments, SectionType } from '../../parsers/section-tool-arguments';
+export interface SectionBuilderPayload {
+    sectionType: SectionType;
+    arguments: SectionToolArguments;
+    /** Only required for update operations. */
+    contentId?: string;
+    /** Target page ID — used for create operations to place the new section on the correct page. */
+    pageId?: string;
+}
+/**
+ * Abstract base for per-section builders.
+ *
+ * Concrete builders implement `buildAsync` directly, using
+ * `resolveContent()` 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);
+    protected get sectionType(): SectionType;
+    protected get mode(): 'create' | 'update';
+    protected get args(): SectionToolArguments;
+    /** Override in subclasses for per-section validation. */
+    protected validateSection(): string[];
+    validateAsync(): Promise<{
+        errors: string[];
+    }>;
+    /**
+     * 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): {
+        content: C;
+    } | {
+        error: BuilderResult;
+    };
+    private createContent;
+    private findContent;
+}

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

@@ -0,0 +1,108 @@
+import {} from '../../../brand-page/models';
+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.
+ */
+export class BaseSectionBuilder extends BaseMetadataBuilder {
+    constructor(request, logger) {
+        super(request, logger);
+    }
+    get sectionType() {
+        return this.request.payload.sectionType;
+    }
+    get mode() {
+        return this.request.type.startsWith('create-') ? 'create' : 'update';
+    }
+    get args() {
+        return this.request.payload.arguments;
+    }
+    /** Override in subclasses for per-section validation. */
+    validateSection() {
+        return [];
+    }
+    async validateAsync() {
+        const errors = [];
+        const payload = this.request.payload;
+        if (this.mode === 'create') {
+            if (!createDefaultSectionContent(payload.sectionType)) {
+                errors.push(`Unsupported section type: "${payload.sectionType}"`);
+            }
+        }
+        if (this.mode === 'update') {
+            if (!payload.contentId) {
+                errors.push('contentId is required for update operations');
+            }
+        }
+        errors.push(...this.validateSection());
+        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) {
+        if (this.mode === 'create') {
+            return this.createContent(model);
+        }
+        return this.findContent(model);
+    }
+    createContent(model) {
+        const payload = this.request.payload;
+        const { pageId } = payload;
+        const content = createDefaultSectionContent(this.sectionType);
+        if (!content) {
+            return {
+                error: {
+                    request: this.request,
+                    model,
+                    errors: [
+                        `Failed to create default content for section type: "${this.sectionType}"`,
+                    ],
+                },
+            };
+        }
+        const targetPage = pageId
+            ? model.pages.find((p) => p.id === pageId)
+            : model.pages[0];
+        if (!targetPage) {
+            return {
+                error: {
+                    request: this.request,
+                    model,
+                    errors: [
+                        pageId
+                            ? `Page with ID "${pageId}" not found`
+                            : 'No pages found in model',
+                    ],
+                },
+            };
+        }
+        targetPage.contents.push(content);
+        this.log({
+            message: `Created ${this.sectionType} section on page ${targetPage.id}`,
+            contentId: content.id,
+        });
+        return { content: content };
+    }
+    findContent(model) {
+        const { contentId } = this.request.payload;
+        for (const page of model.pages) {
+            for (const content of page.contents) {
+                if (content.id === contentId) {
+                    return { content: content };
+                }
+            }
+        }
+        return {
+            error: {
+                request: this.request,
+                model,
+                errors: [`Content with ID "${contentId}" not found`],
+            },
+        };
+    }
+}

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

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

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

@@ -0,0 +1,16 @@
+import { applyScalarFields } from '../section-field-utils';
+import { BaseSectionBuilder } from './base-section-builder';
+export class ButtonSectionBuilder extends BaseSectionBuilder {
+    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);
+        if ('error' in resolved)
+            return resolved.error;
+        applyScalarFields(resolved.content, this.args, this.sectionType);
+        return { request: this.request, model };
+    }
+}

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

@@ -0,0 +1,6 @@
+import type { ContactFormContent, BrandPageModel } from '../../../brand-page/models';
+import type { BuilderResult } from '../../models';
+import { BaseSectionBuilder } from './base-section-builder';
+export declare class ContactFormBuilder extends BaseSectionBuilder<ContactFormContent> {
+    buildAsync(model: BrandPageModel): Promise<BuilderResult>;
+}

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

@@ -0,0 +1,27 @@
+import { applyScalarFields, applyStyleFields } from '../section-field-utils';
+import { BaseSectionBuilder } from './base-section-builder';
+export class ContactFormBuilder extends BaseSectionBuilder {
+    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);
+        if ('error' in resolved)
+            return resolved.error;
+        const content = resolved.content;
+        applyScalarFields(content, this.args, this.sectionType);
+        applyStyleFields(content, this.args, this.sectionType);
+        const args = this.args;
+        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);
+                if (field) {
+                    field.enabled = toggle.enabled;
+                }
+            }
+        }
+        return { request: this.request, model };
+    }
+}

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

@@ -0,0 +1,13 @@
+import type { BrandPageModel } from '../../../brand-page/models';
+import { BaseMetadataBuilder, type BuilderResult, type MetadataBuilderRequest } from '../../models';
+import type { Logger } from '../../logger';
+export interface DeleteSectionPayload {
+    contentId: string;
+}
+export declare class DeleteSectionBuilder extends BaseMetadataBuilder<DeleteSectionPayload> {
+    constructor(request: MetadataBuilderRequest<DeleteSectionPayload>, logger?: Logger);
+    validateAsync(): Promise<{
+        errors: string[];
+    }>;
+    buildAsync(model: BrandPageModel): Promise<BuilderResult>;
+}

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

@@ -0,0 +1,37 @@
+import { BaseMetadataBuilder, } from '../../models';
+export class DeleteSectionBuilder extends BaseMetadataBuilder {
+    constructor(request, logger) {
+        super(request, logger);
+    }
+    async validateAsync() {
+        const errors = [];
+        const payload = this.request.payload;
+        if (!payload?.contentId) {
+            errors.push('contentId is required for delete_section');
+        }
+        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 { contentId } = this.request.payload;
+        for (const page of model.pages) {
+            const index = page.contents.findIndex((c) => c.id === contentId);
+            if (index !== -1) {
+                page.contents.splice(index, 1);
+                this.log({
+                    message: `Deleted section ${contentId} from page ${page.id}`,
+                });
+                return { request: this.request, model };
+            }
+        }
+        return {
+            request: this.request,
+            model,
+            errors: [`Section with ID "${contentId}" not found`],
+        };
+    }
+}

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

@@ -0,0 +1,6 @@
+import type { DividerSectionContent, BrandPageModel } from '../../../brand-page/models';
+import type { BuilderResult } from '../../models';
+import { BaseSectionBuilder } from './base-section-builder';
+export declare class DividerSectionBuilder extends BaseSectionBuilder<DividerSectionContent> {
+    buildAsync(model: BrandPageModel): Promise<BuilderResult>;
+}

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

@@ -0,0 +1,16 @@
+import { applyScalarFields } from '../section-field-utils';
+import { BaseSectionBuilder } from './base-section-builder';
+export class DividerSectionBuilder extends BaseSectionBuilder {
+    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);
+        if ('error' in resolved)
+            return resolved.error;
+        applyScalarFields(resolved.content, this.args, this.sectionType);
+        return { request: this.request, model };
+    }
+}

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

@@ -0,0 +1,6 @@
+import type { ImageGalleryContent, BrandPageModel } from '../../../brand-page/models';
+import type { BuilderResult } from '../../models';
+import { BaseSectionBuilder } from './base-section-builder';
+export declare class ImageGalleryBuilder extends BaseSectionBuilder<ImageGalleryContent> {
+    buildAsync(model: BrandPageModel): Promise<BuilderResult>;
+}