@deenruv/admin-ui 1.0.0

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

@@ -0,0 +1,247 @@
+import { toggleMark } from 'prosemirror-commands';
+import { redo, undo } from 'prosemirror-history';
+import { blockTypeItem, Dropdown, icons, joinUpItem, liftItem, MenuItem, selectParentNodeItem, wrapItem, } from 'prosemirror-menu';
+import { wrapInList } from 'prosemirror-schema-list';
+import { insertImageItem } from '../plugins/image-plugin';
+import { addTable } from '../plugins/tables-plugin';
+import { linkItem } from './links';
+import { canInsert, IconSize, markActive, renderClarityIcon, wrapInMenuItemWithIcon } from './menu-common';
+import { SubMenuWithIcon } from './sub-menu-with-icon';
+function cmdItem(cmd, options) {
+    const passedOptions = {
+        label: options.title,
+        run: cmd,
+        render: options.iconShape
+            ? renderClarityIcon({ shape: options.iconShape, size: IconSize.Large })
+            : undefined,
+    };
+    // eslint-disable-next-line guard-for-in
+    for (const prop in options) {
+        passedOptions[prop] = options[prop];
+    }
+    if ((!options.enable || options.enable === true) && !options.select) {
+        passedOptions[options.enable ? 'enable' : 'select'] = state => cmd(state);
+    }
+    return new MenuItem(passedOptions);
+}
+function markItem(markType, options) {
+    const passedOptions = {
+        active(state) {
+            return markActive(state, markType);
+        },
+        enable: true,
+    };
+    // eslint-disable-next-line guard-for-in
+    for (const prop in options) {
+        passedOptions[prop] = options[prop];
+    }
+    return cmdItem(toggleMark(markType), passedOptions);
+}
+function wrapListItem(nodeType, options) {
+    return cmdItem(wrapInList(nodeType, options.attrs), options);
+}
+// :: (Schema) → Object
+// Given a schema, look for default mark and node types in it and
+// return an object with relevant menu items relating to those marks:
+//
+// **`toggleStrong`**`: MenuItem`
+//   : A menu item to toggle the [strong mark](#schema-basic.StrongMark).
+//
+// **`toggleEm`**`: MenuItem`
+//   : A menu item to toggle the [emphasis mark](#schema-basic.EmMark).
+//
+// **`toggleCode`**`: MenuItem`
+//   : A menu item to toggle the [code font mark](#schema-basic.CodeMark).
+//
+// **`toggleLink`**`: MenuItem`
+//   : A menu item to toggle the [link mark](#schema-basic.LinkMark).
+//
+// **`insertImage`**`: MenuItem`
+//   : A menu item to insert an [image](#schema-basic.Image).
+//
+// **`wrapBulletList`**`: MenuItem`
+//   : A menu item to wrap the selection in a [bullet list](#schema-list.BulletList).
+//
+// **`wrapOrderedList`**`: MenuItem`
+//   : A menu item to wrap the selection in an [ordered list](#schema-list.OrderedList).
+//
+// **`wrapBlockQuote`**`: MenuItem`
+//   : A menu item to wrap the selection in a [block quote](#schema-basic.BlockQuote).
+//
+// **`makeParagraph`**`: MenuItem`
+//   : A menu item to set the current textblock to be a normal
+//     [paragraph](#schema-basic.Paragraph).
+//
+// **`makeCodeBlock`**`: MenuItem`
+//   : A menu item to set the current textblock to be a
+//     [code block](#schema-basic.CodeBlock).
+//
+// **`makeHead[N]`**`: MenuItem`
+//   : Where _N_ is 1 to 6. Menu items to set the current textblock to
+//     be a [heading](#schema-basic.Heading) of level _N_.
+//
+// **`insertHorizontalRule`**`: MenuItem`
+//   : A menu item to insert a horizontal rule.
+//
+// The return value also contains some prefabricated menu elements and
+// menus, that you can use instead of composing your own menu from
+// scratch:
+//
+// **`insertMenu`**`: Dropdown`
+//   : A dropdown containing the `insertImage` and
+//     `insertHorizontalRule` items.
+//
+// **`typeMenu`**`: Dropdown`
+//   : A dropdown containing the items for making the current
+//     textblock a paragraph, code block, or heading.
+//
+// **`fullMenu`**`: [[MenuElement]]`
+//   : An array of arrays of menu elements for use as the full menu
+//     for, for example the [menu bar](https://github.com/prosemirror/prosemirror-menu#user-content-menubar).
+export function buildMenuItems(schema, modalService) {
+    const r = {};
+    let type;
+    /* eslint-disable no-cond-assign */
+    if ((type = schema.marks.strong)) {
+        r.toggleStrong = markItem(type, {
+            title: 'Toggle strong style',
+            iconShape: 'bold',
+        });
+    }
+    if ((type = schema.marks.em)) {
+        r.toggleEm = markItem(type, {
+            title: 'Toggle emphasis',
+            iconShape: 'italic',
+        });
+    }
+    if ((type = schema.marks.code)) {
+        r.toggleCode = markItem(type, { title: 'Toggle code font', icon: icons.code });
+    }
+    if ((type = schema.marks.link)) {
+        r.toggleLink = linkItem(type, modalService);
+    }
+    if ((type = schema.nodes.image)) {
+        r.insertImage = insertImageItem(type, modalService);
+    }
+    if ((type = schema.nodes.bullet_list)) {
+        r.wrapBulletList = wrapListItem(type, {
+            title: 'Wrap in bullet list',
+            iconShape: 'bullet-list',
+        });
+    }
+    if ((type = schema.nodes.ordered_list)) {
+        r.wrapOrderedList = wrapListItem(type, {
+            title: 'Wrap in ordered list',
+            iconShape: 'number-list',
+        });
+    }
+    if ((type = schema.nodes.blockquote)) {
+        r.wrapBlockQuote = wrapItem(type, {
+            title: 'Wrap in block quote',
+            render: renderClarityIcon({ shape: 'block-quote', size: IconSize.Large }),
+        });
+    }
+    if ((type = schema.nodes.paragraph)) {
+        r.makeParagraph = blockTypeItem(type, {
+            title: 'Change to paragraph',
+            render: renderClarityIcon({ shape: 'text', label: 'Plain' }),
+        });
+    }
+    if ((type = schema.nodes.code_block)) {
+        r.makeCodeBlock = blockTypeItem(type, {
+            title: 'Change to code block',
+            render: renderClarityIcon({ shape: 'code', label: 'Code' }),
+        });
+    }
+    if ((type = schema.nodes.heading)) {
+        for (let i = 1; i <= 10; i++) {
+            r['makeHead' + i] = blockTypeItem(type, {
+                title: 'Change to heading ' + i,
+                label: 'Level ' + i,
+                attrs: { level: i },
+            });
+        }
+    }
+    if ((type = schema.nodes.horizontal_rule)) {
+        const hr = type;
+        r.insertHorizontalRule = new MenuItem({
+            title: 'Insert horizontal rule',
+            render: view => {
+                const icon = document.createElement('div');
+                icon.classList.add('custom-icon', 'hr-icon');
+                const labelEl = document.createElement('span');
+                labelEl.textContent = 'Horizontal rule';
+                return wrapInMenuItemWithIcon(icon, labelEl);
+            },
+            enable(state) {
+                return canInsert(state, hr);
+            },
+            run(state, dispatch) {
+                dispatch(state.tr.replaceSelectionWith(hr.create()));
+            },
+        });
+    }
+    const cut = (arr) => arr.filter(x => x);
+    r.insertMenu = new Dropdown(cut([
+        r.insertImage,
+        r.insertHorizontalRule,
+        new MenuItem({
+            run: (state, dispatch) => {
+                addTable(state, dispatch, {
+                    rowsCount: 2,
+                    colsCount: 2,
+                    withHeaderRow: true,
+                    cellContent: '',
+                });
+            },
+            render: renderClarityIcon({ shape: 'table', label: 'Table' }),
+        }),
+    ]), { label: 'Insert' });
+    r.typeMenu = new Dropdown(cut([
+        r.makeParagraph,
+        r.makeCodeBlock,
+        r.makeHead1 &&
+            new SubMenuWithIcon(cut([r.makeHead1, r.makeHead2, r.makeHead3, r.makeHead4, r.makeHead5, r.makeHead6]), {
+                label: 'Heading',
+                icon: () => {
+                    const icon = document.createElement('div');
+                    icon.textContent = 'H';
+                    icon.classList.add('custom-icon', 'h-icon');
+                    return icon;
+                },
+            }),
+    ]), { label: 'Type...' });
+    const inlineMenu = cut([r.toggleStrong, r.toggleEm, r.toggleLink]);
+    r.inlineMenu = [inlineMenu];
+    r.blockMenu = [
+        cut([
+            r.wrapBulletList,
+            r.wrapOrderedList,
+            r.wrapBlockQuote,
+            joinUpItem,
+            liftItem,
+            selectParentNodeItem,
+        ]),
+    ];
+    const undoRedo = [
+        new MenuItem({
+            title: 'Undo last change',
+            run: undo,
+            enable(state) {
+                return undo(state);
+            },
+            render: renderClarityIcon({ shape: 'undo', size: IconSize.Large }),
+        }),
+        new MenuItem({
+            title: 'Redo last undone change',
+            run: redo,
+            enable(state) {
+                return redo(state);
+            },
+            render: renderClarityIcon({ shape: 'redo', size: IconSize.Large }),
+        }),
+    ];
+    r.fullMenu = [inlineMenu].concat([[r.insertMenu, r.typeMenu]], [undoRedo], r.blockMenu);
+    return r;
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"menu.js","sourceRoot":"","sources":["../../../../../../../../src/lib/core/src/shared/components/rich-text-editor/prosemirror/menu/menu.ts"],"names":[],"mappings":"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","sourcesContent":["import { toggleMark } from 'prosemirror-commands';\nimport { redo, undo } from 'prosemirror-history';\nimport {\n    blockTypeItem,\n    Dropdown,\n    icons,\n    joinUpItem,\n    liftItem,\n    MenuItem,\n    selectParentNodeItem,\n    wrapItem,\n} from 'prosemirror-menu';\nimport { MarkType, NodeType, Schema } from 'prosemirror-model';\nimport { wrapInList } from 'prosemirror-schema-list';\nimport { EditorState } from 'prosemirror-state';\n\nimport { ModalService } from '../../../../../providers/modal/modal.service';\nimport { insertImageItem } from '../plugins/image-plugin';\nimport { addTable } from '../plugins/tables-plugin';\n\nimport { linkItem } from './links';\nimport { canInsert, IconSize, markActive, renderClarityIcon, wrapInMenuItemWithIcon } from './menu-common';\nimport { SubMenuWithIcon } from './sub-menu-with-icon';\n\n// Helpers to create specific types of items\n\ntype CmdItemOptions = Record<string, any> & { iconShape?: string };\n\nfunction cmdItem(cmd: (...args: any[]) => void, options: CmdItemOptions) {\n    const passedOptions = {\n        label: options.title,\n        run: cmd,\n        render: options.iconShape\n            ? renderClarityIcon({ shape: options.iconShape, size: IconSize.Large })\n            : undefined,\n    };\n    // eslint-disable-next-line guard-for-in\n    for (const prop in options) {\n        passedOptions[prop] = options[prop];\n    }\n    if ((!options.enable || options.enable === true) && !options.select) {\n        passedOptions[options.enable ? 'enable' : 'select'] = state => cmd(state);\n    }\n\n    return new MenuItem(passedOptions as any);\n}\n\nfunction markItem(markType, options: CmdItemOptions) {\n    const passedOptions = {\n        active(state) {\n            return markActive(state, markType);\n        },\n        enable: true,\n    };\n    // eslint-disable-next-line guard-for-in\n    for (const prop in options) {\n        passedOptions[prop] = options[prop];\n    }\n    return cmdItem(toggleMark(markType), passedOptions);\n}\n\nfunction wrapListItem(nodeType, options: CmdItemOptions) {\n    return cmdItem(wrapInList(nodeType, options.attrs), options);\n}\n\n// :: (Schema) → Object\n// Given a schema, look for default mark and node types in it and\n// return an object with relevant menu items relating to those marks:\n//\n// **`toggleStrong`**`: MenuItem`\n//   : A menu item to toggle the [strong mark](#schema-basic.StrongMark).\n//\n// **`toggleEm`**`: MenuItem`\n//   : A menu item to toggle the [emphasis mark](#schema-basic.EmMark).\n//\n// **`toggleCode`**`: MenuItem`\n//   : A menu item to toggle the [code font mark](#schema-basic.CodeMark).\n//\n// **`toggleLink`**`: MenuItem`\n//   : A menu item to toggle the [link mark](#schema-basic.LinkMark).\n//\n// **`insertImage`**`: MenuItem`\n//   : A menu item to insert an [image](#schema-basic.Image).\n//\n// **`wrapBulletList`**`: MenuItem`\n//   : A menu item to wrap the selection in a [bullet list](#schema-list.BulletList).\n//\n// **`wrapOrderedList`**`: MenuItem`\n//   : A menu item to wrap the selection in an [ordered list](#schema-list.OrderedList).\n//\n// **`wrapBlockQuote`**`: MenuItem`\n//   : A menu item to wrap the selection in a [block quote](#schema-basic.BlockQuote).\n//\n// **`makeParagraph`**`: MenuItem`\n//   : A menu item to set the current textblock to be a normal\n//     [paragraph](#schema-basic.Paragraph).\n//\n// **`makeCodeBlock`**`: MenuItem`\n//   : A menu item to set the current textblock to be a\n//     [code block](#schema-basic.CodeBlock).\n//\n// **`makeHead[N]`**`: MenuItem`\n//   : Where _N_ is 1 to 6. Menu items to set the current textblock to\n//     be a [heading](#schema-basic.Heading) of level _N_.\n//\n// **`insertHorizontalRule`**`: MenuItem`\n//   : A menu item to insert a horizontal rule.\n//\n// The return value also contains some prefabricated menu elements and\n// menus, that you can use instead of composing your own menu from\n// scratch:\n//\n// **`insertMenu`**`: Dropdown`\n//   : A dropdown containing the `insertImage` and\n//     `insertHorizontalRule` items.\n//\n// **`typeMenu`**`: Dropdown`\n//   : A dropdown containing the items for making the current\n//     textblock a paragraph, code block, or heading.\n//\n// **`fullMenu`**`: [[MenuElement]]`\n//   : An array of arrays of menu elements for use as the full menu\n//     for, for example the [menu bar](https://github.com/prosemirror/prosemirror-menu#user-content-menubar).\nexport function buildMenuItems(schema: Schema, modalService: ModalService) {\n    const r: Record<string, any> = {};\n    let type: MarkType | NodeType;\n    /* eslint-disable no-cond-assign */\n    if ((type = schema.marks.strong)) {\n        r.toggleStrong = markItem(type, {\n            title: 'Toggle strong style',\n            iconShape: 'bold',\n        });\n    }\n    if ((type = schema.marks.em)) {\n        r.toggleEm = markItem(type, {\n            title: 'Toggle emphasis',\n            iconShape: 'italic',\n        });\n    }\n    if ((type = schema.marks.code)) {\n        r.toggleCode = markItem(type, { title: 'Toggle code font', icon: icons.code });\n    }\n    if ((type = schema.marks.link)) {\n        r.toggleLink = linkItem(type, modalService);\n    }\n\n    if ((type = schema.nodes.image)) {\n        r.insertImage = insertImageItem(type, modalService);\n    }\n    if ((type = schema.nodes.bullet_list)) {\n        r.wrapBulletList = wrapListItem(type, {\n            title: 'Wrap in bullet list',\n            iconShape: 'bullet-list',\n        });\n    }\n    if ((type = schema.nodes.ordered_list)) {\n        r.wrapOrderedList = wrapListItem(type, {\n            title: 'Wrap in ordered list',\n            iconShape: 'number-list',\n        });\n    }\n    if ((type = schema.nodes.blockquote)) {\n        r.wrapBlockQuote = wrapItem(type, {\n            title: 'Wrap in block quote',\n            render: renderClarityIcon({ shape: 'block-quote', size: IconSize.Large }),\n        });\n    }\n    if ((type = schema.nodes.paragraph)) {\n        r.makeParagraph = blockTypeItem(type, {\n            title: 'Change to paragraph',\n            render: renderClarityIcon({ shape: 'text', label: 'Plain' }),\n        });\n    }\n    if ((type = schema.nodes.code_block)) {\n        r.makeCodeBlock = blockTypeItem(type, {\n            title: 'Change to code block',\n            render: renderClarityIcon({ shape: 'code', label: 'Code' }),\n        });\n    }\n    if ((type = schema.nodes.heading)) {\n        for (let i = 1; i <= 10; i++) {\n            r['makeHead' + i] = blockTypeItem(type, {\n                title: 'Change to heading ' + i,\n                label: 'Level ' + i,\n                attrs: { level: i },\n            });\n        }\n    }\n    if ((type = schema.nodes.horizontal_rule)) {\n        const hr = type;\n        r.insertHorizontalRule = new MenuItem({\n            title: 'Insert horizontal rule',\n            render: view => {\n                const icon = document.createElement('div');\n                icon.classList.add('custom-icon', 'hr-icon');\n                const labelEl = document.createElement('span');\n                labelEl.textContent = 'Horizontal rule';\n                return wrapInMenuItemWithIcon(icon, labelEl);\n            },\n            enable(state) {\n                return canInsert(state, hr);\n            },\n            run(state: EditorState, dispatch) {\n                dispatch(state.tr.replaceSelectionWith(hr.create()));\n            },\n        });\n    }\n\n    const cut = <T>(arr: T[]): T[] => arr.filter(x => x);\n    r.insertMenu = new Dropdown(\n        cut([\n            r.insertImage,\n            r.insertHorizontalRule,\n            new MenuItem({\n                run: (state, dispatch) => {\n                    addTable(state, dispatch, {\n                        rowsCount: 2,\n                        colsCount: 2,\n                        withHeaderRow: true,\n                        cellContent: '',\n                    });\n                },\n                render: renderClarityIcon({ shape: 'table', label: 'Table' }),\n            }),\n        ]),\n        { label: 'Insert' },\n    );\n    r.typeMenu = new Dropdown(\n        cut([\n            r.makeParagraph,\n            r.makeCodeBlock,\n            r.makeHead1 &&\n                new SubMenuWithIcon(\n                    cut([r.makeHead1, r.makeHead2, r.makeHead3, r.makeHead4, r.makeHead5, r.makeHead6]),\n                    {\n                        label: 'Heading',\n                        icon: () => {\n                            const icon = document.createElement('div');\n                            icon.textContent = 'H';\n                            icon.classList.add('custom-icon', 'h-icon');\n                            return icon;\n                        },\n                    },\n                ),\n        ]),\n        { label: 'Type...' },\n    );\n\n    const inlineMenu = cut([r.toggleStrong, r.toggleEm, r.toggleLink]);\n    r.inlineMenu = [inlineMenu];\n    r.blockMenu = [\n        cut([\n            r.wrapBulletList,\n            r.wrapOrderedList,\n            r.wrapBlockQuote,\n            joinUpItem,\n            liftItem,\n            selectParentNodeItem,\n        ]),\n    ];\n    const undoRedo = [\n        new MenuItem({\n            title: 'Undo last change',\n            run: undo,\n            enable(state) {\n                return undo(state);\n            },\n            render: renderClarityIcon({ shape: 'undo', size: IconSize.Large }),\n        }),\n        new MenuItem({\n            title: 'Redo last undone change',\n            run: redo,\n            enable(state) {\n                return redo(state);\n            },\n            render: renderClarityIcon({ shape: 'redo', size: IconSize.Large }),\n        }),\n    ];\n    r.fullMenu = [inlineMenu].concat([[r.insertMenu, r.typeMenu]], [undoRedo], r.blockMenu);\n\n    return r;\n}\n"]}

