@vendure/admin-ui 1.7.3 → 1.8.0

package/package/esm2015/core/shared/components/rich-text-editor/prosemirror/menu/menu-plugin.js

@@ -0,0 +1,12 @@
+import { menuBar } from 'prosemirror-menu';
+import { ModalService } from '../../../../../providers/modal/modal.service';
+import { buildMenuItems } from './menu';
+export function customMenuPlugin(options) {
+    const modalService = options.injector.get(ModalService);
+    const pmMenuBarPlugin = menuBar({
+        floating: options.floatingMenu !== false,
+        content: buildMenuItems(options.schema, modalService).fullMenu,
+    });
+    return pmMenuBarPlugin;
+}
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoibWVudS1wbHVnaW4uanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi8uLi8uLi8uLi9zcmMvbGliL2NvcmUvc3JjL3NoYXJlZC9jb21wb25lbnRzL3JpY2gtdGV4dC1lZGl0b3IvcHJvc2VtaXJyb3IvbWVudS9tZW51LXBsdWdpbi50cyJdLCJuYW1lcyI6W10sIm1hcHBpbmdzIjoiQUFDQSxPQUFPLEVBQUUsT0FBTyxFQUFFLE1BQU0sa0JBQWtCLENBQUM7QUFJM0MsT0FBTyxFQUFFLFlBQVksRUFBRSxNQUFNLDhDQUE4QyxDQUFDO0FBRTVFLE9BQU8sRUFBRSxjQUFjLEVBQUUsTUFBTSxRQUFRLENBQUM7QUFReEMsTUFBTSxVQUFVLGdCQUFnQixDQUFDLE9BQWdDO0lBQzdELE1BQU0sWUFBWSxHQUFHLE9BQU8sQ0FBQyxRQUFRLENBQUMsR0FBRyxDQUFDLFlBQVksQ0FBQyxDQUFDO0lBQ3hELE1BQU0sZUFBZSxHQUFHLE9BQU8sQ0FBQztRQUM1QixRQUFRLEVBQUUsT0FBTyxDQUFDLFlBQVksS0FBSyxLQUFLO1FBQ3hDLE9BQU8sRUFBRSxjQUFjLENBQUMsT0FBTyxDQUFDLE1BQU0sRUFBRSxZQUFZLENBQUMsQ0FBQyxRQUFRO0tBQ2pFLENBQUMsQ0FBQztJQUNILE9BQU8sZUFBZSxDQUFDO0FBQzNCLENBQUMiLCJzb3VyY2VzQ29udGVudCI6WyJpbXBvcnQgeyBJbmplY3RvciB9IGZyb20gJ0Bhbmd1bGFyL2NvcmUnO1xyXG5pbXBvcnQgeyBtZW51QmFyIH0gZnJvbSAncHJvc2VtaXJyb3ItbWVudSc7XHJcbmltcG9ydCB7IFNjaGVtYSB9IGZyb20gJ3Byb3NlbWlycm9yLW1vZGVsJztcclxuaW1wb3J0IHsgRWRpdG9yU3RhdGUsIFBsdWdpbiB9IGZyb20gJ3Byb3NlbWlycm9yLXN0YXRlJztcclxuXHJcbmltcG9ydCB7IE1vZGFsU2VydmljZSB9IGZyb20gJy4uLy4uLy4uLy4uLy4uL3Byb3ZpZGVycy9tb2RhbC9tb2RhbC5zZXJ2aWNlJztcclxuXHJcbmltcG9ydCB7IGJ1aWxkTWVudUl0ZW1zIH0gZnJvbSAnLi9tZW51JztcclxuXHJcbmV4cG9ydCBpbnRlcmZhY2UgQ3VzdG9tTWVudVBsdWdpbk9wdGlvbnMge1xyXG4gICAgZmxvYXRpbmdNZW51PzogYm9vbGVhbjtcclxuICAgIHNjaGVtYTogU2NoZW1hO1xyXG4gICAgaW5qZWN0b3I6IEluamVjdG9yO1xyXG59XHJcblxyXG5leHBvcnQgZnVuY3Rpb24gY3VzdG9tTWVudVBsdWdpbihvcHRpb25zOiBDdXN0b21NZW51UGx1Z2luT3B0aW9ucykge1xyXG4gICAgY29uc3QgbW9kYWxTZXJ2aWNlID0gb3B0aW9ucy5pbmplY3Rvci5nZXQoTW9kYWxTZXJ2aWNlKTtcclxuICAgIGNvbnN0IHBtTWVudUJhclBsdWdpbiA9IG1lbnVCYXIoe1xyXG4gICAgICAgIGZsb2F0aW5nOiBvcHRpb25zLmZsb2F0aW5nTWVudSAhPT0gZmFsc2UsXHJcbiAgICAgICAgY29udGVudDogYnVpbGRNZW51SXRlbXMob3B0aW9ucy5zY2hlbWEsIG1vZGFsU2VydmljZSkuZnVsbE1lbnUsXHJcbiAgICB9KTtcclxuICAgIHJldHVybiBwbU1lbnVCYXJQbHVnaW47XHJcbn1cclxuIl19

package/package/esm2015/core/shared/components/rich-text-editor/prosemirror/menu/menu.js

