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

package/dist/cjs/plugins/List/components/ListItem.js

@@ -0,0 +1,73 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "ListItem", {
+    enumerable: true,
+    get: function() {
+        return ListItem;
+    }
+});
+const _react = _interop_require_wildcard(require("react"));
+const _f36tokens = _interop_require_default(require("@contentful/f36-tokens"));
+const _emotion = require("emotion");
+function _interop_require_default(obj) {
+    return obj && obj.__esModule ? obj : {
+        default: obj
+    };
+}
+function _getRequireWildcardCache(nodeInterop) {
+    if (typeof WeakMap !== "function") return null;
+    var cacheBabelInterop = new WeakMap();
+    var cacheNodeInterop = new WeakMap();
+    return (_getRequireWildcardCache = function(nodeInterop) {
+        return nodeInterop ? cacheNodeInterop : cacheBabelInterop;
+    })(nodeInterop);
+}
+function _interop_require_wildcard(obj, nodeInterop) {
+    if (!nodeInterop && obj && obj.__esModule) {
+        return obj;
+    }
+    if (obj === null || typeof obj !== "object" && typeof obj !== "function") {
+        return {
+            default: obj
+        };
+    }
+    var cache = _getRequireWildcardCache(nodeInterop);
+    if (cache && cache.has(obj)) {
+        return cache.get(obj);
+    }
+    var newObj = {};
+    var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor;
+    for(var key in obj){
+        if (key !== "default" && Object.prototype.hasOwnProperty.call(obj, key)) {
+            var desc = hasPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : null;
+            if (desc && (desc.get || desc.set)) {
+                Object.defineProperty(newObj, key, desc);
+            } else {
+                newObj[key] = obj[key];
+            }
+        }
+    }
+    newObj.default = obj;
+    if (cache) {
+        cache.set(obj, newObj);
+    }
+    return newObj;
+}
+const style = (0, _emotion.css)`
+  margin: 0;
+  list-style: inherit;
+  margin-top: ${_f36tokens.default.spacingXs};
+
+  ol,
+  ul {
+    margin: 0 0 0 ${_f36tokens.default.spacingL};
+  }
+`;
+function ListItem(props) {
+    return _react.createElement("li", {
+        ...props.attributes,
+        className: style
+    }, props.children);
+}

package/dist/cjs/plugins/List/components/ToolbarListButton.js

