@designcrowd/library.brand-page 6.2.4 → 6.2.5-ast-seo

package/lib/src/brand-page-maker/components/upgrade-to-premium-button/UpgradeToPremiumButton.mixin.d.ts

@@ -89,6 +89,14 @@ declare const _default: import("vue").DefineComponent<import("vue").ExtractPropT
             requestVerificationToken?: string | undefined;
             isHostModalVisible?: boolean | undefined;
             livePreviewUrl?: string | undefined;
+            pendingSettingsUpdate?: {
+                meta?: {
+                    title?: string | undefined;
+                    description?: string | undefined;
+                } | undefined;
+                sensitiveContent?: number | undefined;
+            } | null | undefined;
+            hostSettingsSaveRequest?: number | undefined;
         } & import("pinia").PiniaCustomStateProperties<import("@brand-page-maker/stores").BrandPageContainerState>) => boolean;
         isUserDraft: (state: {
             availableTaxes: any[];
@@ -171,6 +179,14 @@ declare const _default: import("vue").DefineComponent<import("vue").ExtractPropT
             requestVerificationToken?: string | undefined;
             isHostModalVisible?: boolean | undefined;
             livePreviewUrl?: string | undefined;
+            pendingSettingsUpdate?: {
+                meta?: {
+                    title?: string | undefined;
+                    description?: string | undefined;
+                } | undefined;
+                sensitiveContent?: number | undefined;
+            } | null | undefined;
+            hostSettingsSaveRequest?: number | undefined;
         } & import("pinia").PiniaCustomStateProperties<import("@brand-page-maker/stores").BrandPageContainerState>) => boolean;
         isAnyModalVisible: (state: {
             availableTaxes: any[];
@@ -253,6 +269,14 @@ declare const _default: import("vue").DefineComponent<import("vue").ExtractPropT
             requestVerificationToken?: string | undefined;
             isHostModalVisible?: boolean | undefined;
             livePreviewUrl?: string | undefined;
+            pendingSettingsUpdate?: {
+                meta?: {
+                    title?: string | undefined;
+                    description?: string | undefined;
+                } | undefined;
+                sensitiveContent?: number | undefined;
+            } | null | undefined;
+            hostSettingsSaveRequest?: number | undefined;
         } & import("pinia").PiniaCustomStateProperties<import("@brand-page-maker/stores").BrandPageContainerState>) => boolean;
     }, {
         initialise(payload: import("../../stores/brandpage-container").InitialisePayload): void;
@@ -342,6 +366,12 @@ declare const _default: import("vue").DefineComponent<import("vue").ExtractPropT
         updateSensitiveContent({ sensitiveContent }: {
             sensitiveContent: any;
         }): Promise<void>;
+        routeNeverSavedSettingsUpdate(update: import("../../utils/pending-settings-update.util").PendingSettingsUpdateValue): Promise<void>;
+        mergePendingSettingsUpdate(update: import("../../utils/pending-settings-update.util").PendingSettingsUpdateValue): void;
+        saveSiteThenUpdateSettings(update: import("../../utils/pending-settings-update.util").PendingSettingsUpdateValue): Promise<void>;
+        applyPendingSettingsUpdate(): Promise<void>;
+        cancelPendingSettingsUpdate(): void;
+        writeSettingsUpdate(update: import("../../utils/pending-settings-update.util").PendingSettingsUpdateValue): Promise<boolean>;
         createBrandPageCustomDomain({ domainName }: {
             domainName: any;
         }): Promise<false | undefined>;

package/lib/src/brand-page-maker/stores/brandpage-container/brand-page-container-store.d.ts

@@ -5,6 +5,7 @@ import { type AbTest } from '@brand-page';
 import type { WebsiteSlugCheckResponse } from '@brand-page-maker/models/api.model';
 import { WEBSITE_UPGRADE_CONTEXT_TYPES } from '@designcrowd/fe-shared-lib';
 import { type OnSearchTermChangedCallback } from '@shared/template-settings/store';
+import { type PendingSettingsUpdateValue } from '../../utils/pending-settings-update.util';
 export type WebsiteContextUpgradeType = keyof typeof WEBSITE_UPGRADE_CONTEXT_TYPES;
 export interface BrandPageContainerState {
     availableTaxes: any[];
@@ -59,6 +60,8 @@ export interface BrandPageContainerState {
     requestVerificationToken?: string;
     isHostModalVisible?: boolean;
     livePreviewUrl?: string;
+    pendingSettingsUpdate?: PendingSettingsUpdateValue | null;
+    hostSettingsSaveRequest?: number;
 }
 export type GettyVideoEditorViewModelResponse = {
     assetId: string;
@@ -172,6 +175,14 @@ export declare const useBrandPageContainerStore: import("pinia").StoreDefinition
         requestVerificationToken?: string | undefined;
         isHostModalVisible?: boolean | undefined;
         livePreviewUrl?: string | undefined;
+        pendingSettingsUpdate?: {
+            meta?: {
+                title?: string | undefined;
+                description?: string | undefined;
+            } | undefined;
+            sensitiveContent?: number | undefined;
+        } | null | undefined;
+        hostSettingsSaveRequest?: number | undefined;
     } & import("pinia").PiniaCustomStateProperties<BrandPageContainerState>) => boolean;
     isUserDraft: (state: {
         availableTaxes: any[];
@@ -254,6 +265,14 @@ export declare const useBrandPageContainerStore: import("pinia").StoreDefinition
         requestVerificationToken?: string | undefined;
         isHostModalVisible?: boolean | undefined;
         livePreviewUrl?: string | undefined;
+        pendingSettingsUpdate?: {
+            meta?: {
+                title?: string | undefined;
+                description?: string | undefined;
+            } | undefined;
+            sensitiveContent?: number | undefined;
+        } | null | undefined;
+        hostSettingsSaveRequest?: number | undefined;
     } & import("pinia").PiniaCustomStateProperties<BrandPageContainerState>) => boolean;
     isAnyModalVisible: (state: {
         availableTaxes: any[];
@@ -336,6 +355,14 @@ export declare const useBrandPageContainerStore: import("pinia").StoreDefinition
         requestVerificationToken?: string | undefined;
         isHostModalVisible?: boolean | undefined;
         livePreviewUrl?: string | undefined;
+        pendingSettingsUpdate?: {
+            meta?: {
+                title?: string | undefined;
+                description?: string | undefined;
+            } | undefined;
+            sensitiveContent?: number | undefined;
+        } | null | undefined;
+        hostSettingsSaveRequest?: number | undefined;
     } & import("pinia").PiniaCustomStateProperties<BrandPageContainerState>) => boolean;
 }, {
     initialise(payload: InitialisePayload): void;
@@ -425,6 +452,12 @@ export declare const useBrandPageContainerStore: import("pinia").StoreDefinition
     updateSensitiveContent({ sensitiveContent }: {
         sensitiveContent: any;
     }): Promise<void>;
+    routeNeverSavedSettingsUpdate(update: PendingSettingsUpdateValue): Promise<void>;
+    mergePendingSettingsUpdate(update: PendingSettingsUpdateValue): void;
+    saveSiteThenUpdateSettings(update: PendingSettingsUpdateValue): Promise<void>;
+    applyPendingSettingsUpdate(): Promise<void>;
+    cancelPendingSettingsUpdate(): void;
+    writeSettingsUpdate(update: PendingSettingsUpdateValue): Promise<boolean>;
     createBrandPageCustomDomain({ domainName }: {
         domainName: any;
     }): Promise<false | undefined>;

package/lib/src/brand-page-maker/stores/brandpage-container/brand-page-container-store.js

@@ -14,6 +14,7 @@ import { errorTr, constantsTr } from '@src/composables/useTranslate';
 import { findValuesByKey } from '../../../helpers/ts.helper';
 import { WEBSITE_UPGRADE_CONTEXT_TYPES } from '@designcrowd/fe-shared-lib';
 import { useUiTemplateSettingsStore, } from '@shared/template-settings/store';
+import { clearPendingSettingsUpdate, readPendingSettingsUpdate, writePendingSettingsUpdate, } from '../../utils/pending-settings-update.util';
 export const BRANDPAGE_STATUS = Object.freeze({
     Published: 'Published',
     Unpublished: 'Unpublished',
@@ -73,6 +74,8 @@ export const useBrandPageContainerStore = defineStore('brandPageContainer', {
             isHostModalVisible: false,
             requestVerificationToken: undefined,
             livePreviewUrl: undefined,
+            pendingSettingsUpdate: null,
+            hostSettingsSaveRequest: 0,
         };
     },
     actions: {
@@ -864,19 +867,21 @@ export const useBrandPageContainerStore = defineStore('brandPageContainer', {
             }
         },
         async updateBrandPageSettings({ description, title }) {
+            const update = {
+                meta: { title, description },
+            };
+            if (!this.designDraftToken) {
+                await this.routeNeverSavedSettingsUpdate(update);
+                return;
+            }
             const brandPageMakerStore = useBrandPageMakerStore();
             try {
                 this.setIsPublishing({ isPublishing: true });
-                const result = await brandPageClient.updateBrandPageMetaAsync(brandPageMakerStore.brandPageType, this.designDraftToken, {
-                    pageDescription: description,
-                    pageTitle: title,
-                    metaKeywords: [],
-                });
-                if (!result) {
+                const ok = await this.writeSettingsUpdate(update);
+                if (!ok) {
                     await brandPageMakerStore.enqueueErrorMessage();
                     return;
                 }
-                this.updateBrandPageMeta(result);
                 await brandPageMakerStore.enqueueSaveSuccessMessage({
                     description: constantsTr('settingsSaveSuccessMessage'),
                     isPublished: this.isPublished,
@@ -894,17 +899,111 @@ export const useBrandPageContainerStore = defineStore('brandPageContainer', {
             }
         },
         async updateSensitiveContent({ sensitiveContent }) {
+            const update = { sensitiveContent };
+            if (!this.designDraftToken) {
+                await this.routeNeverSavedSettingsUpdate(update);
+                return;
+            }
             const brandPageMakerStore = useBrandPageMakerStore();
             try {
                 this.setIsPublishing({ isPublishing: true });
-                const result = await brandPageClient.updateSensitiveContentAsync(brandPageMakerStore.brandPageType, this.designDraftToken, {
-                    sensitiveContentType: sensitiveContent,
+                const ok = await this.writeSettingsUpdate(update);
+                if (!ok) {
+                    await brandPageMakerStore.enqueueErrorMessage();
+                    return;
+                }
+                await brandPageMakerStore.enqueueSaveSuccessMessage({
+                    description: constantsTr('settingsSaveSuccessMessage'),
+                    isPublished: this.isPublished,
                 });
-                if (!result) {
+            }
+            catch (err) {
+                await brandPageMakerStore.enqueueErrorMessage();
+                if (process.env.NODE_ENV !== 'production') {
+                    console.error(err);
+                }
+            }
+            finally {
+                this.setIsPublishing({ isPublishing: false });
+                await brandPageMakerStore.showNextNotificationMessage();
+            }
+        },
+        // The no-token branch shared by both settings writes: a never-saved site has
+        // nowhere to write yet, so the site is saved first (post-purchase, via the maker
+        // itself) or the write waits on the host's save (pre-purchase). Admin templates
+        // have no draft token and never gain one, so they never save (T6.2).
+        async routeNeverSavedSettingsUpdate(update) {
+            if (this.isAdminMaker) {
+                return;
+            }
+            if (!this.isPrePurchase) {
+                await this.saveSiteThenUpdateSettings(update);
+                return;
+            }
+            this.mergePendingSettingsUpdate(update);
+        },
+        // Merges into the in-memory pending update AND sessionStorage (so it survives
+        // the pre-purchase email-capture reload) every time, so a second write is never
+        // lost. Only asks BrandPageMaker's watcher to ask the host to save when no host
+        // save is already running: while one is in flight, this write rides along with
+        // it (the apply once it lands writes the merged value) instead of re-asking,
+        // which would run a second host save concurrently and risk a second draft.
+        mergePendingSettingsUpdate(update) {
+            const brandPageMakerStore = useBrandPageMakerStore();
+            const mergedMeta = update.meta || this.pendingSettingsUpdate?.meta
+                ? { ...this.pendingSettingsUpdate?.meta, ...update.meta }
+                : undefined;
+            this.pendingSettingsUpdate = {
+                ...this.pendingSettingsUpdate,
+                ...update,
+                meta: mergedMeta,
+            };
+            writePendingSettingsUpdate(brandPageMakerStore.brandPageType, this.designTemplateToken, this.pendingSettingsUpdate);
+            if (!this.isSaving) {
+                this.hostSettingsSaveRequest = (this.hostSettingsSaveRequest ?? 0) + 1;
+            }
+        },
+        // Post-purchase first save: saves the whole site (Save Progress's own path,
+        // `saveOnly` so a published site isn't republished), then writes the setting
+        // against the fresh token. Reused by `applyPendingSettingsUpdate` for the
+        // pre-purchase counterpart once the host's save has produced a token.
+        async saveSiteThenUpdateSettings(update) {
+            const brandPageMakerStore = useBrandPageMakerStore();
+            if (this.isAdminMaker) {
+                return;
+            }
+            if (this.isSaving) {
+                await brandPageMakerStore.enqueueErrorMessage();
+                await brandPageMakerStore.showNextNotificationMessage();
+                return;
+            }
+            this.setIsPublishing({ isPublishing: true });
+            try {
+                // saveBrandPage's inferred return type doesn't narrow to the `saved` shape
+                // at this call site, so this reads the one field it needs.
+                const result = await this.saveBrandPage({ saveOnly: true });
+                if (!result || !result.saved) {
+                    // A thrown save error already enqueued its own message (saveBrandPage's
+                    // own catch); a silent `false`/empty response didn't, so cover that case
+                    // here rather than leave the customer with no feedback. Checked by type,
+                    // not just presence, so an unrelated message already queued (e.g. from a
+                    // previous action) can't be mistaken for this save's own error.
+                    const hasErrorQueued = brandPageMakerStore.notificationMessageQueue.some((message) => message.type === 'error');
+                    if (!hasErrorQueued) {
+                        await brandPageMakerStore.enqueueErrorMessage();
+                    }
+                    return;
+                }
+                // The save's own banner is disarmed — the setting write's banner below is
+                // the only notification for this sequence.
+                this.setTriggerSaveSuccessMessage({
+                    triggerSaveSuccessMessage: false,
+                });
+                const ok = await this.writeSettingsUpdate(update);
+                if (!ok) {
                     await brandPageMakerStore.enqueueErrorMessage();
                     return;
                 }
-                this.updateBrandPageSensitiveContent(result);
                 await brandPageMakerStore.enqueueSaveSuccessMessage({
                     description: constantsTr('settingsSaveSuccessMessage'),
                     isPublished: this.isPublished,
@@ -921,6 +1020,74 @@ export const useBrandPageContainerStore = defineStore('brandPageContainer', {
                 await brandPageMakerStore.showNextNotificationMessage();
             }
         },
+        // Applies whatever settings update is pending once a draft token exists:
+        // in-session pre-purchase (memory) or after the email-capture reload
+        // (sessionStorage, scoped to the current brand page type). Clears both before
+        // writing so it runs exactly once even if the write itself fails.
+        async applyPendingSettingsUpdate() {
+            const brandPageMakerStore = useBrandPageMakerStore();
+            const pending = this.pendingSettingsUpdate ||
+                readPendingSettingsUpdate(brandPageMakerStore.brandPageType, this.designTemplateToken);
+            if (!pending || !this.designDraftToken) {
+                return;
+            }
+            this.cancelPendingSettingsUpdate();
+            try {
+                this.setIsPublishing({ isPublishing: true });
+                const ok = await this.writeSettingsUpdate(pending);
+                if (!ok) {
+                    await brandPageMakerStore.enqueueErrorMessage();
+                    return;
+                }
+                await brandPageMakerStore.enqueueSaveSuccessMessage({
+                    description: constantsTr('settingsSaveSuccessMessage'),
+                    isPublished: this.isPublished,
+                });
+            }
+            catch (err) {
+                await brandPageMakerStore.enqueueErrorMessage();
+                if (process.env.NODE_ENV !== 'production') {
+                    console.error(err);
+                }
+            }
+            finally {
+                this.setIsPublishing({ isPublishing: false });
+                await brandPageMakerStore.showNextNotificationMessage();
+            }
+        },
+        // The visitor abandoned the host's save prompt (or it threw): drop the pending
+        // update from memory and storage without writing anything.
+        cancelPendingSettingsUpdate() {
+            this.pendingSettingsUpdate = null;
+            clearPendingSettingsUpdate();
+        },
+        // The actual endpoint write(s) shared by the saved-site path, the post-purchase
+        // first save and the pre-purchase apply-on-reload path. Callers own
+        // isPublishing/notification sequencing; this only reports success or failure.
+        async writeSettingsUpdate(update) {
+            const brandPageMakerStore = useBrandPageMakerStore();
+            if (update.meta) {
+                const result = await brandPageClient.updateBrandPageMetaAsync(brandPageMakerStore.brandPageType, this.designDraftToken, {
+                    pageDescription: update.meta.description,
+                    pageTitle: update.meta.title,
+                    metaKeywords: [],
+                });
+                if (!result) {
+                    return false;
+                }
+                this.updateBrandPageMeta(result);
+            }
+            if (update.sensitiveContent !== undefined) {
+                const result = await brandPageClient.updateSensitiveContentAsync(brandPageMakerStore.brandPageType, this.designDraftToken, {
+                    sensitiveContentType: update.sensitiveContent,
+                });
+                if (!result) {
+                    return false;
+                }
+                this.updateBrandPageSensitiveContent(result);
+            }
+            return true;
+        },
         async createBrandPageCustomDomain({ domainName }) {
             const brandPageMakerStore = useBrandPageMakerStore();
             const customDomainResponse = await brandPageClient.createBrandPageCustomDomainAsync(brandPageMakerStore.brandPageType, this.designDraftToken, domainName, false);

package/lib/src/brand-page-maker/utils/pending-settings-update.util.d.ts

@@ -0,0 +1,10 @@
+export interface PendingSettingsUpdateValue {
+    meta?: {
+        title?: string;
+        description?: string;
+    };
+    sensitiveContent?: number;
+}
+export declare const clearPendingSettingsUpdate: () => void;
+export declare const writePendingSettingsUpdate: (brandPageType: string, designTemplateToken: string, update: PendingSettingsUpdateValue) => void;
+export declare const readPendingSettingsUpdate: (brandPageType: string, designTemplateToken: string) => PendingSettingsUpdateValue | undefined;

package/lib/src/brand-page-maker/utils/pending-settings-update.util.js

@@ -0,0 +1,63 @@
+// Carries a settings write across the pre-purchase email-capture reload (a full page
+// load), which a store or an in-memory-only flag can't survive.
+const STORAGE_KEY = 'bc-pending-settings-update';
+const EXPIRY_MS = 30 * 60 * 1000;
+// Private mode / blocked storage can throw on property access, not just on the
+// calls below, so this is wrapped too.
+const getSessionStorage = () => {
+    try {
+        return typeof window !== 'undefined' ? window.sessionStorage : undefined;
+    }
+    catch {
+        return undefined;
+    }
+};
+export const clearPendingSettingsUpdate = () => {
+    try {
+        getSessionStorage()?.removeItem(STORAGE_KEY);
+    }
+    catch {
+        // Storage unavailable or blocked — nothing to clear.
+    }
+};
+export const writePendingSettingsUpdate = (brandPageType, designTemplateToken, update) => {
+    try {
+        const entry = {
+            brandPageType,
+            designTemplateToken,
+            update,
+            savedAt: Date.now(),
+        };
+        getSessionStorage()?.setItem(STORAGE_KEY, JSON.stringify(entry));
+    }
+    catch {
+        // Storage unavailable or blocked — the in-memory pending state (the store's
+        // own `pendingSettingsUpdate`) still carries the update through this session.
+    }
+};
+// Returns undefined, and drops the stored entry, when it's missing, unreadable,
+// expired, or belongs to a different brand page or a different site — the reload
+// always passes the brand page type and design template token it's carrying the
+// update for, so a mismatch means a stale entry from another pre-purchase draft
+// (possibly of the same type) rather than the one this reload continues.
+export const readPendingSettingsUpdate = (brandPageType, designTemplateToken) => {
+    try {
+        const raw = getSessionStorage()?.getItem(STORAGE_KEY);
+        if (!raw) {
+            return undefined;
+        }
+        const entry = JSON.parse(raw);
+        const isExpired = Date.now() - entry.savedAt > EXPIRY_MS;
+        const isOtherBrandPage = entry.brandPageType !== brandPageType;
+        const isOtherSite = entry.designTemplateToken !== designTemplateToken;
+        if (isExpired || isOtherBrandPage || isOtherSite) {
+            clearPendingSettingsUpdate();
+            return undefined;
+        }
+        return entry.update;
+    }
+    catch {
+        clearPendingSettingsUpdate();
+        return undefined;
+    }
+};