@focus-reactive/payload-plugin-translator 0.1.0

package/dist/server/shared/lexical/isEmptyRichText.test.js

@@ -0,0 +1,251 @@
+import { describe, it, expect } from 'vitest';
+import { isEmptyRichText } from './isEmptyRichText';
+const createRichText = (root) => ({ root });
+describe('isEmptyRichText', () => {
+    describe('empty cases', () => {
+        it('returns true for empty root with no children', () => {
+            const value = createRichText({
+                type: 'root',
+                children: [],
+            });
+            expect(isEmptyRichText(value)).toBe(true);
+        });
+        it('returns true for root with empty paragraph', () => {
+            const value = createRichText({
+                type: 'root',
+                children: [
+                    {
+                        type: 'paragraph',
+                        children: [],
+                    },
+                ],
+            });
+            expect(isEmptyRichText(value)).toBe(true);
+        });
+        it('returns true for paragraph with empty text node', () => {
+            const value = createRichText({
+                type: 'root',
+                children: [
+                    {
+                        type: 'paragraph',
+                        children: [
+                            {
+                                type: 'text',
+                                text: '',
+                            },
+                        ],
+                    },
+                ],
+            });
+            expect(isEmptyRichText(value)).toBe(true);
+        });
+        it('returns true for paragraph with whitespace-only text', () => {
+            const value = createRichText({
+                type: 'root',
+                children: [
+                    {
+                        type: 'paragraph',
+                        children: [
+                            {
+                                type: 'text',
+                                text: '   \n\t  ',
+                            },
+                        ],
+                    },
+                ],
+            });
+            expect(isEmptyRichText(value)).toBe(true);
+        });
+        it('returns true for multiple empty paragraphs', () => {
+            const value = createRichText({
+                type: 'root',
+                children: [
+                    { type: 'paragraph', children: [] },
+                    { type: 'paragraph', children: [{ type: 'text', text: '' }] },
+                    { type: 'paragraph', children: [{ type: 'text', text: '  ' }] },
+                ],
+            });
+            expect(isEmptyRichText(value)).toBe(true);
+        });
+    });
+    describe('non-empty cases - text content', () => {
+        it('returns false for paragraph with text content', () => {
+            const value = createRichText({
+                type: 'root',
+                children: [
+                    {
+                        type: 'paragraph',
+                        children: [
+                            {
+                                type: 'text',
+                                text: 'Hello world',
+                            },
+                        ],
+                    },
+                ],
+            });
+            expect(isEmptyRichText(value)).toBe(false);
+        });
+        it('returns false for text with leading/trailing whitespace', () => {
+            const value = createRichText({
+                type: 'root',
+                children: [
+                    {
+                        type: 'paragraph',
+                        children: [
+                            {
+                                type: 'text',
+                                text: '  content  ',
+                            },
+                        ],
+                    },
+                ],
+            });
+            expect(isEmptyRichText(value)).toBe(false);
+        });
+        it('returns false for multiple text nodes with one having content', () => {
+            const value = createRichText({
+                type: 'root',
+                children: [
+                    {
+                        type: 'paragraph',
+                        children: [
+                            { type: 'text', text: '' },
+                            { type: 'text', text: 'content' },
+                            { type: 'text', text: '' },
+                        ],
+                    },
+                ],
+            });
+            expect(isEmptyRichText(value)).toBe(false);
+        });
+    });
+    describe('non-empty cases - structural nodes', () => {
+        it('returns false for heading node', () => {
+            const value = createRichText({
+                type: 'root',
+                children: [
+                    {
+                        type: 'heading',
+                        tag: 'h1',
+                        children: [],
+                    },
+                ],
+            });
+            expect(isEmptyRichText(value)).toBe(false);
+        });
+        it('returns false for upload node', () => {
+            const value = createRichText({
+                type: 'root',
+                children: [
+                    {
+                        type: 'upload',
+                        relationTo: 'media',
+                        value: { id: '123' },
+                    },
+                ],
+            });
+            expect(isEmptyRichText(value)).toBe(false);
+        });
+        it('returns false for block node', () => {
+            const value = createRichText({
+                type: 'root',
+                children: [
+                    {
+                        type: 'block',
+                        blockType: 'cta',
+                        fields: {},
+                    },
+                ],
+            });
+            expect(isEmptyRichText(value)).toBe(false);
+        });
+        it('returns false for relationship node', () => {
+            const value = createRichText({
+                type: 'root',
+                children: [
+                    {
+                        type: 'relationship',
+                        relationTo: 'posts',
+                        value: { id: '456' },
+                    },
+                ],
+            });
+            expect(isEmptyRichText(value)).toBe(false);
+        });
+        it('returns false for list node', () => {
+            const value = createRichText({
+                type: 'root',
+                children: [
+                    {
+                        type: 'list',
+                        listType: 'bullet',
+                        children: [],
+                    },
+                ],
+            });
+            expect(isEmptyRichText(value)).toBe(false);
+        });
+        it('returns false for quote node', () => {
+            const value = createRichText({
+                type: 'root',
+                children: [
+                    {
+                        type: 'quote',
+                        children: [],
+                    },
+                ],
+            });
+            expect(isEmptyRichText(value)).toBe(false);
+        });
+        it('returns false for link node nested in paragraph', () => {
+            const value = createRichText({
+                type: 'root',
+                children: [
+                    {
+                        type: 'paragraph',
+                        children: [
+                            {
+                                type: 'link',
+                                url: 'https://example.com',
+                                children: [],
+                            },
+                        ],
+                    },
+                ],
+            });
+            expect(isEmptyRichText(value)).toBe(false);
+        });
+    });
+    describe('early exit optimization', () => {
+        it('stops traversal on first content found', () => {
+            const value = createRichText({
+                type: 'root',
+                children: [
+                    {
+                        type: 'paragraph',
+                        children: [
+                            { type: 'text', text: 'content' },
+                            { type: 'text', text: 'more content' },
+                        ],
+                    },
+                    {
+                        type: 'paragraph',
+                        children: [{ type: 'text', text: 'even more' }],
+                    },
+                ],
+            });
+            expect(isEmptyRichText(value)).toBe(false);
+        });
+        it('stops traversal on first structural node', () => {
+            const value = createRichText({
+                type: 'root',
+                children: [
+                    { type: 'heading', tag: 'h1', children: [] },
+                    { type: 'paragraph', children: [{ type: 'text', text: '' }] },
+                ],
+            });
+            expect(isEmptyRichText(value)).toBe(false);
+        });
+    });
+});