@@ -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,
+    };
+    // tslint:disable-next-line:forin
+    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,
+    };
+    // tslint:disable-next-line:forin
+    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;
+    // tslint:disable:no-conditional-assignment
+    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":"AAAA,OAAO,EAAE,UAAU,EAAE,MAAM,sBAAsB,CAAC;AAClD,OAAO,EAAE,IAAI,EAAE,IAAI,EAAE,MAAM,qBAAqB,CAAC;AACjD,OAAO,EACH,aAAa,EACb,QAAQ,EACR,KAAK,EACL,UAAU,EACV,QAAQ,EACR,QAAQ,EACR,oBAAoB,EACpB,QAAQ,GACX,MAAM,kBAAkB,CAAC;AAE1B,OAAO,EAAE,UAAU,EAAE,MAAM,yBAAyB,CAAC;AAIrD,OAAO,EAAE,eAAe,EAAE,MAAM,yBAAyB,CAAC;AAC1D,OAAO,EAAE,QAAQ,EAAE,MAAM,0BAA0B,CAAC;AAEpD,OAAO,EAAE,QAAQ,EAAE,MAAM,SAAS,CAAC;AACnC,OAAO,EAAE,SAAS,EAAE,QAAQ,EAAE,UAAU,EAAE,iBAAiB,EAAE,sBAAsB,EAAE,MAAM,eAAe,CAAC;AAC3G,OAAO,EAAE,eAAe,EAAE,MAAM,sBAAsB,CAAC;AAMvD,SAAS,OAAO,CAAC,GAA6B,EAAE,OAAuB;IACnE,MAAM,aAAa,GAAG;QAClB,KAAK,EAAE,OAAO,CAAC,KAAK;QACpB,GAAG,EAAE,GAAG;QACR,MAAM,EAAE,OAAO,CAAC,SAAS;YACrB,CAAC,CAAC,iBAAiB,CAAC,EAAE,KAAK,EAAE,OAAO,CAAC,SAAS,EAAE,IAAI,EAAE,QAAQ,CAAC,KAAK,EAAE,CAAC;YACvE,CAAC,CAAC,SAAS;KAClB,CAAC;IACF,iCAAiC;IACjC,KAAK,MAAM,IAAI,IAAI,OAAO,EAAE;QACxB,aAAa,CAAC,IAAI,CAAC,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC;KACvC;IACD,IAAI,CAAC,CAAC,OAAO,CAAC,MAAM,IAAI,OAAO,CAAC,MAAM,KAAK,IAAI,CAAC,IAAI,CAAC,OAAO,CAAC,MAAM,EAAE;QACjE,aAAa,CAAC,OAAO,CAAC,MAAM,CAAC,CAAC,CAAC,QAAQ,CAAC,CAAC,CAAC,QAAQ,CAAC,GAAG,KAAK,CAAC,EAAE,CAAC,GAAG,CAAC,KAAK,CAAC,CAAC;KAC7E;IAED,OAAO,IAAI,QAAQ,CAAC,aAAoB,CAAC,CAAC;AAC9C,CAAC;AAED,SAAS,QAAQ,CAAC,QAAQ,EAAE,OAAuB;IAC/C,MAAM,aAAa,GAAG;QAClB,MAAM,CAAC,KAAK;YACR,OAAO,UAAU,CAAC,KAAK,EAAE,QAAQ,CAAC,CAAC;QACvC,CAAC;QACD,MAAM,EAAE,IAAI;KACf,CAAC;IACF,iCAAiC;IACjC,KAAK,MAAM,IAAI,IAAI,OAAO,EAAE;QACxB,aAAa,CAAC,IAAI,CAAC,GAAG,OAAO,CAAC,IAAI,CAAC,CAAC;KACvC;IACD,OAAO,OAAO,CAAC,UAAU,CAAC,QAAQ,CAAC,EAAE,aAAa,CAAC,CAAC;AACxD,CAAC;AAED,SAAS,YAAY,CAAC,QAAQ,EAAE,OAAuB;IACnD,OAAO,OAAO,CAAC,UAAU,CAAC,QAAQ,EAAE,OAAO,CAAC,KAAK,CAAC,EAAE,OAAO,CAAC,CAAC;AACjE,CAAC;AAED,uBAAuB;AACvB,iEAAiE;AACjE,qEAAqE;AACrE,EAAE;AACF,iCAAiC;AACjC,yEAAyE;AACzE,EAAE;AACF,6BAA6B;AAC7B,uEAAuE;AACvE,EAAE;AACF,+BAA+B;AAC/B,0EAA0E;AAC1E,EAAE;AACF,+BAA+B;AAC/B,qEAAqE;AACrE,EAAE;AACF,gCAAgC;AAChC,6DAA6D;AAC7D,EAAE;AACF,mCAAmC;AACnC,qFAAqF;AACrF,EAAE;AACF,oCAAoC;AACpC,wFAAwF;AACxF,EAAE;AACF,mCAAmC;AACnC,sFAAsF;AACtF,EAAE;AACF,kCAAkC;AAClC,8DAA8D;AAC9D,4CAA4C;AAC5C,EAAE;AACF,kCAAkC;AAClC,uDAAuD;AACvD,6CAA6C;AAC7C,EAAE;AACF,gCAAgC;AAChC,sEAAsE;AACtE,0DAA0D;AAC1D,EAAE;AACF,yCAAyC;AACzC,+CAA+C;AAC/C,EAAE;AACF,sEAAsE;AACtE,kEAAkE;AAClE,WAAW;AACX,EAAE;AACF,+BAA+B;AAC/B,kDAAkD;AAClD,oCAAoC;AACpC,EAAE;AACF,6BAA6B;AAC7B,6DAA6D;AAC7D,qDAAqD;AACrD,EAAE;AACF,oCAAoC;AACpC,mEAAmE;AACnE,6GAA6G;AAC7G,MAAM,UAAU,cAAc,CAAC,MAAc,EAAE,YAA0B;IACrE,MAAM,CAAC,GAAwB,EAAE,CAAC;IAClC,IAAI,IAAyB,CAAC;IAC9B,2CAA2C;IAC3C,IAAI,CAAC,IAAI,GAAG,MAAM,CAAC,KAAK,CAAC,MAAM,CAAC,EAAE;QAC9B,CAAC,CAAC,YAAY,GAAG,QAAQ,CAAC,IAAI,EAAE;YAC5B,KAAK,EAAE,qBAAqB;YAC5B,SAAS,EAAE,MAAM;SACpB,CAAC,CAAC;KACN;IACD,IAAI,CAAC,IAAI,GAAG,MAAM,CAAC,KAAK,CAAC,EAAE,CAAC,EAAE;QAC1B,CAAC,CAAC,QAAQ,GAAG,QAAQ,CAAC,IAAI,EAAE;YACxB,KAAK,EAAE,iBAAiB;YACxB,SAAS,EAAE,QAAQ;SACtB,CAAC,CAAC;KACN;IACD,IAAI,CAAC,IAAI,GAAG,MAAM,CAAC,KAAK,CAAC,IAAI,CAAC,EAAE;QAC5B,CAAC,CAAC,UAAU,GAAG,QAAQ,CAAC,IAAI,EAAE,EAAE,KAAK,EAAE,kBAAkB,EAAE,IAAI,EAAE,KAAK,CAAC,IAAI,EAAE,CAAC,CAAC;KAClF;IACD,IAAI,CAAC,IAAI,GAAG,MAAM,CAAC,KAAK,CAAC,IAAI,CAAC,EAAE;QAC5B,CAAC,CAAC,UAAU,GAAG,QAAQ,CAAC,IAAI,EAAE,YAAY,CAAC,CAAC;KAC/C;IAED,IAAI,CAAC,IAAI,GAAG,MAAM,CAAC,KAAK,CAAC,KAAK,CAAC,EAAE;QAC7B,CAAC,CAAC,WAAW,GAAG,eAAe,CAAC,IAAI,EAAE,YAAY,CAAC,CAAC;KACvD;IACD,IAAI,CAAC,IAAI,GAAG,MAAM,CAAC,KAAK,CAAC,WAAW,CAAC,EAAE;QACnC,CAAC,CAAC,cAAc,GAAG,YAAY,CAAC,IAAI,EAAE;YAClC,KAAK,EAAE,qBAAqB;YAC5B,SAAS,EAAE,aAAa;SAC3B,CAAC,CAAC;KACN;IACD,IAAI,CAAC,IAAI,GAAG,MAAM,CAAC,KAAK,CAAC,YAAY,CAAC,EAAE;QACpC,CAAC,CAAC,eAAe,GAAG,YAAY,CAAC,IAAI,EAAE;YACnC,KAAK,EAAE,sBAAsB;YAC7B,SAAS,EAAE,aAAa;SAC3B,CAAC,CAAC;KACN;IACD,IAAI,CAAC,IAAI,GAAG,MAAM,CAAC,KAAK,CAAC,UAAU,CAAC,EAAE;QAClC,CAAC,CAAC,cAAc,GAAG,QAAQ,CAAC,IAAI,EAAE;YAC9B,KAAK,EAAE,qBAAqB;YAC5B,MAAM,EAAE,iBAAiB,CAAC,EAAE,KAAK,EAAE,aAAa,EAAE,IAAI,EAAE,QAAQ,CAAC,KAAK,EAAE,CAAC;SAC5E,CAAC,CAAC;KACN;IACD,IAAI,CAAC,IAAI,GAAG,MAAM,CAAC,KAAK,CAAC,SAAS,CAAC,EAAE;QACjC,CAAC,CAAC,aAAa,GAAG,aAAa,CAAC,IAAI,EAAE;YAClC,KAAK,EAAE,qBAAqB;YAC5B,MAAM,EAAE,iBAAiB,CAAC,EAAE,KAAK,EAAE,MAAM,EAAE,KAAK,EAAE,OAAO,EAAE,CAAC;SAC/D,CAAC,CAAC;KACN;IACD,IAAI,CAAC,IAAI,GAAG,MAAM,CAAC,KAAK,CAAC,UAAU,CAAC,EAAE;QAClC,CAAC,CAAC,aAAa,GAAG,aAAa,CAAC,IAAI,EAAE;YAClC,KAAK,EAAE,sBAAsB;YAC7B,MAAM,EAAE,iBAAiB,CAAC,EAAE,KAAK,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM,EAAE,CAAC;SAC9D,CAAC,CAAC;KACN;IACD,IAAI,CAAC,IAAI,GAAG,MAAM,CAAC,KAAK,CAAC,OAAO,CAAC,EAAE;QAC/B,KAAK,IAAI,CAAC,GAAG,CAAC,EAAE,CAAC,IAAI,EAAE,EAAE,CAAC,EAAE,EAAE;YAC1B,CAAC,CAAC,UAAU,GAAG,CAAC,CAAC,GAAG,aAAa,CAAC,IAAI,EAAE;gBACpC,KAAK,EAAE,oBAAoB,GAAG,CAAC;gBAC/B,KAAK,EAAE,QAAQ,GAAG,CAAC;gBACnB,KAAK,EAAE,EAAE,KAAK,EAAE,CAAC,EAAE;aACtB,CAAC,CAAC;SACN;KACJ;IACD,IAAI,CAAC,IAAI,GAAG,MAAM,CAAC,KAAK,CAAC,eAAe,CAAC,EAAE;QACvC,MAAM,EAAE,GAAG,IAAI,CAAC;QAChB,CAAC,CAAC,oBAAoB,GAAG,IAAI,QAAQ,CAAC;YAClC,KAAK,EAAE,wBAAwB;YAC/B,MAAM,EAAE,IAAI,CAAC,EAAE;gBACX,MAAM,IAAI,GAAG,QAAQ,CAAC,aAAa,CAAC,KAAK,CAAC,CAAC;gBAC3C,IAAI,CAAC,SAAS,CAAC,GAAG,CAAC,aAAa,EAAE,SAAS,CAAC,CAAC;gBAC7C,MAAM,OAAO,GAAG,QAAQ,CAAC,aAAa,CAAC,MAAM,CAAC,CAAC;gBAC/C,OAAO,CAAC,WAAW,GAAG,iBAAiB,CAAC;gBACxC,OAAO,sBAAsB,CAAC,IAAI,EAAE,OAAO,CAAC,CAAC;YACjD,CAAC;YACD,MAAM,CAAC,KAAK;gBACR,OAAO,SAAS,CAAC,KAAK,EAAE,EAAE,CAAC,CAAC;YAChC,CAAC;YACD,GAAG,CAAC,KAAkB,EAAE,QAAQ;gBAC5B,QAAQ,CAAC,KAAK,CAAC,EAAE,CAAC,oBAAoB,CAAC,EAAE,CAAC,MAAM,EAAE,CAAC,CAAC,CAAC;YACzD,CAAC;SACJ,CAAC,CAAC;KACN;IAED,MAAM,GAAG,GAAG,CAAI,GAAQ,EAAO,EAAE,CAAC,GAAG,CAAC,MAAM,CAAC,CAAC,CAAC,EAAE,CAAC,CAAC,CAAC,CAAC;IACrD,CAAC,CAAC,UAAU,GAAG,IAAI,QAAQ,CACvB,GAAG,CAAC;QACA,CAAC,CAAC,WAAW;QACb,CAAC,CAAC,oBAAoB;QACtB,IAAI,QAAQ,CAAC;YACT,GAAG,EAAE,CAAC,KAAK,EAAE,QAAQ,EAAE,EAAE;gBACrB,QAAQ,CAAC,KAAK,EAAE,QAAQ,EAAE;oBACtB,SAAS,EAAE,CAAC;oBACZ,SAAS,EAAE,CAAC;oBACZ,aAAa,EAAE,IAAI;oBACnB,WAAW,EAAE,EAAE;iBAClB,CAAC,CAAC;YACP,CAAC;YACD,MAAM,EAAE,iBAAiB,CAAC,EAAE,KAAK,EAAE,OAAO,EAAE,KAAK,EAAE,OAAO,EAAE,CAAC;SAChE,CAAC;KACL,CAAC,EACF,EAAE,KAAK,EAAE,QAAQ,EAAE,CACtB,CAAC;IACF,CAAC,CAAC,QAAQ,GAAG,IAAI,QAAQ,CACrB,GAAG,CAAC;QACA,CAAC,CAAC,aAAa;QACf,CAAC,CAAC,aAAa;QACf,CAAC,CAAC,SAAS;YACP,IAAI,eAAe,CACf,GAAG,CAAC,CAAC,CAAC,CAAC,SAAS,EAAE,CAAC,CAAC,SAAS,EAAE,CAAC,CAAC,SAAS,EAAE,CAAC,CAAC,SAAS,EAAE,CAAC,CAAC,SAAS,EAAE,CAAC,CAAC,SAAS,CAAC,CAAC,EACnF;gBACI,KAAK,EAAE,SAAS;gBAChB,IAAI,EAAE,GAAG,EAAE;oBACP,MAAM,IAAI,GAAG,QAAQ,CAAC,aAAa,CAAC,KAAK,CAAC,CAAC;oBAC3C,IAAI,CAAC,WAAW,GAAG,GAAG,CAAC;oBACvB,IAAI,CAAC,SAAS,CAAC,GAAG,CAAC,aAAa,EAAE,QAAQ,CAAC,CAAC;oBAC5C,OAAO,IAAI,CAAC;gBAChB,CAAC;aACJ,CACJ;KACR,CAAC,EACF,EAAE,KAAK,EAAE,SAAS,EAAE,CACvB,CAAC;IAEF,MAAM,UAAU,GAAG,GAAG,CAAC,CAAC,CAAC,CAAC,YAAY,EAAE,CAAC,CAAC,QAAQ,EAAE,CAAC,CAAC,UAAU,CAAC,CAAC,CAAC;IACnE,CAAC,CAAC,UAAU,GAAG,CAAC,UAAU,CAAC,CAAC;IAC5B,CAAC,CAAC,SAAS,GAAG;QACV,GAAG,CAAC;YACA,CAAC,CAAC,cAAc;YAChB,CAAC,CAAC,eAAe;YACjB,CAAC,CAAC,cAAc;YAChB,UAAU;YACV,QAAQ;YACR,oBAAoB;SACvB,CAAC;KACL,CAAC;IACF,MAAM,QAAQ,GAAG;QACb,IAAI,QAAQ,CAAC;YACT,KAAK,EAAE,kBAAkB;YACzB,GAAG,EAAE,IAAI;YACT,MAAM,CAAC,KAAK;gBACR,OAAO,IAAI,CAAC,KAAK,CAAC,CAAC;YACvB,CAAC;YACD,MAAM,EAAE,iBAAiB,CAAC,EAAE,KAAK,EAAE,MAAM,EAAE,IAAI,EAAE,QAAQ,CAAC,KAAK,EAAE,CAAC;SACrE,CAAC;QACF,IAAI,QAAQ,CAAC;YACT,KAAK,EAAE,yBAAyB;YAChC,GAAG,EAAE,IAAI;YACT,MAAM,CAAC,KAAK;gBACR,OAAO,IAAI,CAAC,KAAK,CAAC,CAAC;YACvB,CAAC;YACD,MAAM,EAAE,iBAAiB,CAAC,EAAE,KAAK,EAAE,MAAM,EAAE,IAAI,EAAE,QAAQ,CAAC,KAAK,EAAE,CAAC;SACrE,CAAC;KACL,CAAC;IACF,CAAC,CAAC,QAAQ,GAAG,CAAC,UAAU,CAAC,CAAC,MAAM,CAAC,CAAC,CAAC,CAAC,CAAC,UAAU,EAAE,CAAC,CAAC,QAAQ,CAAC,CAAC,EAAE,CAAC,QAAQ,CAAC,EAAE,CAAC,CAAC,SAAS,CAAC,CAAC;IAExF,OAAO,CAAC,CAAC;AACb,CAAC","sourcesContent":["import { toggleMark } from 'prosemirror-commands';\r\nimport { redo, undo } from 'prosemirror-history';\r\nimport {\r\n    blockTypeItem,\r\n    Dropdown,\r\n    icons,\r\n    joinUpItem,\r\n    liftItem,\r\n    MenuItem,\r\n    selectParentNodeItem,\r\n    wrapItem,\r\n} from 'prosemirror-menu';\r\nimport { MarkType, NodeType, Schema } from 'prosemirror-model';\r\nimport { wrapInList } from 'prosemirror-schema-list';\r\nimport { EditorState } from 'prosemirror-state';\r\n\r\nimport { ModalService } from '../../../../../providers/modal/modal.service';\r\nimport { insertImageItem } from '../plugins/image-plugin';\r\nimport { addTable } from '../plugins/tables-plugin';\r\n\r\nimport { linkItem } from './links';\r\nimport { canInsert, IconSize, markActive, renderClarityIcon, wrapInMenuItemWithIcon } from './menu-common';\r\nimport { SubMenuWithIcon } from './sub-menu-with-icon';\r\n\r\n// Helpers to create specific types of items\r\n\r\ntype CmdItemOptions = Record<string, any> & { iconShape?: string };\r\n\r\nfunction cmdItem(cmd: (...args: any[]) => void, options: CmdItemOptions) {\r\n    const passedOptions = {\r\n        label: options.title,\r\n        run: cmd,\r\n        render: options.iconShape\r\n            ? renderClarityIcon({ shape: options.iconShape, size: IconSize.Large })\r\n            : undefined,\r\n    };\r\n    // tslint:disable-next-line:forin\r\n    for (const prop in options) {\r\n        passedOptions[prop] = options[prop];\r\n    }\r\n    if ((!options.enable || options.enable === true) && !options.select) {\r\n        passedOptions[options.enable ? 'enable' : 'select'] = state => cmd(state);\r\n    }\r\n\r\n    return new MenuItem(passedOptions as any);\r\n}\r\n\r\nfunction markItem(markType, options: CmdItemOptions) {\r\n    const passedOptions = {\r\n        active(state) {\r\n            return markActive(state, markType);\r\n        },\r\n        enable: true,\r\n    };\r\n    // tslint:disable-next-line:forin\r\n    for (const prop in options) {\r\n        passedOptions[prop] = options[prop];\r\n    }\r\n    return cmdItem(toggleMark(markType), passedOptions);\r\n}\r\n\r\nfunction wrapListItem(nodeType, options: CmdItemOptions) {\r\n    return cmdItem(wrapInList(nodeType, options.attrs), options);\r\n}\r\n\r\n// :: (Schema) → Object\r\n// Given a schema, look for default mark and node types in it and\r\n// return an object with relevant menu items relating to those marks:\r\n//\r\n// **`toggleStrong`**`: MenuItem`\r\n//   : A menu item to toggle the [strong mark](#schema-basic.StrongMark).\r\n//\r\n// **`toggleEm`**`: MenuItem`\r\n//   : A menu item to toggle the [emphasis mark](#schema-basic.EmMark).\r\n//\r\n// **`toggleCode`**`: MenuItem`\r\n//   : A menu item to toggle the [code font mark](#schema-basic.CodeMark).\r\n//\r\n// **`toggleLink`**`: MenuItem`\r\n//   : A menu item to toggle the [link mark](#schema-basic.LinkMark).\r\n//\r\n// **`insertImage`**`: MenuItem`\r\n//   : A menu item to insert an [image](#schema-basic.Image).\r\n//\r\n// **`wrapBulletList`**`: MenuItem`\r\n//   : A menu item to wrap the selection in a [bullet list](#schema-list.BulletList).\r\n//\r\n// **`wrapOrderedList`**`: MenuItem`\r\n//   : A menu item to wrap the selection in an [ordered list](#schema-list.OrderedList).\r\n//\r\n// **`wrapBlockQuote`**`: MenuItem`\r\n//   : A menu item to wrap the selection in a [block quote](#schema-basic.BlockQuote).\r\n//\r\n// **`makeParagraph`**`: MenuItem`\r\n//   : A menu item to set the current textblock to be a normal\r\n//     [paragraph](#schema-basic.Paragraph).\r\n//\r\n// **`makeCodeBlock`**`: MenuItem`\r\n//   : A menu item to set the current textblock to be a\r\n//     [code block](#schema-basic.CodeBlock).\r\n//\r\n// **`makeHead[N]`**`: MenuItem`\r\n//   : Where _N_ is 1 to 6. Menu items to set the current textblock to\r\n//     be a [heading](#schema-basic.Heading) of level _N_.\r\n//\r\n// **`insertHorizontalRule`**`: MenuItem`\r\n//   : A menu item to insert a horizontal rule.\r\n//\r\n// The return value also contains some prefabricated menu elements and\r\n// menus, that you can use instead of composing your own menu from\r\n// scratch:\r\n//\r\n// **`insertMenu`**`: Dropdown`\r\n//   : A dropdown containing the `insertImage` and\r\n//     `insertHorizontalRule` items.\r\n//\r\n// **`typeMenu`**`: Dropdown`\r\n//   : A dropdown containing the items for making the current\r\n//     textblock a paragraph, code block, or heading.\r\n//\r\n// **`fullMenu`**`: [[MenuElement]]`\r\n//   : An array of arrays of menu elements for use as the full menu\r\n//     for, for example the [menu bar](https://github.com/prosemirror/prosemirror-menu#user-content-menubar).\r\nexport function buildMenuItems(schema: Schema, modalService: ModalService) {\r\n    const r: Record<string, any> = {};\r\n    let type: MarkType | NodeType;\r\n    // tslint:disable:no-conditional-assignment\r\n    if ((type = schema.marks.strong)) {\r\n        r.toggleStrong = markItem(type, {\r\n            title: 'Toggle strong style',\r\n            iconShape: 'bold',\r\n        });\r\n    }\r\n    if ((type = schema.marks.em)) {\r\n        r.toggleEm = markItem(type, {\r\n            title: 'Toggle emphasis',\r\n            iconShape: 'italic',\r\n        });\r\n    }\r\n    if ((type = schema.marks.code)) {\r\n        r.toggleCode = markItem(type, { title: 'Toggle code font', icon: icons.code });\r\n    }\r\n    if ((type = schema.marks.link)) {\r\n        r.toggleLink = linkItem(type, modalService);\r\n    }\r\n\r\n    if ((type = schema.nodes.image)) {\r\n        r.insertImage = insertImageItem(type, modalService);\r\n    }\r\n    if ((type = schema.nodes.bullet_list)) {\r\n        r.wrapBulletList = wrapListItem(type, {\r\n            title: 'Wrap in bullet list',\r\n            iconShape: 'bullet-list',\r\n        });\r\n    }\r\n    if ((type = schema.nodes.ordered_list)) {\r\n        r.wrapOrderedList = wrapListItem(type, {\r\n            title: 'Wrap in ordered list',\r\n            iconShape: 'number-list',\r\n        });\r\n    }\r\n    if ((type = schema.nodes.blockquote)) {\r\n        r.wrapBlockQuote = wrapItem(type, {\r\n            title: 'Wrap in block quote',\r\n            render: renderClarityIcon({ shape: 'block-quote', size: IconSize.Large }),\r\n        });\r\n    }\r\n    if ((type = schema.nodes.paragraph)) {\r\n        r.makeParagraph = blockTypeItem(type, {\r\n            title: 'Change to paragraph',\r\n            render: renderClarityIcon({ shape: 'text', label: 'Plain' }),\r\n        });\r\n    }\r\n    if ((type = schema.nodes.code_block)) {\r\n        r.makeCodeBlock = blockTypeItem(type, {\r\n            title: 'Change to code block',\r\n            render: renderClarityIcon({ shape: 'code', label: 'Code' }),\r\n        });\r\n    }\r\n    if ((type = schema.nodes.heading)) {\r\n        for (let i = 1; i <= 10; i++) {\r\n            r['makeHead' + i] = blockTypeItem(type, {\r\n                title: 'Change to heading ' + i,\r\n                label: 'Level ' + i,\r\n                attrs: { level: i },\r\n            });\r\n        }\r\n    }\r\n    if ((type = schema.nodes.horizontal_rule)) {\r\n        const hr = type;\r\n        r.insertHorizontalRule = new MenuItem({\r\n            title: 'Insert horizontal rule',\r\n            render: view => {\r\n                const icon = document.createElement('div');\r\n                icon.classList.add('custom-icon', 'hr-icon');\r\n                const labelEl = document.createElement('span');\r\n                labelEl.textContent = 'Horizontal rule';\r\n                return wrapInMenuItemWithIcon(icon, labelEl);\r\n            },\r\n            enable(state) {\r\n                return canInsert(state, hr);\r\n            },\r\n            run(state: EditorState, dispatch) {\r\n                dispatch(state.tr.replaceSelectionWith(hr.create()));\r\n            },\r\n        });\r\n    }\r\n\r\n    const cut = <T>(arr: T[]): T[] => arr.filter(x => x);\r\n    r.insertMenu = new Dropdown(\r\n        cut([\r\n            r.insertImage,\r\n            r.insertHorizontalRule,\r\n            new MenuItem({\r\n                run: (state, dispatch) => {\r\n                    addTable(state, dispatch, {\r\n                        rowsCount: 2,\r\n                        colsCount: 2,\r\n                        withHeaderRow: true,\r\n                        cellContent: '',\r\n                    });\r\n                },\r\n                render: renderClarityIcon({ shape: 'table', label: 'Table' }),\r\n            }),\r\n        ]),\r\n        { label: 'Insert' },\r\n    );\r\n    r.typeMenu = new Dropdown(\r\n        cut([\r\n            r.makeParagraph,\r\n            r.makeCodeBlock,\r\n            r.makeHead1 &&\r\n                new SubMenuWithIcon(\r\n                    cut([r.makeHead1, r.makeHead2, r.makeHead3, r.makeHead4, r.makeHead5, r.makeHead6]),\r\n                    {\r\n                        label: 'Heading',\r\n                        icon: () => {\r\n                            const icon = document.createElement('div');\r\n                            icon.textContent = 'H';\r\n                            icon.classList.add('custom-icon', 'h-icon');\r\n                            return icon;\r\n                        },\r\n                    },\r\n                ),\r\n        ]),\r\n        { label: 'Type...' },\r\n    );\r\n\r\n    const inlineMenu = cut([r.toggleStrong, r.toggleEm, r.toggleLink]);\r\n    r.inlineMenu = [inlineMenu];\r\n    r.blockMenu = [\r\n        cut([\r\n            r.wrapBulletList,\r\n            r.wrapOrderedList,\r\n            r.wrapBlockQuote,\r\n            joinUpItem,\r\n            liftItem,\r\n            selectParentNodeItem,\r\n        ]),\r\n    ];\r\n    const undoRedo = [\r\n        new MenuItem({\r\n            title: 'Undo last change',\r\n            run: undo,\r\n            enable(state) {\r\n                return undo(state);\r\n            },\r\n            render: renderClarityIcon({ shape: 'undo', size: IconSize.Large }),\r\n        }),\r\n        new MenuItem({\r\n            title: 'Redo last undone change',\r\n            run: redo,\r\n            enable(state) {\r\n                return redo(state);\r\n            },\r\n            render: renderClarityIcon({ shape: 'redo', size: IconSize.Large }),\r\n        }),\r\n    ];\r\n    r.fullMenu = [inlineMenu].concat([[r.insertMenu, r.typeMenu]], [undoRedo], r.blockMenu);\r\n\r\n    return r;\r\n}\r\n"]}

