[Bug/VB-447] Fixes data-cslp generation logic in case of applied_variants

__test__/entry-editable.test.ts

@@ -1,7 +1,5 @@
-import { EntryModel } from '../src'
 import { addTags } from '../src/entry-editable'
-import { entry_global_field, entry_global_field_multiple, entry_modular_block, entry_reference, entry_with_text } from './mock/entry-editable-mock'
-import { entryMultipleContent } from './mock/entry-multiple-rich-text-content'
+import { entry_global_field, entry_global_field_multiple, entry_modular_block, entry_reference, entry_with_text, entry_with_applied_variants, entry_with_system_variants, entry_with_parent_path_variants } from './mock/entry-editable-mock'
 
 describe('Entry editable test', () => {
     it('Entry with text test', done => {
@@ -129,4 +127,138 @@ describe('Entry editable test', () => {
         done()
     })
 
+    // Tests for applied variants functionality
+    describe('Applied Variants Tests', () => {
+        it('Entry with applied variants should generate v2 tags with variant suffix', done => {
+            addTags(entry_with_applied_variants, 'entry_asset', false)
+
+            // Field with direct variant match should get v2 prefix and variant suffix
+            expect((entry_with_applied_variants as any)['$']['rich_text_editor']).toEqual('data-cslp=v2:entry_asset.entry_uid_1_variant_1.en-us.rich_text_editor')
+            expect((entry_with_applied_variants as any)['$']['rich_text_editor_multiple']).toEqual('data-cslp=v2:entry_asset.entry_uid_1_variant_1.en-us.rich_text_editor_multiple')
+
+            // Nested field with direct variant match
+            expect((entry_with_applied_variants as any)['nested']['$']['field']).toEqual('data-cslp=v2:entry_asset.entry_uid_1_variant_2.en-us.nested.field')
+
+            // Field without variant should not have v2 prefix
+            expect((entry_with_applied_variants as any)['nested']['$']['other_field']).toEqual('data-cslp=entry_asset.entry_uid_1.en-us.nested.other_field')
+
+            done()
+        })
+
+        it('Entry with applied variants should return v2 objects when tagsAsObject is true', done => {
+            addTags(entry_with_applied_variants, 'entry_asset', true)
+
+            // Field with direct variant match should get v2 prefix and variant suffix as object
+            expect((entry_with_applied_variants as any)['$']['rich_text_editor']).toEqual({'data-cslp': 'v2:entry_asset.entry_uid_1_variant_1.en-us.rich_text_editor'})
+            expect((entry_with_applied_variants as any)['$']['rich_text_editor_multiple']).toEqual({'data-cslp': 'v2:entry_asset.entry_uid_1_variant_1.en-us.rich_text_editor_multiple'})
+
+            // Nested field with direct variant match
+            expect((entry_with_applied_variants as any)['nested']['$']['field']).toEqual({'data-cslp': 'v2:entry_asset.entry_uid_1_variant_2.en-us.nested.field'})
+
+            // Field without variant should not have v2 prefix
+            expect((entry_with_applied_variants as any)['nested']['$']['other_field']).toEqual({'data-cslp': 'entry_asset.entry_uid_1.en-us.nested.other_field'})
+
+            done()
+        })
+
+        it('Entry with system-level applied variants should work correctly', done => {
+            addTags(entry_with_system_variants, 'entry_asset', false)
+
+            // Fields with system variants should get v2 prefix and variant suffix
+            expect((entry_with_system_variants as any)['$']['title']).toEqual('data-cslp=v2:entry_asset.entry_uid_2_system_variant.en-us.title')
+            expect((entry_with_system_variants as any)['$']['description']).toEqual('data-cslp=v2:entry_asset.entry_uid_2_desc_variant.en-us.description')
+
+            done()
+        })
+
+        it('Entry with parent path variants should find correct variant', done => {
+            addTags(entry_with_parent_path_variants, 'entry_asset', false)
+
+            // Field under 'group' parent should get parent variant
+            expect((entry_with_parent_path_variants as any)['group']['$']['other']).toEqual('data-cslp=v2:entry_asset.entry_uid_3_parent_variant.en-us.group.other')
+
+            // Field under 'group.nested' should get parent variant (group is longer match)
+            expect((entry_with_parent_path_variants as any)['group']['nested']['$']['field']).toEqual('data-cslp=v2:entry_asset.entry_uid_3_parent_variant.en-us.group.nested.field')
+
+            // Field with exact deep path match should get deep variant
+            expect((entry_with_parent_path_variants as any)['group']['nested']['deep']['$']['field']).toEqual('data-cslp=v2:entry_asset.entry_uid_3_deep_variant.en-us.group.nested.deep.field')
+
+            done()
+        })
+
+        it('Entry with modular block variants should apply variants correctly', done => {
+            addTags(entry_with_applied_variants, 'entry_asset', false)
+
+            // Modular block content with variant should get v2 prefix and variant suffix
+            expect((entry_with_applied_variants as any)['modular_blocks'][0]['$']['content']).toEqual('data-cslp=v2:entry_asset.entry_uid_1_variant_3.en-us.modular_blocks.0.content')
+
+            // Modular block field without variant should not have v2 prefix
+            expect((entry_with_applied_variants as any)['modular_blocks'][0]['$']['title']).toEqual('data-cslp=entry_asset.entry_uid_1.en-us.modular_blocks.0.title')
+
+            done()
+        })
+
+        it('Entry without applied variants should work normally', done => {
+            addTags(entry_with_text, 'entry_asset', false)
+
+            // Should not have v2 prefix when no variants are applied
+            expect((entry_with_text as any)['$']['rich_text_editor']).toEqual('data-cslp=entry_asset.entry_uid_1.en-us.rich_text_editor')
+            expect((entry_with_text as any)['$']['rich_text_editor_multiple']).toEqual('data-cslp=entry_asset.entry_uid_1.en-us.rich_text_editor_multiple')
+
+            done()
+        })
+
+        it('Entry with empty applied variants should work normally', done => {
+            const entryWithEmptyVariants = {
+                ...entry_with_text,
+                _applied_variants: {}
+            }
+
+            addTags(entryWithEmptyVariants, 'entry_asset', false)
+
+            // Should not have v2 prefix when variants object is empty
+            expect((entryWithEmptyVariants as any)['$']['rich_text_editor']).toEqual('data-cslp=entry_asset.entry_uid_1.en-us.rich_text_editor')
+            expect((entryWithEmptyVariants as any)['$']['rich_text_editor_multiple']).toEqual('data-cslp=entry_asset.entry_uid_1.en-us.rich_text_editor_multiple')
+
+            done()
+        })
+
+        it('Variant path sorting should work correctly for nested paths', done => {
+            const entryWithComplexVariants = {
+                "_version": 10,
+                "locale": "en-us",
+                "uid": "entry_uid_test",
+                "ACL": {},
+                "_applied_variants": {
+                    "a": "variant_a",
+                    "a.b": "variant_ab", 
+                    "a.b.c": "variant_abc",
+                    "a.b.c.d": "variant_abcd"
+                },
+                "a": {
+                    "b": {
+                        "c": {
+                            "d": {
+                                "field": "deep field"
+                            },
+                            "field": "c field"
+                        },
+                        "field": "b field"
+                    },
+                    "field": "a field"
+                }
+            }
+
+            addTags(entryWithComplexVariants, 'entry_asset', false)
+
+            // Should use the longest matching path variant
+            expect((entryWithComplexVariants as any)['a']['b']['c']['d']['$']['field']).toEqual('data-cslp=v2:entry_asset.entry_uid_test_variant_abcd.en-us.a.b.c.d.field')
+            expect((entryWithComplexVariants as any)['a']['b']['c']['$']['field']).toEqual('data-cslp=v2:entry_asset.entry_uid_test_variant_abc.en-us.a.b.c.field')
+            expect((entryWithComplexVariants as any)['a']['b']['$']['field']).toEqual('data-cslp=v2:entry_asset.entry_uid_test_variant_ab.en-us.a.b.field')
+            expect((entryWithComplexVariants as any)['a']['$']['field']).toEqual('data-cslp=v2:entry_asset.entry_uid_test_variant_a.en-us.a.field')
+
+            done()
+        })
+    })
+
 })

__test__/mock/entry-editable-mock.ts

@@ -150,10 +150,77 @@ const entry_global_field_multiple = {
         }
     ]
 }
