@capillarytech/creatives-library 8.0.60-alpha.2 → 8.0.60-alpha.3

package/package.json

@@ -1,7 +1,7 @@
 {
   "name": "@capillarytech/creatives-library",
   "author": "meharaj",
-  "version": "8.0.60-alpha.2",
+  "version": "8.0.60-alpha.3",
   "description": "Capillary creatives ui",
   "main": "./index.js",
   "module": "./index.es.js",

package/utils/tagValidations.js

@@ -294,4 +294,36 @@ export const getTagMapValue = (object = {}) => {
   ).reduce((acc, current) => {
     return { ...acc?.subtags ?? {}, ...current?.subtags ?? {} };
   }, {});
+};
+
+
+/**
+ * Extracts and merges all subtags and top-level keys from the provided object into a single flat map.
+ *
+ * @param {Object} object - The input object containing top-level keys with optional subtags.
+ * @returns {Object} - A flat map containing all top-level keys and their subtags.
+ */
+export const getForwardedMapValues = (object = {}) => {
+  return Object?.entries(object)?.reduce((acc, [key, current]) => {
+    // Check if current has 'subtags' and it's an object
+    if (current && current?.subtags && typeof current?.subtags === 'object') {
+      // Add the top-level key with its 'name' and 'desc'
+      acc[key] = {
+        name: current?.name,
+        desc: current?.desc,
+      };
+      
+      // Merge the subtags into the accumulator
+      acc = { ...acc, ...current?.subtags };
+    } else if (current && typeof current === 'object') {
+      // If no 'subtags', add the top-level key with its 'name' and 'desc'
+      acc[key] = {
+        name: current?.name,
+        desc: current?.desc,
+      };
+    }
+    
+    // If the current entry is not an object or lacks 'name'/'desc', skip it
+    return acc;
+  }, {});
 };

package/utils/tests/tagValidations.test.js

@@ -1,6 +1,6 @@
 import React from 'react';
 import '@testing-library/jest-dom';