package/package/esm2015/core/shared/components/rich-text-editor/prosemirror/menu/sub-menu-with-icon.js

@@ -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/package/esm2015/core/shared/components/rich-text-editor/prosemirror/plugins/image-plugin.js

@@ -0,0 +1,100 @@
+import { MenuItem } from 'prosemirror-menu';
+import { NodeSelection, Plugin } from 'prosemirror-state';
+import { ExternalImageDialogComponent, } from '../../external-image-dialog/external-image-dialog.component';
+import { canInsert, renderClarityIcon } from '../menu/menu-common';
+export function insertImageItem(nodeType, modalService) {
+    return new MenuItem({
+        title: 'Insert image',
+        label: 'Image',
+        render: renderClarityIcon({ shape: 'image', label: 'Image' }),
+        class: '',
+        css: '',
+        enable(state) {
+            return canInsert(state, nodeType);
+        },
+        run(state, _, view) {
+            let attrs;
+            if (state.selection instanceof NodeSelection && state.selection.node.type === nodeType) {
+                attrs = state.selection.node.attrs;
+            }
+            modalService
+                .fromComponent(ExternalImageDialogComponent, {
+                closable: true,
+                locals: {
+                    existing: attrs,
+                },
+            })
+                .subscribe(result => {
+                if (result) {
+                    // tslint:disable-next-line:no-non-null-assertion
+                    view.dispatch(view.state.tr.replaceSelectionWith(nodeType.createAndFill(result)));
+                }
+                view.focus();
+            });
+        },
+    });
+}
+export const imageContextMenuPlugin = (contextMenuService, modalService) => new Plugin({
+    view: () => {
+        return {
+            update: view => {
+                if (!view.hasFocus()) {
+                    return;
+                }
+                const { doc, selection } = view.state;
+                let imageNode;
+                let imageNodePos = 0;
+                doc.nodesBetween(selection.from, selection.to, (n, pos, parent) => {
+                    if (n.type.name === 'image') {
+                        imageNode = n;
+                        imageNodePos = pos;
+                        return false;
+                    }
+                });
+                if (imageNode) {
+                    const node = view.nodeDOM(imageNodePos);
+                    if (node instanceof HTMLImageElement) {
+                        contextMenuService.setContextMenu({
+                            ref: selection,
+                            title: 'Image',
+                            iconShape: 'image',
+                            element: node,
+                            coords: view.coordsAtPos(imageNodePos),
+                            items: [
+                                {
+                                    enabled: true,
+                                    iconShape: 'image',
+                                    label: 'Image properties',
+                                    onClick: () => {
+                                        contextMenuService.clearContextMenu();
+                                        modalService
+                                            .fromComponent(ExternalImageDialogComponent, {
+                                            closable: true,
+                                            locals: {
+                                                // tslint:disable-next-line:no-non-null-assertion
+                                                existing: imageNode.attrs,
+                                            },
+                                        })
+                                            .subscribe(result => {
+                                            if (result) {
+                                                // tslint:disable-next-line:no-non-null-assertion
+                                                view.dispatch(view.state.tr.replaceSelectionWith(
+                                                // tslint:disable-next-line:no-non-null-assertion
+                                                imageNode.type.createAndFill(result)));
+                                            }
+                                            view.focus();
+                                        });
+                                    },
+                                },
+                            ],
+                        });
+                    }
+                }
+                else {
+                    contextMenuService.clearContextMenu();
+                }
+            },
+        };
+    },
+});
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"image-plugin.js","sourceRoot":"","sources":["../../../../../../../../src/lib/core/src/shared/components/rich-text-editor/prosemirror/plugins/image-plugin.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,QAAQ,EAAE,MAAM,kBAAkB,CAAC;AAE5C,OAAO,EAAe,aAAa,EAAE,MAAM,EAAe,MAAM,mBAAmB,CAAC;AAiBpF,OAAO,EAEH,4BAA4B,GAC/B,MAAM,6DAA6D,CAAC;AAGrE,OAAO,EAAE,SAAS,EAAE,iBAAiB,EAAE,MAAM,qBAAqB,CAAC;AAEnE,MAAM,UAAU,eAAe,CAAC,QAAkB,EAAE,YAA0B;IAC1E,OAAO,IAAI,QAAQ,CAAC;QAChB,KAAK,EAAE,cAAc;QACrB,KAAK,EAAE,OAAO;QACd,MAAM,EAAE,iBAAiB,CAAC,EAAE,KAAK,EAAE,OAAO,EAAE,KAAK,EAAE,OAAO,EAAE,CAAC;QAC7D,KAAK,EAAE,EAAE;QACT,GAAG,EAAE,EAAE;QACP,MAAM,CAAC,KAAkB;YACrB,OAAO,SAAS,CAAC,KAAK,EAAE,QAAQ,CAAC,CAAC;QACtC,CAAC;QACD,GAAG,CAAC,KAAkB,EAAE,CAAC,EAAE,IAAgB;YACvC,IAAI,KAAqC,CAAC;YAC1C,IAAI,KAAK,CAAC,SAAS,YAAY,aAAa,IAAI,KAAK,CAAC,SAAS,CAAC,IAAI,CAAC,IAAI,KAAK,QAAQ,EAAE;gBACpF,KAAK,GAAG,KAAK,CAAC,SAAS,CAAC,IAAI,CAAC,KAA2B,CAAC;aAC5D;YACD,YAAY;iBACP,aAAa,CAAC,4BAA4B,EAAE;gBACzC,QAAQ,EAAE,IAAI;gBACd,MAAM,EAAE;oBACJ,QAAQ,EAAE,KAAK;iBAClB;aACJ,CAAC;iBACD,SAAS,CAAC,MAAM,CAAC,EAAE;gBAChB,IAAI,MAAM,EAAE;oBACR,iDAAiD;oBACjD,IAAI,CAAC,QAAQ,CAAC,IAAI,CAAC,KAAK,CAAC,EAAE,CAAC,oBAAoB,CAAC,QAAQ,CAAC,aAAa,CAAC,MAAM,CAAE,CAAC,CAAC,CAAC;iBACtF;gBACD,IAAI,CAAC,KAAK,EAAE,CAAC;YACjB,CAAC,CAAC,CAAC;QACX,CAAC;KACJ,CAAC,CAAC;AACP,CAAC;AAED,MAAM,CAAC,MAAM,sBAAsB,GAAG,CAAC,kBAAsC,EAAE,YAA0B,EAAE,EAAE,CACzG,IAAI,MAAM,CAAC;IACP,IAAI,EAAE,GAAG,EAAE;QACP,OAAO;YACH,MAAM,EAAE,IAAI,CAAC,EAAE;gBACX,IAAI,CAAC,IAAI,CAAC,QAAQ,EAAE,EAAE;oBAClB,OAAO;iBACV;gBACD,MAAM,EAAE,GAAG,EAAE,SAAS,EAAE,GAAG,IAAI,CAAC,KAAK,CAAC;gBACtC,IAAI,SAA2B,CAAC;gBAChC,IAAI,YAAY,GAAG,CAAC,CAAC;gBACrB,GAAG,CAAC,YAAY,CAAC,SAAS,CAAC,IAAI,EAAE,SAAS,CAAC,EAAE,EAAE,CAAC,CAAC,EAAE,GAAG,EAAE,MAAM,EAAE,EAAE;oBAC9D,IAAI,CAAC,CAAC,IAAI,CAAC,IAAI,KAAK,OAAO,EAAE;wBACzB,SAAS,GAAG,CAAC,CAAC;wBACd,YAAY,GAAG,GAAG,CAAC;wBACnB,OAAO,KAAK,CAAC;qBAChB;gBACL,CAAC,CAAC,CAAC;gBACH,IAAI,SAAS,EAAE;oBACX,MAAM,IAAI,GAAG,IAAI,CAAC,OAAO,CAAC,YAAY,CAAC,CAAC;oBACxC,IAAI,IAAI,YAAY,gBAAgB,EAAE;wBAClC,kBAAkB,CAAC,cAAc,CAAC;4BAC9B,GAAG,EAAE,SAAS;4BACd,KAAK,EAAE,OAAO;4BACd,SAAS,EAAE,OAAO;4BAClB,OAAO,EAAE,IAAI;4BACb,MAAM,EAAE,IAAI,CAAC,WAAW,CAAC,YAAY,CAAC;4BACtC,KAAK,EAAE;gCACH;oCACI,OAAO,EAAE,IAAI;oCACb,SAAS,EAAE,OAAO;oCAClB,KAAK,EAAE,kBAAkB;oCACzB,OAAO,EAAE,GAAG,EAAE;wCACV,kBAAkB,CAAC,gBAAgB,EAAE,CAAC;wCACtC,YAAY;6CACP,aAAa,CAAC,4BAA4B,EAAE;4CACzC,QAAQ,EAAE,IAAI;4CACd,MAAM,EAAE;gDACJ,iDAAiD;gDACjD,QAAQ,EAAE,SAAU,CAAC,KAA2B;6CACnD;yCACJ,CAAC;6CACD,SAAS,CAAC,MAAM,CAAC,EAAE;4CAChB,IAAI,MAAM,EAAE;gDACR,iDAAiD;gDACjD,IAAI,CAAC,QAAQ,CACT,IAAI,CAAC,KAAK,CAAC,EAAE,CAAC,oBAAoB;gDAC9B,iDAAiD;gDACjD,SAAU,CAAC,IAAI,CAAC,aAAa,CAAC,MAAM,CAAE,CACzC,CACJ,CAAC;6CACL;4CACD,IAAI,CAAC,KAAK,EAAE,CAAC;wCACjB,CAAC,CAAC,CAAC;oCACX,CAAC;iCACJ;6BACJ;yBACJ,CAAC,CAAC;qBACN;iBACJ;qBAAM;oBACH,kBAAkB,CAAC,gBAAgB,EAAE,CAAC;iBACzC;YACL,CAAC;SACJ,CAAC;IACN,CAAC;CACJ,CAAC,CAAC","sourcesContent":["import { MenuItem } from 'prosemirror-menu';\r\nimport { Node, NodeType } from 'prosemirror-model';\r\nimport { EditorState, NodeSelection, Plugin, Transaction } from 'prosemirror-state';\r\nimport {\r\n    addColumnAfter,\r\n    addColumnBefore,\r\n    addRowAfter,\r\n    addRowBefore,\r\n    deleteColumn,\r\n    deleteRow,\r\n    deleteTable,\r\n    mergeCells,\r\n    splitCell,\r\n    toggleHeaderColumn,\r\n    toggleHeaderRow,\r\n} from 'prosemirror-tables';\r\nimport { EditorView } from 'prosemirror-view';\r\n\r\nimport { ModalService } from '../../../../../providers/modal/modal.service';\r\nimport {\r\n    ExternalImageAttrs,\r\n    ExternalImageDialogComponent,\r\n} from '../../external-image-dialog/external-image-dialog.component';\r\nimport { RawHtmlDialogComponent } from '../../raw-html-dialog/raw-html-dialog.component';\r\nimport { ContextMenuItem, ContextMenuService } from '../context-menu/context-menu.service';\r\nimport { canInsert, renderClarityIcon } from '../menu/menu-common';\r\n\r\nexport function insertImageItem(nodeType: NodeType, modalService: ModalService) {\r\n    return new MenuItem({\r\n        title: 'Insert image',\r\n        label: 'Image',\r\n        render: renderClarityIcon({ shape: 'image', label: 'Image' }),\r\n        class: '',\r\n        css: '',\r\n        enable(state: EditorState) {\r\n            return canInsert(state, nodeType);\r\n        },\r\n        run(state: EditorState, _, view: EditorView) {\r\n            let attrs: ExternalImageAttrs | undefined;\r\n            if (state.selection instanceof NodeSelection && state.selection.node.type === nodeType) {\r\n                attrs = state.selection.node.attrs as ExternalImageAttrs;\r\n            }\r\n            modalService\r\n                .fromComponent(ExternalImageDialogComponent, {\r\n                    closable: true,\r\n                    locals: {\r\n                        existing: attrs,\r\n                    },\r\n                })\r\n                .subscribe(result => {\r\n                    if (result) {\r\n                        // tslint:disable-next-line:no-non-null-assertion\r\n                        view.dispatch(view.state.tr.replaceSelectionWith(nodeType.createAndFill(result)!));\r\n                    }\r\n                    view.focus();\r\n                });\r\n        },\r\n    });\r\n}\r\n\r\nexport const imageContextMenuPlugin = (contextMenuService: ContextMenuService, modalService: ModalService) =>\r\n    new Plugin({\r\n        view: () => {\r\n            return {\r\n                update: view => {\r\n                    if (!view.hasFocus()) {\r\n                        return;\r\n                    }\r\n                    const { doc, selection } = view.state;\r\n                    let imageNode: Node | undefined;\r\n                    let imageNodePos = 0;\r\n                    doc.nodesBetween(selection.from, selection.to, (n, pos, parent) => {\r\n                        if (n.type.name === 'image') {\r\n                            imageNode = n;\r\n                            imageNodePos = pos;\r\n                            return false;\r\n                        }\r\n                    });\r\n                    if (imageNode) {\r\n                        const node = view.nodeDOM(imageNodePos);\r\n                        if (node instanceof HTMLImageElement) {\r\n                            contextMenuService.setContextMenu({\r\n                                ref: selection,\r\n                                title: 'Image',\r\n                                iconShape: 'image',\r\n                                element: node,\r\n                                coords: view.coordsAtPos(imageNodePos),\r\n                                items: [\r\n                                    {\r\n                                        enabled: true,\r\n                                        iconShape: 'image',\r\n                                        label: 'Image properties',\r\n                                        onClick: () => {\r\n                                            contextMenuService.clearContextMenu();\r\n                                            modalService\r\n                                                .fromComponent(ExternalImageDialogComponent, {\r\n                                                    closable: true,\r\n                                                    locals: {\r\n                                                        // tslint:disable-next-line:no-non-null-assertion\r\n                                                        existing: imageNode!.attrs as ExternalImageAttrs,\r\n                                                    },\r\n                                                })\r\n                                                .subscribe(result => {\r\n                                                    if (result) {\r\n                                                        // tslint:disable-next-line:no-non-null-assertion\r\n                                                        view.dispatch(\r\n                                                            view.state.tr.replaceSelectionWith(\r\n                                                                // tslint:disable-next-line:no-non-null-assertion\r\n                                                                imageNode!.type.createAndFill(result)!,\r\n                                                            ),\r\n                                                        );\r\n                                                    }\r\n                                                    view.focus();\r\n                                                });\r\n                                        },\r\n                                    },\r\n                                ],\r\n                            });\r\n                        }\r\n                    } else {\r\n                        contextMenuService.clearContextMenu();\r\n                    }\r\n                },\r\n            };\r\n        },\r\n    });\r\n"]}

