@vendure/admin-ui 2.0.0-next.11 → 2.0.0-next.14

package/package/esm2020/core/shared/components/rich-text-editor/prosemirror/plugins/image-plugin.mjs

@@ -0,0 +1,100 @@
+import { MenuItem } from 'prosemirror-menu';
+import { NodeSelection, Plugin } from 'prosemirror-state';
+import { ExternalImageDialogComponent, } from '../../external-image-dialog/external-image-dialog.component';
+import { canInsert, renderClarityIcon } from '../menu/menu-common';
+export function insertImageItem(nodeType, modalService) {
+    return new MenuItem({
+        title: 'Insert image',
+        label: 'Image',
+        render: renderClarityIcon({ shape: 'image', label: 'Image' }),
+        class: '',
+        css: '',
+        enable(state) {
+            return canInsert(state, nodeType);
+        },
+        run(state, _, view) {
+            let attrs;
+            if (state.selection instanceof NodeSelection && state.selection.node.type === nodeType) {
+                attrs = state.selection.node.attrs;
+            }
+            modalService
+                .fromComponent(ExternalImageDialogComponent, {
+                closable: true,
+                locals: {
+                    existing: attrs,
+                },
+            })
+                .subscribe(result => {
+                if (result) {
+                    // tslint:disable-next-line:no-non-null-assertion
+                    view.dispatch(view.state.tr.replaceSelectionWith(nodeType.createAndFill(result)));
+                }
+                view.focus();
+            });
+        },
+    });
+}
+export const imageContextMenuPlugin = (contextMenuService, modalService) => new Plugin({
+    view: () => {
+        return {
+            update: view => {
+                if (!view.hasFocus()) {
+                    return;
+                }
+                const { doc, selection } = view.state;
+                let imageNode;
+                let imageNodePos = 0;
+                doc.nodesBetween(selection.from, selection.to, (n, pos, parent) => {
+                    if (n.type.name === 'image') {
+                        imageNode = n;
+                        imageNodePos = pos;
+                        return false;
+                    }
+                });
+                if (imageNode) {
+                    const node = view.nodeDOM(imageNodePos);
+                    if (node instanceof HTMLImageElement) {
+                        contextMenuService.setContextMenu({
+                            ref: selection,
+                            title: 'Image',
+                            iconShape: 'image',
+                            element: node,
+                            coords: view.coordsAtPos(imageNodePos),
+                            items: [
+                                {
+                                    enabled: true,
+                                    iconShape: 'image',
+                                    label: 'Image properties',
+                                    onClick: () => {
+                                        contextMenuService.clearContextMenu();
+                                        modalService
+                                            .fromComponent(ExternalImageDialogComponent, {
+                                            closable: true,
+                                            locals: {
+                                                // tslint:disable-next-line:no-non-null-assertion
+                                                existing: imageNode.attrs,
+                                            },
+                                        })
+                                            .subscribe(result => {
+                                            if (result) {
+                                                // tslint:disable-next-line:no-non-null-assertion
+                                                view.dispatch(view.state.tr.replaceSelectionWith(
+                                                // tslint:disable-next-line:no-non-null-assertion
+                                                imageNode.type.createAndFill(result)));
+                                            }
+                                            view.focus();
+                                        });
+                                    },
+                                },
+                            ],
+                        });
+                    }
+                }
+                else {
+                    contextMenuService.clearContextMenu();
+                }
+            },
+        };
+    },
+});
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"image-plugin.js","sourceRoot":"","sources":["../../../../../../../../src/lib/core/src/shared/components/rich-text-editor/prosemirror/plugins/image-plugin.ts"],"names":[],"mappings":"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","sourcesContent":["import { MenuItem } from 'prosemirror-menu';\r\nimport { Node, NodeType } from 'prosemirror-model';\r\nimport { EditorState, NodeSelection, Plugin, Transaction } from 'prosemirror-state';\r\nimport {\r\n    addColumnAfter,\r\n    addColumnBefore,\r\n    addRowAfter,\r\n    addRowBefore,\r\n    deleteColumn,\r\n    deleteRow,\r\n    deleteTable,\r\n    mergeCells,\r\n    splitCell,\r\n    toggleHeaderColumn,\r\n    toggleHeaderRow,\r\n} from 'prosemirror-tables';\r\nimport { EditorView } from 'prosemirror-view';\r\n\r\nimport { ModalService } from '../../../../../providers/modal/modal.service';\r\nimport {\r\n    ExternalImageAttrs,\r\n    ExternalImageDialogComponent,\r\n} from '../../external-image-dialog/external-image-dialog.component';\r\nimport { RawHtmlDialogComponent } from '../../raw-html-dialog/raw-html-dialog.component';\r\nimport { ContextMenuItem, ContextMenuService } from '../context-menu/context-menu.service';\r\nimport { canInsert, renderClarityIcon } from '../menu/menu-common';\r\n\r\nexport function insertImageItem(nodeType: NodeType, modalService: ModalService) {\r\n    return new MenuItem({\r\n        title: 'Insert image',\r\n        label: 'Image',\r\n        render: renderClarityIcon({ shape: 'image', label: 'Image' }),\r\n        class: '',\r\n        css: '',\r\n        enable(state: EditorState) {\r\n            return canInsert(state, nodeType);\r\n        },\r\n        run(state: EditorState, _, view: EditorView) {\r\n            let attrs: ExternalImageAttrs | undefined;\r\n            if (state.selection instanceof NodeSelection && state.selection.node.type === nodeType) {\r\n                attrs = state.selection.node.attrs as ExternalImageAttrs;\r\n            }\r\n            modalService\r\n                .fromComponent(ExternalImageDialogComponent, {\r\n                    closable: true,\r\n                    locals: {\r\n                        existing: attrs,\r\n                    },\r\n                })\r\n                .subscribe(result => {\r\n                    if (result) {\r\n                        // tslint:disable-next-line:no-non-null-assertion\r\n                        view.dispatch(view.state.tr.replaceSelectionWith(nodeType.createAndFill(result)!));\r\n                    }\r\n                    view.focus();\r\n                });\r\n        },\r\n    });\r\n}\r\n\r\nexport const imageContextMenuPlugin = (contextMenuService: ContextMenuService, modalService: ModalService) =>\r\n    new Plugin({\r\n        view: () => {\r\n            return {\r\n                update: view => {\r\n                    if (!view.hasFocus()) {\r\n                        return;\r\n                    }\r\n                    const { doc, selection } = view.state;\r\n                    let imageNode: Node | undefined;\r\n                    let imageNodePos = 0;\r\n                    doc.nodesBetween(selection.from, selection.to, (n, pos, parent) => {\r\n                        if (n.type.name === 'image') {\r\n                            imageNode = n;\r\n                            imageNodePos = pos;\r\n                            return false;\r\n                        }\r\n                    });\r\n                    if (imageNode) {\r\n                        const node = view.nodeDOM(imageNodePos);\r\n                        if (node instanceof HTMLImageElement) {\r\n                            contextMenuService.setContextMenu({\r\n                                ref: selection,\r\n                                title: 'Image',\r\n                                iconShape: 'image',\r\n                                element: node,\r\n                                coords: view.coordsAtPos(imageNodePos),\r\n                                items: [\r\n                                    {\r\n                                        enabled: true,\r\n                                        iconShape: 'image',\r\n                                        label: 'Image properties',\r\n                                        onClick: () => {\r\n                                            contextMenuService.clearContextMenu();\r\n                                            modalService\r\n                                                .fromComponent(ExternalImageDialogComponent, {\r\n                                                    closable: true,\r\n                                                    locals: {\r\n                                                        // tslint:disable-next-line:no-non-null-assertion\r\n                                                        existing: imageNode!.attrs as ExternalImageAttrs,\r\n                                                    },\r\n                                                })\r\n                                                .subscribe(result => {\r\n                                                    if (result) {\r\n                                                        // tslint:disable-next-line:no-non-null-assertion\r\n                                                        view.dispatch(\r\n                                                            view.state.tr.replaceSelectionWith(\r\n                                                                // tslint:disable-next-line:no-non-null-assertion\r\n                                                                imageNode!.type.createAndFill(result)!,\r\n                                                            ),\r\n                                                        );\r\n                                                    }\r\n                                                    view.focus();\r\n                                                });\r\n                                        },\r\n                                    },\r\n                                ],\r\n                            });\r\n                        }\r\n                    } else {\r\n                        contextMenuService.clearContextMenu();\r\n                    }\r\n                },\r\n            };\r\n        },\r\n    });\r\n"]}

