@contentful/field-editor-rich-text 3.4.22 → 3.6.0

package/dist/cjs/helpers/__tests__/extractNodes.test.js

@@ -0,0 +1,299 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+const _richtexttypes = require("@contentful/rich-text-types");
+const _platetestutils = require("@udecode/plate-test-utils");
+const _extractNodes = require("../extractNodes");
+const createEditor = (children)=>(0, _platetestutils.createEditor)('test-editor', {}, children);
+const buildParagraph = (children = [])=>({
+        type: _richtexttypes.BLOCKS.PARAGRAPH,
+        data: {},
+        isVoid: false,
+        children: children.map((child)=>({
+                data: {},
+                ...child
+            }))
+    });
+const paragraph = (text = '', marks = {})=>buildParagraph([
+        {
+            text,
+            ...marks
+        }
+    ]);
+const buildList = (type = _richtexttypes.BLOCKS.UL_LIST, secondType = _richtexttypes.BLOCKS.UL_LIST)=>({
+        data: {},
+        isVoid: false,
+        type,
+        children: [
+            {
+                data: {},
+                isVoid: false,
+                type: _richtexttypes.BLOCKS.LIST_ITEM,
+                children: [
+                    {
+                        type: secondType,
+                        isVoid: false,
+                        data: {},
+                        children: [
+                            {
+                                data: {},
+                                isVoid: false,
+                                type: _richtexttypes.BLOCKS.LIST_ITEM,
+                                children: [
+                                    paragraph('text 1')
+                                ]
+                            }
+                        ]
+                    }
+                ]
+            },
+            {
+                data: {},
+                isVoid: false,
+                type: _richtexttypes.BLOCKS.LIST_ITEM,
+                children: [
+                    paragraph('text 2')
+                ]
+            },
+            {
+                data: {},
+                isVoid: false,
+                type: _richtexttypes.BLOCKS.LIST_ITEM,
+                children: [
+                    paragraph('text 3')
+                ]
+            }
+        ]
+    });
+describe('extractParagraphs', ()=>{
+    it('table', ()=>{
+        const table = {
+            data: {},
+            isVoid: false,
+            type: _richtexttypes.BLOCKS.TABLE,
+            children: [
+                {
+                    type: _richtexttypes.BLOCKS.TABLE_ROW,
+                    data: {},
+                    isVoid: false,
+                    children: [
+                        {
+                            type: _richtexttypes.BLOCKS.TABLE_HEADER_CELL,
+                            data: {},
+                            isVoid: false,
+                            children: [
+                                paragraph('header 1')
+                            ]
+                        },
+                        {
+                            type: _richtexttypes.BLOCKS.TABLE_HEADER_CELL,
+                            data: {},
+                            isVoid: false,
+                            children: [
+                                paragraph('header 2')
+                            ]
+                        }
+                    ]
+                },
+                {
+                    type: _richtexttypes.BLOCKS.TABLE_ROW,
+                    data: {},
+                    isVoid: false,
+                    children: [
+                        {
+                            type: _richtexttypes.BLOCKS.TABLE_CELL,
+                            data: {},
+                            isVoid: false,
+                            children: [
+                                paragraph('cell 1')
+                            ]
+                        },
+                        {
+                            type: _richtexttypes.BLOCKS.TABLE_CELL,
+                            data: {},
+                            isVoid: false,
+                            children: [
+                                paragraph('cell 2')
+                            ]
+                        }
+                    ]
+                }
+            ]
+        };
+        const editor = createEditor([
+            table
+        ]);
+        const path = [
+            0
+        ];
+        expect((0, _extractNodes.extractParagraphs)(editor, path)).toEqual([
+            paragraph('header 1'),
+            paragraph('header 2'),
+            paragraph('cell 1'),
+            paragraph('cell 2')
+        ]);
+    });
+    it('blockquote', ()=>{
+        const blockquote = {
+            data: {},
+            isVoid: false,
+            type: _richtexttypes.BLOCKS.QUOTE,
+            children: [
+                paragraph('text 1'),
+                paragraph('text 2')
+            ]
+        };
+        const editor = createEditor([
+            blockquote
+        ]);
+        const path = [
+            0
+        ];
+        expect((0, _extractNodes.extractParagraphs)(editor, path)).toEqual([
+            paragraph('text 1'),
+            paragraph('text 2')
+        ]);
+    });
+    it('list - UL', ()=>{
+        const ul = buildList(_richtexttypes.BLOCKS.UL_LIST, _richtexttypes.BLOCKS.OL_LIST);
+        const editor = createEditor([
+            ul
+        ]);
+        const path = [
+            0
+        ];
+        expect((0, _extractNodes.extractParagraphs)(editor, path)).toEqual([
+            paragraph('text 1'),
+            paragraph('text 2'),
+            paragraph('text 3')
+        ]);
+    });
+    it('list - OL', ()=>{
+        const ol = buildList(_richtexttypes.BLOCKS.OL_LIST, _richtexttypes.BLOCKS.UL_LIST);
+        const editor = createEditor([
+            ol
+        ]);
+        const path = [
+            0
+        ];
+        expect((0, _extractNodes.extractParagraphs)(editor, path)).toEqual([
+            paragraph('text 1'),
+            paragraph('text 2'),
+            paragraph('text 3')
+        ]);
+    });
+    it('should preserve marks', ()=>{
+        const element = {
+            data: {},
+            isVoid: false,
+            type: _richtexttypes.BLOCKS.QUOTE,
+            children: [
+                paragraph('text 1', {
+                    bold: true,
+                    italic: true
+                }),
+                paragraph('text 2', {
+                    underline: true,
+                    code: true
+                })
+            ]
+        };
+        const editor = createEditor([
+            element
+        ]);
+        const path = [
+            0
+        ];
+        expect((0, _extractNodes.extractParagraphs)(editor, path)).toEqual([
+            paragraph('text 1', {
+                bold: true,
+                italic: true
+            }),
+            paragraph('text 2', {
+                underline: true,
+                code: true
+            })
+        ]);
+    });
+    it('should preserve hyperlinks', ()=>{
+        const paragraphWithLink = buildParagraph([
+            {
+                text: 'text 1 '
+            },
+            {
+                type: _richtexttypes.INLINES.HYPERLINK,
+                children: [
+                    {
+                        text: 'with link'
+                    }
+                ],
+                data: {
+                    uri: 'https://link.com'
+                }
+            }
+        ]);
+        const element = {
+            data: {},
+            isVoid: false,
+            type: _richtexttypes.BLOCKS.QUOTE,
+            children: [
+                paragraphWithLink,
+                paragraph('text 2')
+            ]
+        };
+        const editor = createEditor([
+            element
+        ]);
+        const path = [
+            0
+        ];
+        expect((0, _extractNodes.extractParagraphs)(editor, path)).toEqual([
+            paragraphWithLink,
+            paragraph('text 2')
+        ]);
+    });
+    it('should preserve embedded inline entries', ()=>{
+        const paragraphWithEmbedded = buildParagraph([
+            {
+                text: 'text 1 '
+            },
+            {
+                type: _richtexttypes.INLINES.EMBEDDED_ENTRY,
+                children: [
+                    {
+                        text: ''
+                    }
+                ],
+                data: {
+                    target: {
+                        sys: {
+                            id: 'inline-id',
+                            linkType: 'Entry',
+                            type: 'Link'
+                        }
+                    }
+                }
+            }
+        ]);
+        const element = {
+            data: {},
+            isVoid: false,
+            type: _richtexttypes.BLOCKS.QUOTE,
+            children: [
+                paragraphWithEmbedded,
+                paragraph('text 2')
+            ]
+        };
+        const editor = createEditor([
+            element
+        ]);
+        const path = [
+            0
+        ];
+        expect((0, _extractNodes.extractParagraphs)(editor, path)).toEqual([
+            paragraphWithEmbedded,
+            paragraph('text 2')
+        ]);
+    });
+});