+// Mock entry with applied variants for testing variant functionality
+const entry_with_applied_variants = {
+    "_version": 10,
+    "locale": "en-us",
+    "uid": "entry_uid_1",
+    "ACL": {},
+    "_applied_variants": {
+        "rich_text_editor": "variant_1",
+        "nested.field": "variant_2",
+        "modular_blocks.content": "variant_3"
+    },
+    "rich_text_editor": "<p>Content with variant</p>",
+    "rich_text_editor_multiple": [
+        "<p>Multiple content with variant</p>"
+    ],
+    "nested": {
+        "field": "nested field content",
+        "other_field": "other nested content"
+    },
+    "modular_blocks": [
+        {
+            "content": "modular content",
+            "title": "modular title"
+        }
+    ]
+}
+
+// Mock entry with system-level applied variants
+const entry_with_system_variants = {
+    "_version": 10,
+    "locale": "en-us",
+    "uid": "entry_uid_2",
+    "ACL": {},
+    "system": {
+        "applied_variants": {
+            "title": "system_variant",
+            "description": "desc_variant"
+        }
+    },
+    "title": "System variant title",
+    "description": "System variant description"
+}
+
+// Mock entry with nested parent path variants
+const entry_with_parent_path_variants = {
+    "_version": 10,
+    "locale": "en-us", 
+    "uid": "entry_uid_3",
+    "ACL": {},
+    "_applied_variants": {
+        "group": "parent_variant",
+        "group.nested.deep": "deep_variant"
+    },
+    "group": {
+        "nested": {
+            "field": "nested field",
+            "deep": {
+                "field": "deep field"
+            }
+        },
+        "other": "other field"
+    }
+}
+
 export {
     entry_with_text,
     entry_reference,
     entry_global_field,
     entry_modular_block,
-    entry_global_field_multiple
+    entry_global_field_multiple,
+    entry_with_applied_variants,
+    entry_with_system_variants,
+    entry_with_parent_path_variants
 }