package/package/esm2020/core/shared/components/rich-text-editor/prosemirror/plugins/raw-editor-plugin.mjs

@@ -0,0 +1,96 @@
+import { DOMParser, DOMSerializer } from 'prosemirror-model';
+import { Plugin } from 'prosemirror-state';
+import { RawHtmlDialogComponent } from '../../raw-html-dialog/raw-html-dialog.component';
+/**
+ * Implements editing of raw HTML for the selected node in the editor.
+ */
+export const rawEditorPlugin = (contextMenuService, modalService) => new Plugin({
+    view: _view => {
+        const domParser = DOMParser.fromSchema(_view.state.schema);
+        const domSerializer = DOMSerializer.fromSchema(_view.state.schema);
+        return {
+            update: view => {
+                if (!view.hasFocus()) {
+                    return;
+                }
+                let topLevelNode;
+                const { doc, selection } = view.state;
+                let topLevelNodePos = 0;
+                doc.nodesBetween(selection.from, selection.to, (n, pos, parent) => {
+                    if (parent === doc) {
+                        topLevelNode = n;
+                        topLevelNodePos = pos;
+                        return false;
+                    }
+                });
+                if (topLevelNode) {
+                    const node = view.nodeDOM(topLevelNodePos);
+                    if (node instanceof HTMLElement) {
+                        contextMenuService.setContextMenu({
+                            ref: selection,
+                            title: '',
+                            // iconShape: 'ellipsis-vertical',
+                            element: node,
+                            coords: view.coordsAtPos(topLevelNodePos),
+                            items: [
+                                {
+                                    enabled: true,
+                                    iconShape: 'code',
+                                    label: 'Edit HTML',
+                                    onClick: () => {
+                                        contextMenuService.clearContextMenu();
+                                        const element = domSerializer.serializeNode(
+                                        // tslint:disable-next-line:no-non-null-assertion
+                                        topLevelNode);
+                                        modalService
+                                            .fromComponent(RawHtmlDialogComponent, {
+                                            size: 'xl',
+                                            locals: {
+                                                html: element.outerHTML,
+                                            },
+                                        })
+                                            .subscribe(result => {
+                                            if (result) {
+                                                const domNode = htmlToDomNode(result, topLevelNode?.isLeaf ? undefined : node);
+                                                if (domNode) {
+                                                    let tr = view.state.tr;
+                                                    const parsedNodeSlice = domParser.parse(domNode);
+                                                    try {
+                                                        tr = tr.replaceRangeWith(topLevelNodePos, topLevelNodePos +
+                                                            (topLevelNode?.nodeSize ?? 0), parsedNodeSlice);
+                                                    }
+                                                    catch (err) {
+                                                        // tslint:disable-next-line:no-console
+                                                        console.error(err);
+                                                    }
+                                                    view.dispatch(tr);
+                                                    view.focus();
+                                                }
+                                            }
+                                        });
+                                    },
+                                },
+                            ],
+                        });
+                    }
+                }
+            },
+        };
+    },
+});
+function htmlToDomNode(html, wrapInParent) {
+    html = `${html.trim()}`;
+    const template = document.createElement('template');
+    if (wrapInParent) {
+        const parentClone = wrapInParent.cloneNode(false);
+        parentClone.innerHTML = html;
+        template.content.appendChild(parentClone);
+    }
+    else {
+        const parent = document.createElement('p');
+        parent.innerHTML = html;
+        template.content.appendChild(parent);
+    }
+    return template.content.firstChild;
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"raw-editor-plugin.js","sourceRoot":"","sources":["../../../../../../../../src/lib/core/src/shared/components/rich-text-editor/prosemirror/plugins/raw-editor-plugin.ts"],"names":[],"mappings":"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","sourcesContent":["import { DOMParser, DOMSerializer, Node } from 'prosemirror-model';\r\nimport { Plugin } from 'prosemirror-state';\r\nimport { Protocol } from 'puppeteer';\r\n\r\nimport { ModalService } from '../../../../../providers/modal/modal.service';\r\nimport { RawHtmlDialogComponent } from '../../raw-html-dialog/raw-html-dialog.component';\r\nimport { ContextMenuService } from '../context-menu/context-menu.service';\r\n\r\n/**\r\n * Implements editing of raw HTML for the selected node in the editor.\r\n */\r\nexport const rawEditorPlugin = (contextMenuService: ContextMenuService, modalService: ModalService) =>\r\n    new Plugin({\r\n        view: _view => {\r\n            const domParser = DOMParser.fromSchema(_view.state.schema);\r\n            const domSerializer = DOMSerializer.fromSchema(_view.state.schema);\r\n            return {\r\n                update: view => {\r\n                    if (!view.hasFocus()) {\r\n                        return;\r\n                    }\r\n                    let topLevelNode: Node | undefined;\r\n                    const { doc, selection } = view.state;\r\n                    let topLevelNodePos = 0;\r\n                    doc.nodesBetween(selection.from, selection.to, (n, pos, parent) => {\r\n                        if (parent === doc) {\r\n                            topLevelNode = n;\r\n                            topLevelNodePos = pos;\r\n                            return false;\r\n                        }\r\n                    });\r\n                    if (topLevelNode) {\r\n                        const node = view.nodeDOM(topLevelNodePos);\r\n                        if (node instanceof HTMLElement) {\r\n                            contextMenuService.setContextMenu({\r\n                                ref: selection,\r\n                                title: '',\r\n                                // iconShape: 'ellipsis-vertical',\r\n                                element: node,\r\n                                coords: view.coordsAtPos(topLevelNodePos),\r\n                                items: [\r\n                                    {\r\n                                        enabled: true,\r\n                                        iconShape: 'code',\r\n                                        label: 'Edit HTML',\r\n                                        onClick: () => {\r\n                                            contextMenuService.clearContextMenu();\r\n                                            const element = domSerializer.serializeNode(\r\n                                                // tslint:disable-next-line:no-non-null-assertion\r\n                                                topLevelNode!,\r\n                                            ) as HTMLElement;\r\n                                            modalService\r\n                                                .fromComponent(RawHtmlDialogComponent, {\r\n                                                    size: 'xl',\r\n                                                    locals: {\r\n                                                        html: element.outerHTML,\r\n                                                    },\r\n                                                })\r\n                                                .subscribe(result => {\r\n                                                    if (result) {\r\n                                                        const domNode = htmlToDomNode(\r\n                                                            result,\r\n                                                            topLevelNode?.isLeaf ? undefined : node,\r\n                                                        );\r\n                                                        if (domNode) {\r\n                                                            let tr = view.state.tr;\r\n                                                            const parsedNodeSlice = domParser.parse(domNode);\r\n                                                            try {\r\n                                                                tr = tr.replaceRangeWith(\r\n                                                                    topLevelNodePos,\r\n                                                                    topLevelNodePos +\r\n                                                                        (topLevelNode?.nodeSize ?? 0),\r\n                                                                    parsedNodeSlice,\r\n                                                                );\r\n                                                            } catch (err: any) {\r\n                                                                // tslint:disable-next-line:no-console\r\n                                                                console.error(err);\r\n                                                            }\r\n                                                            view.dispatch(tr);\r\n                                                            view.focus();\r\n                                                        }\r\n                                                    }\r\n                                                });\r\n                                        },\r\n                                    },\r\n                                ],\r\n                            });\r\n                        }\r\n                    }\r\n                },\r\n            };\r\n        },\r\n    });\r\n\r\nfunction htmlToDomNode(html: string, wrapInParent?: HTMLElement) {\r\n    html = `${html.trim()}`;\r\n    const template = document.createElement('template');\r\n    if (wrapInParent) {\r\n        const parentClone = wrapInParent.cloneNode(false) as HTMLElement;\r\n        parentClone.innerHTML = html;\r\n        template.content.appendChild(parentClone);\r\n    } else {\r\n        const parent = document.createElement('p');\r\n        parent.innerHTML = html;\r\n        template.content.appendChild(parent);\r\n    }\r\n    return template.content.firstChild;\r\n}\r\n"]}