package/dist/server/shared/lexical/traverseLexicalTree.d.ts

@@ -0,0 +1,11 @@
+import type { SerializedLexicalNode } from './types';
+/**
+ * Traverses serialized Lexical tree depth-first and calls visitor for each node.
+ * Stops early if visitor returns false.
+ *
+ * @param node - The serialized Lexical node to traverse
+ * @param visitor - Callback for each node. Return false to stop traversal.
+ * @returns false if traversal was stopped early, true otherwise
+ */
+export declare function traverseLexicalTree(node: SerializedLexicalNode, visitor: (node: SerializedLexicalNode) => boolean | void): boolean;
+//# sourceMappingURL=traverseLexicalTree.d.ts.map

package/dist/server/shared/lexical/traverseLexicalTree.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"traverseLexicalTree.d.ts","sourceRoot":"","sources":["../../../../src/server/shared/lexical/traverseLexicalTree.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,qBAAqB,EAAE,MAAM,SAAS,CAAA;AAGpD;;;;;;;GAOG;AACH,wBAAgB,mBAAmB,CACjC,IAAI,EAAE,qBAAqB,EAC3B,OAAO,EAAE,CAAC,IAAI,EAAE,qBAAqB,KAAK,OAAO,GAAG,IAAI,GACvD,OAAO,CAST"}

package/dist/server/shared/lexical/traverseLexicalTree.js

@@ -0,0 +1,19 @@
+import { hasChildren } from './guards';
+/**
+ * Traverses serialized Lexical tree depth-first and calls visitor for each node.
+ * Stops early if visitor returns false.
+ *
+ * @param node - The serialized Lexical node to traverse
+ * @param visitor - Callback for each node. Return false to stop traversal.
+ * @returns false if traversal was stopped early, true otherwise
+ */ export function traverseLexicalTree(node, visitor) {
+    if (visitor(node) === false) return false;
+    if (hasChildren(node)) {
+        for (const child of node.children){
+            if (traverseLexicalTree(child, visitor) === false) return false;
+        }
+    }
+    return true;
+}
+
+//# sourceMappingURL=traverseLexicalTree.js.map

