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

package/dist/server/shared/http/withErrorHandler.test.d.ts.map

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

package/dist/server/shared/http/withErrorHandler.test.js

@@ -1,69 +0,0 @@
-import { describe, it, expect, vi, beforeEach } from 'vitest';
-import { APIError } from 'payload';
-import { withErrorHandler } from './withErrorHandler';
-import { ServerResponse } from './ServerResponse';
-describe('withErrorHandler', () => {
-    beforeEach(() => {
-        vi.spyOn(console, 'error').mockImplementation(() => { });
-    });
-    it('returns handler result on success', async () => {
-        const expectedResponse = ServerResponse.success({ data: 'test' });
-        const handler = vi.fn().mockResolvedValue(expectedResponse);
-        const wrappedHandler = withErrorHandler(handler);
-        const result = await wrappedHandler();
-        expect(result).toBe(expectedResponse);
-    });
-    it('passes arguments to handler', async () => {
-        const handler = vi.fn().mockResolvedValue(ServerResponse.success());
-        const wrappedHandler = withErrorHandler(handler);
-        await wrappedHandler('arg1', 'arg2', { option: true });
-        expect(handler).toHaveBeenCalledWith('arg1', 'arg2', { option: true });
-    });
-    it('handles APIError with custom status', async () => {
-        const apiError = new APIError('Not found', 404);
-        const handler = vi.fn().mockRejectedValue(apiError);
-        const wrappedHandler = withErrorHandler(handler);
-        const result = await wrappedHandler();
-        expect(result.status).toBe(404);
-        expect(await result.json()).toEqual({ message: 'Not found' });
-    });
-    it('handles APIError with different statuses', async () => {
-        const badRequestError = new APIError('Bad request data', 400);
-        const handler = vi.fn().mockRejectedValue(badRequestError);
-        const wrappedHandler = withErrorHandler(handler);
-        const result = await wrappedHandler();
-        expect(result.status).toBe(400);
-        expect(await result.json()).toEqual({ message: 'Bad request data' });
-    });
-    it('handles generic Error with 500 status', async () => {
-        const error = new Error('Something went wrong');
-        const handler = vi.fn().mockRejectedValue(error);
-        const wrappedHandler = withErrorHandler(handler);
-        const result = await wrappedHandler();
-        expect(result.status).toBe(500);
-        expect(await result.json()).toEqual({ message: 'Something went wrong' });
-    });
-    it('handles unknown error with default message', async () => {
-        const handler = vi.fn().mockRejectedValue('string error');
-        const wrappedHandler = withErrorHandler(handler);
-        const result = await wrappedHandler();
-        expect(result.status).toBe(500);
-        expect(await result.json()).toEqual({ message: 'Internal server error' });
-    });
-    it('logs error to console', async () => {
-        const error = new Error('Test error');
-        const handler = vi.fn().mockRejectedValue(error);
-        const wrappedHandler = withErrorHandler(handler);
-        await wrappedHandler();
-        expect(console.error).toHaveBeenCalledWith('[TranslateKit] Handler error:', error);
-    });
-    it('preserves handler type signature', async () => {
-        const typedHandler = async (id, options) => {
-            return ServerResponse.success({ id, options });
-        };
-        const wrappedHandler = withErrorHandler(typedHandler);
-        // TypeScript should allow these calls
-        const result = await wrappedHandler('test-id', { force: true });
-        expect(result.status).toBe(200);
-    });
-});

package/dist/server/shared/index.d.ts.map

@@ -1 +0,0 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../src/server/shared/index.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,cAAc,EAAE,gBAAgB,EAAE,eAAe,EAAE,MAAM,QAAQ,CAAA;AAG1E,OAAO,EAAE,cAAc,EAAE,MAAM,UAAU,CAAA;AACzC,YAAY,EAAE,WAAW,EAAE,kBAAkB,EAAE,OAAO,EAAE,MAAM,UAAU,CAAA;AAGxE,OAAO,EAAE,OAAO,EAAE,QAAQ,EAAE,aAAa,EAAE,IAAI,EAAE,SAAS,EAAE,SAAS,EAAE,qBAAqB,EAAE,MAAM,SAAS,CAAA;AAG7G,YAAY,EAAE,iBAAiB,EAAE,MAAM,UAAU,CAAA;AACjD,OAAO,EACL,mBAAmB,EACnB,gBAAgB,EAChB,mBAAmB,EACnB,WAAW,EACX,WAAW,EACX,SAAS,GACV,MAAM,UAAU,CAAA;AAGjB,OAAO,EAAE,8BAA8B,EAAE,0BAA0B,EAAE,MAAM,gBAAgB,CAAA;AAC3F,YAAY,EAAE,uBAAuB,EAAE,MAAM,gBAAgB,CAAA;AAG7D,OAAO,EACL,uBAAuB,EACvB,eAAe,EACf,mBAAmB,EACnB,iCAAiC,GAClC,MAAM,WAAW,CAAA;AAClB,YAAY,EAAE,qBAAqB,EAAE,MAAM,WAAW,CAAA"}

