@vendure/admin-ui 2.0.0-next.12 → 2.0.0-next.13

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/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/esm2020/core/shared/components/rich-text-editor/prosemirror/prosemirror.service.mjs

@@ -4,25 +4,33 @@ import { dropCursor } from 'prosemirror-dropcursor';
 import { gapCursor } from 'prosemirror-gapcursor';
 import { history } from 'prosemirror-history';
 import { keymap } from 'prosemirror-keymap';
-import { menuBar } from 'prosemirror-menu';
 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 { buildMenuItems } from './menu/menu';
+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 "../../../../providers/modal/modal.service";
+import * as i1 from "./context-menu/context-menu.service";
 export class ProsemirrorService {
-    constructor(modalService) {
-        this.modalService = modalService;
+    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'),
+            nodes: addListNodes(schema.spec.nodes, 'paragraph block*', 'block')
+                .append(getTableNodes())
+                .addToEnd('iframe', iframeNode),
             marks: schema.spec.marks,
         });
         this.enabled = true;
@@ -41,12 +49,26 @@ export class ProsemirrorService {
                 }
             },
             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 state = this.getStateFromText(text);
+            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);
             }
         }
@@ -87,13 +109,17 @@ export class ProsemirrorService {
             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.menuBar !== false) {
-            plugins.push(menuBar({
-                floating: options.floatingMenu !== false,
-                content: options.menuContent || buildMenuItems(options.schema, this.modalService).fullMenu,
-            }));
-        }
         if (options.history !== false) {
             plugins.push(history());
         }
@@ -104,9 +130,9 @@ export class ProsemirrorService {
         }));
     }
 }
-ProsemirrorService.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.2.3", ngImport: i0, type: ProsemirrorService, deps: [{ token: i1.ModalService }], target: i0.ɵɵFactoryTarget.Injectable });
+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: i1.ModalService }]; } });
-//# 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":"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","sourcesContent":["import { Injectable } 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 { menuBar } from 'prosemirror-menu';\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 { EditorView } from 'prosemirror-view';\r\n\r\nimport { ModalService } from '../../../../providers/modal/modal.service';\r\n\r\nimport { buildInputRules } from './inputrules';\r\nimport { buildKeymap } from './keymap';\r\nimport { buildMenuItems } from './menu/menu';\r\nimport { linkSelectPlugin } from './plugins/link-select-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        marks: schema.spec.marks,\r\n    });\r\n    private enabled = true;\r\n\r\n    constructor(private modalService: ModalService) {}\r\n\r\n    createEditorView(options: CreateEditorViewOptions) {\r\n        this.editorView = new EditorView<Schema>(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        });\r\n    }\r\n\r\n    update(text: string) {\r\n        if (this.editorView) {\r\n            const state = this.getStateFromText(text);\r\n            if (document.body.contains(this.editorView.dom)) {\r\n                this.editorView.updateState(state);\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        ];\r\n        if (options.menuBar !== false) {\r\n            plugins.push(\r\n                menuBar({\r\n                    floating: options.floatingMenu !== false,\r\n                    content:\r\n                        options.menuContent || buildMenuItems(options.schema, this.modalService).fullMenu,\r\n                }),\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"]}
+        }], 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":"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","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\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            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    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/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==

package/esm2020/core/shared/components/rich-text-editor/raw-html-dialog/raw-html-dialog.component.mjs

@@ -0,0 +1,59 @@
+import { ChangeDetectionStrategy, Component } from '@angular/core';
+import { FormControl } from '@angular/forms';
+import { HtmlEditorFormInputComponent } from '../../../dynamic-form-inputs/code-editor-form-input/html-editor-form-input.component';
+import * as i0 from "@angular/core";
+import * as i1 from "../../../dynamic-form-inputs/dynamic-form-input/dynamic-form-input.component";
+import * as i2 from "../../modal-dialog/dialog-buttons.directive";
+import * as i3 from "@ngx-translate/core";
+export class RawHtmlDialogComponent {
+    constructor() {
+        this.formControl = new FormControl();
+        this.config = {
+            name: '',
+            type: '',
+            list: false,
+            required: true,
+            ui: { component: HtmlEditorFormInputComponent.id },
+        };
+    }
+    ngOnInit() {
+        this.formControl.setValue(this.process(this.html));
+    }
+    process(str) {
+        const div = document.createElement('div');
+        div.innerHTML = str.trim();
+        return this.format(div, 0).innerHTML.trim();
+    }
+    /**
+     * Taken from https://stackoverflow.com/a/26361620/772859
+     */
+    format(node, level = 0) {
+        const indentBefore = new Array(level++ + 1).join('\t');
+        const indentAfter = new Array(level - 1).join('\t');
+        let textNode;
+        // tslint:disable-next-line:prefer-for-of
+        for (let i = 0; i < node.children.length; i++) {
+            textNode = document.createTextNode('\n' + indentBefore);
+            node.insertBefore(textNode, node.children[i]);
+            this.format(node.children[i], level);
+            if (node.lastElementChild === node.children[i]) {
+                textNode = document.createTextNode('\n' + indentAfter);
+                node.appendChild(textNode);
+            }
+        }
+        return node;
+    }
+    cancel() {
+        this.resolveWith(undefined);
+    }
+    select() {
+        this.resolveWith(this.formControl.value);
+    }
+}
+RawHtmlDialogComponent.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "13.2.3", ngImport: i0, type: RawHtmlDialogComponent, deps: [], target: i0.ɵɵFactoryTarget.Component });
+RawHtmlDialogComponent.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "12.0.0", version: "13.2.3", type: RawHtmlDialogComponent, selector: "vdr-raw-html-dialog", ngImport: i0, template: "<vdr-dynamic-form-input\r\n                      [def]=\"config\"\r\n                      [control]=\"formControl\"\r\n                  ></vdr-dynamic-form-input>\r\n<ng-template vdrDialogButtons>\r\n    <button type=\"button\" class=\"btn btn-secondary\" (click)=\"cancel()\">\r\n       {{ 'common.cancel' | translate }}\r\n    </button>\r\n    <button type=\"submit\" (click)=\"select()\" class=\"btn btn-primary\" [disabled]=\"formControl.invalid\">\r\n        {{ 'common.update' | translate }}\r\n    </button>\r\n</ng-template>\r\n", styles: [""], components: [{ type: i1.DynamicFormInputComponent, selector: "vdr-dynamic-form-input", inputs: ["def", "readonly", "control"] }], directives: [{ type: i2.DialogButtonsDirective, selector: "[vdrDialogButtons]" }], pipes: { "translate": i3.TranslatePipe }, changeDetection: i0.ChangeDetectionStrategy.OnPush });
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "13.2.3", ngImport: i0, type: RawHtmlDialogComponent, decorators: [{
+            type: Component,
+            args: [{ selector: 'vdr-raw-html-dialog', changeDetection: ChangeDetectionStrategy.OnPush, template: "<vdr-dynamic-form-input\r\n                      [def]=\"config\"\r\n                      [control]=\"formControl\"\r\n                  ></vdr-dynamic-form-input>\r\n<ng-template vdrDialogButtons>\r\n    <button type=\"button\" class=\"btn btn-secondary\" (click)=\"cancel()\">\r\n       {{ 'common.cancel' | translate }}\r\n    </button>\r\n    <button type=\"submit\" (click)=\"select()\" class=\"btn btn-primary\" [disabled]=\"formControl.invalid\">\r\n        {{ 'common.update' | translate }}\r\n    </button>\r\n</ng-template>\r\n", styles: [""] }]
+        }] });
+//# sourceMappingURL=data:application/json;base64,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