package/dist/server/shared/lexical/traverseLexicalTree.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../src/server/shared/lexical/traverseLexicalTree.ts"],"sourcesContent":["import type { SerializedLexicalNode } from './types'\nimport { hasChildren } from './guards'\n\n/**\n * Traverses serialized Lexical tree depth-first and calls visitor for each node.\n * Stops early if visitor returns false.\n *\n * @param node - The serialized Lexical node to traverse\n * @param visitor - Callback for each node. Return false to stop traversal.\n * @returns false if traversal was stopped early, true otherwise\n */\nexport function traverseLexicalTree(\n  node: SerializedLexicalNode,\n  visitor: (node: SerializedLexicalNode) => boolean | void,\n): boolean {\n  if (visitor(node) === false) return false\n\n  if (hasChildren(node)) {\n    for (const child of node.children) {\n      if (traverseLexicalTree(child, visitor) === false) return false\n    }\n  }\n  return true\n}\n"],"names":["hasChildren","traverseLexicalTree","node","visitor","child","children"],"mappings":"AACA,SAASA,WAAW,QAAQ,WAAU;AAEtC;;;;;;;CAOC,GACD,OAAO,SAASC,oBACdC,IAA2B,EAC3BC,OAAwD;IAExD,IAAIA,QAAQD,UAAU,OAAO,OAAO;IAEpC,IAAIF,YAAYE,OAAO;QACrB,KAAK,MAAME,SAASF,KAAKG,QAAQ,CAAE;YACjC,IAAIJ,oBAAoBG,OAAOD,aAAa,OAAO,OAAO;QAC5D;IACF;IACA,OAAO;AACT"}

package/dist/server/shared/lexical/traverseLexicalTree.test.d.ts

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

package/dist/server/shared/lexical/traverseLexicalTree.test.d.ts.map

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

package/dist/server/shared/lexical/traverseLexicalTree.test.js

@@ -0,0 +1,112 @@
+import { describe, it, expect, vi } from 'vitest';
+import { traverseLexicalTree } from './traverseLexicalTree';
+const createNode = (type, children) => ({ type, ...(children && { children }) });
+describe('traverseLexicalTree', () => {
+    describe('traversal order', () => {
+        it('visits all nodes depth-first', () => {
+            const visited = [];
+            const root = createNode('root', [
+                createNode('paragraph', [createNode('text'), createNode('text')]),
+                createNode('paragraph', [createNode('text')]),
+            ]);
+            traverseLexicalTree(root, (node) => {
+                visited.push(node.type);
+            });
+            expect(visited).toEqual(['root', 'paragraph', 'text', 'text', 'paragraph', 'text']);
+        });
+        it('visits root node first', () => {
+            const visited = [];
+            const root = createNode('root', [createNode('paragraph')]);
+            traverseLexicalTree(root, (node) => {
+                visited.push(node.type);
+            });
+            expect(visited[0]).toBe('root');
+        });
+    });
+    describe('early exit', () => {
+        it('stops traversal when visitor returns false', () => {
+            const visited = [];
+            const root = createNode('root', [
+                createNode('paragraph', [createNode('text'), createNode('text')]),
+                createNode('paragraph', [createNode('text')]),
+            ]);
+            const result = traverseLexicalTree(root, (node) => {
+                visited.push(node.type);
+                if (node.type === 'text')
+                    return false;
+            });
+            expect(result).toBe(false);
+            expect(visited).toEqual(['root', 'paragraph', 'text']);
+        });
+        it('returns true when traversal completes without stopping', () => {
+            const root = createNode('root', [createNode('paragraph')]);
+            const result = traverseLexicalTree(root, () => { });
+            expect(result).toBe(true);
+        });
+        it('stops at root if visitor returns false immediately', () => {
+            const visited = [];
+            const root = createNode('root', [createNode('paragraph')]);
+            const result = traverseLexicalTree(root, (node) => {
+                visited.push(node.type);
+                return false;
+            });
+            expect(result).toBe(false);
+            expect(visited).toEqual(['root']);
+        });
+    });
+    describe('edge cases', () => {
+        it('handles nodes without children property', () => {
+            const visited = [];
+            const node = { type: 'text', text: 'hello' };
+            traverseLexicalTree(node, (n) => {
+                visited.push(n.type);
+            });
+            expect(visited).toEqual(['text']);
+        });
+        it('handles empty children array', () => {
+            const visited = [];
+            const root = createNode('root', []);
+            traverseLexicalTree(root, (node) => {
+                visited.push(node.type);
+            });
+            expect(visited).toEqual(['root']);
+        });
+        it('handles deeply nested structures', () => {
+            const visited = [];
+            const root = createNode('root', [
+                createNode('list', [createNode('listitem', [createNode('paragraph', [createNode('text')])])]),
+            ]);
+            traverseLexicalTree(root, (node) => {
+                visited.push(node.type);
+            });
+            expect(visited).toEqual(['root', 'list', 'listitem', 'paragraph', 'text']);
+        });
+        it('handles single node without children', () => {
+            const visitor = vi.fn();
+            const node = createNode('text');
+            traverseLexicalTree(node, visitor);
+            expect(visitor).toHaveBeenCalledTimes(1);
+            expect(visitor).toHaveBeenCalledWith(node);
+        });
+    });
+    describe('visitor behavior', () => {
+        it('continues traversal when visitor returns undefined', () => {
+            const visited = [];
+            const root = createNode('root', [createNode('paragraph')]);
+            traverseLexicalTree(root, (node) => {
+                visited.push(node.type);
+                return undefined;
+            });
+            expect(visited).toEqual(['root', 'paragraph']);
+        });
+        it('continues traversal when visitor returns true', () => {
+            const visited = [];
+            const root = createNode('root', [createNode('paragraph')]);
+            traverseLexicalTree(root, (node) => {
+                visited.push(node.type);
+                return true;
+            });
+            expect(visited).toEqual(['root', 'paragraph']);
+        });
+    });
+});

