@deenruv/admin-ui 1.0.0

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

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

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

@@ -0,0 +1,155 @@
+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, linkMark } 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.update('link', linkMark),
+        });
+        this.enabled = true;
+        /**
+         * This is a Document used for processing incoming text. It ensures that malicious HTML is not executed by the
+         * actual document that is attached to the browser DOM, which could cause XSS attacks.
+         */
+        this.detachedDoc = null;
+    }
+    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 doc = this.getDetachedDoc();
+        const div = doc.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 doc = this.getDetachedDoc();
+        const div = doc.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' },
+            },
+        }));
+    }
+    getDetachedDoc() {
+        if (!this.detachedDoc) {
+            this.detachedDoc = document.implementation.createHTMLDocument();
+        }
+        return this.detachedDoc;
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: ProsemirrorService, deps: [{ token: i0.Injector }, { token: i1.ContextMenuService }], target: i0.ɵɵFactoryTarget.Injectable }); }
+    static { this.ɵprov = i0.ɵɵngDeclareInjectable({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: ProsemirrorService }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: ProsemirrorService, decorators: [{
+            type: Injectable
+        }], ctorParameters: () => [{ 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';\nimport { baseKeymap } from 'prosemirror-commands';\nimport { dropCursor } from 'prosemirror-dropcursor';\nimport { gapCursor } from 'prosemirror-gapcursor';\nimport { history } from 'prosemirror-history';\nimport { keymap } from 'prosemirror-keymap';\nimport { DOMParser, DOMSerializer, Schema } from 'prosemirror-model';\nimport { schema } from 'prosemirror-schema-basic';\nimport { addListNodes } from 'prosemirror-schema-list';\nimport { EditorState, Plugin } from 'prosemirror-state';\nimport { columnResizing, fixTables, tableEditing } from 'prosemirror-tables';\nimport { EditorView } from 'prosemirror-view';\nimport { Observable } from 'rxjs';\n\nimport { ModalService } from '../../../../providers/modal/modal.service';\n\nimport { ContextMenuService } from './context-menu/context-menu.service';\nimport { iframeNode, iframeNodeView, linkMark } from './custom-nodes';\nimport { buildInputRules } from './inputrules';\nimport { buildKeymap } from './keymap';\nimport { customMenuPlugin } from './menu/menu-plugin';\nimport { imageContextMenuPlugin } from './plugins/image-plugin';\nimport { linkSelectPlugin } from './plugins/link-select-plugin';\nimport { rawEditorPlugin } from './plugins/raw-editor-plugin';\nimport { getTableNodes, tableContextMenuPlugin } from './plugins/tables-plugin';\nimport { SetupOptions } from './types';\n\nexport interface CreateEditorViewOptions {\n    onTextInput: (content: string) => void;\n    element: HTMLElement;\n    isReadOnly: () => boolean;\n}\n\n@Injectable()\nexport class ProsemirrorService {\n    editorView: EditorView;\n\n    // Mix the nodes from prosemirror-schema-list into the basic schema to\n    // create a schema with list support.\n    private mySchema = new Schema({\n        nodes: addListNodes(schema.spec.nodes, 'paragraph block*', 'block')\n            .append(getTableNodes() as any)\n            .addToEnd('iframe', iframeNode),\n        marks: schema.spec.marks.update('link', linkMark),\n    });\n    private enabled = true;\n    /**\n     * This is a Document used for processing incoming text. It ensures that malicious HTML is not executed by the\n     * actual document that is attached to the browser DOM, which could cause XSS attacks.\n     */\n    private detachedDoc: Document | null = null;\n\n    constructor(private injector: Injector, private contextMenuService: ContextMenuService) {}\n\n    contextMenuItems$: Observable<string>;\n\n    createEditorView(options: CreateEditorViewOptions) {\n        this.editorView = new EditorView(options.element, {\n            state: this.getStateFromText(''),\n            dispatchTransaction: tr => {\n                if (!this.enabled) {\n                    return;\n                }\n                this.editorView.updateState(this.editorView.state.apply(tr));\n                if (tr.docChanged) {\n                    const content = this.getTextFromState(this.editorView.state);\n                    options.onTextInput(content);\n                }\n            },\n            editable: () => options.isReadOnly(),\n            handleDOMEvents: {\n                focus: view => {\n                    this.contextMenuService.setVisibility(true);\n                },\n                blur: view => {\n                    this.contextMenuService.setVisibility(false);\n                },\n            },\n            nodeViews: {\n                iframe: iframeNodeView,\n            },\n        });\n    }\n\n    update(text: string) {\n        if (this.editorView) {\n            const currentText = this.getTextFromState(this.editorView.state);\n            if (text !== currentText) {\n                let state = this.getStateFromText(text);\n                if (document.body.contains(this.editorView.dom)) {\n                    const fix = fixTables(state);\n                    if (fix) {\n                        state = state.apply(fix.setMeta('addToHistory', false));\n                    }\n                    this.editorView.updateState(state);\n                }\n            }\n        }\n    }\n\n    destroy() {\n        if (this.editorView) {\n            this.editorView.destroy();\n        }\n    }\n\n    setEnabled(enabled: boolean) {\n        if (this.editorView) {\n            this.enabled = enabled;\n            // Updating the state causes ProseMirror to check the\n            // `editable()` function from the contructor config object\n            // newly.\n            this.editorView.updateState(this.editorView.state);\n        }\n    }\n\n    private getStateFromText(text: string | null | undefined): EditorState {\n        const doc = this.getDetachedDoc();\n        const div = doc.createElement('div');\n        div.innerHTML = text ?? '';\n        return EditorState.create({\n            doc: DOMParser.fromSchema(this.mySchema).parse(div),\n            plugins: this.configurePlugins({ schema: this.mySchema, floatingMenu: false }),\n        });\n    }\n\n    private getTextFromState(state: EditorState): string {\n        const doc = this.getDetachedDoc();\n        const div = doc.createElement('div');\n        const fragment = DOMSerializer.fromSchema(this.mySchema).serializeFragment(state.doc.content);\n\n        div.appendChild(fragment);\n\n        return div.innerHTML;\n    }\n\n    private configurePlugins(options: SetupOptions) {\n        const plugins = [\n            buildInputRules(options.schema),\n            keymap(buildKeymap(options.schema, options.mapKeys)),\n            keymap(baseKeymap),\n            dropCursor(),\n            gapCursor(),\n            linkSelectPlugin,\n            columnResizing({}),\n            tableEditing({ allowTableNodeSelection: true }),\n            tableContextMenuPlugin(this.contextMenuService),\n            imageContextMenuPlugin(this.contextMenuService, this.injector.get(ModalService)),\n            rawEditorPlugin(this.contextMenuService, this.injector.get(ModalService)),\n            customMenuPlugin({\n                floatingMenu: options.floatingMenu,\n                injector: this.injector,\n                schema: options.schema,\n            }),\n        ];\n        if (options.history !== false) {\n            plugins.push(history());\n        }\n\n        return plugins.concat(\n            new Plugin({\n                props: {\n                    attributes: { class: 'vdr-prosemirror' },\n                },\n            }),\n        );\n    }\n\n    private getDetachedDoc() {\n        if (!this.detachedDoc) {\n            this.detachedDoc = document.implementation.createHTMLDocument();\n        }\n        return this.detachedDoc;\n    }\n}\n"]}

package/esm2022/core/shared/components/rich-text-editor/prosemirror/types.mjs

@@ -0,0 +1,2 @@
+export {};
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoidHlwZXMuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi8uLi9zcmMvbGliL2NvcmUvc3JjL3NoYXJlZC9jb21wb25lbnRzL3JpY2gtdGV4dC1lZGl0b3IvcHJvc2VtaXJyb3IvdHlwZXMudHMiXSwibmFtZXMiOltdLCJtYXBwaW5ncyI6IiIsInNvdXJjZXNDb250ZW50IjpbImltcG9ydCB7IE1lbnVJdGVtIH0gZnJvbSAncHJvc2VtaXJyb3ItbWVudSc7XG5pbXBvcnQgeyBTY2hlbWEgfSBmcm9tICdwcm9zZW1pcnJvci1tb2RlbCc7XG5cbmV4cG9ydCBpbnRlcmZhY2UgU2V0dXBPcHRpb25zIHtcbiAgICBzY2hlbWE6IFNjaGVtYTtcbiAgICBtYXBLZXlzPzogS2V5bWFwO1xuICAgIG1lbnVCYXI/OiBib29sZWFuO1xuICAgIGhpc3Rvcnk/OiBib29sZWFuO1xuICAgIGZsb2F0aW5nTWVudT86IGJvb2xlYW47XG59XG5cbmV4cG9ydCB0eXBlIEtleW1hcCA9IFJlY29yZDxzdHJpbmcsIHN0cmluZyB8IGZhbHNlPjtcbiJdfQ==

package/esm2022/core/shared/components/rich-text-editor/prosemirror/utils.mjs

@@ -0,0 +1,26 @@
+/**
+ * Retrieve the start and end position of a mark
+ * "Borrowed" from [tiptap](https://github.com/scrumpy/tiptap)
+ */
+export const getMarkRange = (pmPosition = null, type = null) => {
+    if (!pmPosition || !type) {
+        return false;
+    }
+    const start = pmPosition.parent.childAfter(pmPosition.parentOffset);
+    if (!start.node) {
+        return false;
+    }
+    const mark = start.node.marks.find(({ type: markType }) => markType === type);
+    if (!mark) {
+        return false;
+    }
+    let startIndex = pmPosition.index();
+    let startPos = pmPosition.start() + start.offset;
+    while (startIndex > 0 && mark.isInSet(pmPosition.parent.child(startIndex - 1).marks)) {
+        startIndex -= 1;
+        startPos -= pmPosition.parent.child(startIndex).nodeSize;
+    }
+    const endPos = startPos + start.node.nodeSize;
+    return { from: startPos, to: endPos };
+};
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/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 { UntypedFormControl } 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 "../../modal-dialog/dialog-buttons.directive";
+import * as i2 from "../../../dynamic-form-inputs/dynamic-form-input/dynamic-form-input.component";
+import * as i3 from "@ngx-translate/core";
+export class RawHtmlDialogComponent {
+    constructor() {
+        this.formControl = new UntypedFormControl();
+        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;
+        // eslint-disable-next-line @typescript-eslint/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);
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: RawHtmlDialogComponent, deps: [], target: i0.ɵɵFactoryTarget.Component }); }
+    static { this.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "17.3.12", type: RawHtmlDialogComponent, selector: "vdr-raw-html-dialog", ngImport: i0, template: "<vdr-dynamic-form-input\n                      [def]=\"config\"\n                      [control]=\"formControl\"\n                  ></vdr-dynamic-form-input>\n<ng-template vdrDialogButtons>\n    <button type=\"button\" class=\"btn btn-secondary\" (click)=\"cancel()\">\n       {{ 'common.cancel' | translate }}\n    </button>\n    <button type=\"submit\" (click)=\"select()\" class=\"btn btn-primary\" [disabled]=\"formControl.invalid\">\n        {{ 'common.update' | translate }}\n    </button>\n</ng-template>\n", styles: [""], dependencies: [{ kind: "directive", type: i1.DialogButtonsDirective, selector: "[vdrDialogButtons]" }, { kind: "component", type: i2.DynamicFormInputComponent, selector: "vdr-dynamic-form-input", inputs: ["def", "readonly", "control"] }, { kind: "pipe", type: i3.TranslatePipe, name: "translate" }], changeDetection: i0.ChangeDetectionStrategy.OnPush }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: RawHtmlDialogComponent, decorators: [{
+            type: Component,
+            args: [{ selector: 'vdr-raw-html-dialog', changeDetection: ChangeDetectionStrategy.OnPush, template: "<vdr-dynamic-form-input\n                      [def]=\"config\"\n                      [control]=\"formControl\"\n                  ></vdr-dynamic-form-input>\n<ng-template vdrDialogButtons>\n    <button type=\"button\" class=\"btn btn-secondary\" (click)=\"cancel()\">\n       {{ 'common.cancel' | translate }}\n    </button>\n    <button type=\"submit\" (click)=\"select()\" class=\"btn btn-primary\" [disabled]=\"formControl.invalid\">\n        {{ 'common.update' | translate }}\n    </button>\n</ng-template>\n" }]
+        }] });
+//# sourceMappingURL=data:application/json;base64,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

package/esm2022/core/shared/components/rich-text-editor/rich-text-editor.component.mjs

@@ -0,0 +1,106 @@
+import { ChangeDetectionStrategy, Component, HostBinding, Input, ViewChild, } from '@angular/core';
+import { NG_VALUE_ACCESSOR } from '@angular/forms';
+import { ContextMenuService } from './prosemirror/context-menu/context-menu.service';
+import { ProsemirrorService } from './prosemirror/prosemirror.service';
+import * as i0 from "@angular/core";
+import * as i1 from "./prosemirror/prosemirror.service";
+import * as i2 from "./prosemirror/context-menu/context-menu.service";
+import * as i3 from "@clr/angular";
+import * as i4 from "@angular/common";
+import * as i5 from "./prosemirror/context-menu/context-menu.component";
+/**
+ * @description
+ * A rich text (HTML) editor based on Prosemirror (https://prosemirror.net/)
+ *
+ * @example
+ * ```HTML
+ * <vdr-rich-text-editor
+ *     [(ngModel)]="description"
+ *     label="Description"
+ * ></vdr-rich-text-editor>
+ * ```
+ *
+ * @docsCategory components
+ */
+export class RichTextEditorComponent {
+    set readonly(value) {
+        this._readonly = !!value;
+        this.prosemirrorService.setEnabled(!this._readonly);
+    }
+    constructor(changeDetector, prosemirrorService, viewContainerRef, contextMenuService) {
+        this.changeDetector = changeDetector;
+        this.prosemirrorService = prosemirrorService;
+        this.viewContainerRef = viewContainerRef;
+        this.contextMenuService = contextMenuService;
+        this._readonly = false;
+    }
+    get menuElement() {
+        return this.viewContainerRef.element.nativeElement.querySelector('.ProseMirror-menubar');
+    }
+    ngAfterViewInit() {
+        this.prosemirrorService.createEditorView({
+            element: this.editorEl.nativeElement,
+            onTextInput: content => {
+                this.onChange(content);
+                this.changeDetector.markForCheck();
+            },
+            isReadOnly: () => !this._readonly,
+        });
+        if (this.value) {
+            this.prosemirrorService.update(this.value);
+        }
+    }
+    ngOnDestroy() {
+        this.prosemirrorService.destroy();
+    }
+    registerOnChange(fn) {
+        this.onChange = fn;
+    }
+    registerOnTouched(fn) {
+        this.onTouch = fn;
+    }
+    setDisabledState(isDisabled) {
+        this.prosemirrorService.setEnabled(!isDisabled);
+    }
+    writeValue(value) {
+        if (value !== this.value) {
+            this.value = value;
+            if (this.prosemirrorService) {
+                this.prosemirrorService.update(value);
+            }
+        }
+    }
+    static { this.ɵfac = i0.ɵɵngDeclareFactory({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: RichTextEditorComponent, deps: [{ token: i0.ChangeDetectorRef }, { token: i1.ProsemirrorService }, { token: i0.ViewContainerRef }, { token: i2.ContextMenuService }], target: i0.ɵɵFactoryTarget.Component }); }
+    static { this.ɵcmp = i0.ɵɵngDeclareComponent({ minVersion: "14.0.0", version: "17.3.12", type: RichTextEditorComponent, selector: "vdr-rich-text-editor", inputs: { label: "label", readonly: "readonly" }, host: { properties: { "class.readonly": "this._readonly" } }, providers: [
+            {
+                provide: NG_VALUE_ACCESSOR,
+                useExisting: RichTextEditorComponent,
+                multi: true,
+            },
+            ProsemirrorService,
+            ContextMenuService,
+        ], viewQueries: [{ propertyName: "editorEl", first: true, predicate: ["editor"], descendants: true, static: true }], ngImport: i0, template: "<label *ngIf=\"label\" class=\"rich-text-label\">{{ label }}</label>\n<div #editor></div>\n<vdr-context-menu [editorMenuElement]=\"menuElement\"></vdr-context-menu>\n", styles: [":host{display:block;margin-bottom:.5rem}:host.readonly ::ng-deep .ProseMirror-menubar{display:none}.context-menu{position:fixed}\n"], dependencies: [{ kind: "directive", type: i3.ClrLabel, selector: "label", inputs: ["id", "for"] }, { kind: "directive", type: i4.NgIf, selector: "[ngIf]", inputs: ["ngIf", "ngIfThen", "ngIfElse"] }, { kind: "component", type: i5.ContextMenuComponent, selector: "vdr-context-menu", inputs: ["editorMenuElement"] }], changeDetection: i0.ChangeDetectionStrategy.OnPush }); }
+}
+i0.ɵɵngDeclareClassMetadata({ minVersion: "12.0.0", version: "17.3.12", ngImport: i0, type: RichTextEditorComponent, decorators: [{
+            type: Component,
+            args: [{ selector: 'vdr-rich-text-editor', changeDetection: ChangeDetectionStrategy.OnPush, providers: [
+                        {
+                            provide: NG_VALUE_ACCESSOR,
+                            useExisting: RichTextEditorComponent,
+                            multi: true,
+                        },
+                        ProsemirrorService,
+                        ContextMenuService,
+                    ], template: "<label *ngIf=\"label\" class=\"rich-text-label\">{{ label }}</label>\n<div #editor></div>\n<vdr-context-menu [editorMenuElement]=\"menuElement\"></vdr-context-menu>\n", styles: [":host{display:block;margin-bottom:.5rem}:host.readonly ::ng-deep .ProseMirror-menubar{display:none}.context-menu{position:fixed}\n"] }]
+        }], ctorParameters: () => [{ type: i0.ChangeDetectorRef }, { type: i1.ProsemirrorService }, { type: i0.ViewContainerRef }, { type: i2.ContextMenuService }], propDecorators: { label: [{
+                type: Input
+            }], readonly: [{
+                type: Input
+            }], _readonly: [{
+                type: HostBinding,
+                args: ['class.readonly']
+            }], editorEl: [{
+                type: ViewChild,
+                args: ['editor', { static: true }]
+            }] } });
+//# sourceMappingURL=data:application/json;base64,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