@focus-reactive/payload-plugin-translator 0.1.0

package/dist/server/modules/translation-pipeline/stages/data-reconciler/DataReconciler.js

@@ -0,0 +1,97 @@
+import { fieldAffectsData, fieldIsArrayType, fieldIsBlockType, fieldIsGroupType, tabHasName } from 'payload/shared';
+import { hasFields, isBlockItem, isTabsField, isEmpty, isObject } from '../../../../shared';
+/**
+ * Deep merges source and target data with target priority.
+ * Creates full document shape needed for Payload validation.
+ *
+ * Logic:
+ * - If targetValue exists and is not empty → use targetValue
+ * - Otherwise → use sourceValue
+ *
+ * Stage 1 of the translation pipeline.
+ */ export class DataReconciler {
+    schema;
+    constructor(schema){
+        this.schema = schema;
+    }
+    /**
+   * Reconciles source and target data into a complete document shape.
+   * The result contains all fields needed for Payload validation.
+   *
+   * @param sourceData - Source locale document data
+   * @param targetData - Target locale document data (may be empty/partial)
+   * @returns Complete document shape with reconciled field values
+   */ reconcile(sourceData, targetData) {
+        return this.reconcileFields(this.schema, sourceData, targetData ?? {});
+    }
+    reconcileFields(fields, source, target) {
+        const result = {};
+        for (const field of fields){
+            if (isTabsField(field)) {
+                for (const tab of field.tabs){
+                    if (hasFields(tab)) {
+                        if (tabHasName(tab)) {
+                            const tabSource = source[tab.name];
+                            const tabTarget = target[tab.name];
+                            if (isObject(tabSource)) {
+                                result[tab.name] = this.reconcileFields(tab.fields, tabSource, isObject(tabTarget) ? tabTarget : {});
+                            }
+                        } else {
+                            Object.assign(result, this.reconcileFields(tab.fields, source, target));
+                        }
+                    }
+                }
+                continue;
+            }
+            if (!fieldAffectsData(field)) {
+                if (hasFields(field)) Object.assign(result, this.reconcileFields(field.fields, source, target));
+                continue;
+            }
+            const sourceValue = source[field.name];
+            const targetValue = target[field.name];
+            // Skip undefined source values
+            if (sourceValue === undefined) continue;
+            // Group - recursively reconcile
+            if (fieldIsGroupType(field) && isObject(sourceValue)) {
+                const targetGroup = isObject(targetValue) ? targetValue : {};
+                result[field.name] = this.reconcileFields(field.fields, sourceValue, targetGroup);
+                continue;
+            }
+            // Array - recursively reconcile each item (without id - Postgres rejects it)
+            if (fieldIsArrayType(field) && Array.isArray(sourceValue)) {
+                const targetArray = Array.isArray(targetValue) ? targetValue : [];
+                result[field.name] = sourceValue.map((sourceItem, index)=>{
+                    if (isObject(sourceItem)) {
+                        const targetItem = isObject(targetArray[index]) ? targetArray[index] : {};
+                        return this.reconcileFields(field.fields, sourceItem, targetItem);
+                    }
+                    return sourceItem;
+                });
+                continue;
+            }
+            // Blocks - recursively reconcile each block (without id - Postgres rejects it)
+            if (fieldIsBlockType(field) && Array.isArray(sourceValue)) {
+                const targetArray = Array.isArray(targetValue) ? targetValue : [];
+                result[field.name] = sourceValue.map((sourceItem, index)=>{
+                    if (isBlockItem(sourceItem)) {
+                        const block = field.blocks.find((b)=>b.slug === sourceItem.blockType);
+                        if (block) {
+                            const targetItem = isObject(targetArray[index]) ? targetArray[index] : {};
+                            return {
+                                ...this.reconcileFields(block.fields, sourceItem, targetItem),
+                                blockType: sourceItem.blockType
+                            };
+                        }
+                    }
+                    return sourceItem;
+                });
+                continue;
+            }
+            // Deep merge: target priority, fallback to source
+            result[field.name] = isEmpty(targetValue) ? sourceValue : targetValue;
+        }
+        return result;
+    }
+}
+
+//# sourceMappingURL=DataReconciler.js.map