package/dist/server/shared/lexical/types.d.ts

@@ -0,0 +1,20 @@
+/**
+ * Re-exports serialized Lexical types from 'lexical' package.
+ * These types represent the JSON structure stored in the database.
+ */
+import type { SerializedLexicalNode, SerializedTextNode, SerializedRootNode } from '@payloadcms/richtext-lexical/lexical';
+export type { SerializedLexicalNode, SerializedTextNode, SerializedRootNode };
+/**
+ * Serialized Lexical root structure as stored in Payload CMS richText fields.
+ * Wraps the root node in a { root: ... } object.
+ */
+export type SerializedLexicalRoot = {
+    root: SerializedLexicalNode;
+};
+/**
+ * Reference to a serialized text node for mutation during translation.
+ */
+export type SerializedTextNodeRef = {
+    node: SerializedTextNode;
+};
+//# sourceMappingURL=types.d.ts.map

package/dist/server/shared/lexical/types.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"types.d.ts","sourceRoot":"","sources":["../../../../src/server/shared/lexical/types.ts"],"names":[],"mappings":"AAAA;;;GAGG;AACH,OAAO,KAAK,EACV,qBAAqB,EACrB,kBAAkB,EAClB,kBAAkB,EACnB,MAAM,sCAAsC,CAAA;AAE7C,YAAY,EAAE,qBAAqB,EAAE,kBAAkB,EAAE,kBAAkB,EAAE,CAAA;AAE7E;;;GAGG;AACH,MAAM,MAAM,qBAAqB,GAAG;IAClC,IAAI,EAAE,qBAAqB,CAAA;CAC5B,CAAA;AAED;;GAEG;AACH,MAAM,MAAM,qBAAqB,GAAG;IAClC,IAAI,EAAE,kBAAkB,CAAA;CACzB,CAAA"}

package/dist/server/shared/lexical/types.js

@@ -0,0 +1,8 @@
+/**
+ * Re-exports serialized Lexical types from 'lexical' package.
+ * These types represent the JSON structure stored in the database.
+ */ /**
+ * Reference to a serialized text node for mutation during translation.
+ */ export { };
+
+//# sourceMappingURL=types.js.map

