@capillarytech/creatives-library 8.0.319 → 8.0.321

package/v2Containers/CreativesContainer/tests/embeddedSlideboxUtils.test.js

@@ -0,0 +1,258 @@
+import {
+  CAP_SPACE_32,
+  CAP_SPACE_56,
+  CAP_SPACE_64,
+} from '@capillarytech/cap-ui-library/styled/variables';
+import {
+  isDeepEmpty,
+  getSlideBoxWrapperMarginFromLiquidErrors,
+  computeLiquidFooterUpdateFromFormBuilder,
+} from '../embeddedSlideboxUtils';
+import { ANDROID, IOS, MOBILE_PUSH, LIQUID_ERROR_MSG, STANDARD_ERROR_MSG } from '../constants';
+
+// ---------------------------------------------------------------------------
+// isDeepEmpty
+// ---------------------------------------------------------------------------
+
+describe('isDeepEmpty', () => {
+  it('returns true for null', () => {
+    expect(isDeepEmpty(null)).toBe(true);
+  });
+
+  it('returns true for undefined', () => {
+    expect(isDeepEmpty(undefined)).toBe(true);
+  });
+
+  it('returns true for empty string', () => {
+    expect(isDeepEmpty('')).toBe(true);
+  });
+
+  it('returns false for non-empty string', () => {
+    expect(isDeepEmpty('hello')).toBe(false);
+  });
+
+  it('returns true for empty array', () => {
+    expect(isDeepEmpty([])).toBe(true);
+  });
+
+  it('returns false for non-empty array', () => {
+    expect(isDeepEmpty(['item'])).toBe(false);
+  });
+
+  it('returns true for empty object', () => {
+    expect(isDeepEmpty({})).toBe(true);
+  });
+
+  it('returns true for object where all values are deep-empty', () => {
+    expect(isDeepEmpty({ a: null, b: '', c: [] })).toBe(true);
+  });
+
+  it('returns false for object with at least one non-empty value', () => {
+    expect(isDeepEmpty({ a: null, b: 'something' })).toBe(false);
+  });
+
+  it('returns true for nested all-empty object', () => {
+    expect(isDeepEmpty({ a: { b: null, c: [] } })).toBe(true);
+  });
+
+  it('returns false for nested object with a non-empty leaf', () => {
+    expect(isDeepEmpty({ a: { b: 'value' } })).toBe(false);
+  });
+
+  it('returns false for a number (non-null, non-string, non-array, non-object)', () => {
+    expect(isDeepEmpty(0)).toBe(false);
+    expect(isDeepEmpty(42)).toBe(false);
+  });
+
+  it('returns false for a boolean false', () => {
+    expect(isDeepEmpty(false)).toBe(false);
+  });
+});
+
+// ---------------------------------------------------------------------------
+// getSlideBoxWrapperMarginFromLiquidErrors
+// ---------------------------------------------------------------------------
+
+describe('getSlideBoxWrapperMarginFromLiquidErrors', () => {
+  it('returns 0 when liquidErrorMessage is null', () => {
+    expect(getSlideBoxWrapperMarginFromLiquidErrors(null)).toBe(0);
+  });
+
+  it('returns 0 when liquidErrorMessage is undefined', () => {
+    expect(getSlideBoxWrapperMarginFromLiquidErrors(undefined)).toBe(0);
+  });
+
+  it('returns 0 when both error arrays are empty', () => {
+    expect(getSlideBoxWrapperMarginFromLiquidErrors({
+      STANDARD_ERROR_MSG: [],
+      LIQUID_ERROR_MSG: [],
+    })).toBe(0);
+  });
+
+  it('returns 0 when neither error array is present', () => {
+    expect(getSlideBoxWrapperMarginFromLiquidErrors({})).toBe(0);
+  });
+
+  it('returns CAP_SPACE_64 when both STANDARD and LIQUID errors are present', () => {
+    expect(getSlideBoxWrapperMarginFromLiquidErrors({
+      STANDARD_ERROR_MSG: ['std error'],
+      LIQUID_ERROR_MSG: ['liquid error'],
+    })).toBe(CAP_SPACE_64);
+  });
+
+  it('returns CAP_SPACE_56 when only LIQUID errors are present', () => {
+    expect(getSlideBoxWrapperMarginFromLiquidErrors({
+      STANDARD_ERROR_MSG: [],
+      LIQUID_ERROR_MSG: ['liquid error'],
+    })).toBe(CAP_SPACE_56);
+  });
+
+  it('returns CAP_SPACE_32 when only STANDARD errors are present', () => {
+    expect(getSlideBoxWrapperMarginFromLiquidErrors({
+      STANDARD_ERROR_MSG: ['std error'],
+      LIQUID_ERROR_MSG: [],
+    })).toBe(CAP_SPACE_32);
+  });
+
+  it('returns CAP_SPACE_56 when LIQUID has multiple errors and STANDARD is absent', () => {
+    expect(getSlideBoxWrapperMarginFromLiquidErrors({
+      LIQUID_ERROR_MSG: ['err1', 'err2'],
+    })).toBe(CAP_SPACE_56);
+  });
+
+  it('returns CAP_SPACE_32 when STANDARD has multiple errors and LIQUID is absent', () => {
+    expect(getSlideBoxWrapperMarginFromLiquidErrors({
+      STANDARD_ERROR_MSG: ['err1', 'err2'],
+    })).toBe(CAP_SPACE_32);
+  });
+});
+
+// ---------------------------------------------------------------------------
+// computeLiquidFooterUpdateFromFormBuilder
+// ---------------------------------------------------------------------------
+
+describe('computeLiquidFooterUpdateFromFormBuilder', () => {
+  const noErrors = { [LIQUID_ERROR_MSG]: [], [STANDARD_ERROR_MSG]: [] };
+  const liquidOnly = { [LIQUID_ERROR_MSG]: ['liquid err'], [STANDARD_ERROR_MSG]: [] };
+  const standardOnly = { [LIQUID_ERROR_MSG]: [], [STANDARD_ERROR_MSG]: ['std err'] };
+  const bothErrors = { [LIQUID_ERROR_MSG]: ['l'], [STANDARD_ERROR_MSG]: ['s'] };
+
+  describe('normal (non-null) returns', () => {
+    it('returns isLiquidValidationError=false when no errors', () => {
+      const result = computeLiquidFooterUpdateFromFormBuilder(noErrors, 1, {
+        previousIsLiquidValidationError: false,
+        currentChannelUpper: 'SMS',
+      });
+      expect(result).not.toBeNull();
+      expect(result.isLiquidValidationError).toBe(false);
+      expect(result.liquidErrorMessage).toEqual(noErrors);
+    });
+
+    it('sets isLiquidValidationError=true when liquid errors present', () => {
+      const result = computeLiquidFooterUpdateFromFormBuilder(liquidOnly, 1, {
+        previousIsLiquidValidationError: false,
+        currentChannelUpper: 'SMS',
+      });
+      expect(result.isLiquidValidationError).toBe(true);
+    });
+
+    it('sets isLiquidValidationError=true when standard errors present', () => {
+      const result = computeLiquidFooterUpdateFromFormBuilder(standardOnly, 1, {
+        previousIsLiquidValidationError: false,
+        currentChannelUpper: 'SMS',
+      });
+      expect(result.isLiquidValidationError).toBe(true);
+    });
+
+    it('sets isLiquidValidationError=true when both errors present', () => {
+      const result = computeLiquidFooterUpdateFromFormBuilder(bothErrors, 1, {
+        previousIsLiquidValidationError: false,
+        currentChannelUpper: 'SMS',
+      });
+      expect(result.isLiquidValidationError).toBe(true);
+    });
+
+    it('maps tab 1 to ANDROID', () => {
+      const result = computeLiquidFooterUpdateFromFormBuilder(noErrors, 1, {
+        previousIsLiquidValidationError: false,
+        currentChannelUpper: 'SMS',
+      });
+      expect(result.activeFormBuilderTab).toBe(ANDROID);
+    });
+
+    it('maps tab 2 to IOS', () => {
+      const result = computeLiquidFooterUpdateFromFormBuilder(noErrors, 2, {
+        previousIsLiquidValidationError: false,
+        currentChannelUpper: 'SMS',
+      });
+      expect(result.activeFormBuilderTab).toBe(IOS);
+    });
+
+    it('maps tab 3 (or any other tab) to null', () => {
+      const result = computeLiquidFooterUpdateFromFormBuilder(noErrors, 3, {
+        previousIsLiquidValidationError: false,
+        currentChannelUpper: 'SMS',
+      });
+      expect(result.activeFormBuilderTab).toBeNull();
+    });
+
+    it('maps undefined tab to null for activeFormBuilderTab', () => {
+      const result = computeLiquidFooterUpdateFromFormBuilder(noErrors, undefined, {
+        previousIsLiquidValidationError: false,
+        currentChannelUpper: 'SMS',
+      });
+      expect(result.activeFormBuilderTab).toBeNull();
+    });
+
+    it('does NOT return null for Mobile Push when errors ARE present', () => {
+      const result = computeLiquidFooterUpdateFromFormBuilder(liquidOnly, 1, {
+        previousIsLiquidValidationError: true,
+        currentChannelUpper: MOBILE_PUSH,
+      });
+      expect(result).not.toBeNull();
+      expect(result.isLiquidValidationError).toBe(true);
+    });
+
+    it('does NOT return null for non-Mobile Push channel even with previousIsLiquidValidationError', () => {
+      const result = computeLiquidFooterUpdateFromFormBuilder(noErrors, 1, {
+        previousIsLiquidValidationError: true,
+        currentChannelUpper: 'SMS',
+      });
+      expect(result).not.toBeNull();
+      expect(result.isLiquidValidationError).toBe(false);
+    });
+
+    it('works without options argument (uses defaults)', () => {
+      const result = computeLiquidFooterUpdateFromFormBuilder(noErrors, 1);
+      expect(result).not.toBeNull();
+      expect(result.isLiquidValidationError).toBe(false);
+    });
+  });
+
+  describe('Mobile Push OLD clear (returns null)', () => {
+    it('returns null when no errors and previousIsLiquidValidationError is true for MOBILEPUSH', () => {
+      const result = computeLiquidFooterUpdateFromFormBuilder(noErrors, 1, {
+        previousIsLiquidValidationError: true,
+        currentChannelUpper: MOBILE_PUSH,
+      });
+      expect(result).toBeNull();
+    });
+
+    it('does NOT return null when previousIsLiquidValidationError is false for MOBILEPUSH', () => {
+      const result = computeLiquidFooterUpdateFromFormBuilder(noErrors, 1, {
+        previousIsLiquidValidationError: false,
+        currentChannelUpper: MOBILE_PUSH,
+      });
+      expect(result).not.toBeNull();
+    });
+
+    it('does NOT return null when only standard errors cleared but liquid error remains for MOBILEPUSH', () => {
+      const result = computeLiquidFooterUpdateFromFormBuilder(liquidOnly, 1, {
+        previousIsLiquidValidationError: true,
+        currentChannelUpper: MOBILE_PUSH,
+      });
+      // hasLiquid = true → condition !hasLiquid is false → does not return null
+      expect(result).not.toBeNull();
+    });
+  });
+});

