@capillarytech/creatives-library 8.0.67 → 8.0.68-alpha.2

package/package.json

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

package/v2Containers/Cap/mockData.js

@@ -1,90 +1,92 @@
 export const expectedStateGetLiquidTagsRequest = {
-    fetchingLiquidTags: true,
-    fetchingSchema: true,
-    fetchingSchemaError: "",
-    liquidTags: [],
-    messages: [],
-    metaEntities: {
-      layouts: [],
-      tagLookupMap: {},
-      tags: []
-    },
-    orgID: "",
-    token: ""
-  };
-  
-  export const expectedStateGetLiquidTagsFailure = {
-    fetchingLiquidTags: false,
-    fetchingSchema: true,
-    fetchingSchemaError: "",
-    liquidTags: [],
-    messages: [],
-    metaEntities: {
-      layouts: [],
-      tagLookupMap: {},
-      tags: []
-    },
-    orgID: "",
-    token: ""
-  };
-  
-  export const expectedStateGetLiquidTagsSuccess = {
-    fetchingLiquidTags: false,
-    fetchingSchema: true,
-    fetchingSchemaError: "",
-    liquidTags: [],
-    messages: [],
-    metaEntities: {
-      layouts: [],
-      tagLookupMap: {},
-      tags: []
-    },
-    orgID: "",
-    token: ""
-  };
-  
-  export const expectedStateGetSchemaForEntitySuccessTAG = {
-    fetchingLiquidTags: false,
-    fetchingSchema: false,
-    fetchingSchemaError: false,
-    liquidTags: [],
-    messages: [],
-    metaEntities: {
-      layouts: undefined,
-      tagLookupMap: { undefined: {definition: {}} },
-      tags: { standard: { random: "32" } }
-    },
-    orgID: "",
-    token: ""
-  };
-  
-  export const expectedStateGetSchemaForEntitySuccess = {
-    fetchingLiquidTags: false,
-    fetchingSchema: false,
-    fetchingSchemaError: false,
-    liquidTags: [],
-    messages: [],
-    metaEntities: {
-      layouts: undefined,
-      tagLookupMap: undefined,
-      tags: undefined
-    },
-    orgID: "",
-    token: ""
-  };
+  fetchingLiquidTags: true,
+  fetchingSchema: true,
+  fetchingSchemaError: "",
+  liquidTags: [],
+  messages: [],
+  metaEntities: {
+    layouts: [],
+    tagLookupMap: {},
+    tags: [],
+  },
+  orgID: "",
+  token: "",
+};
+
+export const expectedStateGetLiquidTagsFailure = {
+  fetchingLiquidTags: false,
+  fetchingSchema: true,
+  fetchingSchemaError: "",
+  liquidTags: [],
+  messages: [],
+  metaEntities: {
+    layouts: [],
+    tagLookupMap: {},
+    tags: [],
+  },
+  orgID: "",
+  token: "",
+};
+
+export const expectedStateGetLiquidTagsSuccess = {
+  fetchingLiquidTags: false,
+  fetchingSchema: true,
+  fetchingSchemaError: "",
+  liquidTags: [],
+  messages: [],
+  metaEntities: {
+    layouts: [],
+    tagLookupMap: {},
+    tags: [],
+  },
+  orgID: "",
+  token: "",
+};
+
+export const expectedStateGetSchemaForEntitySuccessTAG = {
+  fetchingLiquidTags: false,
+  fetchingSchema: false,
+  fetchingSchemaError: false,
+  liquidTags: [],
+  messages: [],
+  metaEntities: {
+    layouts: undefined,
+    tagLookupMap: { undefined: { definition: {} } },
+    tags: { standard: { random: "32" } },
+  },
+  orgID: "",
+  token: "",
+};
+
+export const expectedStateGetSchemaForEntitySuccess = {
+  fetchingLiquidTags: false,
+  fetchingSchema: false,
+  fetchingSchemaError: false,
+  liquidTags: [],
+  messages: [],
+  metaEntities: {
+    layouts: undefined,
+    tagLookupMap: undefined,
+    tags: undefined,
+  },
+  orgID: "",
+  token: "",
+};
+
+export const expectedForwardedTags = {
+  fetchingLiquidTags: false,
+  fetchingSchema: false,
+  fetchingSchemaError: '',
+  injectedTags: undefined,
+  liquidTags: [],
+  messages: [],
+  metaEntities: {
+    layouts: [],
+    tagLookupMap: {
 
-  export const expectedForwardedTags = {
-    fetchingLiquidTags: false,
-    fetchingSchema: true,
-    fetchingSchemaError: '',
-    injectedTags: undefined,
-    liquidTags: [],
-    messages: [],
-    metaEntities: {
-      layouts: [],
-      tagLookupMap: {},
-      tags: []
     },
-    orgID: "",
-    token: ""
-  };
+    tags: [],
+  },
+  orgID: "",
+  token: "",
+};

package/v2Containers/Cap/reducer.js

@@ -1,7 +1,7 @@
 /**
  * Created by vivek on 22/5/17.
  */
-import { fromJS } from 'immutable';
+import { fromJS, Map as ImmutableMap } from 'immutable';
 import _ from 'lodash';
 import * as types from './constants';
 import initialState from '../../initialState';
@@ -113,20 +113,28 @@ function capReducer(state = fromJS(initialState.cap), action) {
       // Process extended tags
       const extendedSubtags = getTagMapValue(action?.data?.metaEntities?.extended);
 
+      const getExistingTagLookupMap = (state) => {
+        if (!state || !state.get) return {};
+        const tagLookupMap = state.getIn(['metaEntities', 'tagLookupMap']);
+        return state.get('metaEntities') && ImmutableMap.isMap(tagLookupMap)
+          ? tagLookupMap.toJS()
+          : {};
+      };
+
       // Combine all maps
       const combinedTagMap = {
         ...standardTagMap,
         ...customSubtags,
         ...extendedSubtags,
-        ...state.getIn(['metaEntities', 'tagLookupMap'])?.toJS(),
+        ...getExistingTagLookupMap(state),
       };
       const stateMeta = state.get("metaEntities");
       return state
         .set('fetchingSchema', false)
         .set('fetchingLiquidTags', false)
         .set('metaEntities', {
-          layouts: action.data && action.entityType === 'LAYOUT' ? action.data.metaEntities : stateMeta.layouts,
-          tags: action.data && action.entityType === 'TAG' ? action.data.metaEntities : stateMeta.tags,
+          layouts: action.data && action.entityType === 'LAYOUT' ? action.data.metaEntities : stateMeta?.layouts,
+          tags: action.data && action.entityType === 'TAG' ? action.data.metaEntities : stateMeta?.tags,
           tagLookupMap: action?.data && action?.entityType === TAG ? combinedTagMap : stateMeta?.tagLookupMap,
         })
         .set('fetchingSchemaError', false);

package/v2Containers/Cap/tests/reducer.test.js

@@ -1,16 +1,16 @@
-import { fromJS } from 'immutable';
+import { fromJS, Map as ImmutableMap } from 'immutable';
 import {
-    GET_SUPPORT_VIDEOS_CONFIG_REQUEST,
-    GET_SUPPORT_VIDEOS_CONFIG_SUCCESS,
-    GET_SUPPORT_VIDEOS_CONFIG_FAILURE,
-    REQUEST,
-    SUCCESS,
-    FAILURE,
-    GET_LIQUID_TAGS_SUCCESS,
-    GET_LIQUID_TAGS_FAILURE,
-    GET_LIQUID_TAGS_REQUEST,
-    GET_SCHEMA_FOR_ENTITY_SUCCESS,
-    SET_INJECTED_TAGS,
+  GET_SUPPORT_VIDEOS_CONFIG_REQUEST,
+  GET_SUPPORT_VIDEOS_CONFIG_SUCCESS,
+  GET_SUPPORT_VIDEOS_CONFIG_FAILURE,
+  REQUEST,
+  SUCCESS,
+  FAILURE,
+  GET_LIQUID_TAGS_SUCCESS,
+  GET_LIQUID_TAGS_FAILURE,
+  GET_LIQUID_TAGS_REQUEST,
+  GET_SCHEMA_FOR_ENTITY_SUCCESS,
+  SET_INJECTED_TAGS,
 } from '../constants';
 import reducer from '../reducer';
 import initialState from '../../../initialState';
@@ -20,12 +20,13 @@ import {
   expectedStateGetLiquidTagsSuccess,
   expectedStateGetSchemaForEntitySuccessTAG,
   expectedStateGetSchemaForEntitySuccess,
-  expectedForwardedTags
 } from '../mockData';
+import { TAG } from '../../Whatsapp/constants';
+import { loadItem } from '../../../services/localStorageApi';
 
-const mockedInitialState = fromJS(initialState.cap);
 
 describe('should handle GET_SUPPORT_VIDEOS_CONFIG', () => {
+  const mockedInitialState = fromJS(initialState.cap);
   it('should handle GET_SUPPORT_VIDEOS_CONFIG_REQUEST', () => {
     const action = {
       type: GET_SUPPORT_VIDEOS_CONFIG_REQUEST,
@@ -42,7 +43,7 @@ describe('should handle GET_SUPPORT_VIDEOS_CONFIG', () => {
       is_active: true,
       _id: "12345",
       json_config: [
-              { data: 'Test data' },
+        { data: 'Test data' },
       ],
     };
     const action = {
@@ -93,8 +94,8 @@ describe('should handle GET_SUPPORT_VIDEOS_CONFIG', () => {
   it('handles the GET_SCHEMA_FOR_ENTITY_SUCCESS action with action type as TAG', () => {
     const action = {
       type: GET_SCHEMA_FOR_ENTITY_SUCCESS,
-      data: {metaEntities:{standard:{"random": "32"}}},
-      entityType: "TAG"
+      data: { metaEntities: { standard: { random: "32" } } },
+      entityType: "TAG",
     };
 
     expect(reducer(mockedInitialState, action).toJS()).toEqual(expectedStateGetSchemaForEntitySuccessTAG);
@@ -103,7 +104,7 @@ describe('should handle GET_SUPPORT_VIDEOS_CONFIG', () => {
   it('handles the GET_SCHEMA_FOR_ENTITY_SUCCESS action', () => {
     const action = {
       type: GET_SCHEMA_FOR_ENTITY_SUCCESS,
-      data: {metaEntities:{standard:{"random": "32"}}},
+      data: { metaEntities: { standard: { random: "32" } } },
     };
 
     expect(reducer(mockedInitialState, action).toJS()).toEqual(expectedStateGetSchemaForEntitySuccess);
@@ -113,7 +114,108 @@ describe('should handle GET_SUPPORT_VIDEOS_CONFIG', () => {
       type: SET_INJECTED_TAGS,
       data: {},
     };
-    
+
     expect(reducer(mockedInitialState, action).toJS())?.fetchingSchema?.toEqual(true);
   });
 });
+
+describe('GET_SCHEMA_FOR_ENTITY_SUCCESS handler', () => {
+  it('should handle existing tagLookupMap correctly when metaEntities and tagLookupMap exist', () => {
+    const initialStateTest = fromJS({
+      token: loadItem('token') || '',
+      orgID: loadItem('orgID') || '',
+      messages: [],
+      metaEntities: {
+        tags: [{ id: 1, name: 'tag1' }],
+        layouts: ['layout1', 'layout2'],
+        tagLookupMap: {
+          existingTag: { definition: { value: 'existing' } },
+          anotherTag: { definition: { value: 'another' } },
+        },
+        standard: [],
+      },
+      liquidTags: [],
+      fetchingLiquidTags: false,
+      fetchingSchema: false,
+      fetchingSchemaError: '',
+    });
+
+    let action = {
+      type: GET_SCHEMA_FOR_ENTITY_SUCCESS,
+      entityType: TAG,
+      data: {
+        metaEntities: {
+          standard: [],
+          custom: [],
+          extended: [],
+        },
+      },
+    };
+
+    let newState = reducer(initialStateTest, action);
+    let metaEntities = newState.get('metaEntities');
+
+    expect(metaEntities).toEqual(expect.objectContaining({
+      tagLookupMap: expect.objectContaining({
+        existingTag: expect.objectContaining({
+          definition: expect.objectContaining({
+            value: 'existing',
+          }),
+        }),
+      }),
+    }));
+
+    action = {
+      type: GET_SCHEMA_FOR_ENTITY_SUCCESS,
+      entityType: 'LAYOUT',
+      data: {
+        metaEntities: {
+          layouts: ['layout1', 'layout2'],
+          standard: [],
+        },
+      },
+    };
+    newState = reducer(initialStateTest, action);
+    metaEntities = newState.get('metaEntities');
+    expect(metaEntities).toEqual(expect.objectContaining({
+      layouts: expect.objectContaining({
+        layouts: expect.arrayContaining(['layout1', 'layout2']),
+      }),
+    }));
+  });
+
+  it('should handle non-existent tagLookupMap by returning empty object', () => {
+    const initialStateTest = fromJS({
+      token: loadItem('token') || '',
+      orgID: loadItem('orgID') || '',
+      messages: [],
+      metaEntities: {
+        tagLookupMap: {},
+      },
+      liquidTags: [],
+      fetchingLiquidTags: false,
+      fetchingSchema: false,
+      fetchingSchemaError: '',
+    });
+
+    const action = {
+      type: GET_SCHEMA_FOR_ENTITY_SUCCESS,
+      entityType: TAG,
+      data: {
+        metaEntities: {
+          standard: [],
+          custom: [],
+          extended: [],
+        },
+      },
+    };
+
+    const newState = reducer(initialStateTest, action);
+    const metaEntities = newState.get('metaEntities');
+
+    // Updated assertions to handle plain object
+    expect(metaEntities).toBeDefined();
+    expect(metaEntities.tagLookupMap).toBeDefined();
+    expect(metaEntities.tagLookupMap).toEqual({});
+  });
+});