@capillarytech/creatives-library 9.0.26 → 9.0.29-alpha.1

package/v2Containers/Rcs/rcsLibraryHydrationUtils.js

@@ -0,0 +1,484 @@
+import isEmpty from 'lodash/isEmpty';
+import get from 'lodash/get';
+import { extractRegisteredSenderIdsFromSmsFallbackRecord } from '../../utils/commonUtils';
+import { isTraiDLTEnable } from '../../utils/common';
+import { RCS_SMS_FALLBACK_VAR_MAPPED_PROP } from '../../v2Components/CommonTestAndPreview/constants';
+import {
+  RCS_NUMERIC_VAR_NAME_REGEX,
+  RCS_CARD_VAR_MAPPED_SEMANTIC_KEY_REGEX,
+  REGEX_SPECIAL_CHARS_ESCAPE_PATTERN,
+  RCS_MUSTACHE_WRAPPED_REGEX,
+} from './constants';
+
+/** RCS card `cardVarMapped` / `rcsCardVarMapped` only (SMS fallback slot keys stay on `smsFallBackContent`). */
+export function pickRcsCardVarMappedEntries(record) {
+  if (record == null || typeof record !== 'object' || Array.isArray(record)) return {};
+  return Object.fromEntries(
+    Object.entries(record).filter(([entryKey]) => {
+      const key = String(entryKey);
+      return (
+        RCS_NUMERIC_VAR_NAME_REGEX.test(key)
+        || RCS_CARD_VAR_MAPPED_SEMANTIC_KEY_REGEX.test(key)
+      );
+    }),
+  );
+}
+
+/**
+ * Nested `versions…smsFallBackContent` and root `smsFallBackContent` (CreativesContainer mirror)
+ * can diverge. Merge explicitly (avoid `get(..., {}) || root` — `{}` is truthy and blocks fallback).
+ *
+ * When both exist, **nested wins on overlap**: the canonical RCS path is what `createPayload` / submit
+ * update; the root mirror can lag behind campaign parent state and would otherwise keep old
+ * `message` / `rcsSmsFallbackVarMapped` in hydration and approval payloads.
+ */
+export function mergeRcsSmsFallBackContentFromDetails(details) {
+  if (!details || typeof details !== 'object') return {};
+  const nestedSmsFallback = details?.versions?.base?.content?.RCS?.smsFallBackContent;
+  const rootSmsFallback = details?.smsFallBackContent;
+  const nestedRecord =
+    nestedSmsFallback != null && typeof nestedSmsFallback === 'object' ? nestedSmsFallback : {};
+  const rootRecord =
+    rootSmsFallback != null && typeof rootSmsFallback === 'object' ? rootSmsFallback : {};
+  return { ...rootRecord, ...nestedRecord };
+}
+
+/**
+ * Merge SMS fallback slot maps from API/templateData (`apiShape`) and editor state (`localShape`).
+ * Spreading `{ ...api, ...local }` lets `rcsSmsFallbackVarMapped: {}` on local wipe a populated API map,
+ * which keeps Done disabled in DLT campaigns until fixed.
+ */
+export function mergeRcsSmsFallbackVarMapLayers(apiShape = {}, localShape = {}) {
+  const readMap = (shape) => {
+    if (!shape || typeof shape !== 'object') return {};
+    const camel = shape.rcsSmsFallbackVarMapped;
+    const kebab = shape['rcs-sms-fallback-var-mapped'];
+    const src =
+      camel && typeof camel === 'object'
+        ? camel
+        : kebab && typeof kebab === 'object'
+          ? kebab
+          : {};
+    return { ...src };
+  };
+  return { ...readMap(apiShape), ...readMap(localShape) };
+}
+
+/**
+ * First non-empty trimmed string for SMS fallback body used in DLT slot checks / payload `templateContent`.
+ * Prefer **raw** template fields before resolved `message` so `{#…#}` / `{{…}}` tokens are not lost
+ * when `message` is consumer-resolved text (campaigns).
+ */
+/**
+ * Whether an SMS fallback object carries template body, name, or var-map data (same rule as Rcs `createPayload`).
+ */
+export function hasMeaningfulSmsFallbackShape(smsFallback) {
+  return !!(
+    smsFallback
+    && (
+      String(
+        smsFallback.content
+        || smsFallback.templateContent
+        || smsFallback.message
+        || smsFallback.smsContent
+        || smsFallback.smsTemplateContent
+        || '',
+      ).trim() !== ''
+      || String(smsFallback.templateName || smsFallback.smsTemplateName || '').trim() !== ''
+      || (smsFallback.rcsSmsFallbackVarMapped && Object.keys(smsFallback.rcsSmsFallbackVarMapped).length > 0)
+      || (smsFallback[RCS_SMS_FALLBACK_VAR_MAPPED_PROP]
+        && Object.keys(smsFallback[RCS_SMS_FALLBACK_VAR_MAPPED_PROP]).length > 0)
+    )
+  );
+}
+
+/**
+ * Library `templateData`: merged root + nested `smsFallBackContent` (nested wins), matching `createPayload`.
+ */
+export function getLibrarySmsFallbackApiBaselineFromTemplateData(templateData) {
+  const smsFromTemplateRoot = get(
+    templateData,
+    'versions.base.content.RCS.smsFallBackContent',
+  );
+  return {
+    ...(templateData?.smsFallBackContent && typeof templateData.smsFallBackContent === 'object'
+      ? templateData.smsFallBackContent
+      : {}),
+    ...(smsFromTemplateRoot && typeof smsFromTemplateRoot === 'object'
+      ? smsFromTemplateRoot
+      : {}),
+  };
+}
+
+export { extractRegisteredSenderIdsFromSmsFallbackRecord } from '../../utils/commonUtils';
+
+/**
+ * Library/campaign: merge API baseline (`templateData`) with local editor state (`smsFallbackData`).
+ * Full mode has no API baseline to merge against — Send-for-approval reads editor state as-is.
+ * Shared by `createPayload`'s payload merge and Done/slot validation so both read the same merge
+ * and can't drift apart.
+ */
+export function mergeSmsFallbackForLibrary(templateData, smsFallbackData, isFullMode) {
+  if (isFullMode) {
+    return smsFallbackData || {};
+  }
+  const smsFromApiShape = getLibrarySmsFallbackApiBaselineFromTemplateData(templateData);
+  const local =
+    smsFallbackData && typeof smsFallbackData === 'object' ? smsFallbackData : {};
+  return {
+    ...smsFromApiShape,
+    ...local,
+    rcsSmsFallbackVarMapped: mergeRcsSmsFallbackVarMapLayers(smsFromApiShape, local),
+  };
+}
+
+/**
+ * Build the `smsFallBackContent` object for the RCS template save/edit payload, or `undefined`
+ * when there is no meaningful SMS fallback to persist. Mirrors `createPayload`'s two shapes:
+ * full mode (Send for approval) only carries the fields cap-campaigns-v2's
+ * `normalizeRcsMessageContentForApi` reads (`message` + `templateConfigs`); library/campaign mode
+ * also stores template name/content/var-map/sender-ids so reopening the editor can rehydrate.
+ */
+export function buildSmsFallBackContentForPayload({
+  smsFallbackData,
+  templateData,
+  isFullMode,
+  smsRegister,
+}) {
+  const smsFallbackMerged = mergeSmsFallbackForLibrary(templateData, smsFallbackData, isFullMode);
+  const smsFallbackForPayload = isFullMode
+    ? (hasMeaningfulSmsFallbackShape(smsFallbackData) ? smsFallbackData : null)
+    : (() => {
+      const mapped = {
+        templateName:
+          smsFallbackMerged.templateName
+          || smsFallbackMerged.smsTemplateName
+          || '',
+        // Use `||` so empty `content` does not block campaign/API `message` (common in embedded flows).
+        content:
+          smsFallbackMerged.content
+          || smsFallbackMerged.smsContent
+          || smsFallbackMerged.smsTemplateContent
+          || smsFallbackMerged.message
+          || '',
+        templateContent:
+          pickFirstSmsFallbackTemplateString(smsFallbackMerged)
+          || '',
+        ...(typeof smsFallbackMerged.unicodeValidity === 'boolean'
+          && { unicodeValidity: smsFallbackMerged.unicodeValidity }),
+        ...(smsFallbackMerged[RCS_SMS_FALLBACK_VAR_MAPPED_PROP]
+          && Object.keys(smsFallbackMerged[RCS_SMS_FALLBACK_VAR_MAPPED_PROP]).length > 0 && {
+          [RCS_SMS_FALLBACK_VAR_MAPPED_PROP]:
+            smsFallbackMerged[RCS_SMS_FALLBACK_VAR_MAPPED_PROP],
+        }),
+      };
+      return hasMeaningfulSmsFallbackShape(mapped) ? mapped : null;
+    })();
+
+  if (!smsFallbackForPayload) return undefined;
+
+  const smsBodyText =
+    smsFallbackForPayload.content
+    || smsFallbackForPayload.templateContent
+    || smsFallbackForPayload.message
+    || smsFallbackForPayload.smsContent
+    || '';
+  /**
+   * Campaigns `getTraiSenderIds` / Iris read `smsFallBackContent.templateConfigs.registeredSenderIds`.
+   * Library `smsFallbackForPayload` omits ids — use merged state (`smsFallbackMerged`) like test preview.
+   */
+  const mergedFallback = smsFallbackMerged || {};
+  const tcSibling = mergedFallback.templateConfigs && typeof mergedFallback.templateConfigs === 'object'
+    ? mergedFallback.templateConfigs
+    : {};
+  const smsFallbackTemplateId =
+    (mergedFallback.smsTemplateId != null && String(mergedFallback.smsTemplateId).trim() !== ''
+      ? String(mergedFallback.smsTemplateId)
+      : '')
+    || (tcSibling.templateId != null && String(tcSibling.templateId).trim() !== ''
+      ? String(tcSibling.templateId)
+      : '');
+  const smsFallbackTemplateStr =
+    pickFirstSmsFallbackTemplateString(mergedFallback)
+    || (typeof mergedFallback.templateContent === 'string' ? mergedFallback.templateContent : '')
+    || (typeof tcSibling.template === 'string' ? tcSibling.template : '')
+    || '';
+  const smsFallbackTemplateName =
+    mergedFallback.templateName
+    || mergedFallback.smsTemplateName
+    || tcSibling.templateName
+    || tcSibling.name
+    || '';
+  const registeredSenderIdsForPayload = Array.isArray(mergedFallback.registeredSenderIds)
+    ? mergedFallback.registeredSenderIds
+    : Array.isArray(tcSibling.registeredSenderIds)
+      ? tcSibling.registeredSenderIds
+      : Array.isArray(tcSibling.header)
+        ? tcSibling.header
+        : null;
+  const hasRegisteredSenderIds = Array.isArray(registeredSenderIdsForPayload);
+  const smsFallbackTemplateConfigs =
+    smsFallbackTemplateId || hasRegisteredSenderIds
+      ? {
+          ...(smsFallbackTemplateId && { templateId: smsFallbackTemplateId }),
+          ...(smsFallbackTemplateStr && { template: smsFallbackTemplateStr }),
+          ...(smsFallbackTemplateName && {
+            templateName: smsFallbackTemplateName,
+          }),
+          ...(hasRegisteredSenderIds && {
+            registeredSenderIds: registeredSenderIdsForPayload,
+          }),
+        }
+      : null;
+  const isDltCampaign = !isFullMode && isTraiDLTEnable(isFullMode, smsRegister);
+
+  const smsFallBackContent = isFullMode
+    ? {
+        smsTemplateName: smsFallbackForPayload.templateName || '',
+        smsContent: smsBodyText,
+        // cap-campaigns-v2 `normalizeRcsMessageContentForApi` only serializes `message` (+ templateConfigs); without this key SMS fallback is dropped on send.
+        message: smsBodyText,
+        ...(typeof smsFallbackForPayload.unicodeValidity === 'boolean' && {
+          unicodeValidity: smsFallbackForPayload.unicodeValidity,
+        }),
+        ...(smsFallbackForPayload.rcsSmsFallbackVarMapped
+          && Object.keys(smsFallbackForPayload.rcsSmsFallbackVarMapped).length > 0 && {
+          [RCS_SMS_FALLBACK_VAR_MAPPED_PROP]: smsFallbackForPayload.rcsSmsFallbackVarMapped,
+        }),
+        ...(smsFallbackTemplateConfigs && {
+          templateConfigs: smsFallbackTemplateConfigs,
+        }),
+      }
+    : {
+        // Round-trip storage: full shape so reopening the editor restores template
+        // name, sender IDs, and var mappings. normalizeRcsMessageContentForApi
+        // (called in CreativesContainer getCreativesData) strips this to
+        // { message, templateConfigs } before the API call — the extra fields here
+        // are only used for re-hydration, never sent to the API.
+        message: smsBodyText,
+        ...(smsFallbackForPayload.templateName && {
+          smsTemplateName: smsFallbackForPayload.templateName,
+        }),
+        ...(smsFallbackForPayload.templateContent && {
+          templateContent: smsFallbackForPayload.templateContent,
+        }),
+        ...(typeof smsFallbackForPayload.unicodeValidity === 'boolean' && {
+          unicodeValidity: smsFallbackForPayload.unicodeValidity,
+        }),
+        ...(Array.isArray(registeredSenderIdsForPayload) && {
+          registeredSenderIds: registeredSenderIdsForPayload,
+        }),
+        ...(smsFallbackForPayload[RCS_SMS_FALLBACK_VAR_MAPPED_PROP]
+          && Object.keys(smsFallbackForPayload[RCS_SMS_FALLBACK_VAR_MAPPED_PROP]).length > 0 && {
+          [RCS_SMS_FALLBACK_VAR_MAPPED_PROP]:
+            smsFallbackForPayload[RCS_SMS_FALLBACK_VAR_MAPPED_PROP],
+        }),
+        ...(isDltCampaign && smsFallbackTemplateConfigs && {
+          templateConfigs: smsFallbackTemplateConfigs,
+        }),
+      };
+
+  return { smsFallBackContent };
+}
+
+/**
+ * Resolve SMS-fallback hydration state from RCS template `details` — shared by the carousel and
+ * non-carousel hydration branches in Rcs/index.js so template shape doesn't fork the fallback-message
+ * / unicode / var-map / sender-id resolution logic. `hydrationKey` is a stable fingerprint used to
+ * skip a redundant `setSmsFallbackData` when re-hydrating with unchanged data.
+ */
+export function resolveSmsFallbackHydrationFromDetails(details) {
+  const smsFallbackContent = mergeRcsSmsFallBackContentFromDetails(details);
+  const base = get(smsFallbackContent, 'versions.base', {});
+  const updatedEditor = base['updated-sms-editor'] ?? base['sms-editor'];
+  const smsEditor = base['sms-editor'];
+  const fromNested = Array.isArray(updatedEditor)
+    ? updatedEditor.join('')
+    : (typeof updatedEditor === 'string' ? updatedEditor : (smsEditor || ''));
+  const fallbackMessage = smsFallbackContent.smsContent
+    || smsFallbackContent.smsTemplateContent
+    || smsFallbackContent.message
+    || fromNested
+    || '';
+  const varMappedFromPayload = smsFallbackContent[RCS_SMS_FALLBACK_VAR_MAPPED_PROP] || {};
+  const hasVarMapped = Object.keys(varMappedFromPayload).length > 0;
+  const hasFallbackPayload =
+    smsFallbackContent
+    && Object.keys(smsFallbackContent).length > 0
+    && (
+      !!smsFallbackContent.smsTemplateName
+      || !!fallbackMessage
+      || hasVarMapped
+    );
+
+  if (!hasFallbackPayload) {
+    return { hasFallbackPayload: false, nextSmsState: null, hydrationKey: '__EMPTY__' };
+  }
+
+  if (!fallbackMessage && !hasVarMapped && process.env.NODE_ENV !== 'production') {
+    // eslint-disable-next-line no-console
+    console.warn('[RCS SMS Fallback] No message text found in API response. Inspect shape:', smsFallbackContent);
+  }
+  const unicodeFromApi =
+    typeof smsFallbackContent.unicodeValidity === 'boolean'
+      ? smsFallbackContent.unicodeValidity
+      : (typeof base['unicode-validity'] === 'boolean' ? base['unicode-validity'] : true);
+  const registeredSenderIds = extractRegisteredSenderIdsFromSmsFallbackRecord(smsFallbackContent);
+  const nextSmsState = {
+    templateName: smsFallbackContent.smsTemplateName || '',
+    content: fallbackMessage,
+    templateContent: fallbackMessage,
+    unicodeValidity: unicodeFromApi,
+    ...(hasVarMapped && { rcsSmsFallbackVarMapped: varMappedFromPayload }),
+    ...(Array.isArray(registeredSenderIds) && registeredSenderIds.length > 0
+      ? { registeredSenderIds }
+      : {}),
+  };
+  const hydrationKey = JSON.stringify({
+    creativeKey: details._id || details.name || details.creativeName || '',
+    templateName: nextSmsState.templateName,
+    content: nextSmsState.content,
+    unicodeValidity: nextSmsState.unicodeValidity,
+    varMapped: nextSmsState.rcsSmsFallbackVarMapped || {},
+    senderIds: Array.isArray(registeredSenderIds) ? registeredSenderIds.join('') : '',
+  });
+  return { hasFallbackPayload: true, nextSmsState, hydrationKey };
+}
+
+/**
+ * Apply SMS-fallback hydration to component state — shared by the carousel and non-carousel
+ * hydration branches in Rcs/index.js so both stay in sync on the ref-guard / setSmsFallbackData logic.
+ */
+export function applySmsFallbackHydration({
+  details,
+  isFullMode,
+  lastSmsFallbackHydrationKeyRef,
+  setSmsFallbackData,
+}) {
+  const smsFallback = resolveSmsFallbackHydrationFromDetails(details);
+  if (smsFallback.hasFallbackPayload) {
+    if (isFullMode || lastSmsFallbackHydrationKeyRef.current !== smsFallback.hydrationKey) {
+      lastSmsFallbackHydrationKeyRef.current = smsFallback.hydrationKey;
+      setSmsFallbackData(smsFallback.nextSmsState);
+    }
+  } else if (isFullMode || lastSmsFallbackHydrationKeyRef.current !== '__EMPTY__') {
+    lastSmsFallbackHydrationKeyRef.current = '__EMPTY__';
+    setSmsFallbackData(null);
+  }
+}
+
+export function pickFirstSmsFallbackTemplateString(sms = {}) {
+  if (!sms || typeof sms !== 'object') return '';
+  const keys = [
+    'templateContent',
+    'smsTemplateContent',
+    'content',
+    'smsContent',
+    'message',
+  ];
+  for (let i = 0; i < keys.length; i += 1) {
+    const fieldValue = sms[keys[i]];
+    if (fieldValue == null) continue;
+    const trimmedValue = String(fieldValue).trim();
+    if (trimmedValue) return trimmedValue;
+  }
+  return '';
+}
+
+/**
+ * Campaign reopen: payloads often keep tag/label values on numeric keys (`"1"`, `"2"`, …) while
+ * semantic keys (`user_name`, …) stay `""`. Copy non-empty slot values onto empty semantic keys so
+ * VarSegment editors prepopulate after Done → Edit without changing global resolve behavior.
+ */
+export function syncCardVarMappedSemanticsFromSlots(
+  cardVarMappedInput,
+  templateTitle,
+  templateDesc,
+  rcsVarRegex,
+) {
+  const cardVarMappedSynced =
+    cardVarMappedInput != null && typeof cardVarMappedInput === 'object'
+      ? { ...cardVarMappedInput }
+      : {};
+  const getVarNameFromToken = (token = '') => token.replace(/^\{\{|\}\}$/g, '').trim();
+  const templateVarTokens = [
+    ...(templateTitle?.match(rcsVarRegex) ?? []),
+    ...(templateDesc?.match(rcsVarRegex) ?? []),
+  ];
+  templateVarTokens.forEach((token, slotIndexZeroBased) => {
+    const semanticVarName = getVarNameFromToken(token);
+    if (!semanticVarName) return;
+    const numericSlotKey = String(slotIndexZeroBased + 1);
+    const semanticValueTrimmed = String(cardVarMappedSynced[semanticVarName] ?? '').trim();
+    const numericSlotValueTrimmed = String(cardVarMappedSynced[numericSlotKey] ?? '').trim();
+    if (!semanticValueTrimmed && numericSlotValueTrimmed) {
+      cardVarMappedSynced[semanticVarName] = cardVarMappedSynced[numericSlotKey];
+    }
+  });
+  return cardVarMappedSynced;
+}
+
+/**
+ * Maps resolved campaign values back to `{{semanticKey}}` using `cardVarMapped` keys.
+ * Used when hydrating library/journey RCS edit from payloads without existing `{{…}}` tokens.
+ */
+export function getUnmappedDesc(str, mapping) {
+  if (!str) return '';
+  if (!mapping || Object.keys(mapping).length === 0) return str;
+  let result = str;
+  const replacements = [];
+  Object.entries(mapping).forEach(([key, value]) => {
+    const raw = (value ?? '').toString();
+    if (!raw || raw?.trim?.() === '') return;
+    const braced = RCS_MUSTACHE_WRAPPED_REGEX.test(raw) ? raw : `{{${raw}}}`;
+    replacements.push({ key, needle: raw });
+    if (braced !== raw) replacements.push({ key, needle: braced });
+  });
+  const seen = new Set();
+  const uniq = replacements
+    .filter(({ key, needle }) => {
+      const id = `${key}::${needle}`;
+      if (seen.has(id)) return false;
+      seen.add(id);
+      return true;
+    })
+    .sort((a, b) => (b.needle.length - a.needle.length));
+
+  uniq.forEach(({ key, needle }) => {
+    if (!needle) return;
+    const escaped = needle.replace(REGEX_SPECIAL_CHARS_ESCAPE_PATTERN, '\\$&');
+    const regex = new RegExp(escaped, 'g');
+    result = result.replace(regex, `{{${key}}}`);
+  });
+  return result;
+}
+
+export function hasRcsVarTokens(str, rcsVarRegex) {
+  return (str?.match(rcsVarRegex) ?? []).length > 0;
+}
+
+/**
+ * Library / journey: only run `getUnmappedDesc` when the loaded copy has no `{{…}}` tokens
+ * (e.g. fully resolved campaign text). If the API already has numeric or named slots, keep as-is.
+ */
+export function normalizeLibraryLoadedTitleDesc({
+  loadedTitle,
+  loadedDesc,
+  isFullMode,
+  cardVarMappedAfterHydration,
+  rcsVarRegex,
+}) {
+  const normalizedTitle =
+    !isFullMode
+    && !isEmpty(cardVarMappedAfterHydration)
+    && !hasRcsVarTokens(loadedTitle, rcsVarRegex)
+      ? getUnmappedDesc(loadedTitle, cardVarMappedAfterHydration)
+      : loadedTitle;
+  const normalizedDesc =
+    !isFullMode
+    && !isEmpty(cardVarMappedAfterHydration)
+    && !hasRcsVarTokens(loadedDesc, rcsVarRegex)
+      ? getUnmappedDesc(loadedDesc, cardVarMappedAfterHydration)
+      : loadedDesc;
+  return { normalizedTitle, normalizedDesc };
+}