package/dist/server/shared/lexical/types.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../src/server/shared/lexical/types.ts"],"sourcesContent":["/**\n * Re-exports serialized Lexical types from 'lexical' package.\n * These types represent the JSON structure stored in the database.\n */\nimport type {\n  SerializedLexicalNode,\n  SerializedTextNode,\n  SerializedRootNode,\n} from '@payloadcms/richtext-lexical/lexical'\n\nexport type { SerializedLexicalNode, SerializedTextNode, SerializedRootNode }\n\n/**\n * Serialized Lexical root structure as stored in Payload CMS richText fields.\n * Wraps the root node in a { root: ... } object.\n */\nexport type SerializedLexicalRoot = {\n  root: SerializedLexicalNode\n}\n\n/**\n * Reference to a serialized text node for mutation during translation.\n */\nexport type SerializedTextNodeRef = {\n  node: SerializedTextNode\n}\n"],"names":[],"mappings":"AAAA;;;CAGC,GAiBD;;CAEC,GACD,WAEC"}

package/dist/server/shared/utils/LazyMap.d.ts

@@ -0,0 +1,71 @@
+/**
+ * Options for LazyMap configuration.
+ */
+export type LazyMapOptions<V> = {
+    /**
+     * Maximum number of entries to keep in the map.
+     * When exceeded, oldest removable entries are deleted.
+     * @default Infinity
+     */
+    maxSize?: number;
+    /**
+     * Time-to-live for removable entries in milliseconds.
+     * Expired entries are removed lazily during set operations.
+     * @default Infinity
+     */
+    ttlMs?: number;
+    /**
+     * Predicate to determine which entries can be removed during cleanup.
+     * Returns true if the entry is eligible for removal.
+     */
+    isRemovable: (value: V) => boolean;
+    /**
+     * Function to extract timestamp from a value for age calculation.
+     * Used for TTL expiration and oldest-first removal.
+     */
+    getTimestamp: (value: V) => number;
+};
+/**
+ * A Map wrapper with lazy cleanup capabilities.
+ *
+ * Automatically removes expired and excess entries during set operations.
+ * Uses lazy cleanup pattern (no timers) - cleanup runs only when needed.
+ *
+ * @example
+ * ```typescript
+ * const tasks = new LazyMap<string, Task>({
+ *   maxSize: 100,
+ *   ttlMs: 60 * 60 * 1000, // 1 hour
+ *   isRemovable: (task) => task.status === 'completed' || task.status === 'failed',
+ *   getTimestamp: (task) => new Date(task.updatedAt).getTime(),
+ * })
+ *
+ * tasks.set('task-1', task) // Cleanup runs automatically
+ * ```
+ */
+export declare class LazyMap<K, V> {
+    private readonly map;
+    private readonly maxSize;
+    private readonly ttlMs;
+    private readonly isRemovable;
+    private readonly getTimestamp;
+    constructor(options: LazyMapOptions<V>);
+    /**
+     * Sets a key-value pair, triggering cleanup after.
+     */
+    set(key: K, value: V): void;
+    get(key: K): V | undefined;
+    delete(key: K): boolean;
+    has(key: K): boolean;
+    values(): IterableIterator<V>;
+    entries(): IterableIterator<[K, V]>;
+    [Symbol.iterator](): IterableIterator<[K, V]>;
+    get size(): number;
+    /**
+     * Remove expired entries and enforce maxSize limit.
+     * Called automatically during set() operations.
+     */
+    private cleanup;
+    private findOldestRemovableKey;
+}
+//# sourceMappingURL=LazyMap.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"LazyMap.d.ts","sourceRoot":"","sources":["../../../../src/server/shared/utils/LazyMap.ts"],"names":[],"mappings":"AAAA;;GAEG;AACH,MAAM,MAAM,cAAc,CAAC,CAAC,IAAI;IAC9B;;;;OAIG;IACH,OAAO,CAAC,EAAE,MAAM,CAAA;IAChB;;;;OAIG;IACH,KAAK,CAAC,EAAE,MAAM,CAAA;IACd;;;OAGG;IACH,WAAW,EAAE,CAAC,KAAK,EAAE,CAAC,KAAK,OAAO,CAAA;IAClC;;;OAGG;IACH,YAAY,EAAE,CAAC,KAAK,EAAE,CAAC,KAAK,MAAM,CAAA;CACnC,CAAA;AAED;;;;;;;;;;;;;;;;;GAiBG;AACH,qBAAa,OAAO,CAAC,CAAC,EAAE,CAAC;IACvB,OAAO,CAAC,QAAQ,CAAC,GAAG,CAAkB;IACtC,OAAO,CAAC,QAAQ,CAAC,OAAO,CAAQ;IAChC,OAAO,CAAC,QAAQ,CAAC,KAAK,CAAQ;IAC9B,OAAO,CAAC,QAAQ,CAAC,WAAW,CAAuB;IACnD,OAAO,CAAC,QAAQ,CAAC,YAAY,CAAsB;gBAEvC,OAAO,EAAE,cAAc,CAAC,CAAC,CAAC;IAOtC;;OAEG;IACH,GAAG,CAAC,GAAG,EAAE,CAAC,EAAE,KAAK,EAAE,CAAC,GAAG,IAAI;IAK3B,GAAG,CAAC,GAAG,EAAE,CAAC,GAAG,CAAC,GAAG,SAAS;IAI1B,MAAM,CAAC,GAAG,EAAE,CAAC,GAAG,OAAO;IAIvB,GAAG,CAAC,GAAG,EAAE,CAAC,GAAG,OAAO;IAIpB,MAAM,IAAI,gBAAgB,CAAC,CAAC,CAAC;IAI7B,OAAO,IAAI,gBAAgB,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC;IAInC,CAAC,MAAM,CAAC,QAAQ,CAAC,IAAI,gBAAgB,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC;IAI7C,IAAI,IAAI,IAAI,MAAM,CAEjB;IAED;;;OAGG;IACH,OAAO,CAAC,OAAO;IAqBf,OAAO,CAAC,sBAAsB;CAe/B"}

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