@@ -0,0 +1,86 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "ToolbarListButton", {
+    enumerable: true,
+    get: function() {
+        return ToolbarListButton;
+    }
+});
+const _react = _interop_require_wildcard(require("react"));
+const _f36icons = require("@contentful/f36-icons");
+const _richtexttypes = require("@contentful/rich-text-types");
+const _ContentfulEditorProvider = require("../../../ContentfulEditorProvider");
+const _editor = require("../../../helpers/editor");
+const _validations = require("../../../helpers/validations");
+const _SdkProvider = require("../../../SdkProvider");
+const _ToolbarButton = require("../../shared/ToolbarButton");
+const _toggleList = require("../transforms/toggleList");
+const _utils = require("../utils");
+function _getRequireWildcardCache(nodeInterop) {
+    if (typeof WeakMap !== "function") return null;
+    var cacheBabelInterop = new WeakMap();
+    var cacheNodeInterop = new WeakMap();
+    return (_getRequireWildcardCache = function(nodeInterop) {
+        return nodeInterop ? cacheNodeInterop : cacheBabelInterop;
+    })(nodeInterop);
+}
+function _interop_require_wildcard(obj, nodeInterop) {
+    if (!nodeInterop && obj && obj.__esModule) {
+        return obj;
+    }
+    if (obj === null || typeof obj !== "object" && typeof obj !== "function") {
+        return {
+            default: obj
+        };
+    }
+    var cache = _getRequireWildcardCache(nodeInterop);
+    if (cache && cache.has(obj)) {
+        return cache.get(obj);
+    }
+    var newObj = {};
+    var hasPropertyDescriptor = Object.defineProperty && Object.getOwnPropertyDescriptor;
+    for(var key in obj){
+        if (key !== "default" && Object.prototype.hasOwnProperty.call(obj, key)) {
+            var desc = hasPropertyDescriptor ? Object.getOwnPropertyDescriptor(obj, key) : null;
+            if (desc && (desc.get || desc.set)) {
+                Object.defineProperty(newObj, key, desc);
+            } else {
+                newObj[key] = obj[key];
+            }
+        }
+    }
+    newObj.default = obj;
+    if (cache) {
+        cache.set(obj, newObj);
+    }
+    return newObj;
+}
+function ToolbarListButton(props) {
+    const sdk = (0, _SdkProvider.useSdkContext)();
+    const editor = (0, _ContentfulEditorProvider.useContentfulEditor)();
+    function handleClick(type) {
+        return ()=>{
+            if (!editor?.selection) return;
+            (0, _toggleList.toggleList)(editor, {
+                type
+            });
+            (0, _editor.focus)(editor);
+        };
+    }
+    if (!editor) return null;
+    return _react.createElement(_react.Fragment, null, (0, _validations.isNodeTypeEnabled)(sdk.field, _richtexttypes.BLOCKS.UL_LIST) && _react.createElement(_ToolbarButton.ToolbarButton, {
+        title: "UL",
+        testId: "ul-toolbar-button",
+        onClick: handleClick(_richtexttypes.BLOCKS.UL_LIST),
+        isActive: (0, _utils.isListTypeActive)(editor, _richtexttypes.BLOCKS.UL_LIST),
+        isDisabled: props.isDisabled
+    }, _react.createElement(_f36icons.ListBulletedIcon, null)), (0, _validations.isNodeTypeEnabled)(sdk.field, _richtexttypes.BLOCKS.OL_LIST) && _react.createElement(_ToolbarButton.ToolbarButton, {
+        title: "OL",
+        testId: "ol-toolbar-button",
+        onClick: handleClick(_richtexttypes.BLOCKS.OL_LIST),
+        isActive: (0, _utils.isListTypeActive)(editor, _richtexttypes.BLOCKS.OL_LIST),
+        isDisabled: props.isDisabled
+    }, _react.createElement(_f36icons.ListNumberedIcon, null)));
+}

package/dist/cjs/plugins/List/createListPlugin.js

@@ -0,0 +1,76 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "createListPlugin", {
+    enumerable: true,
+    get: function() {
+        return createListPlugin;
+    }
+});
+const _richtexttypes = require("@contentful/rich-text-types");
+const _platelist = require("@udecode/plate-list");
+const _transformers = require("../../helpers/transformers");
+const _List = require("./components/List");
+const _ListItem = require("./components/ListItem");
+const _onKeyDownList = require("./onKeyDownList");
+const _utils = require("./utils");
+const _withList = require("./withList");
+const createListPlugin = ()=>(0, _platelist.createListPlugin)({
+        normalizer: [
+            {
+                match: {
+                    type: [
+                        _richtexttypes.BLOCKS.UL_LIST,
+                        _richtexttypes.BLOCKS.OL_LIST
+                    ]
+                },
+                validChildren: [
+                    _richtexttypes.BLOCKS.LIST_ITEM
+                ],
+                transform: (0, _transformers.transformWrapIn)(_richtexttypes.BLOCKS.LIST_ITEM)
+            }
+        ],
+        overrideByKey: {
+            [_platelist.ELEMENT_UL]: {
+                type: _richtexttypes.BLOCKS.UL_LIST,
+                component: _List.ListUL,
+                handlers: {
+                    onKeyDown: _onKeyDownList.onKeyDownList
+                },
+                withOverrides: _withList.withList
+            },
+            [_platelist.ELEMENT_OL]: {
+                type: _richtexttypes.BLOCKS.OL_LIST,
+                component: _List.ListOL,
+                handlers: {
+                    onKeyDown: _onKeyDownList.onKeyDownList
+                }
+            },
+            [_platelist.ELEMENT_LIC]: {
+                type: _richtexttypes.BLOCKS.PARAGRAPH
+            },
+            [_platelist.ELEMENT_LI]: {
+                type: _richtexttypes.BLOCKS.LIST_ITEM,
+                component: _ListItem.ListItem,
+                normalizer: [
+                    {
+                        validNode: _utils.hasListAsDirectParent,
+                        transform: _utils.normalizeOrphanedListItem
+                    },
+                    {
+                        validNode: _utils.isNonEmptyListItem,
+                        transform: _utils.insertParagraphAsChild
+                    },
+                    {
+                        validChildren: _richtexttypes.LIST_ITEM_BLOCKS,
+                        transform: _transformers.transformParagraphs
+                    },
+                    {
+                        validNode: _utils.firstNodeIsNotList,
+                        transform: _utils.replaceNodeWithListItems
+                    }
+                ]
+            }
+        }
+    });

