@focus-reactive/payload-plugin-translator 0.1.0

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

@@ -0,0 +1,10 @@
+import type { SerializedLexicalNode, SerializedTextNodeRef } from './types';
+/**
+ * Traverses serialized Lexical JSON and returns all non-empty text node references.
+ * Only collects text nodes with content (after trimming whitespace).
+ *
+ * @param node - The serialized Lexical node to traverse
+ * @returns Array of references to text nodes for mutation
+ */
+export declare function collectSerializedLexicalTextNodes(node: SerializedLexicalNode): SerializedTextNodeRef[];
+//# sourceMappingURL=collectTextNodes.d.ts.map

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

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

@@ -0,0 +1,31 @@
+import { hasChildren, isSerializedLexicalTextNode } from './guards';
+/**
+ * Recursively collects text node references from serialized Lexical JSON.
+ */ function collectTextNodesRecursive(node, refs) {
+    if (isSerializedLexicalTextNode(node)) {
+        if (node.text.trim().length > 0) {
+            refs.push({
+                node
+            });
+        }
+        return;
+    }
+    if (hasChildren(node)) {
+        for (const child of node.children){
+            collectTextNodesRecursive(child, refs);
+        }
+    }
+}
+/**
+ * Traverses serialized Lexical JSON and returns all non-empty text node references.
+ * Only collects text nodes with content (after trimming whitespace).
+ *
+ * @param node - The serialized Lexical node to traverse
+ * @returns Array of references to text nodes for mutation
+ */ export function collectSerializedLexicalTextNodes(node) {
+    const refs = [];
+    collectTextNodesRecursive(node, refs);
+    return refs;
+}
+
+//# sourceMappingURL=collectTextNodes.js.map

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

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

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

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

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

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

@@ -0,0 +1,20 @@
+import type { SerializedLexicalNode, SerializedLexicalRoot, SerializedTextNode } from './types';
+/**
+ * Node with children property.
+ */
+export type SerializedLexicalNodeWithChildren = SerializedLexicalNode & {
+    children: SerializedLexicalNode[];
+};
+/**
+ * Type guard: Checks if value is a serialized Lexical root structure.
+ */
+export declare function isSerializedLexicalRoot(value: unknown): value is SerializedLexicalRoot;
+/**
+ * Type guard: Checks if node is a serialized Lexical text node.
+ */
+export declare function isSerializedLexicalTextNode(node: SerializedLexicalNode): node is SerializedTextNode;
+/**
+ * Type guard: Checks if node has children array.
+ */
+export declare function hasChildren(node: SerializedLexicalNode): node is SerializedLexicalNodeWithChildren;
+//# sourceMappingURL=guards.d.ts.map

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

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

@@ -0,0 +1,18 @@
+import { isObject } from '../utils';
+/**
+ * Type guard: Checks if value is a serialized Lexical root structure.
+ */ export function isSerializedLexicalRoot(value) {
+    return isObject(value) && 'root' in value && isObject(value.root);
+}
+/**
+ * Type guard: Checks if node is a serialized Lexical text node.
+ */ export function isSerializedLexicalTextNode(node) {
+    return node.type === 'text' && 'text' in node && typeof node.text === 'string';
+}
+/**
+ * Type guard: Checks if node has children array.
+ */ export function hasChildren(node) {
+    return 'children' in node && Array.isArray(node.children);
+}
+
+//# sourceMappingURL=guards.js.map

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

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

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

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

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

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

@@ -0,0 +1,7 @@
+export type { SerializedTextNodeRef, SerializedLexicalRoot, SerializedLexicalNode, SerializedTextNode, SerializedRootNode, } from './types';
+export type { SerializedLexicalNodeWithChildren } from './guards';
+export { isSerializedLexicalRoot, isSerializedLexicalTextNode, hasChildren } from './guards';
+export { isEmptyRichText } from './isEmptyRichText';
+export { traverseLexicalTree } from './traverseLexicalTree';
+export { collectSerializedLexicalTextNodes } from './collectTextNodes';
+//# sourceMappingURL=index.d.ts.map

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

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

@@ -0,0 +1,6 @@
+export { isSerializedLexicalRoot, isSerializedLexicalTextNode, hasChildren } from './guards';
+export { isEmptyRichText } from './isEmptyRichText';
+export { traverseLexicalTree } from './traverseLexicalTree';
+export { collectSerializedLexicalTextNodes } from './collectTextNodes';
+
+//# sourceMappingURL=index.js.map

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

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

@@ -0,0 +1,14 @@
+import type { SerializedLexicalRoot } from './types';
+/**
+ * Checks if a serialized Lexical richText structure is empty.
+ *
+ * Empty means:
+ * - Only contains root/paragraph nodes with no content
+ * - Text nodes are empty or whitespace-only
+ *
+ * Non-empty means:
+ * - Contains any node other than root/paragraph/text (e.g., upload, block, heading)
+ * - Contains text node with actual content
+ */
+export declare function isEmptyRichText(value: SerializedLexicalRoot): boolean;
+//# sourceMappingURL=isEmptyRichText.d.ts.map

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

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

@@ -0,0 +1,31 @@
+import { traverseLexicalTree } from './traverseLexicalTree';
+import { isSerializedLexicalTextNode } from './guards';
+/**
+ * Checks if a serialized Lexical richText structure is empty.
+ *
+ * Empty means:
+ * - Only contains root/paragraph nodes with no content
+ * - Text nodes are empty or whitespace-only
+ *
+ * Non-empty means:
+ * - Contains any node other than root/paragraph/text (e.g., upload, block, heading)
+ * - Contains text node with actual content
+ */ export function isEmptyRichText(value) {
+    let hasContent = false;
+    traverseLexicalTree(value.root, (node)=>{
+        const { type } = node;
+        if (type !== 'paragraph' && type !== 'text' && type !== 'root') {
+            hasContent = true;
+            return false;
+        }
+        if (isSerializedLexicalTextNode(node)) {
+            if (node.text.trim()) {
+                hasContent = true;
+                return false;
+            }
+        }
+    });
+    return !hasContent;
+}
+
+//# sourceMappingURL=isEmptyRichText.js.map

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

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

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

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

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