package/dist/cjs/helpers/__tests__/removeInternalMarks.test.js

@@ -0,0 +1,68 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+const _contentfulslatejsadapter = require("@contentful/contentful-slatejs-adapter");
+const _constants = require("../../plugins/CommandPalette/constants");
+const _testutils = require("../../test-utils");
+const _removeInternalMarks = require("../removeInternalMarks");
+describe('internal mark', ()=>{
+    describe('First level nodes', ()=>{
+        const data = [
+            {
+                title: 'Paragraph mark is removed',
+                input: (0, _contentfulslatejsadapter.toContentfulDocument)({
+                    document: (0, _testutils.jsx)("editor", null, (0, _testutils.jsx)("hp", null, (0, _testutils.jsx)("htext", {
+                        [_constants.COMMAND_PROMPT]: true
+                    }))).children
+                }),
+                expected: (0, _contentfulslatejsadapter.toContentfulDocument)({
+                    document: (0, _testutils.jsx)("editor", null, (0, _testutils.jsx)("hp", null, (0, _testutils.jsx)("htext", null))).children
+                })
+            },
+            {
+                title: 'Heading mark is removed',
+                input: (0, _contentfulslatejsadapter.toContentfulDocument)({
+                    document: (0, _testutils.jsx)("editor", null, (0, _testutils.jsx)("hh1", null, (0, _testutils.jsx)("htext", {
+                        [_constants.COMMAND_PROMPT]: true
+                    }))).children
+                }),
+                expected: (0, _contentfulslatejsadapter.toContentfulDocument)({
+                    document: (0, _testutils.jsx)("editor", null, (0, _testutils.jsx)("hh1", null, (0, _testutils.jsx)("htext", null))).children
+                })
+            },
+            {
+                title: 'Block quote mark is removed',
+                input: (0, _contentfulslatejsadapter.toContentfulDocument)({
+                    document: (0, _testutils.jsx)("editor", null, (0, _testutils.jsx)("hquote", null, (0, _testutils.jsx)("hp", null, (0, _testutils.jsx)("htext", {
+                        [_constants.COMMAND_PROMPT]: true
+                    })))).children
+                }),
+                expected: (0, _contentfulslatejsadapter.toContentfulDocument)({
+                    document: (0, _testutils.jsx)("editor", null, (0, _testutils.jsx)("hquote", null, (0, _testutils.jsx)("hp", null, (0, _testutils.jsx)("htext", null)))).children
+                })
+            },
+            {
+                title: 'Other marks are not removed',
+                input: (0, _contentfulslatejsadapter.toContentfulDocument)({
+                    document: (0, _testutils.jsx)("editor", null, (0, _testutils.jsx)("hquote", null, (0, _testutils.jsx)("hp", null, (0, _testutils.jsx)("htext", {
+                        bold: true,
+                        underline: true,
+                        [_constants.COMMAND_PROMPT]: true
+                    })))).children
+                }),
+                expected: (0, _contentfulslatejsadapter.toContentfulDocument)({
+                    document: (0, _testutils.jsx)("editor", null, (0, _testutils.jsx)("hquote", null, (0, _testutils.jsx)("hp", null, (0, _testutils.jsx)("htext", {
+                        bold: true,
+                        underline: true
+                    })))).children
+                })
+            }
+        ];
+        for (const { input , expected , title  } of data){
+            it(`${title}`, ()=>{
+                expect((0, _removeInternalMarks.removeInternalMarks)(input)).toEqual(expected);
+            });
+        }
+    });
+});

