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

package/dist/cjs/plugins/Table/helpers.js

@@ -0,0 +1,152 @@
+"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, {
+    insertTableAndFocusFirstCell: function() {
+        return insertTableAndFocusFirstCell;
+    },
+    isTableActive: function() {
+        return isTableActive;
+    },
+    isTableHeaderEnabled: function() {
+        return isTableHeaderEnabled;
+    },
+    replaceEmptyParagraphWithTable: function() {
+        return replaceEmptyParagraphWithTable;
+    },
+    getNoOfMissingTableCellsInRow: function() {
+        return getNoOfMissingTableCellsInRow;
+    },
+    createEmptyTableCells: function() {
+        return createEmptyTableCells;
+    },
+    isNotEmpty: function() {
+        return isNotEmpty;
+    },
+    isTable: function() {
+        return isTable;
+    }
+});
+const _richtexttypes = require("@contentful/rich-text-types");
+const _platetable = require("@udecode/plate-table");
+const _editor = require("../../helpers/editor");
+const _internal = require("../../internal");
+const _queries = require("../../internal/queries");
+const _transforms = require("../../internal/transforms");
+function insertTableAndFocusFirstCell(editor) {
+    const table = {
+        type: _richtexttypes.BLOCKS.TABLE,
+        data: {},
+        children: [
+            (0, _platetable.getEmptyRowNode)(editor, {
+                colCount: 2,
+                header: true
+            }),
+            (0, _platetable.getEmptyRowNode)(editor, {
+                colCount: 2
+            })
+        ]
+    };
+    (0, _transforms.insertNodes)(editor, table);
+    if (editor.selection) {
+        const tableEntry = (0, _queries.getBlockAbove)(editor, {
+            match: {
+                type: _richtexttypes.BLOCKS.TABLE
+            }
+        });
+        if (!tableEntry) return;
+        (0, _internal.selectEditor)(editor, {
+            at: (0, _queries.getStartPoint)(editor, tableEntry[1])
+        });
+    }
+    replaceEmptyParagraphWithTable(editor);
+}
+function isTableActive(editor) {
+    const tableElements = [
+        _platetable.ELEMENT_TABLE,
+        _platetable.ELEMENT_TH,
+        _platetable.ELEMENT_TR,
+        _platetable.ELEMENT_TD
+    ];
+    return tableElements.some((el)=>(0, _editor.isBlockSelected)(editor, el));
+}
+function isTableHeaderEnabled(editor) {
+    const tableItem = (0, _queries.getAboveNode)(editor, {
+        match: {
+            type: _richtexttypes.BLOCKS.TABLE
+        }
+    });
+    if (!tableItem) {
+        return false;
+    }
+    const firstRow = (0, _queries.getChildren)(tableItem)[0];
+    if (!firstRow) {
+        return false;
+    }
+    return (0, _queries.getChildren)(firstRow).every(([node])=>{
+        return node.type === _richtexttypes.BLOCKS.TABLE_HEADER_CELL;
+    });
+}
+function replaceEmptyParagraphWithTable(editor) {
+    const tablePath = (0, _editor.getAncestorPathFromSelection)(editor);
+    if (!tablePath || (0, _queries.isFirstChildPath)(tablePath)) return;
+    const previousPath = (0, _queries.getPreviousPath)(tablePath);
+    if (!previousPath) return;
+    const [nodes] = (0, _queries.getNodeEntries)(editor, {
+        at: previousPath,
+        match: (node)=>node.type === _richtexttypes.BLOCKS.PARAGRAPH
+    });
+    if (!nodes) return;
+    const [previousNode] = nodes;
+    const isPreviousNodeTextEmpty = (0, _queries.isAncestorEmpty)(editor, previousNode);
+    if (isPreviousNodeTextEmpty) {
+        (0, _transforms.moveNodes)(editor, {
+            at: tablePath,
+            to: previousPath
+        });
+        (0, _transforms.removeNodes)(editor, {
+            at: tablePath
+        });
+    }
+}
+const getNoOfMissingTableCellsInRow = (editor, rowEntry)=>{
+    const [, rowPath] = rowEntry;
+    const parent = (0, _queries.getParentNode)(editor, rowPath);
+    if (!parent) {
+        throw new Error('table rows must be wrapped in a table node');
+    }
+    const tableWidth = Math.max(...(0, _queries.getChildren)(parent).map((entry)=>(0, _queries.getChildren)(entry).length));
+    const rowWidth = (0, _queries.getChildren)(rowEntry).length;
+    return tableWidth - rowWidth;
+};
+const createEmptyTableCells = (count)=>{
+    const emptyTableCell = {
+        type: _richtexttypes.BLOCKS.TABLE_CELL,
+        data: {},
+        children: [
+            {
+                type: _richtexttypes.BLOCKS.PARAGRAPH,
+                data: {},
+                children: [
+                    {
+                        text: ''
+                    }
+                ]
+            }
+        ]
+    };
+    return new Array(count).fill(emptyTableCell);
+};
+const isNotEmpty = (_, entry)=>{
+    return (0, _queries.getChildren)(entry).length !== 0;
+};
+const isTable = (node)=>{
+    return (0, _queries.isElement)(node) && node.type === _richtexttypes.BLOCKS.TABLE;
+};

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