-import { checkSupport, extractNames, getTagMapValue, preprocessHtml, validateIfTagClosed,validateTags, skipTags } from '../tagValidations';
+import { checkSupport, extractNames, getTagMapValue,getForwardedMapValues, preprocessHtml, validateIfTagClosed,validateTags, skipTags } from '../tagValidations';
 import { eventContextTags } from '../../v2Containers/TagList/tests/mockdata';
 
 describe("check if curly brackets are balanced", () => {
@@ -496,4 +496,273 @@ describe("skipTags", () => {
     const result = skipTags(tag);
     expect(result).toEqual(true);
   });
+});
+
+
+describe('getForwardedMapValues', () => {
+  test('should return an empty object when input is empty', () => {
+    const input = {};
+    const expected = {};
+    expect(getForwardedMapValues(input)).toEqual(expected);
+  });
+
+  test('should correctly process objects with subtags', () => {
+    const input = {
+      customer: {
+        name: 'Customer',
+        desc: 'Customer Description',
+        subtags: {
+          cumulative_points_currency: {
+            name: 'Lifetime Points (in ₹)',
+            desc: 'Lifetime Points in ₹ Description',
+          },
+          mobile_number: {
+            name: 'Mobile Number',
+            desc: 'Mobile Number Description',
+          },
+        },
+      },
+      store: {
+        name: 'Store',
+        desc: 'Store Description',
+        subtags: {
+          store_name: {
+            name: 'Store Name',
+            desc: 'Store Name Description',
+          },
+          store_address: {
+            name: 'Store Address',
+            desc: 'Store Address Description',
+          },
+        },
+      },
+    };
+
+    const expected = {
+      customer: {
+        name: 'Customer',
+        desc: 'Customer Description',
+      },
+      cumulative_points_currency: {
+        name: 'Lifetime Points (in ₹)',
+        desc: 'Lifetime Points in ₹ Description',
+      },
+      mobile_number: {
+        name: 'Mobile Number',
+        desc: 'Mobile Number Description',
+      },
+      store: {
+        name: 'Store',
+        desc: 'Store Description',
+      },
+      store_name: {
+        name: 'Store Name',
+        desc: 'Store Name Description',
+      },
+      store_address: {
+        name: 'Store Address',
+        desc: 'Store Address Description',
+      },
+    };
+
+    expect(getForwardedMapValues(input)).toEqual(expected);
+  });
+
+  test('should correctly process objects without subtags', () => {
+    const input = {
+      points_on_event: {
+        name: 'Points on event',
+        desc: 'Points on event Description',
+      },
+      unsubscribe: {
+        name: 'Unsubscribe',
+        desc: 'Unsubscribe Description',
+      },
+    };
+
+    const expected = {
+      points_on_event: {
+        name: 'Points on event',
+        desc: 'Points on event Description',
+      },
+      unsubscribe: {
+        name: 'Unsubscribe',
+        desc: 'Unsubscribe Description',
+      },
+    };
+
+    expect(getForwardedMapValues(input)).toEqual(expected);
+  });
+
+  test('should handle a mix of entries with and without subtags', () => {
+    const input = {
+      customer: {
+        name: 'Customer',
+        desc: 'Customer Description',
+        subtags: {
+          cumulative_points_currency: {
+            name: 'Lifetime Points (in ₹)',
+            desc: 'Lifetime Points in ₹ Description',
+          },
+        },
+      },
+      points_on_event: {
+        name: 'Points on event',
+        desc: 'Points on event Description',
+      },
+      store: {
+        name: 'Store',
+        desc: 'Store Description',
+        subtags: {
+          store_name: {
+            name: 'Store Name',
+            desc: 'Store Name Description',
+          },
+        },
+      },
+    };
+
+    const expected = {
+      customer: {
+        name: 'Customer',
+        desc: 'Customer Description',
+      },
+      cumulative_points_currency: {
+        name: 'Lifetime Points (in ₹)',
+        desc: 'Lifetime Points in ₹ Description',
+      },
+      points_on_event: {
+        name: 'Points on event',
+        desc: 'Points on event Description',
+      },
+      store: {
+        name: 'Store',
+        desc: 'Store Description',
+      },
+      store_name: {
+        name: 'Store Name',
+        desc: 'Store Name Description',
+      },
+    };
+
+    expect(getForwardedMapValues(input)).toEqual(expected);
+  });
+
+  test('should ignore entries that are not objects', () => {
+    const input = {
+      valid_entry: {
+        name: 'Valid Entry',
+        desc: 'Valid Entry Description',
+      },
+      invalid_entry: 'This is a string, not an object',
+      another_invalid_entry: null,
+    };
+
+    const expected = {
+      valid_entry: {
+        name: 'Valid Entry',
+        desc: 'Valid Entry Description',
+      },
+    };
+
+    expect(getForwardedMapValues(input)).toEqual(expected);
+  });
+
+  test('should handle entries missing name or desc', () => {
+    const input = {
+      incomplete_entry1: {
+        name: 'Incomplete Entry 1',
+        // desc is missing
+        subtags: {
+          subtag1: {
+            name: 'Subtag 1',
+            desc: 'Subtag 1 Description',
+          },
+        },
+      },
+      incomplete_entry2: {
+        // name is missing
+        desc: 'Incomplete Entry 2 Description',
+      },
+    };
+
+    const expected = {
+      incomplete_entry1: {
+        name: 'Incomplete Entry 1',
+        desc: undefined,
+      },
+      subtag1: {
+        name: 'Subtag 1',
+        desc: 'Subtag 1 Description',
+      },
+      incomplete_entry2: {
+        name: undefined,
+        desc: 'Incomplete Entry 2 Description',
+      },
+    };
+
+    expect(getForwardedMapValues(input)).toEqual(expected);
+  });
+
+  test('should handle deeply nested subtags by only flattening one level', () => {
+    const input = {
+      parent: {
+        name: 'Parent',
+        desc: 'Parent Description',
+        subtags: {
+          child: {
+            name: 'Child',
+            desc: 'Child Description',
+            subtags: {
+              grandchild: {
+                name: 'Grandchild',
+                desc: 'Grandchild Description',
+              },
+            },
+          },
+        },
+      },
+    };
+
+    const expected = {
+      parent: {
+        name: 'Parent',
+        desc: 'Parent Description',
+      },
+      child: {
+        name: 'Child',
+        desc: 'Child Description',
+        subtags: {
+          grandchild: {
+            name: 'Grandchild',
+            desc: 'Grandchild Description',
+          },
+        },
+      },
+    };
+
+    expect(getForwardedMapValues(input)).toEqual(expected);
+  });
+
+
+  test('should not mutate the original input object', () => {
+    const input = {
+      customer: {
+        name: 'Customer',
+        desc: 'Customer Description',
+        subtags: {
+          cumulative_points_currency: {
+            name: 'Lifetime Points (in ₹)',
+            desc: 'Lifetime Points in ₹ Description',
+          },
+        },
+      },
+    };
+
+    const inputCopy = JSON.parse(JSON.stringify(input)); // Deep copy
+
+    getForwardedMapValues(input);
+
+    expect(input).toEqual(inputCopy);
+  });
 });