package/v2Containers/CreativesContainer/tests/index.test.js

@@ -173,19 +173,35 @@ describe('Test SlideBoxContent container', () => {
     expect(getCreativesData).toHaveBeenCalledWith({ channel: 'RCS' });
   });
 
-  it('RCS getFormData does not attach smsFallBackContent to templateData', async () => {
-    renderFunction('RCS', 'editTemplate', rcsTemplates, rcsEditTemplateData);
+  it('RCS getFormData mirrors smsFallBackContent onto templateData for library round-trip', async () => {
+    renderedComponent = shallowWithIntl(
+      <Creatives
+        loyaltyMetaData={loyaltyMetaData}
+        Templates={rcsTemplates}
+        channel="RCS"
+        slidBoxContent="editTemplate"
+        templateData={rcsEditTemplateData}
+        handleCloseCreatives={handleCloseCreatives}
+        getCreativesData={getCreativesData}
+        isFullMode={false}
+        templateActions={{
+          getCdnTransformationConfig,
+        }}
+      />,
+    );
     renderedComponent.instance().onEditTemplate();
 
     const mockValue = {
+      validity: true,
       value: {
         name: 'rcs_creative_name',
+        type: 'RCS',
         versions: {
           base: {
             content: {
               RCS: {
                 rcsContent: { contentType: 'RICHCARD', cardType: 'STANDALONE', cardSettings: {}, cardContent: [{}] },
-                smsFallBackContent: { message: 'should-not-be-copied' },
+                smsFallBackContent: { message: 'fallback-body' },
               },
             },
           },
@@ -193,16 +209,62 @@ describe('Test SlideBoxContent container', () => {
       },
     };
 
-    renderedComponent
-      .find('CapSlideBox')
-      .props()
-      .content.props.getFormData(mockValue);
+    // Call getFormData on the container instance — shallow CapSlideBox `content` shape can differ across wrappers
+    renderedComponent.instance().getFormData(mockValue);
     await tick();
 
     const instance = renderedComponent.instance();
     expect(instance.state.templateData).toBeDefined();
-    // sms fallback content should not be set on templateData per current logic
-    expect(instance.state.templateData.smsFallBackContent).toBeUndefined();
+    expect(instance.state.templateData.smsFallBackContent).toEqual({ message: 'fallback-body' });
+  });
+
+  it('RCS getFormData mirrors rcsCardVarMapped onto templateData for campaign reopen', async () => {
+    renderedComponent = shallowWithIntl(
+      <Creatives
+        loyaltyMetaData={loyaltyMetaData}
+        Templates={rcsTemplates}
+        channel="RCS"
+        slidBoxContent="editTemplate"
+        templateData={rcsEditTemplateData}
+        handleCloseCreatives={handleCloseCreatives}
+        getCreativesData={getCreativesData}
+        isFullMode={false}
+        templateActions={{
+          getCdnTransformationConfig,
+        }}
+      />,
+    );
+    renderedComponent.instance().onEditTemplate();
+
+    const cardVarMapped = { 1: '[Name]', user_name: '[Name]' };
+    const mockValue = {
+      validity: true,
+      value: {
+        name: 'rcs_creative_name',
+        type: 'RCS',
+        versions: {
+          base: {
+            content: {
+              RCS: {
+                rcsContent: {
+                  contentType: 'RICHCARD',
+                  cardType: 'STANDALONE',
+                  cardSettings: {},
+                  cardContent: [{ title: 'Hi {{user_name}}', cardVarMapped }],
+                },
+                smsFallBackContent: {},
+              },
+            },
+          },
+        },
+      },
+    };
+
+    renderedComponent.instance().getFormData(mockValue);
+    await tick();
+
+    const instance = renderedComponent.instance();
+    expect(instance.state.templateData.rcsCardVarMapped).toEqual(cardVarMapped);
   });
 
   it('Text getCreatives data for rcs, data from creatives done to campaigns', async () => {

package/v2Containers/CreativesContainer/tests/useLocalTemplatesProp.test.js

@@ -0,0 +1,125 @@
+/**
+ * Covers local-templates flag resolution: nested `localTemplatesConfig.useLocalTemplates`
+ * vs top-level `useLocalTemplates` (embedded consumers / SlideBoxContent).
+ */
+import React from 'react';
+import { shallowWithIntl } from '../../../helpers/intl-enzym-test-helpers';
+import { Creatives } from '../index';
+import mockdata from '../../mockdata';
+
+const { smsTemplates, loyaltyMetaData } = mockdata;
+
+jest.mock('../../../v2Components/FormBuilder', () => ({
+  __esModule: true,
+  default: (props) => (
+    <div className="FormBuilder-mock" {...props}>
+      FormBuilder
+    </div>
+  ),
+}));
+
+const baseProps = {
+  loyaltyMetaData,
+  Templates: smsTemplates,
+  channel: 'SMS',
+  creativesMode: 'create',
+  templateData: null,
+  isFullMode: true,
+  handleCloseCreatives: jest.fn(),
+  getCreativesData: jest.fn(),
+  templateActions: {
+    getCdnTransformationConfig: jest.fn(),
+    resetTemplateStoreData: jest.fn(),
+  },
+  globalActions: {
+    clearMetaEntities: jest.fn(),
+  },
+};
+
+describe('CreativesContainer useLocalTemplates prop resolution', () => {
+  beforeEach(() => {
+    jest.clearAllMocks();
+  });
+
+  it('initial slidebox is templates when only top-level useLocalTemplates is true', () => {
+    const wrapper = shallowWithIntl(
+      <Creatives
+        {...baseProps}
+        useLocalTemplates
+      />,
+    );
+    expect(wrapper.instance().state.slidBoxContent).toBe('templates');
+  });
+
+  it('initial slidebox is templates when localTemplatesConfig.useLocalTemplates is true', () => {
+    const wrapper = shallowWithIntl(
+      <Creatives
+        {...baseProps}
+        localTemplatesConfig={{ useLocalTemplates: true }}
+      />,
+    );
+    expect(wrapper.instance().state.slidBoxContent).toBe('templates');
+  });
+
+  it('does not reset template store on unmount when embedded and top-level useLocalTemplates is true', () => {
+    const wrapper = shallowWithIntl(
+      <Creatives
+        {...baseProps}
+        location={{ query: { type: 'embedded' } }}
+        useLocalTemplates
+      />,
+    );
+    wrapper.unmount();
+    expect(baseProps.templateActions.resetTemplateStoreData).not.toHaveBeenCalled();
+    expect(baseProps.globalActions.clearMetaEntities).toHaveBeenCalled();
+  });
+
+  it('resets template store on unmount when embedded and local templates are not used', () => {
+    const wrapper = shallowWithIntl(
+      <Creatives
+        {...baseProps}
+        location={{ query: { type: 'embedded' } }}
+        useLocalTemplates={false}
+      />,
+    );
+    wrapper.unmount();
+    expect(baseProps.templateActions.resetTemplateStoreData).toHaveBeenCalled();
+    expect(baseProps.globalActions.clearMetaEntities).toHaveBeenCalled();
+  });
+
+  it('prefers nested localTemplatesConfig.useLocalTemplates=false over top-level true (not local list mode)', () => {
+    const wrapper = shallowWithIntl(
+      <Creatives
+        {...baseProps}
+        localTemplatesConfig={{ useLocalTemplates: false }}
+        useLocalTemplates
+      />,
+    );
+    expect(wrapper.instance().state.slidBoxContent).toBe('createTemplate');
+  });
+
+  it('uses top-level useLocalTemplates when localTemplatesConfig omits the flag', () => {
+    const wrapper = shallowWithIntl(
+      <Creatives
+        {...baseProps}
+        localTemplatesConfig={{}}
+        useLocalTemplates
+      />,
+    );
+    expect(wrapper.instance().state.slidBoxContent).toBe('templates');
+  });
+
+  it('resets template store when nested useLocalTemplates is false even if top-level is true', () => {
+    const wrapper = shallowWithIntl(
+      <Creatives
+        {...baseProps}
+        location={{ query: { type: 'embedded' } }}
+        localTemplatesConfig={{ useLocalTemplates: false }}
+        useLocalTemplates
+      />,
+    );
+    wrapper.unmount();
+    expect(baseProps.templateActions.resetTemplateStoreData).toHaveBeenCalled();
+    expect(baseProps.globalActions.clearMetaEntities).toHaveBeenCalled();
+  });
+});

package/v2Containers/Email/index.js

@@ -3134,6 +3134,7 @@ export class Email extends React.Component { // eslint-disable-line react/prefer
                   moduleType={moduleType}
                   showLiquidErrorInFooter={this.props.showLiquidErrorInFooter}
                   eventContextTags={this.props?.eventContextTags}
+                  waitEventContextTags={this.props?.waitEventContextTags}
                   forwardedTags={this.props?.forwardedTags}
                   isLoyaltyModule={this.props?.isLoyaltyModule}
                   isTestAndPreviewMode={this.state.isTestAndPreviewMode} // Add flag to prevent validation

package/v2Containers/EmailWrapper/components/EmailHTMLEditor.js

@@ -54,6 +54,7 @@ const EmailHTMLEditor = (props) => {
     globalActions,
     loadingTags,
     eventContextTags,
+    waitEventContextTags,
     forwardedTags,
     selectedOfferDetails,
     currentOrgDetails,
@@ -502,6 +503,7 @@ const EmailHTMLEditor = (props) => {
         location,
         tagModule: getDefaultTags,
         isFullMode,
+        waitEventContextTags,
       });
 
       if (!validationResult.valid) {
@@ -510,7 +512,7 @@ const EmailHTMLEditor = (props) => {
         setTagValidationError(null);
       }
     }
-  }, [tags, injectedTags, location, getDefaultTags, eventContextTags, showLiquidErrorInFooter]);
+  }, [tags, injectedTags, location, getDefaultTags, eventContextTags, waitEventContextTags, showLiquidErrorInFooter]);
 
   // Store the last validation state received from HTMLEditor
   const lastValidationStateRef = useRef(null);
@@ -1100,6 +1102,7 @@ const EmailHTMLEditor = (props) => {
               injectedTags={injectedTags || {}}
               selectedOfferDetails={selectedOfferDetails}
               eventContextTags={eventContextTags}
+              waitEventContextTags={waitEventContextTags}
               showHeading
               showTagList
               showInput
@@ -1124,6 +1127,7 @@ const EmailHTMLEditor = (props) => {
             injectedTags={injectedTags}
             location={location}
             eventContextTags={eventContextTags}
+            waitEventContextTags={waitEventContextTags}
             selectedOfferDetails={selectedOfferDetails}
             channel={EMAIL}
             userLocale={intl.locale || 'en'}
@@ -1151,6 +1155,7 @@ EmailHTMLEditor.propTypes = {
   globalActions: PropTypes.object,
   loadingTags: PropTypes.bool,
   eventContextTags: PropTypes.array,
+  waitEventContextTags: PropTypes.object,
   forwardedTags: PropTypes.object,
   selectedOfferDetails: PropTypes.array,
   currentOrgDetails: PropTypes.object,
@@ -1197,6 +1202,7 @@ EmailHTMLEditor.defaultProps = {
   globalActions: {},
   loadingTags: false,
   eventContextTags: [],
+  waitEventContextTags: {},
   forwardedTags: {},
   selectedOfferDetails: [],
   currentOrgDetails: {},

package/v2Containers/EmailWrapper/components/EmailWrapperView.js

@@ -173,6 +173,7 @@ const EmailWrapperView = ({
   forwardedTags,
   selectedOfferDetails,
   eventContextTags,
+  waitEventContextTags,
   getFormdata,
   isGetFormData,
   getLiquidTags,
@@ -246,6 +247,7 @@ const EmailWrapperView = ({
     globalActions,
     loadingTags,
     eventContextTags,
+    waitEventContextTags,
     forwardedTags,
     selectedOfferDetails,
     currentOrgDetails,
@@ -371,6 +373,7 @@ EmailWrapperView.propTypes = {
   forwardedTags: PropTypes.object,
   selectedOfferDetails: PropTypes.array,
   eventContextTags: PropTypes.array,
+  waitEventContextTags: PropTypes.object,
   emailActions: PropTypes.object,
   Email: PropTypes.object,
   templateData: PropTypes.object,

package/v2Containers/EmailWrapper/components/__tests__/EmailHTMLEditor.test.js

@@ -71,7 +71,10 @@ jest.mock('../../../../v2Components/HtmlEditor/index.lazy', () => {
     }));
 
     return (
-      <div data-testid="html-editor">
+      <div
+        data-testid="html-editor"
+        data-wait-event-context-tags={JSON.stringify(props.waitEventContextTags ?? null)}
+      >
         <button
           onClick={() => props.onContentChange && props.onContentChange('<p>New content</p>')}
           data-testid="trigger-content-change"
@@ -130,7 +133,10 @@ jest.mock('../../../../v2Components/HtmlEditor', () => {
     }));
 
     return (
-      <div data-testid="html-editor">
+      <div
+        data-testid="html-editor"
+        data-wait-event-context-tags={JSON.stringify(props.waitEventContextTags ?? null)}
+      >
         <button
           onClick={() => props.onContentChange && props.onContentChange('<p>New content</p>')}
           data-testid="trigger-content-change"
@@ -364,6 +370,7 @@ const defaultProps = {
   },
   loadingTags: false,
   eventContextTags: [],
+  waitEventContextTags: {},
   forwardedTags: {},
   selectedOfferDetails: [],
   currentOrgDetails: {
@@ -522,6 +529,17 @@ describe('EmailHTMLEditor', () => {
     });
   });
 
+  describe('waitEventContextTags', () => {
+    it('forwards waitEventContextTags to HTMLEditor', () => {
+      const waitMap = { b1: { eventName: 'E', blockName: 'B', tags: ['t'] } };
+      renderWithIntl({ waitEventContextTags: waitMap });
+      expect(screen.getByTestId('html-editor')).toHaveAttribute(
+        'data-wait-event-context-tags',
+        JSON.stringify(waitMap),
+      );
+    });
+  });
+
   describe('Content Initialization', () => {
     it('initializes with empty content in create mode', () => {
       renderWithIntl({ isGetFormData: false });

package/v2Containers/EmailWrapper/components/__tests__/EmailWrapperView.test.js

@@ -37,7 +37,14 @@ jest.mock('../EmailHTMLEditor', () => {
       getContentForPreview: jest.fn(() => '<p>Test</p>'),
     }));
 
-    return <div data-testid="email-html-editor">HTML Editor</div>;
+    return (
+      <div
+        data-testid="email-html-editor"
+        data-wait-event-context-tags={JSON.stringify(props.waitEventContextTags ?? null)}
+      >
+        HTML Editor
+      </div>
+    );
   });
 });
 
@@ -137,6 +144,7 @@ const defaultProps = {
   forwardedTags: {},
   selectedOfferDetails: [],
   eventContextTags: [],
+  waitEventContextTags: {},
   getFormdata: jest.fn(),
   isGetFormData: false,
   getLiquidTags: jest.fn(),
@@ -171,6 +179,13 @@ describe('EmailWrapperView', () => {
     jest.clearAllMocks();
   });
 
+  it('passes waitEventContextTags to EmailHTMLEditor when HTML editor is shown', () => {
+    const waitMap = { b1: { eventName: 'E', blockName: 'B', tags: [] } };
+    renderWithIntl({ waitEventContextTags: waitMap });
+    const el = screen.getByTestId('email-html-editor');
+    expect(el).toHaveAttribute('data-wait-event-context-tags', JSON.stringify(waitMap));
+  });
+
   describe('Mode Selection UI', () => {
     it('renders mode selection when step is MODE_SELECTION', () => {
       renderWithIntl({ step: STEPS.MODE_SELECTION });

package/v2Containers/EmailWrapper/hooks/useEmailWrapper.js

@@ -51,6 +51,7 @@ const useEmailWrapper = ({
   editor,
   moduleType,
   eventContextTags,
+  waitEventContextTags,
   isLoyaltyModule,
   // Props for CmsTemplates component
   cmsTemplatesLoader,
@@ -737,6 +738,7 @@ const useEmailWrapper = ({
       selectedEditorMode, // Pass selected mode to Email component (only for HTML_EDITOR)
       moduleType,
       eventContextTags,
+      waitEventContextTags,
       isLoyaltyModule,
       showTestAndPreviewSlidebox,
       handleTestAndPreview,
@@ -766,6 +768,7 @@ const useEmailWrapper = ({
     editor,
     moduleType,
     eventContextTags,
+    waitEventContextTags,
     isLoyaltyModule,
     showTestAndPreviewSlidebox,
     handleTestAndPreview,