package/dist/cjs/helpers/__tests__/validations.test.js

@@ -0,0 +1,49 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+const _fieldeditortestutils = require("@contentful/field-editor-test-utils");
+const _richtexttypes = require("@contentful/rich-text-types");
+const _validations = require("../validations");
+describe('validations', ()=>{
+    describe('isMarkEnabled', ()=>{
+        [
+            _richtexttypes.MARKS.BOLD,
+            _richtexttypes.MARKS.CODE,
+            _richtexttypes.MARKS.ITALIC,
+            _richtexttypes.MARKS.UNDERLINE
+        ].forEach((mark)=>{
+            it(`returns true for ${mark} mark when no validation explicity set`, ()=>{
+                const [field] = (0, _fieldeditortestutils.createFakeFieldAPI)();
+                const actual = (0, _validations.isMarkEnabled)(field, mark);
+                expect(actual).toBe(true);
+            });
+            it(`returns false for ${mark} mark when validation explicity set without it`, ()=>{
+                const [field] = (0, _fieldeditortestutils.createFakeFieldAPI)((field)=>{
+                    field.validations = [
+                        {
+                            enabledMarks: Object.values(_richtexttypes.MARKS).filter((markDefintion)=>markDefintion !== mark)
+                        }
+                    ];
+                    return field;
+                });
+                const actual = (0, _validations.isMarkEnabled)(field, mark);
+                expect(actual).toBe(false);
+            });
+            it(`returns true for ${mark} mark when validation explicity set with it`, ()=>{
+                const [field] = (0, _fieldeditortestutils.createFakeFieldAPI)((field)=>{
+                    field.validations = [
+                        {
+                            enabledMarks: [
+                                mark
+                            ]
+                        }
+                    ];
+                    return field;
+                });
+                const actual = (0, _validations.isMarkEnabled)(field, mark);
+                expect(actual).toBe(true);
+            });
+        });
+    });
+});