package/package/esm2015/core/shared/components/rich-text-editor/prosemirror/plugins/raw-editor-plugin.js

@@ -0,0 +1,97 @@
+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 => {
+                                            var _a;
+                                            if (result) {
+                                                const domNode = htmlToDomNode(result, (topLevelNode === null || topLevelNode === void 0 ? void 0 : topLevelNode.isLeaf) ? undefined : node);
+                                                if (domNode) {
+                                                    let tr = view.state.tr;
+                                                    const parsedNodeSlice = domParser.parse(domNode);
+                                                    try {
+                                                        tr = tr.replaceRangeWith(topLevelNodePos, topLevelNodePos +
+                                                            ((_a = topLevelNode === null || topLevelNode === void 0 ? void 0 : topLevelNode.nodeSize) !== null && _a !== void 0 ? _a : 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":"AAAA,OAAO,EAAE,SAAS,EAAE,aAAa,EAAQ,MAAM,mBAAmB,CAAC;AACnE,OAAO,EAAE,MAAM,EAAE,MAAM,mBAAmB,CAAC;AAI3C,OAAO,EAAE,sBAAsB,EAAE,MAAM,iDAAiD,CAAC;AAGzF;;GAEG;AACH,MAAM,CAAC,MAAM,eAAe,GAAG,CAAC,kBAAsC,EAAE,YAA0B,EAAE,EAAE,CAClG,IAAI,MAAM,CAAC;IACP,IAAI,EAAE,KAAK,CAAC,EAAE;QACV,MAAM,SAAS,GAAG,SAAS,CAAC,UAAU,CAAC,KAAK,CAAC,KAAK,CAAC,MAAM,CAAC,CAAC;QAC3D,MAAM,aAAa,GAAG,aAAa,CAAC,UAAU,CAAC,KAAK,CAAC,KAAK,CAAC,MAAM,CAAC,CAAC;QACnE,OAAO;YACH,MAAM,EAAE,IAAI,CAAC,EAAE;gBACX,IAAI,CAAC,IAAI,CAAC,QAAQ,EAAE,EAAE;oBAClB,OAAO;iBACV;gBACD,IAAI,YAA8B,CAAC;gBACnC,MAAM,EAAE,GAAG,EAAE,SAAS,EAAE,GAAG,IAAI,CAAC,KAAK,CAAC;gBACtC,IAAI,eAAe,GAAG,CAAC,CAAC;gBACxB,GAAG,CAAC,YAAY,CAAC,SAAS,CAAC,IAAI,EAAE,SAAS,CAAC,EAAE,EAAE,CAAC,CAAC,EAAE,GAAG,EAAE,MAAM,EAAE,EAAE;oBAC9D,IAAI,MAAM,KAAK,GAAG,EAAE;wBAChB,YAAY,GAAG,CAAC,CAAC;wBACjB,eAAe,GAAG,GAAG,CAAC;wBACtB,OAAO,KAAK,CAAC;qBAChB;gBACL,CAAC,CAAC,CAAC;gBACH,IAAI,YAAY,EAAE;oBACd,MAAM,IAAI,GAAG,IAAI,CAAC,OAAO,CAAC,eAAe,CAAC,CAAC;oBAC3C,IAAI,IAAI,YAAY,WAAW,EAAE;wBAC7B,kBAAkB,CAAC,cAAc,CAAC;4BAC9B,GAAG,EAAE,SAAS;4BACd,KAAK,EAAE,EAAE;4BACT,kCAAkC;4BAClC,OAAO,EAAE,IAAI;4BACb,MAAM,EAAE,IAAI,CAAC,WAAW,CAAC,eAAe,CAAC;4BACzC,KAAK,EAAE;gCACH;oCACI,OAAO,EAAE,IAAI;oCACb,SAAS,EAAE,MAAM;oCACjB,KAAK,EAAE,WAAW;oCAClB,OAAO,EAAE,GAAG,EAAE;wCACV,kBAAkB,CAAC,gBAAgB,EAAE,CAAC;wCACtC,MAAM,OAAO,GAAG,aAAa,CAAC,aAAa;wCACvC,iDAAiD;wCACjD,YAAa,CACD,CAAC;wCACjB,YAAY;6CACP,aAAa,CAAC,sBAAsB,EAAE;4CACnC,IAAI,EAAE,IAAI;4CACV,MAAM,EAAE;gDACJ,IAAI,EAAE,OAAO,CAAC,SAAS;6CAC1B;yCACJ,CAAC;6CACD,SAAS,CAAC,MAAM,CAAC,EAAE;;4CAChB,IAAI,MAAM,EAAE;gDACR,MAAM,OAAO,GAAG,aAAa,CACzB,MAAM,EACN,CAAA,YAAY,aAAZ,YAAY,uBAAZ,YAAY,CAAE,MAAM,EAAC,CAAC,CAAC,SAAS,CAAC,CAAC,CAAC,IAAI,CAC1C,CAAC;gDACF,IAAI,OAAO,EAAE;oDACT,IAAI,EAAE,GAAG,IAAI,CAAC,KAAK,CAAC,EAAE,CAAC;oDACvB,MAAM,eAAe,GAAG,SAAS,CAAC,KAAK,CAAC,OAAO,CAAC,CAAC;oDACjD,IAAI;wDACA,EAAE,GAAG,EAAE,CAAC,gBAAgB,CACpB,eAAe,EACf,eAAe;4DACX,CAAC,MAAA,YAAY,aAAZ,YAAY,uBAAZ,YAAY,CAAE,QAAQ,mCAAI,CAAC,CAAC,EACjC,eAAe,CAClB,CAAC;qDACL;oDAAC,OAAO,GAAQ,EAAE;wDACf,sCAAsC;wDACtC,OAAO,CAAC,KAAK,CAAC,GAAG,CAAC,CAAC;qDACtB;oDACD,IAAI,CAAC,QAAQ,CAAC,EAAE,CAAC,CAAC;oDAClB,IAAI,CAAC,KAAK,EAAE,CAAC;iDAChB;6CACJ;wCACL,CAAC,CAAC,CAAC;oCACX,CAAC;iCACJ;6BACJ;yBACJ,CAAC,CAAC;qBACN;iBACJ;YACL,CAAC;SACJ,CAAC;IACN,CAAC;CACJ,CAAC,CAAC;AAEP,SAAS,aAAa,CAAC,IAAY,EAAE,YAA0B;IAC3D,IAAI,GAAG,GAAG,IAAI,CAAC,IAAI,EAAE,EAAE,CAAC;IACxB,MAAM,QAAQ,GAAG,QAAQ,CAAC,aAAa,CAAC,UAAU,CAAC,CAAC;IACpD,IAAI,YAAY,EAAE;QACd,MAAM,WAAW,GAAG,YAAY,CAAC,SAAS,CAAC,KAAK,CAAgB,CAAC;QACjE,WAAW,CAAC,SAAS,GAAG,IAAI,CAAC;QAC7B,QAAQ,CAAC,OAAO,CAAC,WAAW,CAAC,WAAW,CAAC,CAAC;KAC7C;SAAM;QACH,MAAM,MAAM,GAAG,QAAQ,CAAC,aAAa,CAAC,GAAG,CAAC,CAAC;QAC3C,MAAM,CAAC,SAAS,GAAG,IAAI,CAAC;QACxB,QAAQ,CAAC,OAAO,CAAC,WAAW,CAAC,MAAM,CAAC,CAAC;KACxC;IACD,OAAO,QAAQ,CAAC,OAAO,CAAC,UAAU,CAAC;AACvC,CAAC","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"]}