@@ -0,0 +1,19 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+_export_star(require("./createTablePlugin"), exports);
+_export_star(require("./components/ToolbarButton"), 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/Table/insertTableFragment.js

@@ -0,0 +1,50 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "insertTableFragment", {
+    enumerable: true,
+    get: function() {
+        return insertTableFragment;
+    }
+});
+const _richtexttypes = require("@contentful/rich-text-types");
+const _editor = require("../../helpers/editor");
+const _queries = require("../../internal/queries");
+const _helpers = require("./helpers");
+const trimUnnecessaryTableWrapper = (node)=>{
+    if (!(0, _queries.isElement)(node)) {
+        return [
+            node
+        ];
+    }
+    if (node.type !== _richtexttypes.BLOCKS.TABLE || node.children?.length !== 1) {
+        return [
+            node
+        ];
+    }
+    const row = node.children[0];
+    if (row?.children?.length !== 1) {
+        return [
+            node
+        ];
+    }
+    const cell = row.children[0];
+    return cell.children;
+};
+const insertTableFragment = (editor)=>{
+    const { insertFragment  } = editor;
+    return (fragments)=>{
+        if (!editor.selection) {
+            return;
+        }
+        fragments = fragments.flatMap(trimUnnecessaryTableWrapper);
+        const isInsertingTable = fragments.some((fragment)=>(0, _helpers.isTable)(fragment));
+        const isTableFirstFragment = fragments.findIndex((fragment)=>(0, _helpers.isTable)(fragment)) === 0;
+        const currentLineHasText = (0, _queries.getText)(editor, editor.selection?.focus.path) !== '';
+        if (isInsertingTable && isTableFirstFragment && currentLineHasText) {
+            (0, _editor.insertEmptyParagraph)(editor);
+        }
+        return insertFragment(fragments);
+    };
+};

package/dist/cjs/plugins/Table/onKeyDownTable.js

@@ -0,0 +1,62 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "onKeyDownTable", {
+    enumerable: true,
+    get: function() {
+        return onKeyDownTable;
+    }
+});
+const _richtexttypes = require("@contentful/rich-text-types");
+const _platetable = require("@udecode/plate-table");
+const _editor = require("../../helpers/editor");
+const _misc = require("../../internal/misc");
+const _queries = require("../../internal/queries");
+const _actions = require("./actions");
+const onKeyDownTable = (editor, plugin)=>{
+    const defaultHandler = (0, _platetable.onKeyDownTable)(editor, plugin);
+    return (event)=>{
+        const windowSelection = window.getSelection();
+        if (windowSelection) {
+            const blockType = windowSelection.anchorNode.attributes?.['data-block-type']?.value;
+            const isBeforeTable = blockType === _richtexttypes.BLOCKS.TABLE;
+            if (isBeforeTable) {
+                if (event.key === 'Enter') {
+                    const above = (0, _queries.getAboveNode)(editor, {
+                        match: {
+                            type: _richtexttypes.BLOCKS.TABLE
+                        }
+                    });
+                    if (!above) return;
+                    const [, tablePath] = above;
+                    (0, _editor.insertEmptyParagraph)(editor, {
+                        at: tablePath,
+                        select: true
+                    });
+                }
+                event.preventDefault();
+                event.stopPropagation();
+                return;
+            }
+        }
+        if (event.key === 'Tab' && !event.shiftKey) {
+            event.preventDefault();
+            const entry = (0, _platetable.getTableEntries)(editor, {});
+            if (entry) {
+                const { table , row , cell  } = entry;
+                const isLastCell = (0, _queries.isLastChildPath)(row, cell[1]);
+                const isLastRow = (0, _queries.isLastChildPath)(table, row[1]);
+                if (isLastRow && isLastCell) {
+                    (0, _actions.addRowBelow)(editor);
+                    return;
+                } else {
+                    defaultHandler(event);
+                }
+            }
+        }
+        if (event.key === 'Escape') {
+            (0, _misc.blurEditor)(editor);
+        }
+    };
+};