package/dist/cjs/plugins/List/index.js

@@ -0,0 +1,19 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+_export_star(require("./createListPlugin"), exports);
+_export_star(require("./components/ToolbarListButton"), exports);
+function _export_star(from, to) {
+    Object.keys(from).forEach(function(k) {
+        if (k !== "default" && !Object.prototype.hasOwnProperty.call(to, k)) {
+            Object.defineProperty(to, k, {
+                enumerable: true,
+                get: function() {
+                    return from[k];
+                }
+            });
+        }
+    });
+    return from;
+}

package/dist/cjs/plugins/List/insertListBreak.js

@@ -0,0 +1,60 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "insertListBreak", {
+    enumerable: true,
+    get: function() {
+        return insertListBreak;
+    }
+});
+const _richtexttypes = require("@contentful/rich-text-types");
+const _platecore = require("@udecode/plate-core");
+const _platelist = require("@udecode/plate-list");
+const _plateresetnode = require("@udecode/plate-reset-node");
+const _insertListItem = require("./transforms/insertListItem");
+const listBreak = (editor)=>{
+    if (!editor.selection) return false;
+    const res = (0, _platelist.getListItemEntry)(editor, {});
+    let moved;
+    if (res) {
+        const { list , listItem  } = res;
+        const childNode = listItem[0].children[0];
+        if ((0, _platecore.isBlockAboveEmpty)(editor) && listItem[0].children.length === 1 && _richtexttypes.TEXT_CONTAINERS.includes(childNode.type)) {
+            moved = (0, _platelist.moveListItemUp)(editor, {
+                list,
+                listItem
+            });
+            if (moved) return true;
+        }
+    }
+    const didReset = (0, _plateresetnode.onKeyDownResetNode)(editor, (0, _platecore.mockPlugin)({
+        options: {
+            rules: [
+                {
+                    types: [
+                        (0, _platecore.getPluginType)(editor, _platelist.ELEMENT_LI)
+                    ],
+                    defaultType: (0, _platecore.getPluginType)(editor, _platecore.ELEMENT_DEFAULT),
+                    predicate: ()=>!moved && (0, _platecore.isBlockAboveEmpty)(editor),
+                    onReset: (_editor)=>(0, _platelist.unwrapList)(_editor)
+                }
+            ]
+        }
+    }))(_plateresetnode.SIMULATE_BACKSPACE);
+    if (didReset) {
+        return true;
+    }
+    if (!moved) {
+        const inserted = (0, _insertListItem.insertListItem)(editor);
+        if (inserted) return true;
+    }
+    return false;
+};
+const insertListBreak = (editor)=>{
+    const { insertBreak  } = editor;
+    return ()=>{
+        if (listBreak(editor)) return;
+        insertBreak();
+    };
+};

package/dist/cjs/plugins/List/insertListFragment.js