package/esm2022/core/shared/components/rich-text-editor/prosemirror/menu/sub-menu-with-icon.mjs

@@ -0,0 +1,16 @@
+import { DropdownSubmenu } from 'prosemirror-menu';
+import { wrapInMenuItemWithIcon } from './menu-common';
+export class SubMenuWithIcon extends DropdownSubmenu {
+    constructor(content, options) {
+        super(content, options);
+        this.icon = options.icon();
+    }
+    render(view) {
+        const { dom, update } = super.render(view);
+        return {
+            dom: wrapInMenuItemWithIcon(this.icon, dom),
+            update,
+        };
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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

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

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

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

@@ -0,0 +1,22 @@
+import { Plugin, TextSelection } from 'prosemirror-state';
+import { getMarkRange } from '../utils';
+/**
+ * Causes the entire link to be selected when clicked.
+ */
+export const linkSelectPlugin = new Plugin({
+    props: {
+        handleClick(view, pos) {
+            const { doc, tr, schema } = view.state;
+            const range = getMarkRange(doc.resolve(pos), schema.marks.link);
+            if (!range) {
+                return false;
+            }
+            const $start = doc.resolve(range.from);
+            const $end = doc.resolve(range.to);
+            const transaction = tr.setSelection(new TextSelection($start, $end));
+            view.dispatch(transaction);
+            return true;
+        },
+    },
+});
+//# sourceMappingURL=data:application/json;base64,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

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