package/package/esm2020/core/shared/components/rich-text-editor/prosemirror/plugins/tables-plugin.mjs

@@ -0,0 +1,166 @@
+import { MenuItem } from 'prosemirror-menu';
+import { Plugin, TextSelection } from 'prosemirror-state';
+import { addColumnAfter, addColumnBefore, addRowAfter, addRowBefore, deleteColumn, deleteRow, deleteTable, isInTable, mergeCells, splitCell, tableNodes, tableNodeTypes, toggleHeaderCell, toggleHeaderColumn, toggleHeaderRow, } from 'prosemirror-tables';
+import { renderClarityIcon } from '../menu/menu-common';
+export const tableContextMenuPlugin = (contextMenuService) => new Plugin({
+    view: () => {
+        return {
+            update: view => {
+                if (!view.hasFocus()) {
+                    return;
+                }
+                const { doc, selection } = view.state;
+                let tableNode;
+                let tableNodePos = 0;
+                doc.nodesBetween(selection.from, selection.to, (n, pos, parent) => {
+                    if (n.type.name === 'table') {
+                        tableNode = n;
+                        tableNodePos = pos;
+                        return false;
+                    }
+                });
+                if (tableNode) {
+                    const node = view.nodeDOM(tableNodePos);
+                    if (node instanceof Element) {
+                        function createMenuItem(label, commandFn, iconClass) {
+                            const enabled = commandFn(view.state);
+                            return {
+                                label,
+                                enabled,
+                                iconClass,
+                                onClick: () => {
+                                    contextMenuService.clearContextMenu();
+                                    view.focus();
+                                    commandFn(view.state, view.dispatch);
+                                },
+                            };
+                        }
+                        const separator = {
+                            label: '',
+                            separator: true,
+                            enabled: true,
+                            onClick: () => {
+                                /**/
+                            },
+                        };
+                        contextMenuService.setContextMenu({
+                            ref: selection,
+                            title: 'Table',
+                            iconShape: 'table',
+                            element: node,
+                            coords: view.coordsAtPos(tableNodePos),
+                            items: [
+                                createMenuItem('Insert column before', addColumnBefore, 'add-column'),
+                                createMenuItem('Insert column after', addColumnAfter, 'add-column'),
+                                createMenuItem('Insert row before', addRowBefore, 'add-row'),
+                                createMenuItem('Insert row after', addRowAfter, 'add-row'),
+                                createMenuItem('Merge cells', mergeCells),
+                                createMenuItem('Split cell', splitCell),
+                                separator,
+                                createMenuItem('Toggle header column', toggleHeaderColumn),
+                                createMenuItem('Toggle header row', toggleHeaderRow),
+                                separator,
+                                createMenuItem('Delete column', deleteColumn),
+                                createMenuItem('Delete row', deleteRow),
+                                createMenuItem('Delete table', deleteTable),
+                            ],
+                        });
+                    }
+                }
+                else {
+                    contextMenuService.clearContextMenu();
+                }
+            },
+        };
+    },
+});
+export function getTableNodes() {
+    return tableNodes({
+        tableGroup: 'block',
+        cellContent: 'block+',
+        cellAttributes: {
+            background: {
+                default: null,
+                getFromDOM(dom) {
+                    return dom.style.backgroundColor || null;
+                },
+                setDOMAttr(value, attrs) {
+                    if (value) {
+                        attrs.style = (attrs.style || '') + `background-color: ${value};`;
+                    }
+                },
+            },
+        },
+    });
+}
+export function getTableMenu(schema) {
+    function item(label, cmd, iconShape) {
+        return new MenuItem({
+            label,
+            select: cmd,
+            run: cmd,
+            render: iconShape ? renderClarityIcon({ shape: iconShape, label }) : undefined,
+        });
+    }
+    function separator() {
+        return new MenuItem({
+            select: state => isInTable(state),
+            run: state => {
+                /**/
+            },
+            render: view => {
+                const el = document.createElement('div');
+                el.classList.add('menu-separator');
+                return el;
+            },
+        });
+    }
+    return [
+        item('Insert column before', addColumnBefore),
+        item('Insert column after', addColumnAfter),
+        item('Insert row before', addRowBefore),
+        item('Insert row after', addRowAfter),
+        item('Merge cells', mergeCells),
+        item('Split cell', splitCell),
+        separator(),
+        item('Toggle header column', toggleHeaderColumn),
+        item('Toggle header row', toggleHeaderRow),
+        item('Toggle header cells', toggleHeaderCell),
+        separator(),
+        item('Delete column', deleteColumn),
+        item('Delete row', deleteRow),
+        item('Delete table', deleteTable),
+    ];
+}
+export function addTable(state, dispatch, { rowsCount, colsCount, withHeaderRow, cellContent }) {
+    const offset = state.tr.selection.anchor + 1;
+    const nodes = createTable(state, rowsCount, colsCount, withHeaderRow, cellContent);
+    const tr = state.tr.replaceSelectionWith(nodes).scrollIntoView();
+    const resolvedPos = tr.doc.resolve(offset);
+    tr.setSelection(TextSelection.near(resolvedPos));
+    dispatch(tr);
+}
+function createTable(state, rowsCount, colsCount, withHeaderRow, cellContent) {
+    const types = tableNodeTypes(state.schema);
+    const headerCells = [];
+    const cells = [];
+    const createCell = (cellType, _cellContent) => _cellContent ? cellType.createChecked(null, _cellContent) : cellType.createAndFill();
+    for (let index = 0; index < colsCount; index += 1) {
+        const cell = createCell(types.cell, cellContent);
+        if (cell) {
+            cells.push(cell);
+        }
+        if (withHeaderRow) {
+            const headerCell = createCell(types.header_cell, cellContent);
+            if (headerCell) {
+                headerCells.push(headerCell);
+            }
+        }
+    }
+    const rows = [];
+    for (let index = 0; index < rowsCount; index += 1) {
+        rows.push(types.row.createChecked(null, withHeaderRow && index === 0 ? headerCells : cells));
+    }
+    return types.table.createChecked(null, rows);
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"tables-plugin.js","sourceRoot":"","sources":["../../../../../../../../src/lib/core/src/shared/components/rich-text-editor/prosemirror/plugins/tables-plugin.ts"],"names":[],"mappings":"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","sourcesContent":["import { MenuElement, MenuItem } from 'prosemirror-menu';\r\nimport { Node, Schema } from 'prosemirror-model';\r\nimport { EditorState, Plugin, TextSelection, Transaction } from 'prosemirror-state';\r\nimport {\r\n    addColumnAfter,\r\n    addColumnBefore,\r\n    addRowAfter,\r\n    addRowBefore,\r\n    deleteColumn,\r\n    deleteRow,\r\n    deleteTable,\r\n    isInTable,\r\n    mergeCells,\r\n    splitCell,\r\n    tableNodes,\r\n    tableNodeTypes,\r\n    toggleHeaderCell,\r\n    toggleHeaderColumn,\r\n    toggleHeaderRow,\r\n} from 'prosemirror-tables';\r\nimport { Decoration, DecorationSet } from 'prosemirror-view';\r\n\r\nimport { ContextMenuItem, ContextMenuService } from '../context-menu/context-menu.service';\r\nimport { buildMenuItems } from '../menu/menu';\r\nimport { renderClarityIcon } from '../menu/menu-common';\r\n\r\nexport const tableContextMenuPlugin = (contextMenuService: ContextMenuService) =>\r\n    new Plugin({\r\n        view: () => {\r\n            return {\r\n                update: view => {\r\n                    if (!view.hasFocus()) {\r\n                        return;\r\n                    }\r\n                    const { doc, selection } = view.state;\r\n                    let tableNode: Node | undefined;\r\n                    let tableNodePos = 0;\r\n                    doc.nodesBetween(selection.from, selection.to, (n, pos, parent) => {\r\n                        if (n.type.name === 'table') {\r\n                            tableNode = n;\r\n                            tableNodePos = pos;\r\n                            return false;\r\n                        }\r\n                    });\r\n                    if (tableNode) {\r\n                        const node = view.nodeDOM(tableNodePos);\r\n                        if (node instanceof Element) {\r\n                            function createMenuItem(\r\n                                label: string,\r\n                                commandFn: (\r\n                                    state: EditorState,\r\n                                    dispatch?: (tr: Transaction) => void,\r\n                                ) => boolean,\r\n                                iconClass?: string,\r\n                            ): ContextMenuItem {\r\n                                const enabled = commandFn(view.state);\r\n                                return {\r\n                                    label,\r\n                                    enabled,\r\n                                    iconClass,\r\n                                    onClick: () => {\r\n                                        contextMenuService.clearContextMenu();\r\n                                        view.focus();\r\n                                        commandFn(view.state, view.dispatch);\r\n                                    },\r\n                                };\r\n                            }\r\n                            const separator: ContextMenuItem = {\r\n                                label: '',\r\n                                separator: true,\r\n                                enabled: true,\r\n                                onClick: () => {\r\n                                    /**/\r\n                                },\r\n                            };\r\n                            contextMenuService.setContextMenu({\r\n                                ref: selection,\r\n                                title: 'Table',\r\n                                iconShape: 'table',\r\n                                element: node,\r\n                                coords: view.coordsAtPos(tableNodePos),\r\n                                items: [\r\n                                    createMenuItem('Insert column before', addColumnBefore, 'add-column'),\r\n                                    createMenuItem('Insert column after', addColumnAfter, 'add-column'),\r\n                                    createMenuItem('Insert row before', addRowBefore, 'add-row'),\r\n                                    createMenuItem('Insert row after', addRowAfter, 'add-row'),\r\n                                    createMenuItem('Merge cells', mergeCells),\r\n                                    createMenuItem('Split cell', splitCell),\r\n                                    separator,\r\n                                    createMenuItem('Toggle header column', toggleHeaderColumn),\r\n                                    createMenuItem('Toggle header row', toggleHeaderRow),\r\n                                    separator,\r\n                                    createMenuItem('Delete column', deleteColumn),\r\n                                    createMenuItem('Delete row', deleteRow),\r\n                                    createMenuItem('Delete table', deleteTable),\r\n                                ],\r\n                            });\r\n                        }\r\n                    } else {\r\n                        contextMenuService.clearContextMenu();\r\n                    }\r\n                },\r\n            };\r\n        },\r\n    });\r\n\r\nexport function getTableNodes() {\r\n    return tableNodes({\r\n        tableGroup: 'block',\r\n        cellContent: 'block+',\r\n        cellAttributes: {\r\n            background: {\r\n                default: null,\r\n                getFromDOM(dom) {\r\n                    return (dom as HTMLElement).style.backgroundColor || null;\r\n                },\r\n                setDOMAttr(value, attrs) {\r\n                    if (value) {\r\n                        attrs.style = (attrs.style || '') + `background-color: ${value};`;\r\n                    }\r\n                },\r\n            },\r\n        },\r\n    });\r\n}\r\n\r\nexport function getTableMenu(schema: Schema) {\r\n    function item(\r\n        label: string,\r\n        cmd: (state: EditorState, dispatch?: (tr: Transaction) => void) => boolean,\r\n        iconShape?: string,\r\n    ) {\r\n        return new MenuItem({\r\n            label,\r\n            select: cmd,\r\n            run: cmd,\r\n            render: iconShape ? renderClarityIcon({ shape: iconShape, label }) : undefined,\r\n        });\r\n    }\r\n\r\n    function separator(): MenuElement {\r\n        return new MenuItem({\r\n            select: state => isInTable(state),\r\n            run: state => {\r\n                /**/\r\n            },\r\n            render: view => {\r\n                const el = document.createElement('div');\r\n                el.classList.add('menu-separator');\r\n                return el;\r\n            },\r\n        });\r\n    }\r\n\r\n    return [\r\n        item('Insert column before', addColumnBefore),\r\n        item('Insert column after', addColumnAfter),\r\n        item('Insert row before', addRowBefore),\r\n        item('Insert row after', addRowAfter),\r\n        item('Merge cells', mergeCells),\r\n        item('Split cell', splitCell),\r\n        separator(),\r\n        item('Toggle header column', toggleHeaderColumn),\r\n        item('Toggle header row', toggleHeaderRow),\r\n        item('Toggle header cells', toggleHeaderCell),\r\n        separator(),\r\n        item('Delete column', deleteColumn),\r\n        item('Delete row', deleteRow),\r\n        item('Delete table', deleteTable),\r\n    ];\r\n}\r\n\r\nexport function addTable(state, dispatch, { rowsCount, colsCount, withHeaderRow, cellContent }) {\r\n    const offset = state.tr.selection.anchor + 1;\r\n\r\n    const nodes = createTable(state, rowsCount, colsCount, withHeaderRow, cellContent);\r\n    const tr = state.tr.replaceSelectionWith(nodes).scrollIntoView();\r\n    const resolvedPos = tr.doc.resolve(offset);\r\n\r\n    tr.setSelection(TextSelection.near(resolvedPos));\r\n\r\n    dispatch(tr);\r\n}\r\n\r\nfunction createTable(state, rowsCount, colsCount, withHeaderRow, cellContent) {\r\n    const types = tableNodeTypes(state.schema);\r\n    const headerCells: Node[] = [];\r\n    const cells: Node[] = [];\r\n    const createCell = (cellType, _cellContent) =>\r\n        _cellContent ? cellType.createChecked(null, _cellContent) : cellType.createAndFill();\r\n\r\n    for (let index = 0; index < colsCount; index += 1) {\r\n        const cell = createCell(types.cell, cellContent);\r\n\r\n        if (cell) {\r\n            cells.push(cell);\r\n        }\r\n\r\n        if (withHeaderRow) {\r\n            const headerCell = createCell(types.header_cell, cellContent);\r\n\r\n            if (headerCell) {\r\n                headerCells.push(headerCell);\r\n            }\r\n        }\r\n    }\r\n\r\n    const rows: Node[] = [];\r\n\r\n    for (let index = 0; index < rowsCount; index += 1) {\r\n        rows.push(types.row.createChecked(null, withHeaderRow && index === 0 ? headerCells : cells));\r\n    }\r\n\r\n    return types.table.createChecked(null, rows);\r\n}\r\n"]}

