@focus-reactive/payload-plugin-translator 0.1.0 → 0.1.2

package/dist/server/shared/utils/LazyMap.test.js

@@ -1,262 +0,0 @@
-import { describe, it, expect, vi, beforeEach, afterEach } from 'vitest';
-import { LazyMap } from './LazyMap';
-const createEntry = (id, status = 'completed', updatedAt = Date.now()) => ({
-    id,
-    status,
-    updatedAt,
-});
-const defaultOptions = {
-    isRemovable: (entry) => entry.status === 'completed' || entry.status === 'failed',
-    getTimestamp: (entry) => entry.updatedAt,
-};
-describe('LazyMap', () => {
-    beforeEach(() => {
-        vi.useFakeTimers();
-    });
-    afterEach(() => {
-        vi.useRealTimers();
-    });
-    describe('basic Map operations', () => {
-        it('sets and gets values', () => {
-            const map = new LazyMap(defaultOptions);
-            const entry = createEntry('1');
-            map.set('key1', entry);
-            expect(map.get('key1')).toBe(entry);
-        });
-        it('returns undefined for non-existent keys', () => {
-            const map = new LazyMap(defaultOptions);
-            expect(map.get('non-existent')).toBeUndefined();
-        });
-        it('deletes values', () => {
-            const map = new LazyMap(defaultOptions);
-            map.set('key1', createEntry('1'));
-            const result = map.delete('key1');
-            expect(result).toBe(true);
-            expect(map.get('key1')).toBeUndefined();
-        });
-        it('returns false when deleting non-existent key', () => {
-            const map = new LazyMap(defaultOptions);
-            expect(map.delete('non-existent')).toBe(false);
-        });
-        it('checks if key exists with has()', () => {
-            const map = new LazyMap(defaultOptions);
-            map.set('key1', createEntry('1'));
-            expect(map.has('key1')).toBe(true);
-            expect(map.has('key2')).toBe(false);
-        });
-        it('returns correct size', () => {
-            const map = new LazyMap(defaultOptions);
-            expect(map.size).toBe(0);
-            map.set('key1', createEntry('1'));
-            expect(map.size).toBe(1);
-            map.set('key2', createEntry('2'));
-            expect(map.size).toBe(2);
-        });
-        it('iterates over values()', () => {
-            const map = new LazyMap(defaultOptions);
-            const entry1 = createEntry('1');
-            const entry2 = createEntry('2');
-            map.set('key1', entry1);
-            map.set('key2', entry2);
-            const values = [...map.values()];
-            expect(values).toEqual([entry1, entry2]);
-        });
-        it('iterates over entries()', () => {
-            const map = new LazyMap(defaultOptions);
-            const entry1 = createEntry('1');
-            const entry2 = createEntry('2');
-            map.set('key1', entry1);
-            map.set('key2', entry2);
-            const entries = [...map.entries()];
-            expect(entries).toEqual([
-                ['key1', entry1],
-                ['key2', entry2],
-            ]);
-        });
-        it('supports for...of iteration', () => {
-            const map = new LazyMap(defaultOptions);
-            const entry1 = createEntry('1');
-            const entry2 = createEntry('2');
-            map.set('key1', entry1);
-            map.set('key2', entry2);
-            const entries = [];
-            for (const entry of map) {
-                entries.push(entry);
-            }
-            expect(entries).toEqual([
-                ['key1', entry1],
-                ['key2', entry2],
-            ]);
-        });
-    });
-    describe('TTL cleanup', () => {
-        it('removes expired removable entries on set()', () => {
-            const map = new LazyMap({
-                ...defaultOptions,
-                ttlMs: 1000, // 1 second
-            });
-            const now = Date.now();
-            map.set('old', createEntry('old', 'completed', now));
-            vi.advanceTimersByTime(1500); // 1.5 seconds later
-            map.set('new', createEntry('new', 'completed', Date.now()));
-            expect(map.has('old')).toBe(false);
-            expect(map.has('new')).toBe(true);
-        });
-        it('does not remove non-removable entries even if expired', () => {
-            const map = new LazyMap({
-                ...defaultOptions,
-                ttlMs: 1000,
-            });
-            const now = Date.now();
-            map.set('running', createEntry('running', 'running', now));
-            vi.advanceTimersByTime(1500);
-            map.set('new', createEntry('new', 'completed', Date.now()));
-            expect(map.has('running')).toBe(true); // Still there because status is 'running'
-        });
-        it('does not remove entries within TTL', () => {
-            const map = new LazyMap({
-                ...defaultOptions,
-                ttlMs: 1000,
-            });
-            const now = Date.now();
-            map.set('recent', createEntry('recent', 'completed', now));
-            vi.advanceTimersByTime(500); // Only 0.5 seconds
-            map.set('new', createEntry('new', 'completed', Date.now()));
-            expect(map.has('recent')).toBe(true);
-        });
-        it('skips TTL cleanup when ttlMs is Infinity', () => {
-            const map = new LazyMap({
-                ...defaultOptions,
-                // ttlMs defaults to Infinity
-            });
-            const oldTime = Date.now();
-            map.set('old', createEntry('old', 'completed', oldTime));
-            vi.advanceTimersByTime(1000 * 60 * 60 * 24); // 1 day later
-            map.set('new', createEntry('new', 'completed', Date.now()));
-            expect(map.has('old')).toBe(true); // Still there
-        });
-    });
-    describe('maxSize cleanup', () => {
-        it('removes oldest removable entries when exceeding maxSize', () => {
-            const map = new LazyMap({
-                ...defaultOptions,
-                maxSize: 2,
-            });
-            const now = Date.now();
-            map.set('entry1', createEntry('1', 'completed', now));
-            map.set('entry2', createEntry('2', 'completed', now + 100));
-            map.set('entry3', createEntry('3', 'completed', now + 200));
-            expect(map.size).toBe(2);
-            expect(map.has('entry1')).toBe(false); // Oldest removed
-            expect(map.has('entry2')).toBe(true);
-            expect(map.has('entry3')).toBe(true);
-        });
-        it('removes multiple entries to reach maxSize', () => {
-            const map = new LazyMap({
-                ...defaultOptions,
-                maxSize: 1,
-            });
-            const now = Date.now();
-            map.set('entry1', createEntry('1', 'completed', now));
-            map.set('entry2', createEntry('2', 'completed', now + 100));
-            map.set('entry3', createEntry('3', 'completed', now + 200));
-            expect(map.size).toBe(1);
-            expect(map.has('entry3')).toBe(true);
-        });
-        it('does not remove non-removable entries', () => {
-            const map = new LazyMap({
-                ...defaultOptions,
-                maxSize: 2,
-            });
-            const now = Date.now();
-            map.set('running1', createEntry('r1', 'running', now));
-            map.set('running2', createEntry('r2', 'running', now + 100));
-            map.set('running3', createEntry('r3', 'running', now + 200));
-            // All 3 entries remain because running entries cannot be removed
-            expect(map.size).toBe(3);
-            expect(map.has('running1')).toBe(true);
-            expect(map.has('running2')).toBe(true);
-            expect(map.has('running3')).toBe(true);
-        });
-        it('removes removable entries first, keeping non-removable', () => {
-            const map = new LazyMap({
-                ...defaultOptions,
-                maxSize: 2,
-            });
-            const now = Date.now();
-            map.set('completed1', createEntry('c1', 'completed', now));
-            map.set('running', createEntry('r1', 'running', now + 100));
-            map.set('completed2', createEntry('c2', 'completed', now + 200));
-            expect(map.size).toBe(2);
-            expect(map.has('completed1')).toBe(false); // Oldest removable removed
-            expect(map.has('running')).toBe(true); // Non-removable kept
-            expect(map.has('completed2')).toBe(true);
-        });
-    });
-    describe('combined TTL and maxSize', () => {
-        it('applies both TTL and maxSize cleanup', () => {
-            const map = new LazyMap({
-                ...defaultOptions,
-                maxSize: 3,
-                ttlMs: 1000,
-            });
-            const now = Date.now();
-            map.set('expired1', createEntry('e1', 'completed', now));
-            map.set('expired2', createEntry('e2', 'completed', now));
-            vi.advanceTimersByTime(1500);
-            const laterNow = Date.now();
-            map.set('recent1', createEntry('r1', 'completed', laterNow));
-            map.set('recent2', createEntry('r2', 'completed', laterNow + 100));
-            map.set('recent3', createEntry('r3', 'completed', laterNow + 200));
-            // Expired entries removed by TTL, then maxSize enforced
-            expect(map.has('expired1')).toBe(false);
-            expect(map.has('expired2')).toBe(false);
-            expect(map.size).toBe(3);
-        });
-    });
-    describe('edge cases', () => {
-        it('handles empty map', () => {
-            const map = new LazyMap({
-                ...defaultOptions,
-                maxSize: 5,
-                ttlMs: 1000,
-            });
-            expect(map.size).toBe(0);
-            expect([...map.values()]).toEqual([]);
-        });
-        it('handles maxSize of 0', () => {
-            const map = new LazyMap({
-                ...defaultOptions,
-                maxSize: 0,
-            });
-            map.set('key1', createEntry('1', 'completed', Date.now()));
-            // Entry is removed immediately because maxSize is 0
-            expect(map.size).toBe(0);
-        });
-        it('overwrites existing key without affecting count', () => {
-            const map = new LazyMap({
-                ...defaultOptions,
-                maxSize: 2,
-            });
-            const now = Date.now();
-            map.set('key1', createEntry('1', 'completed', now));
-            map.set('key2', createEntry('2', 'completed', now + 100));
-            // Overwrite key1
-            map.set('key1', createEntry('1-updated', 'completed', now + 200));
-            expect(map.size).toBe(2);
-            expect(map.get('key1')?.id).toBe('1-updated');
-        });
-        it('handles failed status as removable', () => {
-            const map = new LazyMap({
-                ...defaultOptions,
-                maxSize: 1,
-            });
-            const now = Date.now();
-            map.set('failed', createEntry('f1', 'failed', now));
-            map.set('new', createEntry('n1', 'completed', now + 100));
-            expect(map.size).toBe(1);
-            expect(map.has('failed')).toBe(false);
-            expect(map.has('new')).toBe(true);
-        });
-    });
-});