@@ -0,0 +1,95 @@
+/**
+ * Options for LazyMap configuration.
+ */ /**
+ * A Map wrapper with lazy cleanup capabilities.
+ *
+ * Automatically removes expired and excess entries during set operations.
+ * Uses lazy cleanup pattern (no timers) - cleanup runs only when needed.
+ *
+ * @example
+ * ```typescript
+ * const tasks = new LazyMap<string, Task>({
+ *   maxSize: 100,
+ *   ttlMs: 60 * 60 * 1000, // 1 hour
+ *   isRemovable: (task) => task.status === 'completed' || task.status === 'failed',
+ *   getTimestamp: (task) => new Date(task.updatedAt).getTime(),
+ * })
+ *
+ * tasks.set('task-1', task) // Cleanup runs automatically
+ * ```
+ */ export class LazyMap {
+    map = new Map();
+    maxSize;
+    ttlMs;
+    isRemovable;
+    getTimestamp;
+    constructor(options){
+        this.maxSize = options.maxSize ?? Infinity;
+        this.ttlMs = options.ttlMs ?? Infinity;
+        this.isRemovable = options.isRemovable;
+        this.getTimestamp = options.getTimestamp;
+    }
+    /**
+   * Sets a key-value pair, triggering cleanup after.
+   */ set(key, value) {
+        this.map.set(key, value);
+        this.cleanup();
+    }
+    get(key) {
+        return this.map.get(key);
+    }
+    delete(key) {
+        return this.map.delete(key);
+    }
+    has(key) {
+        return this.map.has(key);
+    }
+    values() {
+        return this.map.values();
+    }
+    entries() {
+        return this.map.entries();
+    }
+    [Symbol.iterator]() {
+        return this.map[Symbol.iterator]();
+    }
+    get size() {
+        return this.map.size;
+    }
+    /**
+   * Remove expired entries and enforce maxSize limit.
+   * Called automatically during set() operations.
+   */ cleanup() {
+        const now = Date.now();
+        // 1. Remove expired entries
+        if (this.ttlMs !== Infinity) {
+            for (const [key, value] of this.map){
+                if (!this.isRemovable(value)) continue;
+                if (now - this.getTimestamp(value) > this.ttlMs) {
+                    this.map.delete(key);
+                }
+            }
+        }
+        // 2. Enforce maxSize by removing oldest removable entries
+        while(this.map.size > this.maxSize){
+            const oldestKey = this.findOldestRemovableKey();
+            if (!oldestKey) break; // Only non-removable entries left
+            this.map.delete(oldestKey);
+        }
+    }
+    findOldestRemovableKey() {
+        let oldestKey;
+        let oldestTime = Infinity;
+        for (const [key, value] of this.map){
+            if (!this.isRemovable(value)) continue;
+            const timestamp = this.getTimestamp(value);
+            if (timestamp < oldestTime) {
+                oldestTime = timestamp;
+                oldestKey = key;
+            }
+        }
+        return oldestKey;
+    }
+}
+
+//# sourceMappingURL=LazyMap.js.map

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