@@ -0,0 +1,98 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "insertListFragment", {
+    enumerable: true,
+    get: function() {
+        return insertListFragment;
+    }
+});
+const _richtexttypes = require("@contentful/rich-text-types");
+const _platecore = require("@udecode/plate-core");
+const _queries = require("../../internal/queries");
+const _transforms = require("../../internal/transforms");
+const getFirstAncestorOfType = (root, entry)=>{
+    let ancestor = (0, _queries.getParentPath)(entry[1]);
+    while((0, _queries.getDescendantNodeByPath)(root, ancestor).type !== _richtexttypes.BLOCKS.LIST_ITEM){
+        ancestor = (0, _queries.getParentPath)(ancestor);
+    }
+    return [
+        (0, _queries.getDescendantNodeByPath)(root, ancestor),
+        ancestor
+    ];
+};
+const isListRoot = (node)=>[
+        _richtexttypes.BLOCKS.UL_LIST,
+        _richtexttypes.BLOCKS.OL_LIST
+    ].includes(node.type);
+const trimList = (listRoot)=>{
+    if (!isListRoot(listRoot)) {
+        return [
+            listRoot
+        ];
+    }
+    const textEntries = Array.from((0, _queries.getNodeTexts)(listRoot));
+    const commonAncestorEntry = textEntries.reduce((commonAncestor, textEntry)=>(0, _queries.isAncestorPath)(commonAncestor[1], textEntry[1]) ? commonAncestor : (0, _queries.getCommonNode)(listRoot, textEntry[1], commonAncestor[1]), getFirstAncestorOfType(listRoot, textEntries[0]));
+    return isListRoot(commonAncestorEntry[0]) ? commonAncestorEntry[0].children : [
+        commonAncestorEntry[0]
+    ];
+};
+const trimLiWrapper = (nodes)=>{
+    if (nodes.length !== 1) {
+        return nodes;
+    }
+    const node = nodes[0];
+    if (node.type !== _richtexttypes.BLOCKS.LIST_ITEM || node.children.length !== 1) {
+        return nodes;
+    }
+    return node.children;
+};
+const unwrapTextContainerAtStart = (nodes)=>{
+    const node = nodes[0];
+    if (_richtexttypes.TEXT_CONTAINERS.includes(node.type)) {
+        return [
+            ...node.children,
+            ...nodes.slice(1)
+        ];
+    }
+    return nodes;
+};
+const insertListFragment = (editor)=>{
+    const { insertFragment  } = editor;
+    return (fragment)=>{
+        if (!editor.selection) {
+            return;
+        }
+        const liEntry = (0, _platecore.findNode)(editor, {
+            match: {
+                type: _richtexttypes.BLOCKS.LIST_ITEM
+            },
+            mode: 'lowest'
+        });
+        if (liEntry) {
+            const nodes = unwrapTextContainerAtStart(trimLiWrapper(fragment.flatMap((node)=>trimList(node))));
+            let firstBlockIndex = nodes.findIndex((node)=>(0, _queries.isBlockNode)(editor, node));
+            if (firstBlockIndex < 0) {
+                firstBlockIndex = nodes.length;
+            }
+            const inlines = nodes.slice(0, firstBlockIndex);
+            const blocks = nodes.slice(firstBlockIndex);
+            (0, _transforms.insertNodes)(editor, inlines, {
+                at: editor.selection,
+                select: true
+            });
+            return (0, _transforms.insertNodes)(editor, blocks, {
+                at: editor.selection,
+                select: true
+            });
+        }
+        const filtered = isListRoot(fragment[0]) ? [
+            {
+                text: ''
+            },
+            ...fragment
+        ] : fragment;
+        return insertFragment(filtered);
+    };
+};

package/dist/cjs/plugins/List/onKeyDownList.js