package/dist/cjs/plugins/Table/tableTracking.js

@@ -0,0 +1,64 @@
+"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, {
+    addTableTrackingEvents: function() {
+        return addTableTrackingEvents;
+    },
+    withInvalidCellChildrenTracking: function() {
+        return withInvalidCellChildrenTracking;
+    }
+});
+const _richtexttypes = require("@contentful/rich-text-types");
+const _queries = require("../../internal/queries");
+const _Tracking = require("../../plugins/Tracking");
+function hasTables(nodes) {
+    return nodes.some(({ type  })=>{
+        return type === _richtexttypes.BLOCKS.TABLE;
+    });
+}
+const isTableHeaderCell = ({ type  })=>type === _richtexttypes.BLOCKS.TABLE_HEADER_CELL;
+function hasHeadersOutsideFirstRow(nodes) {
+    return nodes.filter(({ type  })=>type === _richtexttypes.BLOCKS.TABLE).flatMap(({ children  })=>children.slice(1)).some(({ children  })=>children.some(isTableHeaderCell));
+}
+function addTableTrackingEvents(editor) {
+    const { insertData  } = editor;
+    editor.insertData = (data)=>{
+        const html = data.getData('text/html');
+        if (html) {
+            const { children: markupBefore  } = editor;
+            insertData(data);
+            const { children: markupAfter  } = editor;
+            setTimeout(()=>{
+                if (hasTables(markupBefore)) return;
+                if (hasTables(markupAfter)) {
+                    editor.tracking.onViewportAction('paste', {
+                        tablePasted: true,
+                        source: (0, _Tracking.getPastingSource)(data),
+                        hasHeadersOutsideFirstRow: hasHeadersOutsideFirstRow(markupAfter)
+                    });
+                }
+            }, 1);
+        } else {
+            insertData(data);
+        }
+    };
+}
+const withInvalidCellChildrenTracking = (transformer)=>{
+    return (editor, childEntry)=>{
+        const [node] = childEntry;
+        if ((0, _queries.isElement)(node)) {
+            editor.tracking?.onViewportAction('invalidTablePaste', {
+                nodeType: node.type
+            });
+        }
+        return transformer(editor, childEntry);
+    };
+};

package/dist/cjs/plugins/Text/__tests__/createTextPlugin.test.js