package/dist/server/shared/utils/filterLocalizedFields.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"filterLocalizedFields.d.ts","sourceRoot":"","sources":["../../../../src/server/shared/utils/filterLocalizedFields.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,KAAK,EAAE,MAAM,SAAS,CAAA;AAOpC;;;;;;;GAOG;AACH,wBAAgB,qBAAqB,CAAC,MAAM,EAAE,KAAK,EAAE,EAAE,IAAI,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,GAAG,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,CAiE7G"}

package/dist/server/shared/utils/filterLocalizedFields.js.map

@@ -1 +0,0 @@
-{"version":3,"sources":["../../../../src/server/shared/utils/filterLocalizedFields.ts"],"sourcesContent":["import type { Field } from 'payload'\nimport { fieldAffectsData, fieldIsArrayType, fieldIsBlockType, fieldIsGroupType } from 'payload/shared'\n\nimport { hasFields, isBlockItem, isLocalizedField, isTabsField, isTranslatableField } from '../guards'\nimport { isObject } from './isObject'\nimport { isEmpty } from './isEmpty'\n\n/**\n * Filters data to keep only translatable localized fields.\n * For container fields (group, array, blocks) recursively filters nested data.\n *\n * @param schema - Payload field schema (original, not sanitized)\n * @param data - Document data to filter\n * @returns Filtered data containing only translatable localized fields\n */\nexport function filterLocalizedFields(schema: Field[], data: Record<string, unknown>): Record<string, unknown> {\n  const result: Record<string, unknown> = {}\n\n  for (const field of schema) {\n    if (isTabsField(field)) {\n      for (const tab of field.tabs) {\n        if (hasFields(tab)) Object.assign(result, filterLocalizedFields(tab.fields, data))\n      }\n      continue\n    }\n\n    if (!fieldAffectsData(field)) {\n      if (hasFields(field)) Object.assign(result, filterLocalizedFields(field.fields, data))\n      continue\n    }\n\n    const value = data[field.name]\n    if (value === undefined) continue\n\n    if (fieldIsGroupType(field) && isObject(value)) {\n      const filtered = filterLocalizedFields(field.fields, value)\n      if (!isEmpty(filtered)) result[field.name] = filtered\n      continue\n    }\n\n    if (fieldIsArrayType(field) && Array.isArray(value)) {\n      const filteredArray = value\n        .map((item) => {\n          if (isObject(item)) {\n            const filtered = filterLocalizedFields(field.fields, item)\n            if (!isEmpty(filtered)) return { ...filtered, id: item.id }\n          }\n          return null\n        })\n        .filter(Boolean)\n\n      if (!isEmpty(filteredArray)) result[field.name] = filteredArray\n      continue\n    }\n\n    if (fieldIsBlockType(field) && Array.isArray(value)) {\n      const filteredBlocks = value\n        .map((item) => {\n          if (isBlockItem(item)) {\n            const block = field.blocks.find((b) => b.slug === item.blockType)\n            if (block) {\n              const filtered = filterLocalizedFields(block.fields, item)\n              if (!isEmpty(filtered)) return { ...filtered, blockType: item.blockType, id: item.id }\n            }\n          }\n          return null\n        })\n        .filter(Boolean)\n\n      if (!isEmpty(filteredBlocks)) result[field.name] = filteredBlocks\n      continue\n    }\n\n    if (isTranslatableField(field) && isLocalizedField(field)) {\n      result[field.name] = value\n      continue\n    }\n  }\n\n  return result\n}\n"],"names":["fieldAffectsData","fieldIsArrayType","fieldIsBlockType","fieldIsGroupType","hasFields","isBlockItem","isLocalizedField","isTabsField","isTranslatableField","isObject","isEmpty","filterLocalizedFields","schema","data","result","field","tab","tabs","Object","assign","fields","value","name","undefined","filtered","Array","isArray","filteredArray","map","item","id","filter","Boolean","filteredBlocks","block","blocks","find","b","slug","blockType"],"mappings":"AACA,SAASA,gBAAgB,EAAEC,gBAAgB,EAAEC,gBAAgB,EAAEC,gBAAgB,QAAQ,iBAAgB;AAEvG,SAASC,SAAS,EAAEC,WAAW,EAAEC,gBAAgB,EAAEC,WAAW,EAAEC,mBAAmB,QAAQ,YAAW;AACtG,SAASC,QAAQ,QAAQ,aAAY;AACrC,SAASC,OAAO,QAAQ,YAAW;AAEnC;;;;;;;CAOC,GACD,OAAO,SAASC,sBAAsBC,MAAe,EAAEC,IAA6B;IAClF,MAAMC,SAAkC,CAAC;IAEzC,KAAK,MAAMC,SAASH,OAAQ;QAC1B,IAAIL,YAAYQ,QAAQ;YACtB,KAAK,MAAMC,OAAOD,MAAME,IAAI,CAAE;gBAC5B,IAAIb,UAAUY,MAAME,OAAOC,MAAM,CAACL,QAAQH,sBAAsBK,IAAII,MAAM,EAAEP;YAC9E;YACA;QACF;QAEA,IAAI,CAACb,iBAAiBe,QAAQ;YAC5B,IAAIX,UAAUW,QAAQG,OAAOC,MAAM,CAACL,QAAQH,sBAAsBI,MAAMK,MAAM,EAAEP;YAChF;QACF;QAEA,MAAMQ,QAAQR,IAAI,CAACE,MAAMO,IAAI,CAAC;QAC9B,IAAID,UAAUE,WAAW;QAEzB,IAAIpB,iBAAiBY,UAAUN,SAASY,QAAQ;YAC9C,MAAMG,WAAWb,sBAAsBI,MAAMK,MAAM,EAAEC;YACrD,IAAI,CAACX,QAAQc,WAAWV,MAAM,CAACC,MAAMO,IAAI,CAAC,GAAGE;YAC7C;QACF;QAEA,IAAIvB,iBAAiBc,UAAUU,MAAMC,OAAO,CAACL,QAAQ;YACnD,MAAMM,gBAAgBN,MACnBO,GAAG,CAAC,CAACC;gBACJ,IAAIpB,SAASoB,OAAO;oBAClB,MAAML,WAAWb,sBAAsBI,MAAMK,MAAM,EAAES;oBACrD,IAAI,CAACnB,QAAQc,WAAW,OAAO;wBAAE,GAAGA,QAAQ;wBAAEM,IAAID,KAAKC,EAAE;oBAAC;gBAC5D;gBACA,OAAO;YACT,GACCC,MAAM,CAACC;YAEV,IAAI,CAACtB,QAAQiB,gBAAgBb,MAAM,CAACC,MAAMO,IAAI,CAAC,GAAGK;YAClD;QACF;QAEA,IAAIzB,iBAAiBa,UAAUU,MAAMC,OAAO,CAACL,QAAQ;YACnD,MAAMY,iBAAiBZ,MACpBO,GAAG,CAAC,CAACC;gBACJ,IAAIxB,YAAYwB,OAAO;oBACrB,MAAMK,QAAQnB,MAAMoB,MAAM,CAACC,IAAI,CAAC,CAACC,IAAMA,EAAEC,IAAI,KAAKT,KAAKU,SAAS;oBAChE,IAAIL,OAAO;wBACT,MAAMV,WAAWb,sBAAsBuB,MAAMd,MAAM,EAAES;wBACrD,IAAI,CAACnB,QAAQc,WAAW,OAAO;4BAAE,GAAGA,QAAQ;4BAAEe,WAAWV,KAAKU,SAAS;4BAAET,IAAID,KAAKC,EAAE;wBAAC;oBACvF;gBACF;gBACA,OAAO;YACT,GACCC,MAAM,CAACC;YAEV,IAAI,CAACtB,QAAQuB,iBAAiBnB,MAAM,CAACC,MAAMO,IAAI,CAAC,GAAGW;YACnD;QACF;QAEA,IAAIzB,oBAAoBO,UAAUT,iBAAiBS,QAAQ;YACzDD,MAAM,CAACC,MAAMO,IAAI,CAAC,GAAGD;YACrB;QACF;IACF;IAEA,OAAOP;AACT"}