@@ -0,0 +1,46 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "onKeyDownList", {
+    enumerable: true,
+    get: function() {
+        return onKeyDownList;
+    }
+});
+const _ishotkey = _interop_require_default(require("is-hotkey"));
+const _castArray = _interop_require_default(require("lodash/castArray"));
+const _queries = require("../../internal/queries");
+const _moveListItems = require("./transforms/moveListItems");
+const _toggleList = require("./transforms/toggleList");
+function _interop_require_default(obj) {
+    return obj && obj.__esModule ? obj : {
+        default: obj
+    };
+}
+const onKeyDownList = (editor, { type , options: { hotkey  }  })=>(e)=>{
+        if (e.key === 'Tab' && editor.selection) {
+            const listSelected = (0, _queries.getAboveNode)(editor, {
+                at: editor.selection,
+                match: {
+                    type
+                }
+            });
+            if (listSelected) {
+                e.preventDefault();
+                (0, _moveListItems.moveListItems)(editor, {
+                    increase: !e.shiftKey
+                });
+                return;
+            }
+        }
+        if (!hotkey) return;
+        const hotkeys = (0, _castArray.default)(hotkey);
+        for (const _hotkey of hotkeys){
+            if ((0, _ishotkey.default)(_hotkey)(e)) {
+                (0, _toggleList.toggleList)(editor, {
+                    type
+                });
+            }
+        }
+    };

package/dist/cjs/plugins/List/transforms/insertListItem.js

@@ -0,0 +1,92 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "insertListItem", {
+    enumerable: true,
+    get: function() {
+        return insertListItem;
+    }
+});
+const _richtexttypes = require("@contentful/rich-text-types");
+const _internal = require("../../../internal");
+const _queries = require("../../../internal/queries");
+const _transforms = require("../../../internal/transforms");
+const emptyListItemNode = (editor, withChildren = false)=>{
+    let children = [];
+    if (withChildren) {
+        const marks = (0, _queries.getMarks)(editor) || {};
+        children = [
+            {
+                type: _richtexttypes.BLOCKS.PARAGRAPH,
+                data: {},
+                children: [
+                    {
+                        text: '',
+                        ...marks
+                    }
+                ]
+            }
+        ];
+    }
+    return {
+        type: _richtexttypes.BLOCKS.LIST_ITEM,
+        data: {},
+        children
+    };
+};
+const insertListItem = (editor)=>{
+    if (!editor.selection) {
+        return false;
+    }
+    const paragraph = (0, _queries.getAboveNode)(editor, {
+        match: {
+            type: _richtexttypes.TEXT_CONTAINERS
+        }
+    });
+    if (!paragraph) {
+        return false;
+    }
+    const [, paragraphPath] = paragraph;
+    const listItem = (0, _queries.getParentNode)(editor, paragraphPath);
+    if (!listItem) {
+        return false;
+    }
+    const [listItemNode, listItemPath] = listItem;
+    if (listItemNode.type !== _richtexttypes.BLOCKS.LIST_ITEM) {
+        return false;
+    }
+    (0, _internal.withoutNormalizing)(editor, ()=>{
+        if (!editor.selection) {
+            return;
+        }
+        const isAtStart = (0, _queries.isSelectionAtBlockStart)(editor);
+        const isAtEnd = (0, _queries.isSelectionAtBlockEnd)(editor);
+        const isAtStartOfListItem = isAtStart && (0, _queries.isFirstChildPath)(paragraphPath);
+        const shouldSplit = !isAtStart && !isAtEnd;
+        if (shouldSplit) {
+            (0, _transforms.splitNodes)(editor);
+        }
+        const newListItemPath = isAtStartOfListItem ? listItemPath : (0, _queries.getNextPath)(listItemPath);
+        (0, _transforms.insertNodes)(editor, emptyListItemNode(editor, !shouldSplit), {
+            at: newListItemPath
+        });
+        const fromPath = isAtStart ? paragraphPath : (0, _queries.getNextPath)(paragraphPath);
+        const fromStartIndex = fromPath[fromPath.length - 1] || 0;
+        const toPath = newListItemPath.concat([
+            shouldSplit ? 0 : 1
+        ]);
+        if (!isAtStartOfListItem) {
+            (0, _transforms.moveChildren)(editor, {
+                at: listItemPath,
+                to: toPath,
+                fromStartIndex
+            });
+        }
+        (0, _transforms.select)(editor, newListItemPath);
+        (0, _transforms.collapseSelection)(editor, {
+            edge: 'start'
+        });
+    });
+    return true;
+};