src/entry-editable.ts

@@ -115,12 +115,27 @@ function getTag(content: object, prefix: string, tagsAsObject: boolean, locale:
 }
 
 function getTagsValue(dataValue: string, tagsAsObject: boolean, appliedVariants: { _applied_variants: { [key: string]: any }, shouldApplyVariant: boolean, metaKey: string }): any {
-    if (appliedVariants.shouldApplyVariant && appliedVariants._applied_variants && appliedVariants._applied_variants[appliedVariants.metaKey]) {
+    if (appliedVariants.shouldApplyVariant && appliedVariants._applied_variants) {
+      const isFieldVariantised = appliedVariants._applied_variants[appliedVariants.metaKey];
+      if(isFieldVariantised) {
         const variant = appliedVariants._applied_variants[appliedVariants.metaKey]
         // Adding v2 prefix to the cslp tag. New cslp tags are in v2 format. ex: v2:content_type_uid.entry_uid.locale.title
         const newDataValueArray = ('v2:' + dataValue).split('.');
         newDataValueArray[1] = newDataValueArray[1] + '_' + variant;
         dataValue = newDataValueArray.join('.');
+      }
+      else {
+        const variantisedFieldPaths = Object.keys(appliedVariants._applied_variants).sort((a, b) => {
+          return b.length - a.length;
+        });
+        const variantisedParentPath = variantisedFieldPaths.find(path => appliedVariants.metaKey.startsWith(path));
+        if(variantisedParentPath) {
+          const variant = appliedVariants._applied_variants[variantisedParentPath];
+          const newDataValueArray = ('v2:' + dataValue).split('.');
+          newDataValueArray[1] = newDataValueArray[1] + '_' + variant;
+          dataValue = newDataValueArray.join('.');
+        }
+      }
     }
     if (tagsAsObject) {
         return { "data-cslp": dataValue };