@@ -0,0 +1,79 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+const _testutils = require("../../../test-utils");
+describe('delete backward', ()=>{
+    const tests = [
+        {
+            title: 'deletes a character of the text inside li',
+            input: (0, _testutils.jsx)("hul", null, (0, _testutils.jsx)("hli", null, (0, _testutils.jsx)("hp", null, "p1", (0, _testutils.jsx)("cursor", null)))),
+            expected: (0, _testutils.jsx)("hul", null, (0, _testutils.jsx)("hli", null, (0, _testutils.jsx)("hp", null, "p", (0, _testutils.jsx)("cursor", null))))
+        },
+        {
+            title: 'deletes the empty paragraph at the beginning of the RTE followed by another paragraph',
+            input: (0, _testutils.jsx)("fragment", null, (0, _testutils.jsx)("hp", null, (0, _testutils.jsx)("cursor", null)), (0, _testutils.jsx)("hp", null, "text")),
+            expected: (0, _testutils.jsx)("hp", null, (0, _testutils.jsx)("cursor", null), "text")
+        },
+        {
+            title: 'deletes the empty paragraph at the beginning of the RTE followed by li',
+            input: (0, _testutils.jsx)("fragment", null, (0, _testutils.jsx)("hp", null, (0, _testutils.jsx)("cursor", null)), (0, _testutils.jsx)("hul", null, (0, _testutils.jsx)("hli", null, (0, _testutils.jsx)("hp", null, "p1")))),
+            expected: (0, _testutils.jsx)("hul", null, (0, _testutils.jsx)("hli", null, (0, _testutils.jsx)("hp", null, (0, _testutils.jsx)("cursor", null), "p1")))
+        },
+        {
+            title: 'deletes the empty paragraph at the beginning of the RTE followed by a blockquote',
+            input: (0, _testutils.jsx)("fragment", null, (0, _testutils.jsx)("hp", null, (0, _testutils.jsx)("cursor", null)), (0, _testutils.jsx)("hquote", null, (0, _testutils.jsx)("hp", null, "p1"))),
+            expected: (0, _testutils.jsx)("hquote", null, (0, _testutils.jsx)("hp", null, (0, _testutils.jsx)("cursor", null), "p1"))
+        }
+    ];
+    const render = (children)=>(0, _testutils.jsx)("editor", null, children, (0, _testutils.jsx)("hp", null, (0, _testutils.jsx)("htext", null)));
+    for (const t of tests){
+        test(t.title, ()=>{
+            const { editor  } = (0, _testutils.createTestEditor)({
+                input: render(t.input)
+            });
+            editor.deleteBackward('character');
+            (0, _testutils.assertOutput)({
+                editor,
+                expected: render(t.expected)
+            });
+        });
+    }
+});
+describe('delete forward', ()=>{
+    const tests = [
+        {
+            title: 'deletes a character of the text inside li',
+            input: (0, _testutils.jsx)("hul", null, (0, _testutils.jsx)("hli", null, (0, _testutils.jsx)("hp", null, (0, _testutils.jsx)("cursor", null), "p1"))),
+            expected: (0, _testutils.jsx)("hul", null, (0, _testutils.jsx)("hli", null, (0, _testutils.jsx)("hp", null, (0, _testutils.jsx)("cursor", null), "1")))
+        },
+        {
+            title: 'deletes the empty paragraph at the beginning of the RTE followed by another paragraph',
+            input: (0, _testutils.jsx)("fragment", null, (0, _testutils.jsx)("hp", null, (0, _testutils.jsx)("cursor", null)), (0, _testutils.jsx)("hp", null, "text")),
+            expected: (0, _testutils.jsx)("hp", null, (0, _testutils.jsx)("cursor", null), "text")
+        },
+        {
+            title: 'deletes the empty paragraph at the beginning of the RTE followed by li',
+            input: (0, _testutils.jsx)("fragment", null, (0, _testutils.jsx)("hp", null, (0, _testutils.jsx)("cursor", null)), (0, _testutils.jsx)("hul", null, (0, _testutils.jsx)("hli", null, (0, _testutils.jsx)("hp", null, "p1")))),
+            expected: (0, _testutils.jsx)("hul", null, (0, _testutils.jsx)("hli", null, (0, _testutils.jsx)("hp", null, (0, _testutils.jsx)("cursor", null), "p1")))
+        },
+        {
+            title: 'deletes the empty paragraph at the beginning of the RTE followed by a blockquote',
+            input: (0, _testutils.jsx)("fragment", null, (0, _testutils.jsx)("hp", null, (0, _testutils.jsx)("cursor", null)), (0, _testutils.jsx)("hquote", null, (0, _testutils.jsx)("hp", null, "p1"))),
+            expected: (0, _testutils.jsx)("hquote", null, (0, _testutils.jsx)("hp", null, (0, _testutils.jsx)("cursor", null), "p1"))
+        }
+    ];
+    const render = (children)=>(0, _testutils.jsx)("editor", null, children, (0, _testutils.jsx)("hp", null, (0, _testutils.jsx)("htext", null)));
+    for (const t of tests){
+        test(t.title, ()=>{
+            const { editor  } = (0, _testutils.createTestEditor)({
+                input: render(t.input)
+            });
+            editor.deleteForward('character');
+            (0, _testutils.assertOutput)({
+                editor,
+                expected: render(t.expected)
+            });
+        });
+    }
+});