package/dist/cjs/plugins/List/transforms/moveListItemDown.js

@@ -0,0 +1,47 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "moveListItemDown", {
+    enumerable: true,
+    get: function() {
+        return moveListItemDown;
+    }
+});
+const _platelist = require("@udecode/plate-list");
+const _misc = require("../../../internal/misc");
+const _queries = require("../../../internal/queries");
+const _transforms = require("../../../internal/transforms");
+const moveListItemDown = (editor, { list , listItem  })=>{
+    const [listNode] = list;
+    const [, listItemPath] = listItem;
+    let previousListItemPath;
+    try {
+        previousListItemPath = (0, _queries.getPreviousPath)(listItemPath);
+    } catch (e) {
+        return;
+    }
+    const previousSiblingItem = (0, _queries.getNodeEntry)(editor, previousListItemPath);
+    if (previousSiblingItem) {
+        const [, previousPath] = previousSiblingItem;
+        const subList = Array.from((0, _queries.getNodeChildren)(editor, previousPath)).find(([n, path])=>(0, _queries.match)(n, path, {
+                type: (0, _platelist.getListTypes)(editor)
+            }));
+        const newPath = (0, _queries.getNextPath)((0, _queries.getLastChildPath)(subList ?? previousSiblingItem));
+        (0, _misc.withoutNormalizing)(editor, ()=>{
+            if (!subList) {
+                (0, _transforms.wrapNodes)(editor, {
+                    type: listNode.type,
+                    children: [],
+                    data: {}
+                }, {
+                    at: listItemPath
+                });
+            }
+            (0, _transforms.moveNodes)(editor, {
+                at: listItemPath,
+                to: newPath
+            });
+        });
+    }
+};

package/dist/cjs/plugins/List/transforms/moveListItems.js

@@ -0,0 +1,56 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "moveListItems", {
+    enumerable: true,
+    get: function() {
+        return moveListItems;
+    }
+});
+const _platelist = require("@udecode/plate-list");
+const _misc = require("../../../internal/misc");
+const _queries = require("../../../internal/queries");
+const _moveListItemDown = require("./moveListItemDown");
+const moveListItems = (editor, { increase =true , at =editor.selection ?? undefined  } = {})=>{
+    const _nodes = (0, _queries.getNodeEntries)(editor, {
+        at,
+        match: {
+            type: (0, _queries.getPluginType)(editor, _platelist.ELEMENT_LIC)
+        }
+    });
+    const lics = Array.from(_nodes);
+    if (!lics.length) return;
+    const highestLicPaths = [];
+    const highestLicPathRefs = [];
+    lics.forEach((lic)=>{
+        const licPath = lic[1];
+        const liPath = (0, _queries.getParentPath)(licPath);
+        const isAncestor = highestLicPaths.some((path)=>{
+            const highestLiPath = (0, _queries.getParentPath)(path);
+            return (0, _queries.isAncestorPath)(highestLiPath, liPath);
+        });
+        if (!isAncestor) {
+            highestLicPaths.push(licPath);
+            highestLicPathRefs.push((0, _queries.createPathRef)(editor, licPath));
+        }
+    });
+    const licPathRefsToMove = increase ? highestLicPathRefs : highestLicPathRefs.reverse();
+    (0, _misc.withoutNormalizing)(editor, ()=>{
+        licPathRefsToMove.forEach((licPathRef)=>{
+            const licPath = licPathRef.unref();
+            if (!licPath) return;
+            const liEntry = (0, _platelist.getListItemEntry)(editor, {
+                at: licPath
+            });
+            if (!liEntry) {
+                return;
+            }
+            if (increase) {
+                (0, _moveListItemDown.moveListItemDown)(editor, liEntry);
+            } else if ((0, _platelist.isListNested)(editor, liEntry.list[1])) {
+                (0, _platelist.moveListItemUp)(editor, liEntry);
+            }
+        });
+    });
+};