package/package/esm2020/core/shared/components/rich-text-editor/prosemirror/prosemirror.service.mjs

@@ -0,0 +1,141 @@
+import { Injectable } from '@angular/core';
+import { baseKeymap } from 'prosemirror-commands';
+import { dropCursor } from 'prosemirror-dropcursor';
+import { gapCursor } from 'prosemirror-gapcursor';
+import { history } from 'prosemirror-history';
+import { keymap } from 'prosemirror-keymap';
+import { DOMParser, DOMSerializer, Schema } from 'prosemirror-model';
+import { schema } from 'prosemirror-schema-basic';
+import { addListNodes } from 'prosemirror-schema-list';
+import { EditorState, Plugin } from 'prosemirror-state';
+import { columnResizing, fixTables, tableEditing } from 'prosemirror-tables';
+import { EditorView } from 'prosemirror-view';
+import { ModalService } from '../../../../providers/modal/modal.service';
+import { iframeNode, iframeNodeView } from './custom-nodes';
+import { buildInputRules } from './inputrules';
+import { buildKeymap } from './keymap';
+import { customMenuPlugin } from './menu/menu-plugin';
+import { imageContextMenuPlugin } from './plugins/image-plugin';
+import { linkSelectPlugin } from './plugins/link-select-plugin';
+import { rawEditorPlugin } from './plugins/raw-editor-plugin';
+import { getTableNodes, tableContextMenuPlugin } from './plugins/tables-plugin';
+import * as i0 from "@angular/core";
+import * as i1 from "./context-menu/context-menu.service";
+export class ProsemirrorService {
+    constructor(injector, contextMenuService) {
+        this.injector = injector;
+        this.contextMenuService = contextMenuService;
+        // Mix the nodes from prosemirror-schema-list into the basic schema to
+        // create a schema with list support.
+        this.mySchema = new Schema({
+            nodes: addListNodes(schema.spec.nodes, 'paragraph block*', 'block')
+                .append(getTableNodes())
+                .addToEnd('iframe', iframeNode),
+            marks: schema.spec.marks,
+        });
+        this.enabled = true;
+    }
+    createEditorView(options) {
+        this.editorView = new EditorView(options.element, {
+            state: this.getStateFromText(''),
+            dispatchTransaction: tr => {
+                if (!this.enabled) {
+                    return;
+                }
+                this.editorView.updateState(this.editorView.state.apply(tr));
+                if (tr.docChanged) {
+                    const content = this.getTextFromState(this.editorView.state);
+                    options.onTextInput(content);
+                }
+            },
+            editable: () => options.isReadOnly(),
+            handleDOMEvents: {
+                focus: view => {
+                    this.contextMenuService.setVisibility(true);
+                },
+                blur: view => {
+                    this.contextMenuService.setVisibility(false);
+                },
+            },
+            nodeViews: {
+                iframe: iframeNodeView,
+            },
+        });
+    }
+    update(text) {
+        if (this.editorView) {
+            const currentText = this.getTextFromState(this.editorView.state);
+            if (text !== currentText) {
+                let state = this.getStateFromText(text);
+                if (document.body.contains(this.editorView.dom)) {
+                    const fix = fixTables(state);
+                    if (fix)
+                        state = state.apply(fix.setMeta('addToHistory', false));
+                    this.editorView.updateState(state);
+                }
+            }
+        }
+    }
+    destroy() {
+        if (this.editorView) {
+            this.editorView.destroy();
+        }
+    }
+    setEnabled(enabled) {
+        if (this.editorView) {
+            this.enabled = enabled;
+            // Updating the state causes ProseMirror to check the
+            // `editable()` function from the contructor config object
+            // newly.
+            this.editorView.updateState(this.editorView.state);
+        }
+    }
+    getStateFromText(text) {
+        const div = document.createElement('div');
+        div.innerHTML = text ?? '';
+        return EditorState.create({
+            doc: DOMParser.fromSchema(this.mySchema).parse(div),
+            plugins: this.configurePlugins({ schema: this.mySchema, floatingMenu: false }),
+        });
+    }
+    getTextFromState(state) {
+        const div = document.createElement('div');
+        const fragment = DOMSerializer.fromSchema(this.mySchema).serializeFragment(state.doc.content);
+        div.appendChild(fragment);
+        return div.innerHTML;
+    }
+    configurePlugins(options) {
+        const plugins = [
+            buildInputRules(options.schema),
+            keymap(buildKeymap(options.schema, options.mapKeys)),
+            keymap(baseKeymap),
+            dropCursor(),
+            gapCursor(),
+            linkSelectPlugin,
+            columnResizing({}),
+            tableEditing({ allowTableNodeSelection: true }),
+            tableContextMenuPlugin(this.contextMenuService),
+            imageContextMenuPlugin(this.contextMenuService, this.injector.get(ModalService)),
+            rawEditorPlugin(this.contextMenuService, this.injector.get(ModalService)),
+            customMenuPlugin({
+                floatingMenu: options.floatingMenu,
+                injector: this.injector,
+                schema: options.schema,
+            }),
+        ];
+        if (options.history !== false) {
+            plugins.push(history());
+        }
+        return plugins.concat(new Plugin({
+            props: {
+                attributes: { class: 'vdr-prosemirror' },
+            },
+        }));
+    }
+}
+ProsemirrorService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.2.3", ngImport: i0, type: ProsemirrorService, deps: [{ token: i0.Injector }, { token: i1.ContextMenuService }], target: i0.ɵɵFactoryTarget.Injectable });
+ProsemirrorService.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "13.2.3", ngImport: i0, type: ProsemirrorService });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.2.3", ngImport: i0, type: ProsemirrorService, decorators: [{
+            type: Injectable
+        }], ctorParameters: function () { return [{ type: i0.Injector }, { type: i1.ContextMenuService }]; } });
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"prosemirror.service.js","sourceRoot":"","sources":["../../../../../../../src/lib/core/src/shared/components/rich-text-editor/prosemirror/prosemirror.service.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,UAAU,EAAY,MAAM,eAAe,CAAC;AACrD,OAAO,EAAE,UAAU,EAAE,MAAM,sBAAsB,CAAC;AAClD,OAAO,EAAE,UAAU,EAAE,MAAM,wBAAwB,CAAC;AACpD,OAAO,EAAE,SAAS,EAAE,MAAM,uBAAuB,CAAC;AAClD,OAAO,EAAE,OAAO,EAAE,MAAM,qBAAqB,CAAC;AAC9C,OAAO,EAAE,MAAM,EAAE,MAAM,oBAAoB,CAAC;AAC5C,OAAO,EAAE,SAAS,EAAE,aAAa,EAAE,MAAM,EAAE,MAAM,mBAAmB,CAAC;AACrE,OAAO,EAAE,MAAM,EAAE,MAAM,0BAA0B,CAAC;AAClD,OAAO,EAAE,YAAY,EAAE,MAAM,yBAAyB,CAAC;AACvD,OAAO,EAAE,WAAW,EAAE,MAAM,EAAE,MAAM,mBAAmB,CAAC;AACxD,OAAO,EAAE,cAAc,EAAE,SAAS,EAAE,YAAY,EAAE,MAAM,oBAAoB,CAAC;AAC7E,OAAO,EAAE,UAAU,EAAE,MAAM,kBAAkB,CAAC;AAG9C,OAAO,EAAE,YAAY,EAAE,MAAM,2CAA2C,CAAC;AAGzE,OAAO,EAAE,UAAU,EAAE,cAAc,EAAE,MAAM,gBAAgB,CAAC;AAC5D,OAAO,EAAE,eAAe,EAAE,MAAM,cAAc,CAAC;AAC/C,OAAO,EAAE,WAAW,EAAE,MAAM,UAAU,CAAC;AACvC,OAAO,EAAE,gBAAgB,EAAE,MAAM,oBAAoB,CAAC;AACtD,OAAO,EAAE,sBAAsB,EAAE,MAAM,wBAAwB,CAAC;AAChE,OAAO,EAAE,gBAAgB,EAAE,MAAM,8BAA8B,CAAC;AAChE,OAAO,EAAE,eAAe,EAAE,MAAM,6BAA6B,CAAC;AAC9D,OAAO,EAAE,aAAa,EAAE,sBAAsB,EAAE,MAAM,yBAAyB,CAAC;;;AAUhF,MAAM,OAAO,kBAAkB;IAa3B,YAAoB,QAAkB,EAAU,kBAAsC;QAAlE,aAAQ,GAAR,QAAQ,CAAU;QAAU,uBAAkB,GAAlB,kBAAkB,CAAoB;QAVtF,sEAAsE;QACtE,qCAAqC;QAC7B,aAAQ,GAAG,IAAI,MAAM,CAAC;YAC1B,KAAK,EAAE,YAAY,CAAC,MAAM,CAAC,IAAI,CAAC,KAAK,EAAE,kBAAkB,EAAE,OAAO,CAAC;iBAC9D,MAAM,CAAC,aAAa,EAAS,CAAC;iBAC9B,QAAQ,CAAC,QAAQ,EAAE,UAAU,CAAC;YACnC,KAAK,EAAE,MAAM,CAAC,IAAI,CAAC,KAAK;SAC3B,CAAC,CAAC;QACK,YAAO,GAAG,IAAI,CAAC;IAEkE,CAAC;IAI1F,gBAAgB,CAAC,OAAgC;QAC7C,IAAI,CAAC,UAAU,GAAG,IAAI,UAAU,CAAC,OAAO,CAAC,OAAO,EAAE;YAC9C,KAAK,EAAE,IAAI,CAAC,gBAAgB,CAAC,EAAE,CAAC;YAChC,mBAAmB,EAAE,EAAE,CAAC,EAAE;gBACtB,IAAI,CAAC,IAAI,CAAC,OAAO,EAAE;oBACf,OAAO;iBACV;gBACD,IAAI,CAAC,UAAU,CAAC,WAAW,CAAC,IAAI,CAAC,UAAU,CAAC,KAAK,CAAC,KAAK,CAAC,EAAE,CAAC,CAAC,CAAC;gBAC7D,IAAI,EAAE,CAAC,UAAU,EAAE;oBACf,MAAM,OAAO,GAAG,IAAI,CAAC,gBAAgB,CAAC,IAAI,CAAC,UAAU,CAAC,KAAK,CAAC,CAAC;oBAC7D,OAAO,CAAC,WAAW,CAAC,OAAO,CAAC,CAAC;iBAChC;YACL,CAAC;YACD,QAAQ,EAAE,GAAG,EAAE,CAAC,OAAO,CAAC,UAAU,EAAE;YACpC,eAAe,EAAE;gBACb,KAAK,EAAE,IAAI,CAAC,EAAE;oBACV,IAAI,CAAC,kBAAkB,CAAC,aAAa,CAAC,IAAI,CAAC,CAAC;gBAChD,CAAC;gBACD,IAAI,EAAE,IAAI,CAAC,EAAE;oBACT,IAAI,CAAC,kBAAkB,CAAC,aAAa,CAAC,KAAK,CAAC,CAAC;gBACjD,CAAC;aACJ;YACD,SAAS,EAAE;gBACP,MAAM,EAAE,cAAc;aACzB;SACJ,CAAC,CAAC;IACP,CAAC;IAED,MAAM,CAAC,IAAY;QACf,IAAI,IAAI,CAAC,UAAU,EAAE;YACjB,MAAM,WAAW,GAAG,IAAI,CAAC,gBAAgB,CAAC,IAAI,CAAC,UAAU,CAAC,KAAK,CAAC,CAAC;YACjE,IAAI,IAAI,KAAK,WAAW,EAAE;gBACtB,IAAI,KAAK,GAAG,IAAI,CAAC,gBAAgB,CAAC,IAAI,CAAC,CAAC;gBACxC,IAAI,QAAQ,CAAC,IAAI,CAAC,QAAQ,CAAC,IAAI,CAAC,UAAU,CAAC,GAAG,CAAC,EAAE;oBAC7C,MAAM,GAAG,GAAG,SAAS,CAAC,KAAK,CAAC,CAAC;oBAC7B,IAAI,GAAG;wBAAE,KAAK,GAAG,KAAK,CAAC,KAAK,CAAC,GAAG,CAAC,OAAO,CAAC,cAAc,EAAE,KAAK,CAAC,CAAC,CAAC;oBACjE,IAAI,CAAC,UAAU,CAAC,WAAW,CAAC,KAAK,CAAC,CAAC;iBACtC;aACJ;SACJ;IACL,CAAC;IAED,OAAO;QACH,IAAI,IAAI,CAAC,UAAU,EAAE;YACjB,IAAI,CAAC,UAAU,CAAC,OAAO,EAAE,CAAC;SAC7B;IACL,CAAC;IAED,UAAU,CAAC,OAAgB;QACvB,IAAI,IAAI,CAAC,UAAU,EAAE;YACjB,IAAI,CAAC,OAAO,GAAG,OAAO,CAAC;YACvB,qDAAqD;YACrD,0DAA0D;YAC1D,SAAS;YACT,IAAI,CAAC,UAAU,CAAC,WAAW,CAAC,IAAI,CAAC,UAAU,CAAC,KAAK,CAAC,CAAC;SACtD;IACL,CAAC;IAEO,gBAAgB,CAAC,IAA+B;QACpD,MAAM,GAAG,GAAG,QAAQ,CAAC,aAAa,CAAC,KAAK,CAAC,CAAC;QAC1C,GAAG,CAAC,SAAS,GAAG,IAAI,IAAI,EAAE,CAAC;QAC3B,OAAO,WAAW,CAAC,MAAM,CAAC;YACtB,GAAG,EAAE,SAAS,CAAC,UAAU,CAAC,IAAI,CAAC,QAAQ,CAAC,CAAC,KAAK,CAAC,GAAG,CAAC;YACnD,OAAO,EAAE,IAAI,CAAC,gBAAgB,CAAC,EAAE,MAAM,EAAE,IAAI,CAAC,QAAQ,EAAE,YAAY,EAAE,KAAK,EAAE,CAAC;SACjF,CAAC,CAAC;IACP,CAAC;IAEO,gBAAgB,CAAC,KAAkB;QACvC,MAAM,GAAG,GAAG,QAAQ,CAAC,aAAa,CAAC,KAAK,CAAC,CAAC;QAC1C,MAAM,QAAQ,GAAG,aAAa,CAAC,UAAU,CAAC,IAAI,CAAC,QAAQ,CAAC,CAAC,iBAAiB,CAAC,KAAK,CAAC,GAAG,CAAC,OAAO,CAAC,CAAC;QAE9F,GAAG,CAAC,WAAW,CAAC,QAAQ,CAAC,CAAC;QAE1B,OAAO,GAAG,CAAC,SAAS,CAAC;IACzB,CAAC;IAEO,gBAAgB,CAAC,OAAqB;QAC1C,MAAM,OAAO,GAAG;YACZ,eAAe,CAAC,OAAO,CAAC,MAAM,CAAC;YAC/B,MAAM,CAAC,WAAW,CAAC,OAAO,CAAC,MAAM,EAAE,OAAO,CAAC,OAAO,CAAC,CAAC;YACpD,MAAM,CAAC,UAAU,CAAC;YAClB,UAAU,EAAE;YACZ,SAAS,EAAE;YACX,gBAAgB;YAChB,cAAc,CAAC,EAAE,CAAC;YAClB,YAAY,CAAC,EAAE,uBAAuB,EAAE,IAAI,EAAE,CAAC;YAC/C,sBAAsB,CAAC,IAAI,CAAC,kBAAkB,CAAC;YAC/C,sBAAsB,CAAC,IAAI,CAAC,kBAAkB,EAAE,IAAI,CAAC,QAAQ,CAAC,GAAG,CAAC,YAAY,CAAC,CAAC;YAChF,eAAe,CAAC,IAAI,CAAC,kBAAkB,EAAE,IAAI,CAAC,QAAQ,CAAC,GAAG,CAAC,YAAY,CAAC,CAAC;YACzE,gBAAgB,CAAC;gBACb,YAAY,EAAE,OAAO,CAAC,YAAY;gBAClC,QAAQ,EAAE,IAAI,CAAC,QAAQ;gBACvB,MAAM,EAAE,OAAO,CAAC,MAAM;aACzB,CAAC;SACL,CAAC;QACF,IAAI,OAAO,CAAC,OAAO,KAAK,KAAK,EAAE;YAC3B,OAAO,CAAC,IAAI,CAAC,OAAO,EAAE,CAAC,CAAC;SAC3B;QAED,OAAO,OAAO,CAAC,MAAM,CACjB,IAAI,MAAM,CAAC;YACP,KAAK,EAAE;gBACH,UAAU,EAAE,EAAE,KAAK,EAAE,iBAAiB,EAAE;aAC3C;SACJ,CAAC,CACL,CAAC;IACN,CAAC;;+GA3HQ,kBAAkB;mHAAlB,kBAAkB;2FAAlB,kBAAkB;kBAD9B,UAAU","sourcesContent":["import { Injectable, Injector } from '@angular/core';\r\nimport { baseKeymap } from 'prosemirror-commands';\r\nimport { dropCursor } from 'prosemirror-dropcursor';\r\nimport { gapCursor } from 'prosemirror-gapcursor';\r\nimport { history } from 'prosemirror-history';\r\nimport { keymap } from 'prosemirror-keymap';\r\nimport { DOMParser, DOMSerializer, Schema } from 'prosemirror-model';\r\nimport { schema } from 'prosemirror-schema-basic';\r\nimport { addListNodes } from 'prosemirror-schema-list';\r\nimport { EditorState, Plugin } from 'prosemirror-state';\r\nimport { columnResizing, fixTables, tableEditing } from 'prosemirror-tables';\r\nimport { EditorView } from 'prosemirror-view';\r\nimport { Observable } from 'rxjs';\r\n\r\nimport { ModalService } from '../../../../providers/modal/modal.service';\r\n\r\nimport { ContextMenuService } from './context-menu/context-menu.service';\r\nimport { iframeNode, iframeNodeView } from './custom-nodes';\r\nimport { buildInputRules } from './inputrules';\r\nimport { buildKeymap } from './keymap';\r\nimport { customMenuPlugin } from './menu/menu-plugin';\r\nimport { imageContextMenuPlugin } from './plugins/image-plugin';\r\nimport { linkSelectPlugin } from './plugins/link-select-plugin';\r\nimport { rawEditorPlugin } from './plugins/raw-editor-plugin';\r\nimport { getTableNodes, tableContextMenuPlugin } from './plugins/tables-plugin';\r\nimport { SetupOptions } from './types';\r\n\r\nexport interface CreateEditorViewOptions {\r\n    onTextInput: (content: string) => void;\r\n    element: HTMLElement;\r\n    isReadOnly: () => boolean;\r\n}\r\n\r\n@Injectable()\r\nexport class ProsemirrorService {\r\n    editorView: EditorView;\r\n\r\n    // Mix the nodes from prosemirror-schema-list into the basic schema to\r\n    // create a schema with list support.\r\n    private mySchema = new Schema({\r\n        nodes: addListNodes(schema.spec.nodes, 'paragraph block*', 'block')\r\n            .append(getTableNodes() as any)\r\n            .addToEnd('iframe', iframeNode),\r\n        marks: schema.spec.marks,\r\n    });\r\n    private enabled = true;\r\n\r\n    constructor(private injector: Injector, private contextMenuService: ContextMenuService) {}\r\n\r\n    contextMenuItems$: Observable<string>;\r\n\r\n    createEditorView(options: CreateEditorViewOptions) {\r\n        this.editorView = new EditorView(options.element, {\r\n            state: this.getStateFromText(''),\r\n            dispatchTransaction: tr => {\r\n                if (!this.enabled) {\r\n                    return;\r\n                }\r\n                this.editorView.updateState(this.editorView.state.apply(tr));\r\n                if (tr.docChanged) {\r\n                    const content = this.getTextFromState(this.editorView.state);\r\n                    options.onTextInput(content);\r\n                }\r\n            },\r\n            editable: () => options.isReadOnly(),\r\n            handleDOMEvents: {\r\n                focus: view => {\r\n                    this.contextMenuService.setVisibility(true);\r\n                },\r\n                blur: view => {\r\n                    this.contextMenuService.setVisibility(false);\r\n                },\r\n            },\r\n            nodeViews: {\r\n                iframe: iframeNodeView,\r\n            },\r\n        });\r\n    }\r\n\r\n    update(text: string) {\r\n        if (this.editorView) {\r\n            const currentText = this.getTextFromState(this.editorView.state);\r\n            if (text !== currentText) {\r\n                let state = this.getStateFromText(text);\r\n                if (document.body.contains(this.editorView.dom)) {\r\n                    const fix = fixTables(state);\r\n                    if (fix) state = state.apply(fix.setMeta('addToHistory', false));\r\n                    this.editorView.updateState(state);\r\n                }\r\n            }\r\n        }\r\n    }\r\n\r\n    destroy() {\r\n        if (this.editorView) {\r\n            this.editorView.destroy();\r\n        }\r\n    }\r\n\r\n    setEnabled(enabled: boolean) {\r\n        if (this.editorView) {\r\n            this.enabled = enabled;\r\n            // Updating the state causes ProseMirror to check the\r\n            // `editable()` function from the contructor config object\r\n            // newly.\r\n            this.editorView.updateState(this.editorView.state);\r\n        }\r\n    }\r\n\r\n    private getStateFromText(text: string | null | undefined): EditorState {\r\n        const div = document.createElement('div');\r\n        div.innerHTML = text ?? '';\r\n        return EditorState.create({\r\n            doc: DOMParser.fromSchema(this.mySchema).parse(div),\r\n            plugins: this.configurePlugins({ schema: this.mySchema, floatingMenu: false }),\r\n        });\r\n    }\r\n\r\n    private getTextFromState(state: EditorState): string {\r\n        const div = document.createElement('div');\r\n        const fragment = DOMSerializer.fromSchema(this.mySchema).serializeFragment(state.doc.content);\r\n\r\n        div.appendChild(fragment);\r\n\r\n        return div.innerHTML;\r\n    }\r\n\r\n    private configurePlugins(options: SetupOptions) {\r\n        const plugins = [\r\n            buildInputRules(options.schema),\r\n            keymap(buildKeymap(options.schema, options.mapKeys)),\r\n            keymap(baseKeymap),\r\n            dropCursor(),\r\n            gapCursor(),\r\n            linkSelectPlugin,\r\n            columnResizing({}),\r\n            tableEditing({ allowTableNodeSelection: true }),\r\n            tableContextMenuPlugin(this.contextMenuService),\r\n            imageContextMenuPlugin(this.contextMenuService, this.injector.get(ModalService)),\r\n            rawEditorPlugin(this.contextMenuService, this.injector.get(ModalService)),\r\n            customMenuPlugin({\r\n                floatingMenu: options.floatingMenu,\r\n                injector: this.injector,\r\n                schema: options.schema,\r\n            }),\r\n        ];\r\n        if (options.history !== false) {\r\n            plugins.push(history());\r\n        }\r\n\r\n        return plugins.concat(\r\n            new Plugin({\r\n                props: {\r\n                    attributes: { class: 'vdr-prosemirror' },\r\n                },\r\n            }),\r\n        );\r\n    }\r\n}\r\n"]}