package/dist/cjs/helpers/editor.js

@@ -0,0 +1,276 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+function _export(target, all) {
+    for(var name in all)Object.defineProperty(target, name, {
+        enumerable: true,
+        get: all[name]
+    });
+}
+_export(exports, {
+    LINK_TYPES: function() {
+        return LINK_TYPES;
+    },
+    isBlockSelected: function() {
+        return isBlockSelected;
+    },
+    isRootLevel: function() {
+        return isRootLevel;
+    },
+    getNodeEntryFromSelection: function() {
+        return getNodeEntryFromSelection;
+    },
+    isNodeTypeSelected: function() {
+        return isNodeTypeSelected;
+    },
+    moveToTheNextLine: function() {
+        return moveToTheNextLine;
+    },
+    moveToTheNextChar: function() {
+        return moveToTheNextChar;
+    },
+    insertEmptyParagraph: function() {
+        return insertEmptyParagraph;
+    },
+    getElementFromCurrentSelection: function() {
+        return getElementFromCurrentSelection;
+    },
+    isList: function() {
+        return isList;
+    },
+    getTableSize: function() {
+        return getTableSize;
+    },
+    insertLink: function() {
+        return insertLink;
+    },
+    isLinkActive: function() {
+        return isLinkActive;
+    },
+    unwrapLink: function() {
+        return unwrapLink;
+    },
+    wrapLink: function() {
+        return wrapLink;
+    },
+    getAncestorPathFromSelection: function() {
+        return getAncestorPathFromSelection;
+    },
+    isAtEndOfTextSelection: function() {
+        return isAtEndOfTextSelection;
+    },
+    getNextNode: function() {
+        return getNextNode;
+    },
+    INLINE_TYPES: function() {
+        return INLINE_TYPES;
+    },
+    isInlineOrText: function() {
+        return isInlineOrText;
+    },
+    focus: function() {
+        return focus;
+    },
+    toggleElement: function() {
+        return toggleElement;
+    }
+});
+const _richtexttypes = require("@contentful/rich-text-types");
+const _misc = require("../internal/misc");
+const _queries = require("../internal/queries");
+const _transforms = require("../internal/transforms");
+const _environment = require("./environment");
+const LINK_TYPES = [
+    _richtexttypes.INLINES.HYPERLINK,
+    _richtexttypes.INLINES.ENTRY_HYPERLINK,
+    _richtexttypes.INLINES.ASSET_HYPERLINK
+];
+const LIST_TYPES = [
+    _richtexttypes.BLOCKS.OL_LIST,
+    _richtexttypes.BLOCKS.UL_LIST
+];
+function isBlockSelected(editor, type) {
+    const [match] = Array.from((0, _queries.getNodeEntries)(editor, {
+        match: (node)=>(0, _queries.isElement)(node) && node.type === type
+    }));
+    return !!match;
+}
+function isRootLevel(path) {
+    return path.length === 1;
+}
+function getNodeEntryFromSelection(editor, nodeTypeOrTypes, path) {
+    path = path ?? editor.selection?.focus.path;
+    if (!path) return [];
+    const nodeTypes = Array.isArray(nodeTypeOrTypes) ? nodeTypeOrTypes : [
+        nodeTypeOrTypes
+    ];
+    for(let i = 0; i < path.length; i++){
+        const nodeEntry = (0, _queries.getNodeEntry)(editor, path.slice(0, i + 1));
+        if (nodeTypes.includes(nodeEntry[0].type)) return nodeEntry;
+    }
+    return [];
+}
+function isNodeTypeSelected(editor, nodeType) {
+    if (!editor) return false;
+    const [node] = getNodeEntryFromSelection(editor, nodeType);
+    return !!node;
+}
+function moveToTheNextLine(editor) {
+    (0, _transforms.moveSelection)(editor, {
+        distance: 1,
+        unit: 'line'
+    });
+}
+function moveToTheNextChar(editor) {
+    (0, _transforms.moveSelection)(editor, {
+        distance: 1,
+        unit: 'offset'
+    });
+}
+function insertEmptyParagraph(editor, options) {
+    const emptyParagraph = {
+        type: _richtexttypes.BLOCKS.PARAGRAPH,
+        children: [
+            {
+                text: ''
+            }
+        ],
+        data: {},
+        isVoid: false
+    };
+    (0, _transforms.insertNodes)(editor, emptyParagraph, options);
+}
+function getElementFromCurrentSelection(editor) {
+    if (!editor.selection) return [];
+    return Array.from((0, _queries.getNodeEntries)(editor, {
+        at: editor.selection,
+        match: (node)=>(0, _queries.isElement)(node)
+    })).flat();
+}
+function isList(editor) {
+    if (!editor) {
+        return false;
+    }
+    const element = getElementFromCurrentSelection(editor);
+    return element.some((element)=>(0, _queries.isElement)(element) && LIST_TYPES.includes(element.type));
+}
+function getTableSize(table) {
+    const numRows = table.children.length;
+    if (!numRows) return null;
+    const [firstRow] = table.children;
+    const numColumns = firstRow.children?.length;
+    return {
+        numRows,
+        numColumns
+    };
+}
+function insertLink(editor, options) {
+    if (editor.selection) {
+        wrapLink(editor, options);
+    }
+}
+function isLinkActive(editor) {
+    if (!editor) {
+        return false;
+    }
+    const [link] = Array.from((0, _queries.getNodeEntries)(editor, {
+        match: (node)=>!(0, _queries.isEditor)(node) && (0, _queries.isElement)(node) && LINK_TYPES.includes(node.type)
+    }));
+    return !!link;
+}
+function unwrapLink(editor) {
+    (0, _transforms.unwrapNodes)(editor, {
+        match: (node)=>!(0, _queries.isEditor)(node) && (0, _queries.isElement)(node) && LINK_TYPES.includes(node.type)
+    });
+}
+function wrapLink(editor, { text , url , target , type , path  }) {
+    if (isLinkActive(editor) && !path) {
+        unwrapLink(editor);
+    }
+    const { selection  } = editor;
+    const isCollapsed = selection && (0, _queries.isRangeCollapsed)(selection);
+    const link = {
+        type,
+        data: {},
+        children: isCollapsed ? [
+            {
+                text
+            }
+        ] : []
+    };
+    if (url) {
+        link.data = {
+            uri: url
+        };
+    }
+    if (target) {
+        link.data = {
+            target
+        };
+    }
+    if (path) {
+        (0, _transforms.setNodes)(editor, link, {
+            at: path
+        });
+        (0, _transforms.insertText)(editor, text, {
+            at: path
+        });
+        (0, _transforms.select)(editor, path);
+    } else if (isCollapsed) {
+        (0, _transforms.insertNodes)(editor, link);
+    } else {
+        (0, _transforms.wrapNodes)(editor, link, {
+            split: true
+        });
+        (0, _transforms.deleteText)(editor);
+        (0, _transforms.insertText)(editor, text);
+        (0, _transforms.collapseSelection)(editor, {
+            edge: 'end'
+        });
+    }
+}
+function getAncestorPathFromSelection(editor) {
+    if (!editor.selection) return undefined;
+    return (0, _queries.getPathLevels)(editor.selection.focus.path).find((level)=>level.length === 1);
+}
+const isAtEndOfTextSelection = (editor)=>editor.selection?.focus.offset === (0, _queries.getText)(editor, editor.selection?.focus.path).length;
+function getNextNode(editor) {
+    if (!editor.selection) {
+        return null;
+    }
+    const descendants = (0, _queries.getNodeDescendants)(editor, {
+        from: editor.selection.focus.path
+    });
+    while(true){
+        const { done , value  } = descendants.next();
+        if (done) {
+            return null;
+        }
+        const [node, path] = value;
+        if ((0, _queries.isCommonPath)(path, editor.selection.focus.path)) {
+            continue;
+        }
+        return node;
+    }
+}
+const INLINE_TYPES = Object.values(_richtexttypes.INLINES);
+const isInlineOrText = (node)=>{
+    return (0, _queries.isText)(node) || (0, _queries.isElement)(node) && INLINE_TYPES.includes(node.type);
+};
+const focus = (editor)=>{
+    const x = window.scrollX;
+    const y = window.scrollY;
+    (0, _misc.focusEditor)(editor);
+    if (_environment.IS_SAFARI) {
+        setTimeout(function() {
+            window.scrollTo(x, y);
+        }, 0);
+    }
+};
+function toggleElement(editor, options, editorOptions) {
+    (0, _transforms.toggleNodeType)(editor, options, editorOptions);
+    (0, _transforms.setNodes)(editor, {
+        data: {}
+    });
+}