@focus-reactive/payload-plugin-translator 0.1.0

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

@@ -0,0 +1,262 @@
+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

@@ -0,0 +1,11 @@
+import type { Field } from 'payload';
+/**
+ * Filters data to keep only translatable localized fields.
+ * For container fields (group, array, blocks) recursively filters nested data.
+ *
+ * @param schema - Payload field schema (original, not sanitized)
+ * @param data - Document data to filter
+ * @returns Filtered data containing only translatable localized fields
+ */
+export declare function filterLocalizedFields(schema: Field[], data: Record<string, unknown>): Record<string, unknown>;
+//# sourceMappingURL=filterLocalizedFields.d.ts.map

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

@@ -0,0 +1 @@
+{"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

@@ -0,0 +1,72 @@
+import { fieldAffectsData, fieldIsArrayType, fieldIsBlockType, fieldIsGroupType } from 'payload/shared';
+import { hasFields, isBlockItem, isLocalizedField, isTabsField, isTranslatableField } from '../guards';
+import { isObject } from './isObject';
+import { isEmpty } from './isEmpty';
+/**
+ * Filters data to keep only translatable localized fields.
+ * For container fields (group, array, blocks) recursively filters nested data.
+ *
+ * @param schema - Payload field schema (original, not sanitized)
+ * @param data - Document data to filter
+ * @returns Filtered data containing only translatable localized fields
+ */ export function filterLocalizedFields(schema, data) {
+    const result = {};
+    for (const field of schema){
+        if (isTabsField(field)) {
+            for (const tab of field.tabs){
+                if (hasFields(tab)) Object.assign(result, filterLocalizedFields(tab.fields, data));
+            }
+            continue;
+        }
+        if (!fieldAffectsData(field)) {
+            if (hasFields(field)) Object.assign(result, filterLocalizedFields(field.fields, data));
+            continue;
+        }
+        const value = data[field.name];
+        if (value === undefined) continue;
+        if (fieldIsGroupType(field) && isObject(value)) {
+            const filtered = filterLocalizedFields(field.fields, value);
+            if (!isEmpty(filtered)) result[field.name] = filtered;
+            continue;
+        }
+        if (fieldIsArrayType(field) && Array.isArray(value)) {
+            const filteredArray = value.map((item)=>{
+                if (isObject(item)) {
+                    const filtered = filterLocalizedFields(field.fields, item);
+                    if (!isEmpty(filtered)) return {
+                        ...filtered,
+                        id: item.id
+                    };
+                }
+                return null;
+            }).filter(Boolean);
+            if (!isEmpty(filteredArray)) result[field.name] = filteredArray;
+            continue;
+        }
+        if (fieldIsBlockType(field) && Array.isArray(value)) {
+            const filteredBlocks = value.map((item)=>{
+                if (isBlockItem(item)) {
+                    const block = field.blocks.find((b)=>b.slug === item.blockType);
+                    if (block) {
+                        const filtered = filterLocalizedFields(block.fields, item);
+                        if (!isEmpty(filtered)) return {
+                            ...filtered,
+                            blockType: item.blockType,
+                            id: item.id
+                        };
+                    }
+                }
+                return null;
+            }).filter(Boolean);
+            if (!isEmpty(filteredBlocks)) result[field.name] = filteredBlocks;
+            continue;
+        }
+        if (isTranslatableField(field) && isLocalizedField(field)) {
+            result[field.name] = value;
+            continue;
+        }
+    }
+    return result;
+}
+
+//# sourceMappingURL=filterLocalizedFields.js.map

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

@@ -0,0 +1 @@
+{"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

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

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

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