package/{esm2020 → package/esm2020}/core/shared/components/rich-text-editor/prosemirror/types.mjs

@@ -1,2 +1,2 @@
 export {};
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoidHlwZXMuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi8uLi9zcmMvbGliL2NvcmUvc3JjL3NoYXJlZC9jb21wb25lbnRzL3JpY2gtdGV4dC1lZGl0b3IvcHJvc2VtaXJyb3IvdHlwZXMudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IiIsInNvdXJjZXNDb250ZW50IjpbImltcG9ydCB7IE1lbnVJdGVtIH0gZnJvbSAncHJvc2VtaXJyb3ItbWVudSc7XHJcbmltcG9ydCB7IFNjaGVtYSB9IGZyb20gJ3Byb3NlbWlycm9yLW1vZGVsJztcclxuXHJcbmV4cG9ydCBpbnRlcmZhY2UgU2V0dXBPcHRpb25zIHtcclxuICAgIHNjaGVtYTogU2NoZW1hO1xyXG4gICAgbWFwS2V5cz86IEtleW1hcDtcclxuICAgIG1lbnVCYXI/OiBib29sZWFuO1xyXG4gICAgaGlzdG9yeT86IGJvb2xlYW47XHJcbiAgICBmbG9hdGluZ01lbnU/OiBib29sZWFuO1xyXG4gICAgbWVudUNvbnRlbnQ/OiBNZW51SXRlbVtdW107XHJcbn1cclxuXHJcbmV4cG9ydCB0eXBlIEtleW1hcCA9IFJlY29yZDxzdHJpbmcsIHN0cmluZyB8IGZhbHNlPjtcclxuIl19
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoidHlwZXMuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi8uLi9zcmMvbGliL2NvcmUvc3JjL3NoYXJlZC9jb21wb25lbnRzL3JpY2gtdGV4dC1lZGl0b3IvcHJvc2VtaXJyb3IvdHlwZXMudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IiIsInNvdXJjZXNDb250ZW50IjpbImltcG9ydCB7IE1lbnVJdGVtIH0gZnJvbSAncHJvc2VtaXJyb3ItbWVudSc7XHJcbmltcG9ydCB7IFNjaGVtYSB9IGZyb20gJ3Byb3NlbWlycm9yLW1vZGVsJztcclxuXHJcbmV4cG9ydCBpbnRlcmZhY2UgU2V0dXBPcHRpb25zIHtcclxuICAgIHNjaGVtYTogU2NoZW1hO1xyXG4gICAgbWFwS2V5cz86IEtleW1hcDtcclxuICAgIG1lbnVCYXI/OiBib29sZWFuO1xyXG4gICAgaGlzdG9yeT86IGJvb2xlYW47XHJcbiAgICBmbG9hdGluZ01lbnU/OiBib29sZWFuO1xyXG59XHJcblxyXG5leHBvcnQgdHlwZSBLZXltYXAgPSBSZWNvcmQ8c3RyaW5nLCBzdHJpbmcgfCBmYWxzZT47XHJcbiJdfQ==