@focus-reactive/payload-plugin-translator 0.1.0

package/dist/server/modules/translation-pipeline/stages/field-collector/FieldChunkCollector.test.js

@@ -0,0 +1,737 @@
+import { describe, it, expect } from 'vitest';
+import { FieldChunkCollector } from './FieldChunkCollector';
+import { OverwriteStrategy } from '../../strategies/Overwrite.strategy';
+import { SkipExistingStrategy } from '../../strategies/SkipExisting.strategy';
+const strategy = new OverwriteStrategy();
+const skipExistingStrategy = new SkipExistingStrategy();
+describe('FieldChunkCollector', () => {
+    describe('simple fields', () => {
+        it('collects localized text fields', () => {
+            const schema = [{ name: 'title', type: 'text', localized: true }];
+            const data = { title: 'Hello' };
+            const collector = new FieldChunkCollector(schema, data, data, {}, strategy);
+            const chunks = collector.collect();
+            expect(chunks).toHaveLength(1);
+            expect(chunks[0].key).toBe('title');
+            expect(chunks[0].path).toEqual(['title']);
+            expect(chunks[0].dataRef).toBe(data);
+            expect(chunks[0].schema.type).toBe('text');
+        });
+        it('collects multiple localized fields', () => {
+            const schema = [
+                { name: 'title', type: 'text', localized: true },
+                { name: 'description', type: 'textarea', localized: true },
+            ];
+            const data = { title: 'Hello', description: 'World' };
+            const collector = new FieldChunkCollector(schema, data, data, {}, strategy);
+            const chunks = collector.collect();
+            expect(chunks).toHaveLength(2);
+            expect(chunks.map((c) => c.key)).toEqual(['title', 'description']);
+        });
+        it('skips non-localized fields', () => {
+            const schema = [
+                { name: 'title', type: 'text', localized: true },
+                { name: 'slug', type: 'text', localized: false },
+            ];
+            const data = { title: 'Hello', slug: 'hello' };
+            const collector = new FieldChunkCollector(schema, data, data, {}, strategy);
+            const chunks = collector.collect();
+            expect(chunks).toHaveLength(1);
+            expect(chunks[0].key).toBe('title');
+        });
+        it('skips non-translatable fields', () => {
+            const schema = [
+                { name: 'title', type: 'text', localized: true },
+                { name: 'author', type: 'relationship', relationTo: 'users', localized: true },
+            ];
+            const data = { title: 'Hello', author: '123' };
+            const collector = new FieldChunkCollector(schema, data, data, {}, strategy);
+            const chunks = collector.collect();
+            expect(chunks).toHaveLength(1);
+            expect(chunks[0].key).toBe('title');
+        });
+        it('skips null and undefined values', () => {
+            const schema = [
+                { name: 'title', type: 'text', localized: true },
+                { name: 'subtitle', type: 'text', localized: true },
+            ];
+            const data = { title: null, subtitle: undefined };
+            const collector = new FieldChunkCollector(schema, data, data, {}, strategy);
+            const chunks = collector.collect();
+            expect(chunks).toHaveLength(0);
+        });
+    });
+    describe('group fields', () => {
+        it('collects nested fields with correct path', () => {
+            const schema = [
+                {
+                    name: 'meta',
+                    type: 'group',
+                    fields: [{ name: 'title', type: 'text', localized: true }],
+                },
+            ];
+            const data = { meta: { title: 'Hello' } };
+            const collector = new FieldChunkCollector(schema, data, data, {}, strategy);
+            const chunks = collector.collect();
+            expect(chunks).toHaveLength(1);
+            expect(chunks[0].key).toBe('title');
+            expect(chunks[0].path).toEqual(['meta', 'title']);
+            expect(chunks[0].dataRef).toBe(data.meta);
+        });
+        it('collects deeply nested fields', () => {
+            const schema = [
+                {
+                    name: 'level1',
+                    type: 'group',
+                    fields: [
+                        {
+                            name: 'level2',
+                            type: 'group',
+                            fields: [{ name: 'title', type: 'text', localized: true }],
+                        },
+                    ],
+                },
+            ];
+            const data = { level1: { level2: { title: 'Deep' } } };
+            const collector = new FieldChunkCollector(schema, data, data, {}, strategy);
+            const chunks = collector.collect();
+            expect(chunks).toHaveLength(1);
+            expect(chunks[0].path).toEqual(['level1', 'level2', 'title']);
+            expect(chunks[0].dataRef).toBe(data.level1.level2);
+        });
+    });
+    describe('array fields', () => {
+        it('collects fields from each array item', () => {
+            const schema = [
+                {
+                    name: 'items',
+                    type: 'array',
+                    fields: [{ name: 'label', type: 'text', localized: true }],
+                },
+            ];
+            const data = {
+                items: [
+                    { id: '1', label: 'First' },
+                    { id: '2', label: 'Second' },
+                ],
+            };
+            const collector = new FieldChunkCollector(schema, data, data, {}, strategy);
+            const chunks = collector.collect();
+            expect(chunks).toHaveLength(2);
+            expect(chunks[0].path).toEqual(['items', '0', 'label']);
+            expect(chunks[1].path).toEqual(['items', '1', 'label']);
+            expect(chunks[0].dataRef).toBe(data.items[0]);
+            expect(chunks[1].dataRef).toBe(data.items[1]);
+        });
+        it('uses numeric index in path', () => {
+            const schema = [
+                {
+                    name: 'items',
+                    type: 'array',
+                    fields: [{ name: 'text', type: 'text', localized: true }],
+                },
+            ];
+            const data = { items: [{ id: '1', text: 'Hello' }] };
+            const collector = new FieldChunkCollector(schema, data, data, {}, strategy);
+            const chunks = collector.collect();
+            expect(chunks[0].path).toEqual(['items', '0', 'text']);
+        });
+    });
+    describe('blocks fields', () => {
+        it('collects fields from blocks with correct path', () => {
+            const schema = [
+                {
+                    name: 'layout',
+                    type: 'blocks',
+                    blocks: [
+                        {
+                            slug: 'text',
+                            fields: [{ name: 'content', type: 'text', localized: true }],
+                        },
+                    ],
+                },
+            ];
+            const data = {
+                layout: [{ id: '1', blockType: 'text', content: 'Hello' }],
+            };
+            const collector = new FieldChunkCollector(schema, data, data, {}, strategy);
+            const chunks = collector.collect();
+            expect(chunks).toHaveLength(1);
+            expect(chunks[0].path).toEqual(['layout', '0', 'content']);
+            expect(chunks[0].dataRef).toBe(data.layout[0]);
+        });
+        it('handles multiple block types', () => {
+            const schema = [
+                {
+                    name: 'layout',
+                    type: 'blocks',
+                    blocks: [
+                        {
+                            slug: 'text',
+                            fields: [{ name: 'content', type: 'text', localized: true }],
+                        },
+                        {
+                            slug: 'heading',
+                            fields: [{ name: 'title', type: 'text', localized: true }],
+                        },
+                    ],
+                },
+            ];
+            const data = {
+                layout: [
+                    { id: '1', blockType: 'text', content: 'Hello' },
+                    { id: '2', blockType: 'heading', title: 'Title' },
+                ],
+            };
+            const collector = new FieldChunkCollector(schema, data, data, {}, strategy);
+            const chunks = collector.collect();
+            expect(chunks).toHaveLength(2);
+            expect(chunks[0].key).toBe('content');
+            expect(chunks[1].key).toBe('title');
+        });
+        it('skips unknown block types', () => {
+            const schema = [
+                {
+                    name: 'layout',
+                    type: 'blocks',
+                    blocks: [
+                        {
+                            slug: 'text',
+                            fields: [{ name: 'content', type: 'text', localized: true }],
+                        },
+                    ],
+                },
+            ];
+            const data = {
+                layout: [{ id: '1', blockType: 'unknown', content: 'Hello' }],
+            };
+            const collector = new FieldChunkCollector(schema, data, data, {}, strategy);
+            const chunks = collector.collect();
+            expect(chunks).toHaveLength(0);
+        });
+    });
+    describe('tabs and row fields', () => {
+        it('collects fields from tabs', () => {
+            const schema = [
+                {
+                    type: 'tabs',
+                    tabs: [
+                        {
+                            label: 'Content',
+                            fields: [{ name: 'title', type: 'text', localized: true }],
+                        },
+                    ],
+                },
+            ];
+            const data = { title: 'Hello' };
+            const collector = new FieldChunkCollector(schema, data, data, {}, strategy);
+            const chunks = collector.collect();
+            expect(chunks).toHaveLength(1);
+            expect(chunks[0].path).toEqual(['title']);
+        });
+        it('collects fields from row', () => {
+            const schema = [
+                {
+                    type: 'row',
+                    fields: [{ name: 'title', type: 'text', localized: true }],
+                },
+            ];
+            const data = { title: 'Hello' };
+            const collector = new FieldChunkCollector(schema, data, data, {}, strategy);
+            const chunks = collector.collect();
+            expect(chunks).toHaveLength(1);
+            expect(chunks[0].path).toEqual(['title']);
+        });
+        it('collects fields from unnamed group (no name property)', () => {
+            const schema = [
+                {
+                    type: 'group',
+                    fields: [
+                        { name: 'title', type: 'text', localized: true },
+                        { name: 'description', type: 'textarea', localized: true },
+                    ],
+                },
+            ];
+            const data = { title: 'Hello', description: 'World' };
+            const collector = new FieldChunkCollector(schema, data, data, {}, strategy);
+            const chunks = collector.collect();
+            expect(chunks).toHaveLength(2);
+            expect(chunks[0].path).toEqual(['title']);
+            expect(chunks[1].path).toEqual(['description']);
+            expect(chunks[0].dataRef).toBe(data);
+        });
+    });
+    describe('complex nested structures', () => {
+        it('collects array fields inside group', () => {
+            const schema = [
+                {
+                    name: 'section',
+                    type: 'group',
+                    fields: [
+                        {
+                            name: 'items',
+                            type: 'array',
+                            fields: [{ name: 'label', type: 'text', localized: true }],
+                        },
+                    ],
+                },
+            ];
+            const data = { section: { items: [{ id: '1', label: 'Hello' }] } };
+            const collector = new FieldChunkCollector(schema, data, data, {}, strategy);
+            const chunks = collector.collect();
+            expect(chunks).toHaveLength(1);
+            expect(chunks[0].key).toBe('label');
+            expect(chunks[0].path).toEqual(['section', 'items', '0', 'label']);
+            expect(chunks[0].dataRef).toBe(data.section.items[0]);
+        });
+        it('collects group fields inside array', () => {
+            const schema = [
+                {
+                    name: 'items',
+                    type: 'array',
+                    fields: [
+                        {
+                            name: 'meta',
+                            type: 'group',
+                            fields: [{ name: 'title', type: 'text', localized: true }],
+                        },
+                    ],
+                },
+            ];
+            const data = { items: [{ id: '1', meta: { title: 'Hello' } }] };
+            const collector = new FieldChunkCollector(schema, data, data, {}, strategy);
+            const chunks = collector.collect();
+            expect(chunks).toHaveLength(1);
+            expect(chunks[0].key).toBe('title');
+            expect(chunks[0].path).toEqual(['items', '0', 'meta', 'title']);
+            expect(chunks[0].dataRef).toBe(data.items[0].meta);
+        });
+        it('collects blocks fields inside group', () => {
+            const schema = [
+                {
+                    name: 'hero',
+                    type: 'group',
+                    fields: [
+                        {
+                            name: 'content',
+                            type: 'blocks',
+                            blocks: [
+                                {
+                                    slug: 'text',
+                                    fields: [{ name: 'body', type: 'text', localized: true }],
+                                },
+                            ],
+                        },
+                    ],
+                },
+            ];
+            const data = { hero: { content: [{ id: '1', blockType: 'text', body: 'Hello' }] } };
+            const collector = new FieldChunkCollector(schema, data, data, {}, strategy);
+            const chunks = collector.collect();
+            expect(chunks).toHaveLength(1);
+            expect(chunks[0].key).toBe('body');
+            expect(chunks[0].path).toEqual(['hero', 'content', '0', 'body']);
+            expect(chunks[0].dataRef).toBe(data.hero.content[0]);
+        });
+        it('collects group fields inside blocks', () => {
+            const schema = [
+                {
+                    name: 'layout',
+                    type: 'blocks',
+                    blocks: [
+                        {
+                            slug: 'card',
+                            fields: [
+                                {
+                                    name: 'meta',
+                                    type: 'group',
+                                    fields: [{ name: 'title', type: 'text', localized: true }],
+                                },
+                            ],
+                        },
+                    ],
+                },
+            ];
+            const data = { layout: [{ id: '1', blockType: 'card', meta: { title: 'Hello' } }] };
+            const collector = new FieldChunkCollector(schema, data, data, {}, strategy);
+            const chunks = collector.collect();
+            expect(chunks).toHaveLength(1);
+            expect(chunks[0].key).toBe('title');
+            expect(chunks[0].path).toEqual(['layout', '0', 'meta', 'title']);
+            expect(chunks[0].dataRef).toBe(data.layout[0].meta);
+        });
+        it('collects blocks fields inside array', () => {
+            const schema = [
+                {
+                    name: 'sections',
+                    type: 'array',
+                    fields: [
+                        {
+                            name: 'blocks',
+                            type: 'blocks',
+                            blocks: [
+                                {
+                                    slug: 'text',
+                                    fields: [{ name: 'content', type: 'text', localized: true }],
+                                },
+                            ],
+                        },
+                    ],
+                },
+            ];
+            const data = {
+                sections: [{ id: '1', blocks: [{ id: 'b1', blockType: 'text', content: 'Hello' }] }],
+            };
+            const collector = new FieldChunkCollector(schema, data, data, {}, strategy);
+            const chunks = collector.collect();
+            expect(chunks).toHaveLength(1);
+            expect(chunks[0].key).toBe('content');
+            expect(chunks[0].path).toEqual(['sections', '0', 'blocks', '0', 'content']);
+            expect(chunks[0].dataRef).toBe(data.sections[0].blocks[0]);
+        });
+        it('collects fields from named tabs', () => {
+            const schema = [
+                {
+                    type: 'tabs',
+                    tabs: [
+                        {
+                            name: 'seo',
+                            fields: [{ name: 'title', type: 'text', localized: true }],
+                        },
+                    ],
+                },
+            ];
+            const data = { seo: { title: 'SEO Title' } };
+            const collector = new FieldChunkCollector(schema, data, data, {}, strategy);
+            const chunks = collector.collect();
+            expect(chunks).toHaveLength(1);
+            expect(chunks[0].key).toBe('title');
+            expect(chunks[0].path).toEqual(['seo', 'title']);
+            expect(chunks[0].dataRef).toBe(data.seo);
+        });
+        it('collects fields from collapsible', () => {
+            const schema = [
+                {
+                    type: 'collapsible',
+                    label: 'Advanced',
+                    fields: [{ name: 'meta', type: 'text', localized: true }],
+                },
+            ];
+            const data = { meta: 'Value' };
+            const collector = new FieldChunkCollector(schema, data, data, {}, strategy);
+            const chunks = collector.collect();
+            expect(chunks).toHaveLength(1);
+            expect(chunks[0].key).toBe('meta');
+            expect(chunks[0].path).toEqual(['meta']);
+        });
+        it('collects 4-level nested structure (tabs > group > array > blocks)', () => {
+            const schema = [
+                {
+                    type: 'tabs',
+                    tabs: [
+                        {
+                            name: 'content',
+                            fields: [
+                                {
+                                    name: 'sections',
+                                    type: 'group',
+                                    fields: [
+                                        {
+                                            name: 'items',
+                                            type: 'array',
+                                            fields: [
+                                                {
+                                                    name: 'blocks',
+                                                    type: 'blocks',
+                                                    blocks: [
+                                                        {
+                                                            slug: 'text',
+                                                            fields: [{ name: 'body', type: 'text', localized: true }],
+                                                        },
+                                                    ],
+                                                },
+                                            ],
+                                        },
+                                    ],
+                                },
+                            ],
+                        },
+                    ],
+                },
+            ];
+            const data = {
+                content: {
+                    sections: {
+                        items: [{ id: '1', blocks: [{ id: 'b1', blockType: 'text', body: 'Deep content' }] }],
+                    },
+                },
+            };
+            const collector = new FieldChunkCollector(schema, data, data, {}, strategy);
+            const chunks = collector.collect();
+            expect(chunks).toHaveLength(1);
+            expect(chunks[0].key).toBe('body');
+            expect(chunks[0].path).toEqual(['content', 'sections', 'items', '0', 'blocks', '0', 'body']);
+            expect(chunks[0].dataRef).toBe(data.content.sections.items[0].blocks[0]);
+        });
+        it('collects multiple fields from complex nested structure', () => {
+            const schema = [
+                {
+                    name: 'page',
+                    type: 'group',
+                    fields: [
+                        { name: 'title', type: 'text', localized: true },
+                        {
+                            name: 'sections',
+                            type: 'array',
+                            fields: [
+                                { name: 'heading', type: 'text', localized: true },
+                                {
+                                    name: 'content',
+                                    type: 'blocks',
+                                    blocks: [
+                                        {
+                                            slug: 'paragraph',
+                                            fields: [{ name: 'text', type: 'text', localized: true }],
+                                        },
+                                    ],
+                                },
+                            ],
+                        },
+                    ],
+                },
+            ];
+            const data = {
+                page: {
+                    title: 'Page Title',
+                    sections: [
+                        {
+                            id: '1',
+                            heading: 'Section 1',
+                            content: [{ id: 'b1', blockType: 'paragraph', text: 'Content 1' }],
+                        },
+                        {
+                            id: '2',
+                            heading: 'Section 2',
+                            content: [{ id: 'b2', blockType: 'paragraph', text: 'Content 2' }],
+                        },
+                    ],
+                },
+            };
+            const collector = new FieldChunkCollector(schema, data, data, {}, strategy);
+            const chunks = collector.collect();
+            expect(chunks).toHaveLength(5);
+            expect(chunks.map((c) => c.path)).toEqual([
+                ['page', 'title'],
+                ['page', 'sections', '0', 'heading'],
+                ['page', 'sections', '0', 'content', '0', 'text'],
+                ['page', 'sections', '1', 'heading'],
+                ['page', 'sections', '1', 'content', '0', 'text'],
+            ]);
+        });
+    });
+    describe('dataRef mutation capability', () => {
+        it('provides mutable reference to parent object', () => {
+            const schema = [{ name: 'title', type: 'text', localized: true }];
+            const data = { title: 'Hello' };
+            const collector = new FieldChunkCollector(schema, data, data, {}, strategy);
+            const chunks = collector.collect();
+            // Mutate through dataRef
+            chunks[0].dataRef[chunks[0].key] = 'Modified';
+            expect(data.title).toBe('Modified');
+        });
+        it('provides mutable reference in nested structures', () => {
+            const schema = [
+                {
+                    name: 'items',
+                    type: 'array',
+                    fields: [{ name: 'label', type: 'text', localized: true }],
+                },
+            ];
+            const data = { items: [{ id: '1', label: 'Original' }] };
+            const collector = new FieldChunkCollector(schema, data, data, {}, strategy);
+            const chunks = collector.collect();
+            // Mutate through dataRef
+            chunks[0].dataRef[chunks[0].key] = 'Modified';
+            expect(data.items[0].label).toBe('Modified');
+        });
+    });
+    describe('strategy filtering', () => {
+        it('skips fields with existing target values (SkipExisting)', () => {
+            const schema = [{ name: 'title', type: 'text', localized: true }];
+            const filteredData = { title: 'Existing' };
+            const sourceData = { title: 'Hello' };
+            const targetData = { title: 'Existing' };
+            const collector = new FieldChunkCollector(schema, filteredData, sourceData, targetData, skipExistingStrategy);
+            const chunks = collector.collect();
+            expect(chunks).toHaveLength(0);
+        });
+        it('collects fields with empty target values (SkipExisting)', () => {
+            const schema = [{ name: 'title', type: 'text', localized: true }];
+            const filteredData = { title: 'Hello' };
+            const sourceData = { title: 'Hello' };
+            const targetData = { title: '' };
+            const collector = new FieldChunkCollector(schema, filteredData, sourceData, targetData, skipExistingStrategy);
+            const chunks = collector.collect();
+            expect(chunks).toHaveLength(1);
+            expect(chunks[0].key).toBe('title');
+        });
+        it('handles mixed fields with SkipExisting', () => {
+            const schema = [
+                { name: 'title', type: 'text', localized: true },
+                { name: 'description', type: 'text', localized: true },
+            ];
+            const filteredData = { title: 'Existing', description: 'World' };
+            const sourceData = { title: 'Hello', description: 'World' };
+            const targetData = { title: 'Existing', description: '' };
+            const collector = new FieldChunkCollector(schema, filteredData, sourceData, targetData, skipExistingStrategy);
+            const chunks = collector.collect();
+            expect(chunks).toHaveLength(1);
+            expect(chunks[0].key).toBe('description');
+        });
+        it('collects all fields with OverwriteStrategy even when target exists', () => {
+            const schema = [{ name: 'title', type: 'text', localized: true }];
+            const filteredData = { title: 'Existing' };
+            const sourceData = { title: 'Hello' };
+            const targetData = { title: 'Existing' };
+            const collector = new FieldChunkCollector(schema, filteredData, sourceData, targetData, strategy);
+            const chunks = collector.collect();
+            expect(chunks).toHaveLength(1);
+        });
+        it('applies SkipExisting to nested array fields', () => {
+            const schema = [
+                {
+                    name: 'items',
+                    type: 'array',
+                    fields: [{ name: 'label', type: 'text', localized: true }],
+                },
+            ];
+            const filteredData = {
+                items: [
+                    { id: '1', label: 'Translated' },
+                    { id: '2', label: 'Second' },
+                ],
+            };
+            const sourceData = {
+                items: [
+                    { id: '1', label: 'First' },
+                    { id: '2', label: 'Second' },
+                ],
+            };
+            const targetData = {
+                items: [
+                    { id: '1', label: 'Translated' },
+                    { id: '2', label: '' },
+                ],
+            };
+            const collector = new FieldChunkCollector(schema, filteredData, sourceData, targetData, skipExistingStrategy);
+            const chunks = collector.collect();
+            expect(chunks).toHaveLength(1);
+            expect(chunks[0].path).toEqual(['items', '1', 'label']);
+        });
+        it('applies SkipExisting to nested group fields', () => {
+            const schema = [
+                {
+                    name: 'meta',
+                    type: 'group',
+                    fields: [
+                        { name: 'title', type: 'text', localized: true },
+                        { name: 'description', type: 'text', localized: true },
+                    ],
+                },
+            ];
+            const filteredData = { meta: { title: 'Translated', description: 'World' } };
+            const sourceData = { meta: { title: 'Hello', description: 'World' } };
+            const targetData = { meta: { title: 'Translated', description: '' } };
+            const collector = new FieldChunkCollector(schema, filteredData, sourceData, targetData, skipExistingStrategy);
+            const chunks = collector.collect();
+            expect(chunks).toHaveLength(1);
+            expect(chunks[0].path).toEqual(['meta', 'description']);
+        });
+        it('applies SkipExisting to blocks fields', () => {
+            const schema = [
+                {
+                    name: 'layout',
+                    type: 'blocks',
+                    blocks: [
+                        {
+                            slug: 'text',
+                            fields: [{ name: 'content', type: 'text', localized: true }],
+                        },
+                    ],
+                },
+            ];
+            const filteredData = {
+                layout: [
+                    { id: '1', blockType: 'text', content: 'Translated' },
+                    { id: '2', blockType: 'text', content: 'World' },
+                ],
+            };
+            const sourceData = {
+                layout: [
+                    { id: '1', blockType: 'text', content: 'Hello' },
+                    { id: '2', blockType: 'text', content: 'World' },
+                ],
+            };
+            const targetData = {
+                layout: [
+                    { id: '1', blockType: 'text', content: 'Translated' },
+                    { id: '2', blockType: 'text', content: '' },
+                ],
+            };
+            const collector = new FieldChunkCollector(schema, filteredData, sourceData, targetData, skipExistingStrategy);
+            const chunks = collector.collect();
+            expect(chunks).toHaveLength(1);
+            expect(chunks[0].path).toEqual(['layout', '1', 'content']);
+        });
+    });
+    describe('sourceValue mutation', () => {
+        it('writes sourceValue to filteredData when shouldTranslate is true', () => {
+            const schema = [{ name: 'title', type: 'text', localized: true }];
+            const filteredData = { title: 'Target value' };
+            const sourceData = { title: 'Source value' };
+            const targetData = { title: 'Target value' };
+            const collector = new FieldChunkCollector(schema, filteredData, sourceData, targetData, strategy);
+            collector.collect();
+            expect(filteredData.title).toBe('Source value');
+        });
+        it('does not modify filteredData when shouldTranslate is false', () => {
+            const schema = [{ name: 'title', type: 'text', localized: true }];
+            const filteredData = { title: 'Existing' };
+            const sourceData = { title: 'Hello' };
+            const targetData = { title: 'Existing' };
+            const collector = new FieldChunkCollector(schema, filteredData, sourceData, targetData, skipExistingStrategy);
+            collector.collect();
+            expect(filteredData.title).toBe('Existing');
+        });
+        it('writes sourceValue in nested structures', () => {
+            const schema = [
+                {
+                    name: 'meta',
+                    type: 'group',
+                    fields: [{ name: 'title', type: 'text', localized: true }],
+                },
+            ];
+            const filteredData = { meta: { title: 'Target' } };
+            const sourceData = { meta: { title: 'Source' } };
+            const targetData = { meta: { title: 'Target' } };
+            const collector = new FieldChunkCollector(schema, filteredData, sourceData, targetData, strategy);
+            collector.collect();
+            expect(filteredData.meta.title).toBe('Source');
+        });
+        it('writes sourceValue in array items', () => {
+            const schema = [
+                {
+                    name: 'items',
+                    type: 'array',
+                    fields: [{ name: 'label', type: 'text', localized: true }],
+                },
+            ];
+            const filteredData = { items: [{ id: '1', label: 'Target' }] };
+            const sourceData = { items: [{ id: '1', label: 'Source' }] };
+            const targetData = { items: [{ id: '1', label: 'Target' }] };
+            const collector = new FieldChunkCollector(schema, filteredData, sourceData, targetData, strategy);
+            collector.collect();
+            expect(filteredData.items[0].label).toBe('Source');
+        });
+    });
+});