@@ -0,0 +1 @@
+{"version":3,"sources":["../../../../src/server/shared/utils/LazyMap.ts"],"sourcesContent":["/**\n * Options for LazyMap configuration.\n */\nexport type LazyMapOptions<V> = {\n  /**\n   * Maximum number of entries to keep in the map.\n   * When exceeded, oldest removable entries are deleted.\n   * @default Infinity\n   */\n  maxSize?: number\n  /**\n   * Time-to-live for removable entries in milliseconds.\n   * Expired entries are removed lazily during set operations.\n   * @default Infinity\n   */\n  ttlMs?: number\n  /**\n   * Predicate to determine which entries can be removed during cleanup.\n   * Returns true if the entry is eligible for removal.\n   */\n  isRemovable: (value: V) => boolean\n  /**\n   * Function to extract timestamp from a value for age calculation.\n   * Used for TTL expiration and oldest-first removal.\n   */\n  getTimestamp: (value: V) => number\n}\n\n/**\n * A Map wrapper with lazy cleanup capabilities.\n *\n * Automatically removes expired and excess entries during set operations.\n * Uses lazy cleanup pattern (no timers) - cleanup runs only when needed.\n *\n * @example\n * ```typescript\n * const tasks = new LazyMap<string, Task>({\n *   maxSize: 100,\n *   ttlMs: 60 * 60 * 1000, // 1 hour\n *   isRemovable: (task) => task.status === 'completed' || task.status === 'failed',\n *   getTimestamp: (task) => new Date(task.updatedAt).getTime(),\n * })\n *\n * tasks.set('task-1', task) // Cleanup runs automatically\n * ```\n */\nexport class LazyMap<K, V> {\n  private readonly map = new Map<K, V>()\n  private readonly maxSize: number\n  private readonly ttlMs: number\n  private readonly isRemovable: (value: V) => boolean\n  private readonly getTimestamp: (value: V) => number\n\n  constructor(options: LazyMapOptions<V>) {\n    this.maxSize = options.maxSize ?? Infinity\n    this.ttlMs = options.ttlMs ?? Infinity\n    this.isRemovable = options.isRemovable\n    this.getTimestamp = options.getTimestamp\n  }\n\n  /**\n   * Sets a key-value pair, triggering cleanup after.\n   */\n  set(key: K, value: V): void {\n    this.map.set(key, value)\n    this.cleanup()\n  }\n\n  get(key: K): V | undefined {\n    return this.map.get(key)\n  }\n\n  delete(key: K): boolean {\n    return this.map.delete(key)\n  }\n\n  has(key: K): boolean {\n    return this.map.has(key)\n  }\n\n  values(): IterableIterator<V> {\n    return this.map.values()\n  }\n\n  entries(): IterableIterator<[K, V]> {\n    return this.map.entries()\n  }\n\n  [Symbol.iterator](): IterableIterator<[K, V]> {\n    return this.map[Symbol.iterator]()\n  }\n\n  get size(): number {\n    return this.map.size\n  }\n\n  /**\n   * Remove expired entries and enforce maxSize limit.\n   * Called automatically during set() operations.\n   */\n  private cleanup(): void {\n    const now = Date.now()\n\n    // 1. Remove expired entries\n    if (this.ttlMs !== Infinity) {\n      for (const [key, value] of this.map) {\n        if (!this.isRemovable(value)) continue\n        if (now - this.getTimestamp(value) > this.ttlMs) {\n          this.map.delete(key)\n        }\n      }\n    }\n\n    // 2. Enforce maxSize by removing oldest removable entries\n    while (this.map.size > this.maxSize) {\n      const oldestKey = this.findOldestRemovableKey()\n      if (!oldestKey) break // Only non-removable entries left\n      this.map.delete(oldestKey)\n    }\n  }\n\n  private findOldestRemovableKey(): K | undefined {\n    let oldestKey: K | undefined\n    let oldestTime = Infinity\n\n    for (const [key, value] of this.map) {\n      if (!this.isRemovable(value)) continue\n      const timestamp = this.getTimestamp(value)\n      if (timestamp < oldestTime) {\n        oldestTime = timestamp\n        oldestKey = key\n      }\n    }\n\n    return oldestKey\n  }\n}\n"],"names":["LazyMap","map","Map","maxSize","ttlMs","isRemovable","getTimestamp","options","Infinity","set","key","value","cleanup","get","delete","has","values","entries","Symbol","iterator","size","now","Date","oldestKey","findOldestRemovableKey","oldestTime","timestamp"],"mappings":"AAAA;;CAEC,GA0BD;;;;;;;;;;;;;;;;;CAiBC,GACD,OAAO,MAAMA;IACMC,MAAM,IAAIC,MAAW;IACrBC,QAAe;IACfC,MAAa;IACbC,YAAkC;IAClCC,aAAkC;IAEnD,YAAYC,OAA0B,CAAE;QACtC,IAAI,CAACJ,OAAO,GAAGI,QAAQJ,OAAO,IAAIK;QAClC,IAAI,CAACJ,KAAK,GAAGG,QAAQH,KAAK,IAAII;QAC9B,IAAI,CAACH,WAAW,GAAGE,QAAQF,WAAW;QACtC,IAAI,CAACC,YAAY,GAAGC,QAAQD,YAAY;IAC1C;IAEA;;GAEC,GACDG,IAAIC,GAAM,EAAEC,KAAQ,EAAQ;QAC1B,IAAI,CAACV,GAAG,CAACQ,GAAG,CAACC,KAAKC;QAClB,IAAI,CAACC,OAAO;IACd;IAEAC,IAAIH,GAAM,EAAiB;QACzB,OAAO,IAAI,CAACT,GAAG,CAACY,GAAG,CAACH;IACtB;IAEAI,OAAOJ,GAAM,EAAW;QACtB,OAAO,IAAI,CAACT,GAAG,CAACa,MAAM,CAACJ;IACzB;IAEAK,IAAIL,GAAM,EAAW;QACnB,OAAO,IAAI,CAACT,GAAG,CAACc,GAAG,CAACL;IACtB;IAEAM,SAA8B;QAC5B,OAAO,IAAI,CAACf,GAAG,CAACe,MAAM;IACxB;IAEAC,UAAoC;QAClC,OAAO,IAAI,CAAChB,GAAG,CAACgB,OAAO;IACzB;IAEA,CAACC,OAAOC,QAAQ,CAAC,GAA6B;QAC5C,OAAO,IAAI,CAAClB,GAAG,CAACiB,OAAOC,QAAQ,CAAC;IAClC;IAEA,IAAIC,OAAe;QACjB,OAAO,IAAI,CAACnB,GAAG,CAACmB,IAAI;IACtB;IAEA;;;GAGC,GACD,AAAQR,UAAgB;QACtB,MAAMS,MAAMC,KAAKD,GAAG;QAEpB,4BAA4B;QAC5B,IAAI,IAAI,CAACjB,KAAK,KAAKI,UAAU;YAC3B,KAAK,MAAM,CAACE,KAAKC,MAAM,IAAI,IAAI,CAACV,GAAG,CAAE;gBACnC,IAAI,CAAC,IAAI,CAACI,WAAW,CAACM,QAAQ;gBAC9B,IAAIU,MAAM,IAAI,CAACf,YAAY,CAACK,SAAS,IAAI,CAACP,KAAK,EAAE;oBAC/C,IAAI,CAACH,GAAG,CAACa,MAAM,CAACJ;gBAClB;YACF;QACF;QAEA,0DAA0D;QAC1D,MAAO,IAAI,CAACT,GAAG,CAACmB,IAAI,GAAG,IAAI,CAACjB,OAAO,CAAE;YACnC,MAAMoB,YAAY,IAAI,CAACC,sBAAsB;YAC7C,IAAI,CAACD,WAAW,OAAM,kCAAkC;YACxD,IAAI,CAACtB,GAAG,CAACa,MAAM,CAACS;QAClB;IACF;IAEQC,yBAAwC;QAC9C,IAAID;QACJ,IAAIE,aAAajB;QAEjB,KAAK,MAAM,CAACE,KAAKC,MAAM,IAAI,IAAI,CAACV,GAAG,CAAE;YACnC,IAAI,CAAC,IAAI,CAACI,WAAW,CAACM,QAAQ;YAC9B,MAAMe,YAAY,IAAI,CAACpB,YAAY,CAACK;YACpC,IAAIe,YAAYD,YAAY;gBAC1BA,aAAaC;gBACbH,YAAYb;YACd;QACF;QAEA,OAAOa;IACT;AACF"}

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

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

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

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