package/dist/cjs/plugins/Text/createTextPlugin.js

@@ -0,0 +1,137 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "createTextPlugin", {
+    enumerable: true,
+    get: function() {
+        return createTextPlugin;
+    }
+});
+const _richtexttypes = require("@contentful/rich-text-types");
+const _queries = require("../../internal/queries");
+const _transforms = require("../../internal/transforms");
+function createTextPlugin(restrictedMarks = []) {
+    return {
+        key: 'TextPlugin',
+        handlers: {
+            onMouseUp: (editor)=>()=>{
+                    if (!editor.selection) {
+                        return;
+                    }
+                    (0, _transforms.setSelection)(editor, (0, _transforms.unhangRange)(editor, editor.selection));
+                }
+        },
+        withOverrides: (editor)=>{
+            const { insertText  } = editor;
+            editor.insertText = (text)=>{
+                const { selection  } = editor;
+                if (selection && (0, _queries.isRangeCollapsed)(selection)) {
+                    const inlinePath = (0, _queries.getAboveNode)(editor, {
+                        match: (n)=>(0, _queries.isInline)(editor, n),
+                        mode: 'highest'
+                    })?.[1];
+                    if (inlinePath && (0, _queries.isEndPoint)(editor, selection.anchor, inlinePath)) {
+                        const point = (0, _queries.getPointAfter)(editor, inlinePath);
+                        (0, _transforms.setSelection)(editor, {
+                            anchor: point,
+                            focus: point
+                        });
+                    }
+                }
+                return insertText(text);
+            };
+            const { deleteForward , deleteBackward  } = editor;
+            editor.deleteBackward = (unit)=>{
+                deleteEmptyParagraph(unit, editor, deleteBackward);
+            };
+            editor.deleteForward = (unit)=>{
+                deleteEmptyParagraph(unit, editor, deleteForward);
+            };
+            fixPasteAsPlainText(editor);
+            return editor;
+        },
+        normalizer: [
+            {
+                match: _queries.isText,
+                transform: (editor, [, path])=>{
+                    (0, _transforms.unsetNodes)(editor, restrictedMarks, {
+                        at: path
+                    });
+                },
+                validNode: (_editor, [node])=>{
+                    return !restrictedMarks.some((mark)=>{
+                        return mark in node;
+                    });
+                }
+            }
+        ]
+    };
+}
+function deleteEmptyParagraph(unit, editor, deleteFunction) {
+    const entry = (0, _queries.getAboveNode)(editor, {
+        match: {
+            type: _richtexttypes.TEXT_CONTAINERS
+        }
+    });
+    if (entry) {
+        const [paragraphOrHeading, path] = entry;
+        const isTextEmpty = (0, _queries.isAncestorEmpty)(editor, paragraphOrHeading);
+        const isRootLevel = path.length === 1;
+        const hasSiblings = editor.children.length > 1;
+        if (isTextEmpty && isRootLevel && hasSiblings) {
+            (0, _transforms.removeNodes)(editor, {
+                at: path
+            });
+            const prevNode = (0, _queries.getPointBefore)(editor, editor.selection, {
+                unit
+            });
+            if (prevNode) {
+                const [prevCell] = (0, _queries.getNodeEntries)(editor, {
+                    match: (node)=>(0, _queries.queryNode)([
+                            node,
+                            prevNode.path
+                        ], {
+                            allow: [
+                                _richtexttypes.BLOCKS.EMBEDDED_ASSET,
+                                _richtexttypes.BLOCKS.EMBEDDED_ENTRY,
+                                _richtexttypes.BLOCKS.EMBEDDED_RESOURCE,
+                                _richtexttypes.BLOCKS.HR
+                            ]
+                        }),
+                    at: prevNode
+                });
+                if (prevCell) {
+                    (0, _transforms.select)(editor, prevNode);
+                }
+            }
+        } else {
+            deleteFunction(unit);
+        }
+    } else {
+        deleteFunction(unit);
+    }
+}
+function fixPasteAsPlainText(editor) {
+    editor.insertTextData = (data)=>{
+        const text = data.getData('text/plain');
+        if (!text) {
+            return false;
+        }
+        const lines = text.split(/\n{2}/);
+        let split = false;
+        for (const line of lines){
+            if (/^(\r\n?|\n)$/.test(line)) {
+                continue;
+            }
+            if (split) {
+                (0, _transforms.splitNodes)(editor, {
+                    always: true
+                });
+            }
+            editor.insertText(line);
+            split = true;
+        }
+        return true;
+    };
+}

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