package/dist/server/shared/index.js.map

@@ -1 +0,0 @@
-{"version":3,"sources":["../../../src/server/shared/index.ts"],"sourcesContent":["// HTTP utilities\nexport { ServerResponse, withErrorHandler, withAccessCheck } from './http'\n\n// Access control\nexport { AnyAccessGuard } from './access'\nexport type { AccessGuard, AccessGuardRequest, Handler } from './access'\n\n// General utilities\nexport { isEmpty, isObject, normalizePath, pipe, getByPath, setByPath, filterLocalizedFields } from './utils'\n\n// Field guards\nexport type { TranslatableField } from './guards'\nexport {\n  isTranslatableField,\n  isLocalizedField,\n  isRelationshipField,\n  isTabsField,\n  isBlockItem,\n  hasFields,\n} from './guards'\n\n// Field config\nexport { isFieldExcludedFromTranslation, getTranslateKitFieldConfig } from './field-config'\nexport type { TranslateKitFieldConfig } from './field-config'\n\n// Lexical utilities\nexport {\n  isSerializedLexicalRoot,\n  isEmptyRichText,\n  traverseLexicalTree,\n  collectSerializedLexicalTextNodes,\n} from './lexical'\nexport type { SerializedTextNodeRef } from './lexical'\n"],"names":["ServerResponse","withErrorHandler","withAccessCheck","AnyAccessGuard","isEmpty","isObject","normalizePath","pipe","getByPath","setByPath","filterLocalizedFields","isTranslatableField","isLocalizedField","isRelationshipField","isTabsField","isBlockItem","hasFields","isFieldExcludedFromTranslation","getTranslateKitFieldConfig","isSerializedLexicalRoot","isEmptyRichText","traverseLexicalTree","collectSerializedLexicalTextNodes"],"mappings":"AAAA,iBAAiB;AACjB,SAASA,cAAc,EAAEC,gBAAgB,EAAEC,eAAe,QAAQ,SAAQ;AAE1E,iBAAiB;AACjB,SAASC,cAAc,QAAQ,WAAU;AAGzC,oBAAoB;AACpB,SAASC,OAAO,EAAEC,QAAQ,EAAEC,aAAa,EAAEC,IAAI,EAAEC,SAAS,EAAEC,SAAS,EAAEC,qBAAqB,QAAQ,UAAS;AAI7G,SACEC,mBAAmB,EACnBC,gBAAgB,EAChBC,mBAAmB,EACnBC,WAAW,EACXC,WAAW,EACXC,SAAS,QACJ,WAAU;AAEjB,eAAe;AACf,SAASC,8BAA8B,EAAEC,0BAA0B,QAAQ,iBAAgB;AAG3F,oBAAoB;AACpB,SACEC,uBAAuB,EACvBC,eAAe,EACfC,mBAAmB,EACnBC,iCAAiC,QAC5B,YAAW"}

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