package/dist/server/shared/utils/filterLocalizedFields.test.d.ts

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

package/dist/server/shared/utils/filterLocalizedFields.test.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"filterLocalizedFields.test.d.ts","sourceRoot":"","sources":["../../../../src/server/shared/utils/filterLocalizedFields.test.ts"],"names":[],"mappings":""}

package/dist/server/shared/utils/filterLocalizedFields.test.js

@@ -1,338 +0,0 @@
-import { describe, expect, it } from 'vitest';
-import { filterLocalizedFields } from './filterLocalizedFields';
-describe('filterLocalizedFields', () => {
-    describe('simple fields', () => {
-        it('should keep localized text field', () => {
-            const schema = [{ name: 'title', type: 'text', localized: true }];
-            const data = { title: 'Hello', other: 'World' };
-            const result = filterLocalizedFields(schema, data);
-            expect(result).toEqual({ title: 'Hello' });
-        });
-        it('should filter out non-localized text field', () => {
-            const schema = [{ name: 'slug', type: 'text' }];
-            const data = { slug: 'hello-world' };
-            const result = filterLocalizedFields(schema, data);
-            expect(result).toEqual({});
-        });
-        it('should handle mixed localized and non-localized fields', () => {
-            const schema = [
-                { name: 'title', type: 'text', localized: true },
-                { name: 'slug', type: 'text' },
-                { name: 'description', type: 'textarea', localized: true },
-            ];
-            const data = { title: 'Hello', slug: 'hello', description: 'World' };
-            const result = filterLocalizedFields(schema, data);
-            expect(result).toEqual({ title: 'Hello', description: 'World' });
-        });
-        it('should skip undefined values', () => {
-            const schema = [{ name: 'title', type: 'text', localized: true }];
-            const data = {};
-            const result = filterLocalizedFields(schema, data);
-            expect(result).toEqual({});
-        });
-    });
-    describe('group fields', () => {
-        it('should recursively filter group with localized nested field', () => {
-            const schema = [
-                {
-                    name: 'seo',
-                    type: 'group',
-                    fields: [
-                        { name: 'title', type: 'text', localized: true },
-                        { name: 'canonical', type: 'text' },
-                    ],
-                },
-            ];
-            const data = { seo: { title: 'SEO Title', canonical: '/page' } };
-            const result = filterLocalizedFields(schema, data);
-            expect(result).toEqual({ seo: { title: 'SEO Title' } });
-        });
-        it('should exclude group if no localized fields inside', () => {
-            const schema = [
-                {
-                    name: 'settings',
-                    type: 'group',
-                    fields: [{ name: 'enabled', type: 'checkbox' }],
-                },
-            ];
-            const data = { settings: { enabled: true } };
-            const result = filterLocalizedFields(schema, data);
-            expect(result).toEqual({});
-        });
-    });
-    describe('array fields', () => {
-        it('should recursively filter array items', () => {
-            const schema = [
-                {
-                    name: 'items',
-                    type: 'array',
-                    fields: [
-                        { name: 'text', type: 'text', localized: true },
-                        { name: 'order', type: 'number' },
-                    ],
-                },
-            ];
-            const data = {
-                items: [
-                    { id: '1', text: 'First', order: 1 },
-                    { id: '2', text: 'Second', order: 2 },
-                ],
-            };
-            const result = filterLocalizedFields(schema, data);
-            expect(result).toEqual({
-                items: [
-                    { id: '1', text: 'First' },
-                    { id: '2', text: 'Second' },
-                ],
-            });
-        });
-        it('should exclude array if no localized fields inside items', () => {
-            const schema = [
-                {
-                    name: 'tags',
-                    type: 'array',
-                    fields: [{ name: 'name', type: 'text' }],
-                },
-            ];
-            const data = { tags: [{ id: '1', name: 'tag1' }] };
-            const result = filterLocalizedFields(schema, data);
-            expect(result).toEqual({});
-        });
-    });
-    describe('blocks fields', () => {
-        it('should recursively filter blocks with blockType and id preserved', () => {
-            const schema = [
-                {
-                    name: 'content',
-                    type: 'blocks',
-                    blocks: [
-                        {
-                            slug: 'text',
-                            fields: [
-                                { name: 'body', type: 'richText', localized: true },
-                                { name: 'alignment', type: 'select', options: ['left', 'center'] },
-                            ],
-                        },
-                    ],
-                },
-            ];
-            const data = {
-                content: [{ id: 'block1', blockType: 'text', body: { root: {} }, alignment: 'center' }],
-            };
-            const result = filterLocalizedFields(schema, data);
-            expect(result).toEqual({
-                content: [{ id: 'block1', blockType: 'text', body: { root: {} } }],
-            });
-        });
-        it('should handle multiple block types', () => {
-            const schema = [
-                {
-                    name: 'content',
-                    type: 'blocks',
-                    blocks: [
-                        {
-                            slug: 'heading',
-                            fields: [{ name: 'title', type: 'text', localized: true }],
-                        },
-                        {
-                            slug: 'image',
-                            fields: [{ name: 'alt', type: 'text', localized: true }],
-                        },
-                    ],
-                },
-            ];
-            const data = {
-                content: [
-                    { id: '1', blockType: 'heading', title: 'Hello' },
-                    { id: '2', blockType: 'image', alt: 'Image alt' },
-                ],
-            };
-            const result = filterLocalizedFields(schema, data);
-            expect(result).toEqual({
-                content: [
-                    { id: '1', blockType: 'heading', title: 'Hello' },
-                    { id: '2', blockType: 'image', alt: 'Image alt' },
-                ],
-            });
-        });
-    });
-    describe('tabs fields', () => {
-        it('should process tabs as flat fields', () => {
-            const schema = [
-                {
-                    type: 'tabs',
-                    tabs: [
-                        {
-                            label: 'Content',
-                            fields: [{ name: 'title', type: 'text', localized: true }],
-                        },
-                        {
-                            label: 'Settings',
-                            fields: [{ name: 'slug', type: 'text' }],
-                        },
-                    ],
-                },
-            ];
-            const data = { title: 'Hello', slug: 'hello' };
-            const result = filterLocalizedFields(schema, data);
-            expect(result).toEqual({ title: 'Hello' });
-        });
-    });
-    describe('row/collapsible fields', () => {
-        it('should process row fields as flat', () => {
-            const schema = [
-                {
-                    type: 'row',
-                    fields: [
-                        { name: 'firstName', type: 'text', localized: true },
-                        { name: 'lastName', type: 'text', localized: true },
-                    ],
-                },
-            ];
-            const data = { firstName: 'John', lastName: 'Doe' };
-            const result = filterLocalizedFields(schema, data);
-            expect(result).toEqual({ firstName: 'John', lastName: 'Doe' });
-        });
-        it('should process collapsible fields', () => {
-            const schema = [
-                {
-                    type: 'collapsible',
-                    label: 'Advanced',
-                    fields: [{ name: 'meta', type: 'text', localized: true }],
-                },
-            ];
-            const data = { meta: 'Some meta' };
-            const result = filterLocalizedFields(schema, data);
-            expect(result).toEqual({ meta: 'Some meta' });
-        });
-    });
-    describe('non-translatable fields', () => {
-        it('should filter out localized number field', () => {
-            const schema = [{ name: 'count', type: 'number', localized: true }];
-            const data = { count: 42 };
-            const result = filterLocalizedFields(schema, data);
-            expect(result).toEqual({});
-        });
-        it('should filter out localized checkbox field', () => {
-            const schema = [{ name: 'enabled', type: 'checkbox', localized: true }];
-            const data = { enabled: true };
-            const result = filterLocalizedFields(schema, data);
-            expect(result).toEqual({});
-        });
-        it('should filter out localized select field', () => {
-            const schema = [{ name: 'status', type: 'select', options: ['draft', 'published'], localized: true }];
-            const data = { status: 'draft' };
-            const result = filterLocalizedFields(schema, data);
-            expect(result).toEqual({});
-        });
-        it('should filter out localized json field', () => {
-            const schema = [{ name: 'metadata', type: 'json', localized: true }];
-            const data = { metadata: { key: 'value' } };
-            const result = filterLocalizedFields(schema, data);
-            expect(result).toEqual({});
-        });
-        it('should filter out localized code field', () => {
-            const schema = [{ name: 'snippet', type: 'code', localized: true }];
-            const data = { snippet: 'const x = 1' };
-            const result = filterLocalizedFields(schema, data);
-            expect(result).toEqual({});
-        });
-        it('should filter out localized point field', () => {
-            const schema = [{ name: 'location', type: 'point', localized: true }];
-            const data = { location: [0, 0] };
-            const result = filterLocalizedFields(schema, data);
-            expect(result).toEqual({});
-        });
-        it('should filter out localized relationship field', () => {
-            const schema = [{ name: 'author', type: 'relationship', relationTo: 'users', localized: true }];
-            const data = { author: '123' };
-            const result = filterLocalizedFields(schema, data);
-            expect(result).toEqual({});
-        });
-        it('should filter out localized upload field', () => {
-            const schema = [{ name: 'image', type: 'upload', relationTo: 'media', localized: true }];
-            const data = { image: '456' };
-            const result = filterLocalizedFields(schema, data);
-            expect(result).toEqual({});
-        });
-        it('should filter out localized date field', () => {
-            const schema = [{ name: 'publishedAt', type: 'date', localized: true }];
-            const data = { publishedAt: '2024-01-01' };
-            const result = filterLocalizedFields(schema, data);
-            expect(result).toEqual({});
-        });
-        it('should filter out localized email field', () => {
-            const schema = [{ name: 'contact', type: 'email', localized: true }];
-            const data = { contact: 'test@example.com' };
-            const result = filterLocalizedFields(schema, data);
-            expect(result).toEqual({});
-        });
-        it('should keep translatable fields while filtering non-translatable', () => {
-            const schema = [
-                { name: 'title', type: 'text', localized: true },
-                { name: 'count', type: 'number', localized: true },
-                { name: 'description', type: 'textarea', localized: true },
-                { name: 'status', type: 'select', options: ['a', 'b'], localized: true },
-                { name: 'body', type: 'richText', localized: true },
-            ];
-            const data = {
-                title: 'Hello',
-                count: 42,
-                description: 'World',
-                status: 'a',
-                body: { root: {} },
-            };
-            const result = filterLocalizedFields(schema, data);
-            expect(result).toEqual({
-                title: 'Hello',
-                description: 'World',
-                body: { root: {} },
-            });
-        });
-    });
-    describe('nested structures', () => {
-        it('should handle deeply nested localized fields', () => {
-            const schema = [
-                {
-                    name: 'sections',
-                    type: 'array',
-                    fields: [
-                        {
-                            name: 'content',
-                            type: 'blocks',
-                            blocks: [
-                                {
-                                    slug: 'text',
-                                    fields: [
-                                        {
-                                            name: 'wrapper',
-                                            type: 'group',
-                                            fields: [{ name: 'body', type: 'richText', localized: true }],
-                                        },
-                                    ],
-                                },
-                            ],
-                        },
-                    ],
-                },
-            ];
-            const data = {
-                sections: [
-                    {
-                        id: 's1',
-                        content: [{ id: 'b1', blockType: 'text', wrapper: { body: { root: {} } } }],
-                    },
-                ],
-            };
-            const result = filterLocalizedFields(schema, data);
-            expect(result).toEqual({
-                sections: [
-                    {
-                        id: 's1',
-                        content: [{ id: 'b1', blockType: 'text', wrapper: { body: { root: {} } } }],
-                    },
-                ],
-            });
-        });
-    });
-});

