@capillarytech/creatives-library 8.0.345-alpha.13 → 8.0.345-alpha.15

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/Rcs/constants.js

@@ -34,18 +34,32 @@ export const RCS_STATUSES = {
   awaitingApproval: 'awaitingApproval',
 };
 
+export const HOST_ICS="rcsicsbulk";
+export const HOST_INFOBIP="rcsinfobipbulk";
+
 export const contentType = {
   text_message: 'text_message',
   rich_card: 'rich_card',
   carousel: 'carousel',
 };
 
+export const CHANNELS = [
+  'email',
+  'mPush',
+  'viber',
+  'whatsapp',
+  'zalo',
+  'facebook',
+  'rcs',
+  'inApp',
+  'line',
+  'weChat',
+  'callTask',
+  'FTP',
+  'webpush',
+];
+
 export const STATUS_OPTIONS = [
-  // {
-  //   key: 'created',
-  //   value: RCS_STATUSES.awaitingApproval,
-  //   label: <FormattedMessage {...messages.created} />,
-  // },
   {
     key: 'approved',
     value: RCS_STATUSES.approved,
@@ -74,10 +88,31 @@ export const RCS_MEDIA_TYPES = {
   VIDEO: 'VIDEO',
 };
 
-export const rcsVarRegex = /\{\{\w+\}\}/g;
-export const rcsVarTestRegex = /\{\{\w+\}\}/;
+/** Match `{{…}}` placeholders including Liquid-style names (e.g. `tag.FORMAT_1`). Must align with split + `isAnyTemplateVarToken` / SMS fallback. */
+export const rcsVarRegex = /\{\{[^}]+\}\}/g;
+/** True when the whole string is a single RCS/mustache token (used when testing segment tokens). */
+export const rcsVarTestRegex = /^\{\{[^}]+\}\}$/;
+
+/** Matches all `{{N}}` numeric-index variable tokens in a template string (global). */
+export const RCS_NUMERIC_VAR_TOKEN_REGEX = /\{\{(\d+)\}\}/g;
+/** `cardVarMapped` slot keys that are numeric only (legacy ordering). */
+export const RCS_NUMERIC_VAR_NAME_REGEX = /^\d+$/;
+/** Semantic Liquid-style keys on RCS `cardVarMapped` (same class as `{{…}}` inner names in the editor). */
+export const RCS_CARD_VAR_MAPPED_SEMANTIC_KEY_REGEX = /^[\w.]+$/;
+/** Escape `RegExp` metacharacters when building a pattern from user/tag text. */
+export const RCS_REGEX_META_CHARS_PATTERN = /[.*+?^${}()|[\]\\]/g;
+/** Entire string is a single `{{tag}}` token (value still a placeholder). */
+export const RCS_SINGLE_MUSTACHE_PLACEHOLDER_REGEX = /^\{\{[^}]+\}\}$/;
+/** Strip leading `{{` and trailing `}}` from a token. */
+export const RCS_STRIP_MUSTACHE_DELIMITERS_REGEX = /^\{\{|\}\}$/g;
+
+/** Tag-popover target: title vs description field (matches `onTagSelect` `field` argument). */
+export const RCS_TAG_AREA_FIELD_TITLE = 'title';
+export const RCS_TAG_AREA_FIELD_DESC = 'desc';
+
 export const TEMPLATE_DESC_MAX_LENGTH = 2500;
-export const FALLBACK_MESSAGE_MAX_LENGTH = 160;
+/** Resolved SMS fallback body cap. Must allow multi-segment DLT (>160); aligns with TRAI / `TEMPLATE_MESSAGE_MAX_LENGTH`. */
+export const FALLBACK_MESSAGE_MAX_LENGTH = TEMPLATE_MESSAGE_MAX_LENGTH;
 export const TEMPLATE_TITLE_MAX_LENGTH = 200;
 export const TEMPLATE_BUTTON_TEXT_MAX_LENGTH = 25;
 export const CTA = 'CTA';
@@ -92,10 +127,12 @@ export const ALLOWED_IMAGE_EXTENSIONS_REGEX = (/\.(png|jpg|jpeg|gif)$/i);
 export const RCS_IMG_WIDTH = 1440;
 export const RCS_IMG_HEIGHT = 1024;
 export const RCS_IMG_SIZE = 2000000; // 2MB
+export const RCS_CAROUSEL_IMG_SIZE = 1 * 1024 * 1024; // 1MB
 export const MAX_FILE_SIZE_MB = 10;
 export const MAX_FILE_SIZE_BYTES = MAX_FILE_SIZE_MB * 1024 * 1024;
 export const ALLOWED_EXTENSIONS_VIDEO_REGEX = (/\.(mp4)$/i);
 export const RCS_VIDEO_SIZE = 10 * 1024 * 1024;