@@ -1 +0,0 @@
-{"version":3,"file":"collectTextNodes.d.ts","sourceRoot":"","sources":["../../../../src/server/shared/lexical/collectTextNodes.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,qBAAqB,EAAE,qBAAqB,EAAE,MAAM,SAAS,CAAA;AAqB3E;;;;;;GAMG;AACH,wBAAgB,iCAAiC,CAAC,IAAI,EAAE,qBAAqB,GAAG,qBAAqB,EAAE,CAItG"}

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

@@ -1 +0,0 @@
-{"version":3,"sources":["../../../../src/server/shared/lexical/collectTextNodes.ts"],"sourcesContent":["import type { SerializedLexicalNode, SerializedTextNodeRef } from './types'\nimport { hasChildren, isSerializedLexicalTextNode } from './guards'\n\n/**\n * Recursively collects text node references from serialized Lexical JSON.\n */\nfunction collectTextNodesRecursive(node: SerializedLexicalNode, refs: SerializedTextNodeRef[]): void {\n  if (isSerializedLexicalTextNode(node)) {\n    if (node.text.trim().length > 0) {\n      refs.push({ node })\n    }\n    return\n  }\n\n  if (hasChildren(node)) {\n    for (const child of node.children) {\n      collectTextNodesRecursive(child, refs)\n    }\n  }\n}\n\n/**\n * Traverses serialized Lexical JSON and returns all non-empty text node references.\n * Only collects text nodes with content (after trimming whitespace).\n *\n * @param node - The serialized Lexical node to traverse\n * @returns Array of references to text nodes for mutation\n */\nexport function collectSerializedLexicalTextNodes(node: SerializedLexicalNode): SerializedTextNodeRef[] {\n  const refs: SerializedTextNodeRef[] = []\n  collectTextNodesRecursive(node, refs)\n  return refs\n}\n"],"names":["hasChildren","isSerializedLexicalTextNode","collectTextNodesRecursive","node","refs","text","trim","length","push","child","children","collectSerializedLexicalTextNodes"],"mappings":"AACA,SAASA,WAAW,EAAEC,2BAA2B,QAAQ,WAAU;AAEnE;;CAEC,GACD,SAASC,0BAA0BC,IAA2B,EAAEC,IAA6B;IAC3F,IAAIH,4BAA4BE,OAAO;QACrC,IAAIA,KAAKE,IAAI,CAACC,IAAI,GAAGC,MAAM,GAAG,GAAG;YAC/BH,KAAKI,IAAI,CAAC;gBAAEL;YAAK;QACnB;QACA;IACF;IAEA,IAAIH,YAAYG,OAAO;QACrB,KAAK,MAAMM,SAASN,KAAKO,QAAQ,CAAE;YACjCR,0BAA0BO,OAAOL;QACnC;IACF;AACF;AAEA;;;;;;CAMC,GACD,OAAO,SAASO,kCAAkCR,IAA2B;IAC3E,MAAMC,OAAgC,EAAE;IACxCF,0BAA0BC,MAAMC;IAChC,OAAOA;AACT"}

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

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

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

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

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

@@ -1,120 +0,0 @@
-import { describe, it, expect } from 'vitest';
-import { collectSerializedLexicalTextNodes } from './collectTextNodes';
-const createNode = (type, props, children) => ({ type, ...props, ...(children && { children }) });
-describe('collectSerializedLexicalTextNodes', () => {
-    describe('text node collection', () => {
-        it('collects text nodes with content', () => {
-            const root = createNode('root', {}, [createNode('paragraph', {}, [createNode('text', { text: 'Hello' })])]);
-            const refs = collectSerializedLexicalTextNodes(root);
-            expect(refs).toHaveLength(1);
-            expect(refs[0].node.text).toBe('Hello');
-        });
-        it('collects multiple text nodes', () => {
-            const root = createNode('root', {}, [
-                createNode('paragraph', {}, [createNode('text', { text: 'Hello' }), createNode('text', { text: 'World' })]),
-            ]);
-            const refs = collectSerializedLexicalTextNodes(root);
-            expect(refs).toHaveLength(2);
-            expect(refs[0].node.text).toBe('Hello');
-            expect(refs[1].node.text).toBe('World');
-        });
-        it('collects text nodes from multiple paragraphs', () => {
-            const root = createNode('root', {}, [
-                createNode('paragraph', {}, [createNode('text', { text: 'First' })]),
-                createNode('paragraph', {}, [createNode('text', { text: 'Second' })]),
-            ]);
-            const refs = collectSerializedLexicalTextNodes(root);
-            expect(refs).toHaveLength(2);
-            expect(refs[0].node.text).toBe('First');
-            expect(refs[1].node.text).toBe('Second');
-        });
-    });
-    describe('empty text filtering', () => {
-        it('skips empty text nodes', () => {
-            const root = createNode('root', {}, [createNode('paragraph', {}, [createNode('text', { text: '' })])]);
-            const refs = collectSerializedLexicalTextNodes(root);
-            expect(refs).toHaveLength(0);
-        });
-        it('skips whitespace-only text nodes', () => {
-            const root = createNode('root', {}, [createNode('paragraph', {}, [createNode('text', { text: '   \n\t  ' })])]);
-            const refs = collectSerializedLexicalTextNodes(root);
-            expect(refs).toHaveLength(0);
-        });
-        it('collects text with leading/trailing whitespace', () => {
-            const root = createNode('root', {}, [createNode('paragraph', {}, [createNode('text', { text: '  content  ' })])]);
-            const refs = collectSerializedLexicalTextNodes(root);
-            expect(refs).toHaveLength(1);
-            expect(refs[0].node.text).toBe('  content  ');
-        });
-        it('mixes empty and non-empty text nodes', () => {
-            const root = createNode('root', {}, [
-                createNode('paragraph', {}, [
-                    createNode('text', { text: '' }),
-                    createNode('text', { text: 'content' }),
-                    createNode('text', { text: '   ' }),
-                    createNode('text', { text: 'more' }),
-                ]),
-            ]);
-            const refs = collectSerializedLexicalTextNodes(root);
-            expect(refs).toHaveLength(2);
-            expect(refs[0].node.text).toBe('content');
-            expect(refs[1].node.text).toBe('more');
-        });
-    });
-    describe('nested structures', () => {
-        it('collects from deeply nested structures', () => {
-            const root = createNode('root', {}, [
-                createNode('list', {}, [
-                    createNode('listitem', {}, [createNode('paragraph', {}, [createNode('text', { text: 'Item 1' })])]),
-                    createNode('listitem', {}, [createNode('paragraph', {}, [createNode('text', { text: 'Item 2' })])]),
-                ]),
-            ]);
-            const refs = collectSerializedLexicalTextNodes(root);
-            expect(refs).toHaveLength(2);
-            expect(refs[0].node.text).toBe('Item 1');
-            expect(refs[1].node.text).toBe('Item 2');
-        });
-        it('collects from link nodes', () => {
-            const root = createNode('root', {}, [
-                createNode('paragraph', {}, [
-                    createNode('text', { text: 'Click ' }),
-                    createNode('link', { url: 'https://example.com' }, [createNode('text', { text: 'here' })]),
-                    createNode('text', { text: ' to continue' }),
-                ]),
-            ]);
-            const refs = collectSerializedLexicalTextNodes(root);
-            expect(refs).toHaveLength(3);
-            expect(refs[0].node.text).toBe('Click ');
-            expect(refs[1].node.text).toBe('here');
-            expect(refs[2].node.text).toBe(' to continue');
-        });
-    });
-    describe('mutation via references', () => {
-        it('returns references that can mutate original nodes', () => {
-            const textNode = createNode('text', { text: 'Original' });
-            const root = createNode('root', {}, [createNode('paragraph', {}, [textNode])]);
-            const refs = collectSerializedLexicalTextNodes(root);
-            refs[0].node.text = 'Translated';
-            expect(textNode.text).toBe('Translated');
-        });
-    });
-    describe('edge cases', () => {
-        it('returns empty array for empty root', () => {
-            const root = createNode('root', {}, []);
-            const refs = collectSerializedLexicalTextNodes(root);
-            expect(refs).toHaveLength(0);
-        });
-        it('returns empty array for root without children', () => {
-            const root = { type: 'root' };
-            const refs = collectSerializedLexicalTextNodes(root);
-            expect(refs).toHaveLength(0);
-        });
-        it('returns empty array for paragraph without text nodes', () => {
-            const root = createNode('root', {}, [
-                createNode('paragraph', {}, [createNode('upload', { relationTo: 'media' })]),
-            ]);
-            const refs = collectSerializedLexicalTextNodes(root);
-            expect(refs).toHaveLength(0);
-        });
-    });
-});

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

@@ -1 +0,0 @@
-{"version":3,"file":"guards.d.ts","sourceRoot":"","sources":["../../../../src/server/shared/lexical/guards.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,qBAAqB,EAAE,qBAAqB,EAAE,kBAAkB,EAAE,MAAM,SAAS,CAAA;AAG/F;;GAEG;AACH,MAAM,MAAM,iCAAiC,GAAG,qBAAqB,GAAG;IACtE,QAAQ,EAAE,qBAAqB,EAAE,CAAA;CAClC,CAAA;AAED;;GAEG;AACH,wBAAgB,uBAAuB,CAAC,KAAK,EAAE,OAAO,GAAG,KAAK,IAAI,qBAAqB,CAEtF;AAED;;GAEG;AACH,wBAAgB,2BAA2B,CAAC,IAAI,EAAE,qBAAqB,GAAG,IAAI,IAAI,kBAAkB,CAEnG;AAED;;GAEG;AACH,wBAAgB,WAAW,CAAC,IAAI,EAAE,qBAAqB,GAAG,IAAI,IAAI,iCAAiC,CAElG"}

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

@@ -1 +0,0 @@
-{"version":3,"sources":["../../../../src/server/shared/lexical/guards.ts"],"sourcesContent":["import type { SerializedLexicalNode, SerializedLexicalRoot, SerializedTextNode } from './types'\nimport { isObject } from '../utils'\n\n/**\n * Node with children property.\n */\nexport type SerializedLexicalNodeWithChildren = SerializedLexicalNode & {\n  children: SerializedLexicalNode[]\n}\n\n/**\n * Type guard: Checks if value is a serialized Lexical root structure.\n */\nexport function isSerializedLexicalRoot(value: unknown): value is SerializedLexicalRoot {\n  return isObject(value) && 'root' in value && isObject(value.root)\n}\n\n/**\n * Type guard: Checks if node is a serialized Lexical text node.\n */\nexport function isSerializedLexicalTextNode(node: SerializedLexicalNode): node is SerializedTextNode {\n  return node.type === 'text' && 'text' in node && typeof node.text === 'string'\n}\n\n/**\n * Type guard: Checks if node has children array.\n */\nexport function hasChildren(node: SerializedLexicalNode): node is SerializedLexicalNodeWithChildren {\n  return 'children' in node && Array.isArray(node.children)\n}\n"],"names":["isObject","isSerializedLexicalRoot","value","root","isSerializedLexicalTextNode","node","type","text","hasChildren","Array","isArray","children"],"mappings":"AACA,SAASA,QAAQ,QAAQ,WAAU;AASnC;;CAEC,GACD,OAAO,SAASC,wBAAwBC,KAAc;IACpD,OAAOF,SAASE,UAAU,UAAUA,SAASF,SAASE,MAAMC,IAAI;AAClE;AAEA;;CAEC,GACD,OAAO,SAASC,4BAA4BC,IAA2B;IACrE,OAAOA,KAAKC,IAAI,KAAK,UAAU,UAAUD,QAAQ,OAAOA,KAAKE,IAAI,KAAK;AACxE;AAEA;;CAEC,GACD,OAAO,SAASC,YAAYH,IAA2B;IACrD,OAAO,cAAcA,QAAQI,MAAMC,OAAO,CAACL,KAAKM,QAAQ;AAC1D"}

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

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

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

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

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

@@ -1,160 +0,0 @@
-import { describe, it, expect } from 'vitest';
-import { isSerializedLexicalRoot, isSerializedLexicalTextNode, hasChildren } from './guards';
-describe('lexical guards', () => {
-    describe('isSerializedLexicalRoot', () => {
-        it('returns true for valid Lexical root structure', () => {
-            const validRoot = {
-                root: {
-                    type: 'root',
-                    children: [],
-                },
-            };
-            expect(isSerializedLexicalRoot(validRoot)).toBe(true);
-        });
-        it('returns true for root with nested content', () => {
-            const rootWithContent = {
-                root: {
-                    type: 'root',
-                    children: [
-                        {
-                            type: 'paragraph',
-                            children: [{ type: 'text', text: 'Hello' }],
-                        },
-                    ],
-                },
-            };
-            expect(isSerializedLexicalRoot(rootWithContent)).toBe(true);
-        });
-        it('returns false for object without root property', () => {
-            expect(isSerializedLexicalRoot({ children: [] })).toBe(false);
-            expect(isSerializedLexicalRoot({ type: 'root' })).toBe(false);
-        });
-        it('returns false for object with non-object root', () => {
-            expect(isSerializedLexicalRoot({ root: null })).toBe(false);
-            expect(isSerializedLexicalRoot({ root: 'string' })).toBe(false);
-            expect(isSerializedLexicalRoot({ root: 123 })).toBe(false);
-            // Note: arrays are objects in JS, so isObject([]) returns true
-            // This is acceptable behavior - arrays would fail other validations
-        });
-        it('returns false for non-objects', () => {
-            expect(isSerializedLexicalRoot(null)).toBe(false);
-            expect(isSerializedLexicalRoot(undefined)).toBe(false);
-            expect(isSerializedLexicalRoot('string')).toBe(false);
-            expect(isSerializedLexicalRoot(123)).toBe(false);
-            expect(isSerializedLexicalRoot([])).toBe(false);
-        });
-    });
-    describe('isSerializedLexicalTextNode', () => {
-        it('returns true for valid text node', () => {
-            // Text nodes have 'text' property which is not on base SerializedLexicalNode type
-            const textNode = {
-                type: 'text',
-                text: 'Hello World',
-                version: 1,
-            };
-            expect(isSerializedLexicalTextNode(textNode)).toBe(true);
-        });
-        it('returns true for text node with empty string', () => {
-            const textNode = {
-                type: 'text',
-                text: '',
-                version: 1,
-            };
-            expect(isSerializedLexicalTextNode(textNode)).toBe(true);
-        });
-        it('returns true for text node with formatting', () => {
-            const textNode = {
-                type: 'text',
-                text: 'Bold text',
-                format: 1,
-                version: 1,
-            };
-            expect(isSerializedLexicalTextNode(textNode)).toBe(true);
-        });
-        it('returns false for paragraph node', () => {
-            const paragraphNode = {
-                type: 'paragraph',
-                children: [],
-                version: 1,
-            };
-            expect(isSerializedLexicalTextNode(paragraphNode)).toBe(false);
-        });
-        it('returns false for heading node', () => {
-            const headingNode = {
-                type: 'heading',
-                tag: 'h1',
-                children: [],
-                version: 1,
-            };
-            expect(isSerializedLexicalTextNode(headingNode)).toBe(false);
-        });
-        it('returns false for node with type text but no text property', () => {
-            const invalidNode = {
-                type: 'text',
-                version: 1,
-            };
-            expect(isSerializedLexicalTextNode(invalidNode)).toBe(false);
-        });
-        it('returns false for node with non-string text property', () => {
-            const invalidNode = {
-                type: 'text',
-                text: 123,
-                version: 1,
-            };
-            expect(isSerializedLexicalTextNode(invalidNode)).toBe(false);
-        });
-    });
-    describe('hasChildren', () => {
-        it('returns true for node with children array', () => {
-            const node = {
-                type: 'paragraph',
-                children: [],
-                version: 1,
-            };
-            expect(hasChildren(node)).toBe(true);
-        });
-        it('returns true for node with populated children', () => {
-            const node = {
-                type: 'paragraph',
-                children: [
-                    { type: 'text', text: 'Hello', version: 1 },
-                    { type: 'text', text: 'World', version: 1 },
-                ],
-                version: 1,
-            };
-            expect(hasChildren(node)).toBe(true);
-        });
-        it('returns true for root node with children', () => {
-            const rootNode = {
-                type: 'root',
-                children: [{ type: 'paragraph', children: [], version: 1 }],
-                version: 1,
-            };
-            expect(hasChildren(rootNode)).toBe(true);
-        });
-        it('returns false for text node (no children)', () => {
-            const textNode = {
-                type: 'text',
-                text: 'Hello',
-                version: 1,
-            };
-            expect(hasChildren(textNode)).toBe(false);
-        });
-        it('returns false for node with non-array children', () => {
-            const invalidNode = {
-                type: 'paragraph',
-                children: 'not-array',
-                version: 1,
-            };
-            expect(hasChildren(invalidNode)).toBe(false);
-        });
-        it('returns false for node with null children', () => {
-            const invalidNode = {
-                type: 'paragraph',
-                children: null,
-                version: 1,
-            };
-            expect(hasChildren(invalidNode)).toBe(false);
-        });
-    });
-});

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

@@ -1 +0,0 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../../../src/server/shared/lexical/index.ts"],"names":[],"mappings":"AAAA,YAAY,EACV,qBAAqB,EACrB,qBAAqB,EACrB,qBAAqB,EACrB,kBAAkB,EAClB,kBAAkB,GACnB,MAAM,SAAS,CAAA;AAChB,YAAY,EAAE,iCAAiC,EAAE,MAAM,UAAU,CAAA;AACjE,OAAO,EAAE,uBAAuB,EAAE,2BAA2B,EAAE,WAAW,EAAE,MAAM,UAAU,CAAA;AAC5F,OAAO,EAAE,eAAe,EAAE,MAAM,mBAAmB,CAAA;AACnD,OAAO,EAAE,mBAAmB,EAAE,MAAM,uBAAuB,CAAA;AAC3D,OAAO,EAAE,iCAAiC,EAAE,MAAM,oBAAoB,CAAA"}

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

@@ -1 +0,0 @@
-{"version":3,"sources":["../../../../src/server/shared/lexical/index.ts"],"sourcesContent":["export type {\n  SerializedTextNodeRef,\n  SerializedLexicalRoot,\n  SerializedLexicalNode,\n  SerializedTextNode,\n  SerializedRootNode,\n} from './types'\nexport type { SerializedLexicalNodeWithChildren } from './guards'\nexport { isSerializedLexicalRoot, isSerializedLexicalTextNode, hasChildren } from './guards'\nexport { isEmptyRichText } from './isEmptyRichText'\nexport { traverseLexicalTree } from './traverseLexicalTree'\nexport { collectSerializedLexicalTextNodes } from './collectTextNodes'\n"],"names":["isSerializedLexicalRoot","isSerializedLexicalTextNode","hasChildren","isEmptyRichText","traverseLexicalTree","collectSerializedLexicalTextNodes"],"mappings":"AAQA,SAASA,uBAAuB,EAAEC,2BAA2B,EAAEC,WAAW,QAAQ,WAAU;AAC5F,SAASC,eAAe,QAAQ,oBAAmB;AACnD,SAASC,mBAAmB,QAAQ,wBAAuB;AAC3D,SAASC,iCAAiC,QAAQ,qBAAoB"}

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

@@ -1 +0,0 @@
-{"version":3,"file":"isEmptyRichText.d.ts","sourceRoot":"","sources":["../../../../src/server/shared/lexical/isEmptyRichText.ts"],"names":[],"mappings":"AAAA,OAAO,KAAK,EAAE,qBAAqB,EAAE,MAAM,SAAS,CAAA;AAIpD;;;;;;;;;;GAUG;AACH,wBAAgB,eAAe,CAAC,KAAK,EAAE,qBAAqB,GAAG,OAAO,CAkBrE"}

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

@@ -1 +0,0 @@
-{"version":3,"sources":["../../../../src/server/shared/lexical/isEmptyRichText.ts"],"sourcesContent":["import type { SerializedLexicalRoot } from './types'\nimport { traverseLexicalTree } from './traverseLexicalTree'\nimport { isSerializedLexicalTextNode } from './guards'\n\n/**\n * Checks if a serialized Lexical richText structure is empty.\n *\n * Empty means:\n * - Only contains root/paragraph nodes with no content\n * - Text nodes are empty or whitespace-only\n *\n * Non-empty means:\n * - Contains any node other than root/paragraph/text (e.g., upload, block, heading)\n * - Contains text node with actual content\n */\nexport function isEmptyRichText(value: SerializedLexicalRoot): boolean {\n  let hasContent = false\n  traverseLexicalTree(value.root, (node) => {\n    const { type } = node\n\n    if (type !== 'paragraph' && type !== 'text' && type !== 'root') {\n      hasContent = true\n      return false\n    }\n\n    if (isSerializedLexicalTextNode(node)) {\n      if (node.text.trim()) {\n        hasContent = true\n        return false\n      }\n    }\n  })\n  return !hasContent\n}\n"],"names":["traverseLexicalTree","isSerializedLexicalTextNode","isEmptyRichText","value","hasContent","root","node","type","text","trim"],"mappings":"AACA,SAASA,mBAAmB,QAAQ,wBAAuB;AAC3D,SAASC,2BAA2B,QAAQ,WAAU;AAEtD;;;;;;;;;;CAUC,GACD,OAAO,SAASC,gBAAgBC,KAA4B;IAC1D,IAAIC,aAAa;IACjBJ,oBAAoBG,MAAME,IAAI,EAAE,CAACC;QAC/B,MAAM,EAAEC,IAAI,EAAE,GAAGD;QAEjB,IAAIC,SAAS,eAAeA,SAAS,UAAUA,SAAS,QAAQ;YAC9DH,aAAa;YACb,OAAO;QACT;QAEA,IAAIH,4BAA4BK,OAAO;YACrC,IAAIA,KAAKE,IAAI,CAACC,IAAI,IAAI;gBACpBL,aAAa;gBACb,OAAO;YACT;QACF;IACF;IACA,OAAO,CAACA;AACV"}

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

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

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

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