package/v2Containers/Cap/reducer.js

@@ -7,7 +7,7 @@ import * as types from './constants';
 import initialState from '../../initialState';
 import { FAILURE } from '../App/constants';
 import { TAG } from '../Whatsapp/constants';
-import { getTagMapValue } from '../../utils/tagValidations';
+import { getTagMapValue, getForwardedMapValues } from '../../utils/tagValidations';
 
 function capReducer(state = fromJS(initialState.cap), action) {
   switch (action.type) {
@@ -117,7 +117,8 @@ function capReducer(state = fromJS(initialState.cap), action) {
       const combinedTagMap = {
         ...standardTagMap,
         ...customSubtags,
-        ...extendedSubtags
+        ...extendedSubtags,
+        ...state.getIn(['metaEntities', 'tagLookupMap'])?.toJS(),
       };
       const stateMeta = state.get("metaEntities");
       return state
@@ -142,26 +143,15 @@ function capReducer(state = fromJS(initialState.cap), action) {
       metaEntities.tags.custom = _.filter(state.get('metaEntities').tags.custom, (tag) => action.tagList.indexOf(tag.name) === -1);
       return state.setIn(['metaEntities'], metaEntities);
     case types.SET_INJECTED_TAGS:
-      const getTagMapValues = (object = {}) => {
-        return Object.values(object).reduce((acc, current) => {
-          // Check if current has 'subtags' and it's an object
-          if (current && current.subtags && typeof current.subtags === 'object') {
-            return { ...acc, ...current.subtags };
-          }
-          // If no 'subtags', return accumulator as is
-          return acc;
-        }, {});
-      };
-      console.log('SET_INJECTED_TAGS',action.injectedTags,getTagMapValues(action?.injectedTags));
+
       // Deep clone the tagLookupMap to avoid direct mutations
       let updatedMetaEntitiesTagLookUp = _.cloneDeep(state.getIn(['metaEntities', 'tagLookupMap']));
-      const formattedInjuectedTags = getTagMapValues(action?.injectedTags);
+      const formattedInjectedTags = getForwardedMapValues(action?.injectedTags);
       // Merge the injectedTags with the existing tagLookupMap
       updatedMetaEntitiesTagLookUp = {
-        ...formattedInjuectedTags|| {},
+        ...formattedInjectedTags || {},
         ...updatedMetaEntitiesTagLookUp || {},
       };
-      // console.log('updatedMetaEntitiesTagLookUp',fromJS(updatedMetaEntitiesTagLookUp));
       return state
         .set('injectedTags', action.injectedTags)
         .setIn(['metaEntities', 'tagLookupMap'], fromJS(updatedMetaEntitiesTagLookUp));