package/dist/server/modules/translation-pipeline/stages/data-reconciler/DataReconciler.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../../../src/server/modules/translation-pipeline/stages/data-reconciler/DataReconciler.ts"],"sourcesContent":["import type { Field } from 'payload'\nimport { fieldAffectsData, fieldIsArrayType, fieldIsBlockType, fieldIsGroupType, tabHasName } from 'payload/shared'\n\nimport { hasFields, isBlockItem, isTabsField, isEmpty, isObject } from '../../../../shared'\n\n/**\n * Deep merges source and target data with target priority.\n * Creates full document shape needed for Payload validation.\n *\n * Logic:\n * - If targetValue exists and is not empty → use targetValue\n * - Otherwise → use sourceValue\n *\n * Stage 1 of the translation pipeline.\n */\nexport class DataReconciler {\n  constructor(private readonly schema: Field[]) {}\n\n  /**\n   * Reconciles source and target data into a complete document shape.\n   * The result contains all fields needed for Payload validation.\n   *\n   * @param sourceData - Source locale document data\n   * @param targetData - Target locale document data (may be empty/partial)\n   * @returns Complete document shape with reconciled field values\n   */\n  reconcile(sourceData: Record<string, unknown>, targetData: Record<string, unknown>): Record<string, unknown> {\n    return this.reconcileFields(this.schema, sourceData, targetData ?? {})\n  }\n\n  private reconcileFields(\n    fields: Field[],\n    source: Record<string, unknown>,\n    target: Record<string, unknown>,\n  ): Record<string, unknown> {\n    const result: Record<string, unknown> = {}\n\n    for (const field of fields) {\n      if (isTabsField(field)) {\n        for (const tab of field.tabs) {\n          if (hasFields(tab)) {\n            if (tabHasName(tab)) {\n              const tabSource = source[tab.name]\n              const tabTarget = target[tab.name]\n              if (isObject(tabSource)) {\n                result[tab.name] = this.reconcileFields(tab.fields, tabSource, isObject(tabTarget) ? tabTarget : {})\n              }\n            } else {\n              Object.assign(result, this.reconcileFields(tab.fields, source, target))\n            }\n          }\n        }\n        continue\n      }\n\n      if (!fieldAffectsData(field)) {\n        if (hasFields(field)) Object.assign(result, this.reconcileFields(field.fields, source, target))\n        continue\n      }\n\n      const sourceValue = source[field.name]\n      const targetValue = target[field.name]\n\n      // Skip undefined source values\n      if (sourceValue === undefined) continue\n\n      // Group - recursively reconcile\n      if (fieldIsGroupType(field) && isObject(sourceValue)) {\n        const targetGroup = isObject(targetValue) ? targetValue : {}\n        result[field.name] = this.reconcileFields(field.fields, sourceValue, targetGroup)\n        continue\n      }\n\n      // Array - recursively reconcile each item (without id - Postgres rejects it)\n      if (fieldIsArrayType(field) && Array.isArray(sourceValue)) {\n        const targetArray = Array.isArray(targetValue) ? targetValue : []\n        result[field.name] = sourceValue.map((sourceItem, index) => {\n          if (isObject(sourceItem)) {\n            const targetItem = isObject(targetArray[index]) ? targetArray[index] : {}\n            return this.reconcileFields(field.fields, sourceItem, targetItem)\n          }\n          return sourceItem\n        })\n        continue\n      }\n\n      // Blocks - recursively reconcile each block (without id - Postgres rejects it)\n      if (fieldIsBlockType(field) && Array.isArray(sourceValue)) {\n        const targetArray = Array.isArray(targetValue) ? targetValue : []\n        result[field.name] = sourceValue.map((sourceItem, index) => {\n          if (isBlockItem(sourceItem)) {\n            const block = field.blocks.find((b) => b.slug === sourceItem.blockType)\n            if (block) {\n              const targetItem = isObject(targetArray[index]) ? targetArray[index] : {}\n              return {\n                ...this.reconcileFields(block.fields, sourceItem, targetItem),\n                blockType: sourceItem.blockType,\n              }\n            }\n          }\n          return sourceItem\n        })\n        continue\n      }\n\n      // Deep merge: target priority, fallback to source\n      result[field.name] = isEmpty(targetValue) ? sourceValue : targetValue\n    }\n\n    return result\n  }\n}\n"],"names":["fieldAffectsData","fieldIsArrayType","fieldIsBlockType","fieldIsGroupType","tabHasName","hasFields","isBlockItem","isTabsField","isEmpty","isObject","DataReconciler","schema","reconcile","sourceData","targetData","reconcileFields","fields","source","target","result","field","tab","tabs","tabSource","name","tabTarget","Object","assign","sourceValue","targetValue","undefined","targetGroup","Array","isArray","targetArray","map","sourceItem","index","targetItem","block","blocks","find","b","slug","blockType"],"mappings":"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"}

package/dist/server/modules/translation-pipeline/stages/data-reconciler/DataReconciler.stage.d.ts

@@ -0,0 +1,9 @@
+import type { PipelineContext, PipelineStage } from '../../types';
+/**
+ * Deep merges source and target data with target priority.
+ * Stage 1 of the translation pipeline.
+ */
+export declare class DataReconcilerStage implements PipelineStage {
+    execute(ctx: PipelineContext): PipelineContext;
+}
+//# sourceMappingURL=DataReconciler.stage.d.ts.map

package/dist/server/modules/translation-pipeline/stages/data-reconciler/DataReconciler.stage.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"DataReconciler.stage.d.ts","sourceRoot":"","sources":["../../../../../../src/server/modules/translation-pipeline/stages/data-reconciler/DataReconciler.stage.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,eAAe,EAAE,aAAa,EAAE,MAAM,aAAa,CAAA;AAGjE;;;GAGG;AACH,qBAAa,mBAAoB,YAAW,aAAa;IACvD,OAAO,CAAC,GAAG,EAAE,eAAe,GAAG,eAAe;CAO/C"}

package/dist/server/modules/translation-pipeline/stages/data-reconciler/DataReconciler.stage.js

@@ -0,0 +1,15 @@
+import { DataReconciler } from './DataReconciler';
+/**
+ * Deep merges source and target data with target priority.
+ * Stage 1 of the translation pipeline.
+ */ export class DataReconcilerStage {
+    execute(ctx) {
+        const reconciler = new DataReconciler(ctx.schema);
+        return {
+            ...ctx,
+            filteredData: reconciler.reconcile(ctx.sourceData, ctx.targetData)
+        };
+    }
+}
+
+//# sourceMappingURL=DataReconciler.stage.js.map

package/dist/server/modules/translation-pipeline/stages/data-reconciler/DataReconciler.stage.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../../../src/server/modules/translation-pipeline/stages/data-reconciler/DataReconciler.stage.ts"],"sourcesContent":["import type { PipelineContext, PipelineStage } from '../../types'\nimport { DataReconciler } from './DataReconciler'\n\n/**\n * Deep merges source and target data with target priority.\n * Stage 1 of the translation pipeline.\n */\nexport class DataReconcilerStage implements PipelineStage {\n  execute(ctx: PipelineContext): PipelineContext {\n    const reconciler = new DataReconciler(ctx.schema)\n    return {\n      ...ctx,\n      filteredData: reconciler.reconcile(ctx.sourceData, ctx.targetData),\n    }\n  }\n}\n"],"names":["DataReconciler","DataReconcilerStage","execute","ctx","reconciler","schema","filteredData","reconcile","sourceData","targetData"],"mappings":"AACA,SAASA,cAAc,QAAQ,mBAAkB;AAEjD;;;CAGC,GACD,OAAO,MAAMC;IACXC,QAAQC,GAAoB,EAAmB;QAC7C,MAAMC,aAAa,IAAIJ,eAAeG,IAAIE,MAAM;QAChD,OAAO;YACL,GAAGF,GAAG;YACNG,cAAcF,WAAWG,SAAS,CAACJ,IAAIK,UAAU,EAAEL,IAAIM,UAAU;QACnE;IACF;AACF"}

package/dist/server/modules/translation-pipeline/stages/data-reconciler/DataReconciler.test.d.ts

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=DataReconciler.test.d.ts.map

package/dist/server/modules/translation-pipeline/stages/data-reconciler/DataReconciler.test.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"DataReconciler.test.d.ts","sourceRoot":"","sources":["../../../../../../src/server/modules/translation-pipeline/stages/data-reconciler/DataReconciler.test.ts"],"names":[],"mappings":""}

package/dist/server/modules/translation-pipeline/stages/data-reconciler/DataReconciler.test.js

@@ -0,0 +1,294 @@
+import { describe, it, expect } from 'vitest';
+import { DataReconciler } from './DataReconciler';
+describe('DataReconciler', () => {
+    describe('deep merge with target priority', () => {
+        it('uses target value when it exists', () => {
+            const schema = [{ name: 'title', type: 'text', localized: true }];
+            const sourceData = { title: 'Hello' };
+            const targetData = { title: 'Existing' };
+            const reconciler = new DataReconciler(schema);
+            expect(reconciler.reconcile(sourceData, targetData)).toEqual({ title: 'Existing' });
+        });
+        it('uses source value when target is empty', () => {
+            const schema = [{ name: 'title', type: 'text', localized: true }];
+            const sourceData = { title: 'Hello' };
+            const targetData = { title: '' };
+            const reconciler = new DataReconciler(schema);
+            expect(reconciler.reconcile(sourceData, targetData)).toEqual({ title: 'Hello' });
+        });
+        it('uses source value when target is missing', () => {
+            const schema = [{ name: 'title', type: 'text', localized: true }];
+            const sourceData = { title: 'Hello' };
+            const targetData = {};
+            const reconciler = new DataReconciler(schema);
+            expect(reconciler.reconcile(sourceData, targetData)).toEqual({ title: 'Hello' });
+        });
+        it('handles multiple fields independently', () => {
+            const schema = [
+                { name: 'title', type: 'text', localized: true },
+                { name: 'description', type: 'text', localized: true },
+                { name: 'slug', type: 'text', localized: false },
+            ];
+            const sourceData = { title: 'Hello', description: 'World', slug: 'hello' };
+            const targetData = { title: 'Translated Title', description: '', slug: 'other-slug' };
+            const reconciler = new DataReconciler(schema);
+            expect(reconciler.reconcile(sourceData, targetData)).toEqual({
+                title: 'Translated Title',
+                description: 'World',
+                slug: 'other-slug',
+            });
+        });
+        it('preserves full document shape', () => {
+            const schema = [
+                { name: 'title', type: 'text', localized: true },
+                { name: 'slug', type: 'text', localized: false },
+                { name: 'author', type: 'relationship', relationTo: 'users', localized: false },
+            ];
+            const sourceData = { title: 'Hello', slug: 'hello', author: '123' };
+            const targetData = {};
+            const reconciler = new DataReconciler(schema);
+            expect(reconciler.reconcile(sourceData, targetData)).toEqual({
+                title: 'Hello',
+                slug: 'hello',
+                author: '123',
+            });
+        });
+    });
+    describe('nested structures', () => {
+        it('reconciles group fields', () => {
+            const schema = [
+                {
+                    name: 'meta',
+                    type: 'group',
+                    fields: [
+                        { name: 'title', type: 'text', localized: true },
+                        { name: 'slug', type: 'text', localized: false },
+                    ],
+                },
+            ];
+            const sourceData = { meta: { title: 'Hello', slug: 'hello' } };
+            const targetData = { meta: { title: 'Existing', slug: '' } };
+            const reconciler = new DataReconciler(schema);
+            expect(reconciler.reconcile(sourceData, targetData)).toEqual({
+                meta: { title: 'Existing', slug: 'hello' },
+            });
+        });
+        it('reconciles array fields', () => {
+            const schema = [
+                {
+                    name: 'items',
+                    type: 'array',
+                    fields: [
+                        { name: 'label', type: 'text', localized: true },
+                        { name: 'value', type: 'text', localized: false },
+                    ],
+                },
+            ];
+            const sourceData = {
+                items: [
+                    { id: '1', label: 'First', value: 'one' },
+                    { id: '2', label: 'Second', value: 'two' },
+                ],
+            };
+            const targetData = {
+                items: [
+                    { id: '1', label: 'Translated', value: '' },
+                    { id: '2', label: '', value: 'y' },
+                ],
+            };
+            const reconciler = new DataReconciler(schema);
+            // Note: id is not included in result - Postgres rejects it on update
+            expect(reconciler.reconcile(sourceData, targetData)).toEqual({
+                items: [
+                    { label: 'Translated', value: 'one' },
+                    { label: 'Second', value: 'y' },
+                ],
+            });
+        });
+        it('reconciles blocks fields', () => {
+            const schema = [
+                {
+                    name: 'layout',
+                    type: 'blocks',
+                    blocks: [
+                        {
+                            slug: 'text',
+                            fields: [
+                                { name: 'content', type: 'text', localized: true },
+                                { name: 'style', type: 'text', localized: false },
+                            ],
+                        },
+                    ],
+                },
+            ];
+            const sourceData = {
+                layout: [{ id: '1', blockType: 'text', content: 'Hello', style: 'bold' }],
+            };
+            const targetData = {
+                layout: [{ id: '1', blockType: 'text', content: 'Existing', style: '' }],
+            };
+            const reconciler = new DataReconciler(schema);
+            // Note: id is not included in result - Postgres rejects it on update
+            expect(reconciler.reconcile(sourceData, targetData)).toEqual({
+                layout: [{ blockType: 'text', content: 'Existing', style: 'bold' }],
+            });
+        });
+        it('uses source for empty target in blocks', () => {
+            const schema = [
+                {
+                    name: 'layout',
+                    type: 'blocks',
+                    blocks: [
+                        {
+                            slug: 'text',
+                            fields: [{ name: 'content', type: 'text', localized: true }],
+                        },
+                    ],
+                },
+            ];
+            const sourceData = {
+                layout: [{ id: '1', blockType: 'text', content: 'Hello' }],
+            };
+            const targetData = {
+                layout: [{ id: '1', blockType: 'text', content: '' }],
+            };
+            const reconciler = new DataReconciler(schema);
+            // Note: id is not included in result - Postgres rejects it on update
+            expect(reconciler.reconcile(sourceData, targetData)).toEqual({
+                layout: [{ blockType: 'text', content: 'Hello' }],
+            });
+        });
+    });
+    describe('edge cases', () => {
+        it('handles null targetData', () => {
+            const schema = [{ name: 'title', type: 'text', localized: true }];
+            const sourceData = { title: 'Hello' };
+            const reconciler = new DataReconciler(schema);
+            expect(reconciler.reconcile(sourceData, null)).toEqual({
+                title: 'Hello',
+            });
+        });
+        it('skips undefined source values', () => {
+            const schema = [
+                { name: 'title', type: 'text', localized: true },
+                { name: 'description', type: 'text', localized: true },
+            ];
+            const sourceData = { title: 'Hello' };
+            const targetData = { title: 'Existing', description: 'Target desc' };
+            const reconciler = new DataReconciler(schema);
+            expect(reconciler.reconcile(sourceData, targetData)).toEqual({
+                title: 'Existing',
+            });
+        });
+    });
+    describe('tabs support', () => {
+        it('reconciles fields in named tabs', () => {
+            const schema = [
+                {
+                    type: 'tabs',
+                    tabs: [
+                        {
+                            name: 'seo',
+                            fields: [
+                                { name: 'title', type: 'text', localized: true },
+                                { name: 'description', type: 'text', localized: true },
+                            ],
+                        },
+                    ],
+                },
+            ];
+            const sourceData = { seo: { title: 'Hello', description: 'World' } };
+            const targetData = { seo: { title: 'Translated', description: '' } };
+            const reconciler = new DataReconciler(schema);
+            expect(reconciler.reconcile(sourceData, targetData)).toEqual({
+                seo: { title: 'Translated', description: 'World' },
+            });
+        });
+        it('reconciles fields in unnamed tabs', () => {
+            const schema = [
+                {
+                    type: 'tabs',
+                    tabs: [
+                        {
+                            label: 'Content',
+                            fields: [
+                                { name: 'title', type: 'text', localized: true },
+                                { name: 'body', type: 'text', localized: true },
+                            ],
+                        },
+                    ],
+                },
+            ];
+            const sourceData = { title: 'Hello', body: 'World' };
+            const targetData = { title: 'Translated', body: '' };
+            const reconciler = new DataReconciler(schema);
+            expect(reconciler.reconcile(sourceData, targetData)).toEqual({
+                title: 'Translated',
+                body: 'World',
+            });
+        });
+        it('reconciles multiple tabs with mixed named/unnamed', () => {
+            const schema = [
+                {
+                    type: 'tabs',
+                    tabs: [
+                        {
+                            label: 'Content',
+                            fields: [{ name: 'title', type: 'text', localized: true }],
+                        },
+                        {
+                            name: 'seo',
+                            fields: [{ name: 'metaTitle', type: 'text', localized: true }],
+                        },
+                    ],
+                },
+            ];
+            const sourceData = { title: 'Hello', seo: { metaTitle: 'SEO Title' } };
+            const targetData = { title: 'Translated', seo: { metaTitle: '' } };
+            const reconciler = new DataReconciler(schema);
+            expect(reconciler.reconcile(sourceData, targetData)).toEqual({
+                title: 'Translated',
+                seo: { metaTitle: 'SEO Title' },
+            });
+        });
+    });
+    describe('row and collapsible fields', () => {
+        it('reconciles fields in row', () => {
+            const schema = [
+                {
+                    type: 'row',
+                    fields: [
+                        { name: 'firstName', type: 'text', localized: true },
+                        { name: 'lastName', type: 'text', localized: true },
+                    ],
+                },
+            ];
+            const sourceData = { firstName: 'John', lastName: 'Doe' };
+            const targetData = { firstName: 'Johann', lastName: '' };
+            const reconciler = new DataReconciler(schema);
+            expect(reconciler.reconcile(sourceData, targetData)).toEqual({
+                firstName: 'Johann',
+                lastName: 'Doe',
+            });
+        });
+        it('reconciles fields in collapsible', () => {
+            const schema = [
+                {
+                    type: 'collapsible',
+                    label: 'Advanced',
+                    fields: [
+                        { name: 'seoTitle', type: 'text', localized: true },
+                        { name: 'seoDescription', type: 'text', localized: true },
+                    ],
+                },
+            ];
+            const sourceData = { seoTitle: 'Title', seoDescription: 'Description' };
+            const targetData = { seoTitle: 'Translated', seoDescription: '' };
+            const reconciler = new DataReconciler(schema);
+            expect(reconciler.reconcile(sourceData, targetData)).toEqual({
+                seoTitle: 'Translated',
+                seoDescription: 'Description',
+            });
+        });
+    });
+});

package/dist/server/modules/translation-pipeline/stages/data-reconciler/index.d.ts

@@ -0,0 +1,3 @@
+export { DataReconciler } from './DataReconciler';
+export { DataReconcilerStage } from './DataReconciler.stage';
+//# sourceMappingURL=index.d.ts.map

package/dist/server/modules/translation-pipeline/stages/data-reconciler/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../../../src/server/modules/translation-pipeline/stages/data-reconciler/index.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,cAAc,EAAE,MAAM,kBAAkB,CAAA;AACjD,OAAO,EAAE,mBAAmB,EAAE,MAAM,wBAAwB,CAAA"}

package/dist/server/modules/translation-pipeline/stages/data-reconciler/index.js

@@ -0,0 +1,4 @@
+export { DataReconciler } from './DataReconciler';
+export { DataReconcilerStage } from './DataReconciler.stage';
+
+//# sourceMappingURL=index.js.map

package/dist/server/modules/translation-pipeline/stages/data-reconciler/index.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../../../src/server/modules/translation-pipeline/stages/data-reconciler/index.ts"],"sourcesContent":["export { DataReconciler } from './DataReconciler'\nexport { DataReconcilerStage } from './DataReconciler.stage'\n"],"names":["DataReconciler","DataReconcilerStage"],"mappings":"AAAA,SAASA,cAAc,QAAQ,mBAAkB;AACjD,SAASC,mBAAmB,QAAQ,yBAAwB"}

package/dist/server/modules/translation-pipeline/stages/field-collector/FieldChunkCollector.d.ts

@@ -0,0 +1,35 @@
+import type { Field } from 'payload';
+import type { FieldChunk } from '../../types';
+import type { TranslationStrategy } from '../../strategies';
+/**
+ * Collects FieldChunks by traversing schema and data in parallel.
+ * Each chunk contains a reference to the parent data object for later mutation.
+ *
+ * Applies all filtering logic:
+ * - isTranslatableField
+ * - isLocalizedField
+ * - strategy.shouldTranslate(sourceValue, targetValue)
+ * - !isFieldExcludedFromTranslation
+ *
+ * IMPORTANT: Expects ORIGINAL collection schemas (before Payload sanitization).
+ * Original schemas preserve `localized: true` on nested fields.
+ */
+export declare class FieldChunkCollector {
+    private readonly schema;
+    private readonly filteredData;
+    private readonly sourceData;
+    private readonly targetData;
+    private readonly strategy;
+    private chunks;
+    constructor(schema: Field[], filteredData: Record<string, unknown>, sourceData: Record<string, unknown>, targetData: Record<string, unknown>, strategy: TranslationStrategy);
+    /**
+     * Collects translatable field chunks that need translation.
+     */
+    collect(): FieldChunk[];
+    /**
+     * Traverses fields recursively, collecting translatable fields that need translation.
+     * Uses strategy.shouldTranslate() to determine if field needs translation.
+     */
+    private traverseFields;
+}
+//# sourceMappingURL=FieldChunkCollector.d.ts.map

package/dist/server/modules/translation-pipeline/stages/field-collector/FieldChunkCollector.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"FieldChunkCollector.d.ts","sourceRoot":"","sources":["../../../../../../src/server/modules/translation-pipeline/stages/field-collector/FieldChunkCollector.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,SAAS,CAAA;AAYpC,OAAO,KAAK,EAAE,UAAU,EAAE,MAAM,aAAa,CAAA;AAC7C,OAAO,KAAK,EAAE,mBAAmB,EAAE,MAAM,kBAAkB,CAAA;AAE3D;;;;;;;;;;;;GAYG;AACH,qBAAa,mBAAmB;IAI5B,OAAO,CAAC,QAAQ,CAAC,MAAM;IACvB,OAAO,CAAC,QAAQ,CAAC,YAAY;IAC7B,OAAO,CAAC,QAAQ,CAAC,UAAU;IAC3B,OAAO,CAAC,QAAQ,CAAC,UAAU;IAC3B,OAAO,CAAC,QAAQ,CAAC,QAAQ;IAP3B,OAAO,CAAC,MAAM,CAAmB;gBAGd,MAAM,EAAE,KAAK,EAAE,EACf,YAAY,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EACrC,UAAU,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EACnC,UAAU,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EACnC,QAAQ,EAAE,mBAAmB;IAGhD;;OAEG;IACH,OAAO,IAAI,UAAU,EAAE;IAMvB;;;OAGG;IACH,OAAO,CAAC,cAAc;CAiGvB"}

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

@@ -0,0 +1,128 @@
+import { fieldAffectsData, fieldIsArrayType, fieldIsBlockType, fieldIsGroupType, tabHasName } from 'payload/shared';
+import { hasFields, isBlockItem, isLocalizedField, isObject, isTabsField, isTranslatableField, isFieldExcludedFromTranslation } from '../../../../shared';
+/**
+ * Collects FieldChunks by traversing schema and data in parallel.
+ * Each chunk contains a reference to the parent data object for later mutation.
+ *
+ * Applies all filtering logic:
+ * - isTranslatableField
+ * - isLocalizedField
+ * - strategy.shouldTranslate(sourceValue, targetValue)
+ * - !isFieldExcludedFromTranslation
+ *
+ * IMPORTANT: Expects ORIGINAL collection schemas (before Payload sanitization).
+ * Original schemas preserve `localized: true` on nested fields.
+ */ export class FieldChunkCollector {
+    schema;
+    filteredData;
+    sourceData;
+    targetData;
+    strategy;
+    chunks = [];
+    constructor(schema, filteredData, sourceData, targetData, strategy){
+        this.schema = schema;
+        this.filteredData = filteredData;
+        this.sourceData = sourceData;
+        this.targetData = targetData;
+        this.strategy = strategy;
+    }
+    /**
+   * Collects translatable field chunks that need translation.
+   */ collect() {
+        this.chunks = [];
+        this.traverseFields(this.schema, this.filteredData, this.sourceData, this.targetData, []);
+        return this.chunks;
+    }
+    /**
+   * Traverses fields recursively, collecting translatable fields that need translation.
+   * Uses strategy.shouldTranslate() to determine if field needs translation.
+   */ traverseFields(fields, data, source, target, path) {
+        for (const field of fields){
+            if (isTabsField(field)) {
+                for (const tab of field.tabs){
+                    if (hasFields(tab)) {
+                        if (tabHasName(tab)) {
+                            const tabData = data[tab.name];
+                            const tabSource = source[tab.name];
+                            const tabTarget = target[tab.name];
+                            if (isObject(tabData)) {
+                                this.traverseFields(tab.fields, tabData, isObject(tabSource) ? tabSource : {}, isObject(tabTarget) ? tabTarget : {}, [
+                                    ...path,
+                                    tab.name
+                                ]);
+                            }
+                        } else {
+                            this.traverseFields(tab.fields, data, source, target, path);
+                        }
+                    }
+                }
+                continue;
+            }
+            if (!fieldAffectsData(field)) {
+                if (hasFields(field)) this.traverseFields(field.fields, data, source, target, path);
+                continue;
+            }
+            const value = data[field.name];
+            const sourceValue = source[field.name];
+            const targetValue = target[field.name];
+            if (value === undefined || value === null) continue;
+            const currentPath = [
+                ...path,
+                field.name
+            ];
+            if (fieldIsGroupType(field) && isObject(value)) {
+                this.traverseFields(field.fields, value, isObject(sourceValue) ? sourceValue : {}, isObject(targetValue) ? targetValue : {}, currentPath);
+                continue;
+            }
+            if (fieldIsArrayType(field) && Array.isArray(value)) {
+                const sourceArray = Array.isArray(sourceValue) ? sourceValue : [];
+                const targetArray = Array.isArray(targetValue) ? targetValue : [];
+                value.forEach((item, index)=>{
+                    if (isObject(item)) {
+                        const sourceItem = isObject(sourceArray[index]) ? sourceArray[index] : {};
+                        const targetItem = isObject(targetArray[index]) ? targetArray[index] : {};
+                        this.traverseFields(field.fields, item, sourceItem, targetItem, [
+                            ...currentPath,
+                            String(index)
+                        ]);
+                    }
+                });
+                continue;
+            }
+            if (fieldIsBlockType(field) && Array.isArray(value)) {
+                const sourceArray = Array.isArray(sourceValue) ? sourceValue : [];
+                const targetArray = Array.isArray(targetValue) ? targetValue : [];
+                value.forEach((item, index)=>{
+                    if (isBlockItem(item)) {
+                        const block = field.blocks.find((b)=>b.slug === item.blockType);
+                        if (block) {
+                            const sourceItem = isObject(sourceArray[index]) ? sourceArray[index] : {};
+                            const targetItem = isObject(targetArray[index]) ? targetArray[index] : {};
+                            this.traverseFields(block.fields, item, sourceItem, targetItem, [
+                                ...currentPath,
+                                String(index)
+                            ]);
+                        }
+                    }
+                });
+                continue;
+            }
+            // Collect if: translatable, localized, not excluded, and strategy says to translate
+            if (isTranslatableField(field) && isLocalizedField(field) && !isFieldExcludedFromTranslation(field) && this.strategy.shouldTranslate({
+                sourceValue,
+                targetValue
+            })) {
+                // Write sourceValue to filteredData — this is what will be translated
+                data[field.name] = sourceValue;
+                this.chunks.push({
+                    schema: field,
+                    dataRef: data,
+                    key: field.name,
+                    path: currentPath
+                });
+            }
+        }
+    }
+}
+
+//# sourceMappingURL=FieldChunkCollector.js.map