package/dist/server/shared/utils/getByPath.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"getByPath.d.ts","sourceRoot":"","sources":["../../../../src/server/shared/utils/getByPath.ts"],"names":[],"mappings":"AAEA;;;;;;GAMG;AACH,wBAAgB,SAAS,CAAC,GAAG,EAAE,MAAM,CAAC,MAAM,EAAE,OAAO,CAAC,EAAE,IAAI,EAAE,MAAM,GAAG,OAAO,CAU7E"}

package/dist/server/shared/utils/getByPath.js.map

@@ -1 +0,0 @@
-{"version":3,"sources":["../../../../src/server/shared/utils/getByPath.ts"],"sourcesContent":["import { isObject } from './isObject'\n\n/**\n * Gets a value from an object by dot-notation path.\n *\n * @example\n * getByPath({ a: { b: 1 } }, 'a.b') // 1\n * getByPath({ arr: [{ x: 1 }] }, 'arr.0.x') // 1\n */\nexport function getByPath(obj: Record<string, unknown>, path: string): unknown {\n  const keys = path.split('.')\n  let current: unknown = obj\n\n  for (const key of keys) {\n    if (!isObject(current)) return undefined\n    current = current[key]\n  }\n\n  return current\n}\n"],"names":["isObject","getByPath","obj","path","keys","split","current","key","undefined"],"mappings":"AAAA,SAASA,QAAQ,QAAQ,aAAY;AAErC;;;;;;CAMC,GACD,OAAO,SAASC,UAAUC,GAA4B,EAAEC,IAAY;IAClE,MAAMC,OAAOD,KAAKE,KAAK,CAAC;IACxB,IAAIC,UAAmBJ;IAEvB,KAAK,MAAMK,OAAOH,KAAM;QACtB,IAAI,CAACJ,SAASM,UAAU,OAAOE;QAC/BF,UAAUA,OAAO,CAACC,IAAI;IACxB;IAEA,OAAOD;AACT"}

package/dist/server/shared/utils/getByPath.test.d.ts

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

package/dist/server/shared/utils/getByPath.test.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"getByPath.test.d.ts","sourceRoot":"","sources":["../../../../src/server/shared/utils/getByPath.test.ts"],"names":[],"mappings":""}