+export const RCS_CAROUSEL_VIDEO_SIZE = 5 * 1024 * 1024; // 5MB
 export const RCS_THUMBNAIL_MIN_SIZE = 40 * 1024;
 export const RCS_THUMBNAIL_MAX_SIZE = 100 * 1024;
 
@@ -142,6 +179,31 @@ export const RCS_IMAGE_DIMENSIONS = {
   },
 };
 
+// Carousel image dimensions (pixel values shown in UI). Keys follow `${HEIGHT}_${WIDTH}`.
+// HEIGHT: SHORT|MEDIUM, WIDTH: SMALL|MEDIUM
+export const RCS_CAROUSEL_IMAGE_DIMENSIONS = {
+  SHORT_SMALL: {
+    width: 1160,
+    height: 720,
+    description: 'Image (1160 x 720)',
+  },
+  SHORT_MEDIUM: {
+    width: 1800,
+    height: 720,
+    description: 'Image (1800 x 720)',
+  },
+  MEDIUM_SMALL: {
+    width: 770,
+    height: 720,
+    description: 'Image (770 x 720)',
+  },
+  MEDIUM_MEDIUM: {
+    width: 1280,
+    height: 720,
+    description: 'Image (1280 x 720)',
+  },
+};
+
 export const RCS_VIDEO_THUMBNAIL_DIMENSIONS = {
   SHORT_HEIGHT: {
     width: 770,
@@ -149,6 +211,8 @@ export const RCS_VIDEO_THUMBNAIL_DIMENSIONS = {
     type: 'SHORT_HEIGHT',
     heightType: 'SHORT',
     label: 'Vertical Short',
+    width: 1140,
+    height: 448,
     description: 'Thumbnail (770 x 257)',
     orientation: 'VERTICAL',
     maxFileSize: 100 * 1024,
@@ -189,6 +253,29 @@ export const RCS_VIDEO_THUMBNAIL_DIMENSIONS = {
   },
 };
 
+// Carousel thumbnail dimensions for video cards (pixel values shown in UI).
+// Keys follow `${HEIGHT}_${WIDTH}`.
+// Human-readable labels: formatMessage(messages.rcsCarouselVideoThumbnailLabel, { width, height })
+// or formatRcsCarouselVideoThumbnailLabel(formatMessage, entry) from ./utils.
+export const RCS_CAROUSEL_VIDEO_THUMBNAIL_DIMENSIONS = {
+  SHORT_SMALL: {
+    width: 718,
+    height: 448,
+  },
+  SHORT_MEDIUM: {
+    width: 1140,
+    height: 448,
+  },
+  MEDIUM_SMALL: {
+    width: 480,
+    height: 448,
+  },
+  MEDIUM_MEDIUM: {
+    width: 796,
+    height: 448,
+  },
+};
+
 const prefix = 'app/v2Containers/Rcs';
 export const UPLOAD_RCS_ASSET_REQUEST = `${prefix}/UPLOAD_RCS_ASSET_REQUEST`;
 export const UPLOAD_RCS_ASSET_SUCCESS = `${prefix}/UPLOAD_RCS_ASSET_SUCCESS`;
@@ -215,6 +302,7 @@ export const CLEAR_EDIT_RESPONSE_REQUEST = `${prefix}/Edit/CLEAR_EDIT_RESPONSE_R
 export const AI_CONTENT_BOT_DISABLED = "AI_CONTENT_BOT_DISABLED";
 
 export const RCS_TEXT_MESSAGE_MAX_LENGTH = 160;
+export const RCS_TEXT_MESSAGE_MAX_LENGTH_INFOBIP = 3072;
 export const RCS_RICH_CARD_MAX_LENGTH = 2000;
 export const MAX_BUTTONS = 4;
 
@@ -250,3 +338,26 @@ export const RCS_BUTTON_TYPES = {
   PHONE_NUMBER: 'PHONE_NUMBER',
   CTA: 'CTA',
 };
+
+/** Default action row for carousel card 1 (mandatory button UX): phone CTA, unsaved until user completes + Save. */
+export const RCS_CAROUSEL_FIRST_CARD_DEFAULT_SUGGESTIONS = [
+  {
+    index: 0,
+    type: RCS_BUTTON_TYPES.PHONE_NUMBER,
+    text: '',
+    phoneNumber: '',
+    url: null,
+    postback: '',
+    isSaved: false,
+  },
+];
+
+
+export const CAROUSEL_HEIGHT_OPTIONS = [
+  { value: 'SHORT', label: 'Short' },
+  { value: 'MEDIUM', label: 'Medium' },
+];
+export const CAROUSEL_WIDTH_OPTIONS = [
+  { value: 'SMALL', label: 'Small' },
+  { value: 'MEDIUM', label: 'Medium' },
+];