@@ -0,0 +1,18 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+_export_star(require("./createTextPlugin"), 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/Tracking/createTrackingPlugin.js

@@ -0,0 +1,101 @@
+"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, {
+    getPastingSource: function() {
+        return getPastingSource;
+    },
+    createTrackingPlugin: function() {
+        return createTrackingPlugin;
+    }
+});
+const _utils = require("./utils");
+const actionOrigin = {
+    TOOLBAR: 'toolbar-icon',
+    SHORTCUT: 'shortcut',
+    VIEWPORT: 'viewport-interaction',
+    SHORTCUT_OR_VIEWPORT: 'shortcut-or-viewport',
+    COMMAND_PALETTE: 'command-palette'
+};
+function getPastingSource(data) {
+    const textHtml = data.getData('text/html');
+    const doc = new DOMParser().parseFromString(textHtml, 'text/html');
+    if (doc.querySelector('[id*="docs-internal-guid"]')) {
+        return 'Google Docs';
+    }
+    if (doc.querySelector('google-sheets-html-origin') || doc.querySelector('[data-sheets-value]')) {
+        return 'Google Spreadsheets';
+    }
+    if (doc.querySelector('meta[content*="Microsoft Excel"]')) {
+        return 'Microsoft Excel';
+    }
+    if (doc.querySelector('meta[content*="Microsoft Word"]')) {
+        return 'Microsoft Word';
+    }
+    if (doc.querySelector('[style*="Arial_MSFontService"]') && (doc.querySelector('.TextRun') || doc.querySelector('.OutlineElement'))) {
+        return 'Microsoft Word Online';
+    }
+    if (doc.querySelector('meta[content="Cocoa HTML Writer"]')) {
+        return 'Apple Notes';
+    }
+    if (doc.querySelector('[style*="Slack-Lato, Slack-Fractions"]')) {
+        return 'Slack';
+    }
+    return 'Unknown';
+}
+const createTrackingPlugin = (onAction)=>{
+    const trackingActions = {
+        onViewportAction: (actionName, data = {})=>onAction(actionName, {
+                origin: actionOrigin.VIEWPORT,
+                ...data
+            }),
+        onShortcutAction: (actionName, data = {})=>onAction(actionName, {
+                origin: actionOrigin.SHORTCUT,
+                ...data
+            }),
+        onShortcutOrViewportAction: (actionName, data = {})=>onAction(actionName, {
+                origin: actionOrigin.SHORTCUT_OR_VIEWPORT,
+                ...data
+            }),
+        onToolbarAction: (actionName, data = {})=>onAction(actionName, {
+                origin: actionOrigin.TOOLBAR,
+                ...data
+            }),
+        onCommandPaletteAction: (actionName, data = {})=>onAction(actionName, {
+                origin: actionOrigin.COMMAND_PALETTE,
+                ...data
+            })
+    };
+    return {
+        key: 'TrackingPlugin',
+        withOverrides: (editor)=>{
+            const { insertData  } = editor;
+            editor.tracking = trackingActions;
+            editor.insertData = (data)=>{
+                const isCopyAndPaste = data.types.length !== 0;
+                if (isCopyAndPaste) {
+                    const characterCountSelection = window.getSelection()?.toString().length;
+                    const characterCountBefore = (0, _utils.getCharacterCount)(editor);
+                    setTimeout(()=>{
+                        const characterCountAfter = (0, _utils.getCharacterCount)(editor);
+                        trackingActions.onShortcutOrViewportAction('paste', {
+                            characterCountAfter,
+                            characterCountBefore,
+                            characterCountSelection,
+                            source: getPastingSource(data)
+                        });
+                    });
+                }
+                insertData(data);
+            };
+            return editor;
+        }
+    };
+};