@ecodev/natural-editor 41.3.0 → 42.0.0

package/esm2020/lib/utils/keymap.mjs

@@ -0,0 +1,115 @@
+import { chainCommands, exitCode, joinDown, joinUp, lift, selectParentNode, setBlockType, toggleMark, wrapIn, } from 'prosemirror-commands';
+import { liftListItem, sinkListItem, splitListItem, wrapInList } from 'prosemirror-schema-list';
+import { redo, undo } from 'prosemirror-history';
+import { undoInputRule } from 'prosemirror-inputrules';
+/**
+ * Inspect the given schema looking for marks and nodes from the
+ * basic schema, and if found, add key bindings related to them.
+ * This will add:
+ *
+ * * **Mod-b** for toggling [strong](#schema-basic.StrongMark)
+ * * **Mod-i** for toggling [emphasis](#schema-basic.EmMark)
+ * * **Mod-`** for toggling [code font](#schema-basic.CodeMark)
+ * * **Ctrl-Shift-0** for making the current textblock a paragraph
+ * * **Ctrl-Shift-1** to **Ctrl-Shift-Digit6** for making the current
+ *   textblock a heading of the corresponding level
+ * * **Ctrl-Shift-Backslash** to make the current textblock a code block
+ * * **Ctrl-Shift-8** to wrap the selection in an ordered list
+ * * **Ctrl-Shift-9** to wrap the selection in a bullet list
+ * * **Ctrl->** to wrap the selection in a block quote
+ * * **Enter** to split a non-empty textblock in a list item while at
+ *   the same time splitting the list item
+ * * **Mod-Enter** to insert a hard break
+ * * **Mod-_** to insert a horizontal rule
+ * * **Backspace** to undo an input rule
+ * * **Alt-ArrowUp** to `joinUp`
+ * * **Alt-ArrowDown** to `joinDown`
+ * * **Mod-BracketLeft** to `lift`
+ * * **Escape** to `selectParentNode`
+ *
+ * You can suppress or map these bindings by passing a `mapKeys`
+ * argument, which maps key names (say `"Mod-B"` to either `false`, to
+ * remove the binding, or a new key name string.
+ */
+export function buildKeymap(schema, isMac) {
+    const keys = {};
+    keys['Mod-z'] = undo;
+    keys['Shift-Mod-z'] = redo;
+    keys['Backspace'] = undoInputRule;
+    if (!isMac) {
+        keys['Mod-y'] = redo;
+    }
+    keys['Alt-ArrowUp'] = joinUp;
+    keys['Alt-ArrowDown'] = joinDown;
+    keys['Mod-BracketLeft'] = lift;
+    keys['Escape'] = selectParentNode;
+    let type = schema.marks.strong;
+    if (type) {
+        keys['Mod-b'] = toggleMark(type);
+        keys['Mod-B'] = toggleMark(type);
+    }
+    type = schema.marks.em;
+    if (type) {
+        keys['Mod-i'] = toggleMark(type);
+        keys['Mod-I'] = toggleMark(type);
+    }
+    type = schema.marks.code;
+    if (type) {
+        keys['Mod-`'] = toggleMark(type);
+    }
+    type = schema.nodes.bullet_list;
+    if (type) {
+        keys['Shift-Ctrl-8'] = wrapInList(type);
+    }
+    type = schema.nodes.ordered_list;
+    if (type) {
+        keys['Shift-Ctrl-9'] = wrapInList(type);
+    }
+    type = schema.nodes.blockquote;
+    if (type) {
+        keys['Ctrl->'] = wrapIn(type);
+    }
+    type = schema.nodes.hard_break;
+    if (type) {
+        const br = type;
+        const cmd = chainCommands(exitCode, (state, dispatch) => {
+            dispatch?.(state.tr.replaceSelectionWith(br.create()).scrollIntoView());
+            return true;
+        });
+        keys['Mod-Enter'] = cmd;
+        keys['Shift-Enter'] = cmd;
+        if (isMac) {
+            keys['Ctrl-Enter'] = cmd;
+        }
+    }
+    type = schema.nodes.list_item;
+    if (type) {
+        keys['Enter'] = splitListItem(type);
+        keys['Mod-['] = liftListItem(type);
+        keys['Mod-]'] = sinkListItem(type);
+    }
+    type = schema.nodes.paragraph;
+    if (type) {
+        keys['Shift-Ctrl-0'] = setBlockType(type);
+    }
+    type = schema.nodes.code_block;
+    if (type) {
+        keys['Shift-Ctrl-\\'] = setBlockType(type);
+    }
+    type = schema.nodes.heading;
+    if (type) {
+        for (let i = 1; i <= 6; i++) {
+            keys['Shift-Ctrl-' + i] = setBlockType(type, { level: i });
+        }
+    }
+    type = schema.nodes.horizontal_rule;
+    if (type) {
+        const hr = type;
+        keys['Mod-_'] = (state, dispatch) => {
+            dispatch?.(state.tr.replaceSelectionWith(hr.create()).scrollIntoView());
+            return true;
+        };
+    }
+    return keys;
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"keymap.js","sourceRoot":"","sources":["../../../../../projects/natural-editor/src/lib/utils/keymap.ts"],"names":[],"mappings":"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","sourcesContent":["import {\n    chainCommands,\n    exitCode,\n    joinDown,\n    joinUp,\n    Keymap,\n    lift,\n    selectParentNode,\n    setBlockType,\n    toggleMark,\n    wrapIn,\n} from 'prosemirror-commands';\nimport {liftListItem, sinkListItem, splitListItem, wrapInList} from 'prosemirror-schema-list';\nimport {redo, undo} from 'prosemirror-history';\nimport {undoInputRule} from 'prosemirror-inputrules';\nimport {MarkType, NodeType, Schema} from 'prosemirror-model';\n\n/**\n * Inspect the given schema looking for marks and nodes from the\n * basic schema, and if found, add key bindings related to them.\n * This will add:\n *\n * * **Mod-b** for toggling [strong](#schema-basic.StrongMark)\n * * **Mod-i** for toggling [emphasis](#schema-basic.EmMark)\n * * **Mod-`** for toggling [code font](#schema-basic.CodeMark)\n * * **Ctrl-Shift-0** for making the current textblock a paragraph\n * * **Ctrl-Shift-1** to **Ctrl-Shift-Digit6** for making the current\n *   textblock a heading of the corresponding level\n * * **Ctrl-Shift-Backslash** to make the current textblock a code block\n * * **Ctrl-Shift-8** to wrap the selection in an ordered list\n * * **Ctrl-Shift-9** to wrap the selection in a bullet list\n * * **Ctrl->** to wrap the selection in a block quote\n * * **Enter** to split a non-empty textblock in a list item while at\n *   the same time splitting the list item\n * * **Mod-Enter** to insert a hard break\n * * **Mod-_** to insert a horizontal rule\n * * **Backspace** to undo an input rule\n * * **Alt-ArrowUp** to `joinUp`\n * * **Alt-ArrowDown** to `joinDown`\n * * **Mod-BracketLeft** to `lift`\n * * **Escape** to `selectParentNode`\n *\n * You can suppress or map these bindings by passing a `mapKeys`\n * argument, which maps key names (say `\"Mod-B\"` to either `false`, to\n * remove the binding, or a new key name string.\n */\nexport function buildKeymap(schema: Schema, isMac: boolean): Keymap {\n    const keys: Keymap = {};\n\n    keys['Mod-z'] = undo;\n    keys['Shift-Mod-z'] = redo;\n    keys['Backspace'] = undoInputRule;\n    if (!isMac) {\n        keys['Mod-y'] = redo;\n    }\n\n    keys['Alt-ArrowUp'] = joinUp;\n    keys['Alt-ArrowDown'] = joinDown;\n    keys['Mod-BracketLeft'] = lift;\n    keys['Escape'] = selectParentNode;\n\n    let type: MarkType | NodeType = schema.marks.strong;\n    if (type) {\n        keys['Mod-b'] = toggleMark(type);\n        keys['Mod-B'] = toggleMark(type);\n    }\n\n    type = schema.marks.em;\n    if (type) {\n        keys['Mod-i'] = toggleMark(type);\n        keys['Mod-I'] = toggleMark(type);\n    }\n\n    type = schema.marks.code;\n    if (type) {\n        keys['Mod-`'] = toggleMark(type);\n    }\n\n    type = schema.nodes.bullet_list;\n    if (type) {\n        keys['Shift-Ctrl-8'] = wrapInList(type);\n    }\n\n    type = schema.nodes.ordered_list;\n    if (type) {\n        keys['Shift-Ctrl-9'] = wrapInList(type);\n    }\n\n    type = schema.nodes.blockquote;\n    if (type) {\n        keys['Ctrl->'] = wrapIn(type);\n    }\n\n    type = schema.nodes.hard_break;\n    if (type) {\n        const br = type;\n        const cmd = chainCommands(exitCode, (state, dispatch) => {\n            dispatch?.(state.tr.replaceSelectionWith(br.create()).scrollIntoView());\n            return true;\n        });\n        keys['Mod-Enter'] = cmd;\n        keys['Shift-Enter'] = cmd;\n        if (isMac) {\n            keys['Ctrl-Enter'] = cmd;\n        }\n    }\n\n    type = schema.nodes.list_item;\n    if (type) {\n        keys['Enter'] = splitListItem(type);\n        keys['Mod-['] = liftListItem(type);\n        keys['Mod-]'] = sinkListItem(type);\n    }\n\n    type = schema.nodes.paragraph;\n    if (type) {\n        keys['Shift-Ctrl-0'] = setBlockType(type);\n    }\n\n    type = schema.nodes.code_block;\n    if (type) {\n        keys['Shift-Ctrl-\\\\'] = setBlockType(type);\n    }\n\n    type = schema.nodes.heading;\n    if (type) {\n        for (let i = 1; i <= 6; i++) {\n            keys['Shift-Ctrl-' + i] = setBlockType(type, {level: i});\n        }\n    }\n\n    type = schema.nodes.horizontal_rule;\n    if (type) {\n        const hr = type;\n        keys['Mod-_'] = (state, dispatch) => {\n            dispatch?.(state.tr.replaceSelectionWith(hr.create()).scrollIntoView());\n            return true;\n        };\n    }\n\n    return keys;\n}\n"]}

package/esm2020/lib/utils/menu.mjs

@@ -0,0 +1,184 @@
+import { blockTypeItem, joinUpItem, liftItem, redoItem, selectParentNodeItem, undoItem, wrapItem, } from 'prosemirror-menu';
+import { toggleMark } from 'prosemirror-commands';
+import { wrapInList } from 'prosemirror-schema-list';
+import { LinkDialogComponent } from '../link-dialog/link-dialog.component';
+import { addColumnAfter, addColumnBefore, addRowAfter, addRowBefore, deleteColumn, deleteRow, deleteTable, mergeCells, splitCell, toggleHeaderCell, toggleHeaderColumn, toggleHeaderRow, } from 'prosemirror-tables';
+import { addTable } from './table';
+import { Item } from './item';
+import { paragraphWithAlignment } from './paragraph-with-alignment';
+import { TextAlignItem } from './text-align-item';
+/**
+ * Convert built-in `MenuItem` into our Angular specific `Item`
+ */
+function toItem(item) {
+    return new Item(item.spec);
+}
+function canInsert(state, nodeType) {
+    const $from = state.selection.$from;
+    for (let d = $from.depth; d >= 0; d--) {
+        const index = $from.index(d);
+        if ($from.node(d).canReplaceWith(index, index, nodeType)) {
+            return true;
+        }
+    }
+    return false;
+}
+function cmdItem(cmd, options = {}, useEnable = false) {
+    const passedOptions = {
+        run: cmd,
+        ...options,
+    };
+    if ((!options.enable || useEnable) && !options.select) {
+        passedOptions[options.enable ? 'enable' : 'select'] = (state) => cmd(state);
+    }
+    return new Item(passedOptions);
+}
+function markActive(state, type) {
+    const { from, $from, to, empty } = state.selection;
+    if (empty) {
+        return !!type.isInSet(state.storedMarks || $from.marks());
+    }
+    else {
+        return state.doc.rangeHasMark(from, to, type);
+    }
+}
+function markItem(markType, options = {}) {
+    const passedOptions = {
+        active(state) {
+            return markActive(state, markType);
+        },
+        ...options,
+    };
+    return cmdItem(toggleMark(markType), passedOptions, true);
+}
+function linkItem(markType, dialog) {
+    return new Item({
+        active(state) {
+            return markActive(state, markType);
+        },
+        enable(state) {
+            return !state.selection.empty;
+        },
+        run(state, dispatch, view) {
+            if (markActive(state, markType)) {
+                toggleMark(markType)(state, dispatch);
+                return true;
+            }
+            dialog
+                .open(LinkDialogComponent, {
+                data: {
+                    href: '',
+                    title: '',
+                },
+            })
+                .afterClosed()
+                .subscribe(result => {
+                if (result) {
+                    if (!result.title) {
+                        delete result.title;
+                    }
+                    toggleMark(markType, result)(view.state, view.dispatch);
+                }
+                view.focus();
+            });
+        },
+    });
+}
+function wrapListItem(nodeType) {
+    return cmdItem(wrapInList(nodeType));
+}
+/**
+ * Given a schema, look for default mark and node types in it and
+ * return an object with relevant menu items relating to those marks:
+ */
+export function buildMenuItems(schema, dialog) {
+    const r = {
+        joinUp: toItem(joinUpItem),
+        lift: toItem(liftItem),
+        selectParentNode: toItem(selectParentNodeItem),
+        undo: toItem(undoItem),
+        redo: toItem(redoItem),
+    };
+    let type;
+    type = schema.marks.strong;
+    if (type) {
+        r.toggleStrong = markItem(type);
+    }
+    type = schema.marks.em;
+    if (type) {
+        r.toggleEm = markItem(type);
+    }
+    type = schema.marks.code;
+    if (type) {
+        r.toggleCode = markItem(type);
+    }
+    type = schema.marks.link;
+    if (type) {
+        r.toggleLink = linkItem(type, dialog);
+    }
+    type = schema.nodes.bullet_list;
+    if (type) {
+        r.wrapBulletList = wrapListItem(type);
+    }
+    type = schema.nodes.ordered_list;
+    if (type) {
+        r.wrapOrderedList = wrapListItem(type);
+    }
+    type = schema.nodes.blockquote;
+    if (type) {
+        r.wrapBlockQuote = toItem(wrapItem(type, {}));
+    }
+    type = schema.nodes.paragraph;
+    if (type) {
+        r.makeParagraph = toItem(blockTypeItem(type, {}));
+        if (type.spec === paragraphWithAlignment) {
+            r.alignLeft = new TextAlignItem('left');
+            r.alignRight = new TextAlignItem('right');
+            r.alignCenter = new TextAlignItem('center');
+            r.alignJustify = new TextAlignItem('justify');
+        }
+    }
+    type = schema.nodes.code_block;
+    if (type) {
+        r.makeCodeBlock = toItem(blockTypeItem(type, {}));
+    }
+    type = schema.nodes.heading;
+    if (type) {
+        r.makeHead1 = toItem(blockTypeItem(type, { attrs: { level: 1 } }));
+        r.makeHead2 = toItem(blockTypeItem(type, { attrs: { level: 2 } }));
+        r.makeHead3 = toItem(blockTypeItem(type, { attrs: { level: 3 } }));
+        r.makeHead4 = toItem(blockTypeItem(type, { attrs: { level: 4 } }));
+        r.makeHead5 = toItem(blockTypeItem(type, { attrs: { level: 5 } }));
+        r.makeHead6 = toItem(blockTypeItem(type, { attrs: { level: 6 } }));
+    }
+    type = schema.nodes.horizontal_rule;
+    if (type) {
+        const hr = type;
+        r.insertHorizontalRule = new Item({
+            enable(state) {
+                return canInsert(state, hr);
+            },
+            run(state, dispatch) {
+                dispatch(state.tr.replaceSelectionWith(hr.create()));
+            },
+        });
+    }
+    type = schema.nodes.table;
+    if (type) {
+        r.insertTable = new Item({ run: (e, tr) => addTable(e, tr) });
+        r.addColumnBefore = new Item({ run: addColumnBefore });
+        r.addColumnAfter = new Item({ run: addColumnAfter });
+        r.deleteColumn = new Item({ run: deleteColumn });
+        r.addRowBefore = new Item({ run: addRowBefore });
+        r.addRowAfter = new Item({ run: addRowAfter });
+        r.deleteRow = new Item({ run: deleteRow });
+        r.deleteTable = new Item({ run: deleteTable });
+        r.mergeCells = new Item({ run: mergeCells });
+        r.splitCell = new Item({ run: splitCell });
+        r.toggleHeaderColumn = new Item({ run: toggleHeaderColumn });
+        r.toggleHeaderRow = new Item({ run: toggleHeaderRow });
+        r.toggleHeaderCell = new Item({ run: toggleHeaderCell });
+    }
+    return r;
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"menu.js","sourceRoot":"","sources":["../../../../../projects/natural-editor/src/lib/utils/menu.ts"],"names":[],"mappings":"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","sourcesContent":["import {\n    blockTypeItem,\n    joinUpItem,\n    liftItem,\n    MenuItem,\n    MenuItemSpec,\n    redoItem,\n    selectParentNodeItem,\n    undoItem,\n    wrapItem,\n} from 'prosemirror-menu';\nimport {EditorState, Transaction} from 'prosemirror-state';\nimport {Command, toggleMark} from 'prosemirror-commands';\nimport {wrapInList} from 'prosemirror-schema-list';\nimport {MarkType, NodeType, Schema} from 'prosemirror-model';\nimport {MatDialog} from '@angular/material/dialog';\nimport {LinkDialogComponent, LinkDialogData} from '../link-dialog/link-dialog.component';\nimport {EditorView} from 'prosemirror-view';\nimport {\n    addColumnAfter,\n    addColumnBefore,\n    addRowAfter,\n    addRowBefore,\n    deleteColumn,\n    deleteRow,\n    deleteTable,\n    mergeCells,\n    splitCell,\n    toggleHeaderCell,\n    toggleHeaderColumn,\n    toggleHeaderRow,\n} from 'prosemirror-tables';\nimport {addTable} from './table';\nimport {Item} from './item';\nimport {paragraphWithAlignment} from './paragraph-with-alignment';\nimport {TextAlignItem} from './text-align-item';\n\n/**\n * Convert built-in `MenuItem` into our Angular specific `Item`\n */\nfunction toItem(item: MenuItem): Item {\n    return new Item(item.spec);\n}\n\nfunction canInsert(state: EditorState, nodeType: NodeType): boolean {\n    const $from = state.selection.$from;\n    for (let d = $from.depth; d >= 0; d--) {\n        const index = $from.index(d);\n        if ($from.node(d).canReplaceWith(index, index, nodeType)) {\n            return true;\n        }\n    }\n\n    return false;\n}\n\nfunction cmdItem(cmd: Command, options: Partial<MenuItemSpec> = {}, useEnable = false): Item {\n    const passedOptions: MenuItemSpec = {\n        run: cmd,\n        ...options,\n    };\n\n    if ((!options.enable || useEnable) && !options.select) {\n        passedOptions[options.enable ? 'enable' : 'select'] = (state: EditorState) => cmd(state);\n    }\n\n    return new Item(passedOptions);\n}\n\nfunction markActive(state: EditorState, type: MarkType): boolean {\n    const {from, $from, to, empty} = state.selection;\n    if (empty) {\n        return !!type.isInSet(state.storedMarks || $from.marks());\n    } else {\n        return state.doc.rangeHasMark(from, to, type);\n    }\n}\n\nfunction markItem(markType: MarkType, options: Partial<MenuItemSpec> = {}): Item {\n    const passedOptions: Partial<MenuItemSpec> = {\n        active(state: EditorState): boolean {\n            return markActive(state, markType);\n        },\n        ...options,\n    };\n\n    return cmdItem(toggleMark(markType), passedOptions, true);\n}\n\nfunction linkItem(markType: MarkType, dialog: MatDialog): Item {\n    return new Item({\n        active(state: EditorState): boolean {\n            return markActive(state, markType);\n        },\n        enable(state: EditorState): boolean {\n            return !state.selection.empty;\n        },\n        run(state: EditorState, dispatch: (p: Transaction) => void, view: EditorView): boolean | void {\n            if (markActive(state, markType)) {\n                toggleMark(markType)(state, dispatch);\n                return true;\n            }\n\n            dialog\n                .open<LinkDialogComponent, LinkDialogData, LinkDialogData>(LinkDialogComponent, {\n                    data: {\n                        href: '',\n                        title: '',\n                    },\n                })\n                .afterClosed()\n                .subscribe(result => {\n                    if (result) {\n                        if (!result.title) {\n                            delete result.title;\n                        }\n\n                        toggleMark(markType, result)(view.state, view.dispatch);\n                    }\n\n                    view.focus();\n                });\n        },\n    });\n}\n\nfunction wrapListItem(nodeType: NodeType): Item {\n    return cmdItem(wrapInList(nodeType));\n}\n\nexport type Key =\n    | 'toggleStrong'\n    | 'toggleEm'\n    | 'toggleCode'\n    | 'toggleLink'\n    | 'wrapBulletList'\n    | 'wrapOrderedList'\n    | 'wrapBlockQuote'\n    | 'makeParagraph'\n    | 'makeCodeBlock'\n    | 'makeHead1'\n    | 'makeHead2'\n    | 'makeHead3'\n    | 'makeHead4'\n    | 'makeHead5'\n    | 'makeHead6'\n    | 'alignLeft'\n    | 'alignRight'\n    | 'alignCenter'\n    | 'alignJustify'\n    | 'insertHorizontalRule'\n    | 'joinUp'\n    | 'lift'\n    | 'selectParentNode'\n    | 'undo'\n    | 'redo'\n    | 'insertTable'\n    | 'addColumnBefore'\n    | 'addColumnAfter'\n    | 'deleteColumn'\n    | 'addRowBefore'\n    | 'addRowAfter'\n    | 'deleteRow'\n    | 'deleteTable'\n    | 'mergeCells'\n    | 'splitCell'\n    | 'toggleHeaderColumn'\n    | 'toggleHeaderRow'\n    | 'toggleHeaderCell';\n\nexport type MenuItems = Partial<Record<Key, Item>>;\n\n/**\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 */\nexport function buildMenuItems(schema: Schema, dialog: MatDialog): MenuItems {\n    const r: MenuItems = {\n        joinUp: toItem(joinUpItem),\n        lift: toItem(liftItem),\n        selectParentNode: toItem(selectParentNodeItem),\n        undo: toItem(undoItem as unknown as MenuItem), // Typing is incorrect, so we force it\n        redo: toItem(redoItem as unknown as MenuItem),\n    };\n\n    let type: MarkType | NodeType | undefined;\n    type = schema.marks.strong;\n    if (type) {\n        r.toggleStrong = markItem(type);\n    }\n\n    type = schema.marks.em;\n    if (type) {\n        r.toggleEm = markItem(type);\n    }\n\n    type = schema.marks.code;\n    if (type) {\n        r.toggleCode = markItem(type);\n    }\n\n    type = schema.marks.link;\n    if (type) {\n        r.toggleLink = linkItem(type, dialog);\n    }\n\n    type = schema.nodes.bullet_list;\n    if (type) {\n        r.wrapBulletList = wrapListItem(type);\n    }\n\n    type = schema.nodes.ordered_list;\n    if (type) {\n        r.wrapOrderedList = wrapListItem(type);\n    }\n\n    type = schema.nodes.blockquote;\n    if (type) {\n        r.wrapBlockQuote = toItem(wrapItem(type, {}));\n    }\n\n    type = schema.nodes.paragraph;\n    if (type) {\n        r.makeParagraph = toItem(blockTypeItem(type, {}));\n\n        if (type.spec === paragraphWithAlignment) {\n            r.alignLeft = new TextAlignItem('left');\n            r.alignRight = new TextAlignItem('right');\n            r.alignCenter = new TextAlignItem('center');\n            r.alignJustify = new TextAlignItem('justify');\n        }\n    }\n\n    type = schema.nodes.code_block;\n    if (type) {\n        r.makeCodeBlock = toItem(blockTypeItem(type, {}));\n    }\n\n    type = schema.nodes.heading;\n    if (type) {\n        r.makeHead1 = toItem(blockTypeItem(type, {attrs: {level: 1}}));\n        r.makeHead2 = toItem(blockTypeItem(type, {attrs: {level: 2}}));\n        r.makeHead3 = toItem(blockTypeItem(type, {attrs: {level: 3}}));\n        r.makeHead4 = toItem(blockTypeItem(type, {attrs: {level: 4}}));\n        r.makeHead5 = toItem(blockTypeItem(type, {attrs: {level: 5}}));\n        r.makeHead6 = toItem(blockTypeItem(type, {attrs: {level: 6}}));\n    }\n\n    type = schema.nodes.horizontal_rule;\n    if (type) {\n        const hr = type;\n        r.insertHorizontalRule = new Item({\n            enable(state): boolean {\n                return canInsert(state, hr);\n            },\n            run(state, dispatch): void {\n                dispatch(state.tr.replaceSelectionWith(hr.create()));\n            },\n        });\n    }\n\n    type = schema.nodes.table;\n    if (type) {\n        r.insertTable = new Item({run: (e, tr) => addTable(e, tr)});\n        r.addColumnBefore = new Item({run: addColumnBefore});\n        r.addColumnAfter = new Item({run: addColumnAfter});\n        r.deleteColumn = new Item({run: deleteColumn});\n        r.addRowBefore = new Item({run: addRowBefore});\n        r.addRowAfter = new Item({run: addRowAfter});\n        r.deleteRow = new Item({run: deleteRow});\n        r.deleteTable = new Item({run: deleteTable});\n        r.mergeCells = new Item({run: mergeCells});\n        r.splitCell = new Item({run: splitCell});\n        r.toggleHeaderColumn = new Item({run: toggleHeaderColumn});\n        r.toggleHeaderRow = new Item({run: toggleHeaderRow});\n        r.toggleHeaderCell = new Item({run: toggleHeaderCell});\n    }\n\n    return r;\n}\n"]}

package/esm2020/lib/utils/paragraph-with-alignment.mjs

@@ -0,0 +1,43 @@
+const ALIGN_PATTERN = /(left|right|center|justify)/;
+// https://github.com/ProseMirror/prosemirror-schema-basic/blob/master/src/schema-basic.js
+// :: NodeSpec A plain paragraph textblock. Represented in the DOM
+// as a `<p>` element.
+export const paragraphWithAlignment = {
+    attrs: {
+        align: { default: null },
+        id: { default: null },
+    },
+    content: 'inline*',
+    group: 'block',
+    parseDOM: [
+        {
+            tag: 'p',
+            getAttrs: (dom) => {
+                if (!(dom instanceof HTMLElement)) {
+                    return;
+                }
+                const { textAlign } = dom.style;
+                let align = dom.getAttribute('align') || textAlign || '';
+                align = ALIGN_PATTERN.test(align) ? align : null;
+                const id = dom.getAttribute('id') || '';
+                return { align, id };
+            },
+        },
+    ],
+    toDOM: node => {
+        const { align, id } = node.attrs;
+        const attrs = {};
+        let style = '';
+        if (align && align !== 'left') {
+            style += `text-align: ${align};`;
+        }
+        if (style) {
+            attrs.style = style;
+        }
+        if (id) {
+            attrs.id = id;
+        }
+        return ['p', attrs, 0];
+    },
+};
+//# sourceMappingURL=data:application/json;base64,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

package/esm2020/lib/utils/schema.mjs

@@ -0,0 +1,51 @@
+import { marks, nodes } from 'prosemirror-schema-basic';
+import { addListNodes } from 'prosemirror-schema-list';
+import { Schema } from 'prosemirror-model';
+import { tableNodes } from 'prosemirror-tables';
+import { paragraphWithAlignment } from './paragraph-with-alignment';
+const basicNodes = {
+    heading: nodes.heading,
+    doc: nodes.doc,
+    paragraph: nodes.paragraph,
+    text: nodes.text,
+    hard_break: nodes.hard_break,
+};
+const basicMarks = {
+    link: marks.link,
+    em: marks.em,
+    strong: marks.strong,
+};
+const tmpSchema = new Schema({ nodes: basicNodes, marks: basicMarks });
+export const basicSchema = new Schema({
+    nodes: addListNodes(tmpSchema.spec.nodes, 'paragraph block*', 'block'),
+    marks: tmpSchema.spec.marks,
+});
+const tmpSchema2 = new Schema({
+    nodes: {
+        ...nodes,
+        ...tableNodes({
+            tableGroup: 'block',
+            cellContent: 'block+',
+            cellAttributes: {
+                background: {
+                    default: null,
+                    getFromDOM(dom) {
+                        return dom.style.backgroundColor || null;
+                    },
+                    setDOMAttr(value, attrs) {
+                        if (value) {
+                            attrs.style = (attrs.style || '') + `background-color: ${value};`;
+                        }
+                    },
+                },
+            },
+        }),
+        paragraph: paragraphWithAlignment,
+    },
+    marks: basicMarks,
+});
+export const advancedSchema = new Schema({
+    nodes: addListNodes(tmpSchema2.spec.nodes, 'paragraph block*', 'block'),
+    marks: basicMarks,
+});
+//# sourceMappingURL=data:application/json;base64,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

package/{esm2015/lib/utils/table.js → esm2020/lib/utils/table.mjs}

@@ -32,6 +32,6 @@ export function addTable(state, dispatch, { rowsCount = 3, colsCount = 3, withHe
     const resolvedPos = tr.doc.resolve(offset);
     // move cursor into table
     tr.setSelection(TextSelection.near(resolvedPos));
-    dispatch === null || dispatch === void 0 ? void 0 : dispatch(tr);
+    dispatch?.(tr);
 }
-//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoidGFibGUuanMiLCJzb3VyY2VSb290IjoiIiwic291cmNlcyI6WyIuLi8uLi8uLi8uLi8uLi9wcm9qZWN0cy9uYXR1cmFsLWVkaXRvci9zcmMvbGliL3V0aWxzL3RhYmxlLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLE9BQU8sRUFBYyxhQUFhLEVBQWMsTUFBTSxtQkFBbUIsQ0FBQztBQUUxRSxPQUFPLEVBQUMsY0FBYyxFQUFDLE1BQU0sb0JBQW9CLENBQUM7QUFFbEQsU0FBUyxVQUFVLENBQ2YsUUFBa0IsRUFDbEIsV0FBaUU7SUFFakUsT0FBTyxXQUFXLENBQUMsQ0FBQyxDQUFDLFFBQVEsQ0FBQyxhQUFhLENBQUMsSUFBSSxFQUFFLFdBQVcsQ0FBQyxDQUFDLENBQUMsQ0FBQyxRQUFRLENBQUMsYUFBYSxFQUFFLENBQUM7QUFDOUYsQ0FBQztBQUVELFNBQVMsV0FBVyxDQUNoQixLQUFrQixFQUNsQixTQUFpQixFQUNqQixTQUFpQixFQUNqQixhQUFzQixFQUN0QixXQUFpRTtJQUVqRSxNQUFNLEtBQUssR0FBRyxjQUFjLENBQUMsS0FBSyxDQUFDLE1BQU0sQ0FBQyxDQUFDO0lBQzNDLE1BQU0sV0FBVyxHQUFHLEVBQUUsQ0FBQztJQUN2QixNQUFNLEtBQUssR0FBRyxFQUFFLENBQUM7SUFFakIsS0FBSyxJQUFJLEtBQUssR0FBRyxDQUFDLEVBQUUsS0FBSyxHQUFHLFNBQVMsRUFBRSxLQUFLLElBQUksQ0FBQyxFQUFFO1FBQy9DLE1BQU0sSUFBSSxHQUFHLFVBQVUsQ0FBQyxLQUFLLENBQUMsSUFBSSxFQUFFLFdBQVcsQ0FBQyxDQUFDO1FBRWpELElBQUksSUFBSSxFQUFFO1lBQ04sS0FBSyxDQUFDLElBQUksQ0FBQyxJQUFJLENBQUMsQ0FBQztTQUNwQjtRQUVELElBQUksYUFBYSxFQUFFO1lBQ2YsTUFBTSxVQUFVLEdBQUcsVUFBVSxDQUFDLEtBQUssQ0FBQyxXQUFXLEVBQUUsV0FBVyxDQUFDLENBQUM7WUFFOUQsSUFBSSxVQUFVLEVBQUU7Z0JBQ1osV0FBVyxDQUFDLElBQUksQ0FBQyxVQUFVLENBQUMsQ0FBQzthQUNoQztTQUNKO0tBQ0o7SUFFRCxNQUFNLElBQUksR0FBRyxFQUFFLENBQUM7SUFFaEIsS0FBSyxJQUFJLEtBQUssR0FBRyxDQUFDLEVBQUUsS0FBSyxHQUFHLFNBQVMsRUFBRSxLQUFLLElBQUksQ0FBQyxFQUFFO1FBQy9DLElBQUksQ0FBQyxJQUFJLENBQUMsS0FBSyxDQUFDLEdBQUcsQ0FBQyxhQUFhLENBQUMsSUFBSSxFQUFFLGFBQWEsSUFBSSxLQUFLLEtBQUssQ0FBQyxDQUFDLENBQUMsQ0FBQyxXQUFXLENBQUMsQ0FBQyxDQUFDLEtBQUssQ0FBQyxDQUFDLENBQUM7S0FDaEc7SUFFRCxPQUFPLEtBQUssQ0FBQyxLQUFLLENBQUMsYUFBYSxDQUFDLElBQUksRUFBRSxJQUFJLENBQUMsQ0FBQztBQUNqRCxDQUFDO0FBRUQsTUFBTSxVQUFVLFFBQVEsQ0FDcEIsS0FBa0IsRUFDbEIsUUFBb0MsRUFDcEMsRUFDSSxTQUFTLEdBQUcsQ0FBQyxFQUNiLFNBQVMsR0FBRyxDQUFDLEVBQ2IsYUFBYSxHQUFHLElBQUksRUFDcEIsV0FBVyxNQU1YLEVBQUU7SUFFTixNQUFNLE1BQU0sR0FBRyxLQUFLLENBQUMsRUFBRSxDQUFDLFNBQVMsQ0FBQyxNQUFNLEdBQUcsQ0FBQyxDQUFDO0lBRTdDLE1BQU0sS0FBSyxHQUFHLFdBQVcsQ0FBQyxLQUFLLEVBQUUsU0FBUyxFQUFFLFNBQVMsRUFBRSxhQUFhLEVBQUUsV0FBVyxDQUFDLENBQUM7SUFDbkYsTUFBTSxFQUFFLEdBQUcsS0FBSyxDQUFDLEVBQUUsQ0FBQyxvQkFBb0IsQ0FBQyxLQUFLLENBQUMsQ0FBQyxjQUFjLEVBQUUsQ0FBQztJQUNqRSxNQUFNLFdBQVcsR0FBRyxFQUFFLENBQUMsR0FBRyxDQUFDLE9BQU8sQ0FBQyxNQUFNLENBQUMsQ0FBQztJQUUzQyx5QkFBeUI7SUFDekIsRUFBRSxDQUFDLFlBQVksQ0FBQyxhQUFhLENBQUMsSUFBSSxDQUFDLFdBQVcsQ0FBQyxDQUFDLENBQUM7SUFFakQsUUFBUSxhQUFSLFFBQVEsdUJBQVIsUUFBUSxDQUFHLEVBQUUsQ0FBQyxDQUFDO0FBQ25CLENBQUMiLCJzb3VyY2VzQ29udGVudCI6WyJpbXBvcnQge0VkaXRvclN0YXRlLCBUZXh0U2VsZWN0aW9uLCBUcmFuc2FjdGlvbn0gZnJvbSAncHJvc2VtaXJyb3Itc3RhdGUnO1xuaW1wb3J0IHtGcmFnbWVudCwgTm9kZSBhcyBQcm9zZW1pcnJvck5vZGUsIE5vZGVUeXBlfSBmcm9tICdwcm9zZW1pcnJvci1tb2RlbCc7XG5pbXBvcnQge3RhYmxlTm9kZVR5cGVzfSBmcm9tICdwcm9zZW1pcnJvci10YWJsZXMnO1xuXG5mdW5jdGlvbiBjcmVhdGVDZWxsKFxuICAgIGNlbGxUeXBlOiBOb2RlVHlwZSxcbiAgICBjZWxsQ29udGVudD86IEZyYWdtZW50IHwgUHJvc2VtaXJyb3JOb2RlIHwgQXJyYXk8UHJvc2VtaXJyb3JOb2RlPixcbik6IFByb3NlbWlycm9yTm9kZTxhbnk+IHwgbnVsbCB8IHVuZGVmaW5lZCB7XG4gICAgcmV0dXJuIGNlbGxDb250ZW50ID8gY2VsbFR5cGUuY3JlYXRlQ2hlY2tlZChudWxsLCBjZWxsQ29udGVudCkgOiBjZWxsVHlwZS5jcmVhdGVBbmRGaWxsKCk7XG59XG5cbmZ1bmN0aW9uIGNyZWF0ZVRhYmxlKFxuICAgIHN0YXRlOiBFZGl0b3JTdGF0ZSxcbiAgICByb3dzQ291bnQ6IG51bWJlcixcbiAgICBjb2xzQ291bnQ6IG51bWJlcixcbiAgICB3aXRoSGVhZGVyUm93OiBib29sZWFuLFxuICAgIGNlbGxDb250ZW50PzogRnJhZ21lbnQgfCBQcm9zZW1pcnJvck5vZGUgfCBBcnJheTxQcm9zZW1pcnJvck5vZGU+LFxuKTogUHJvc2VtaXJyb3JOb2RlIHtcbiAgICBjb25zdCB0eXBlcyA9IHRhYmxlTm9kZVR5cGVzKHN0YXRlLnNjaGVtYSk7XG4gICAgY29uc3QgaGVhZGVyQ2VsbHMgPSBbXTtcbiAgICBjb25zdCBjZWxscyA9IFtdO1xuXG4gICAgZm9yIChsZXQgaW5kZXggPSAwOyBpbmRleCA8IGNvbHNDb3VudDsgaW5kZXggKz0gMSkge1xuICAgICAgICBjb25zdCBjZWxsID0gY3JlYXRlQ2VsbCh0eXBlcy5jZWxsLCBjZWxsQ29udGVudCk7XG5cbiAgICAgICAgaWYgKGNlbGwpIHtcbiAgICAgICAgICAgIGNlbGxzLnB1c2goY2VsbCk7XG4gICAgICAgIH1cblxuICAgICAgICBpZiAod2l0aEhlYWRlclJvdykge1xuICAgICAgICAgICAgY29uc3QgaGVhZGVyQ2VsbCA9IGNyZWF0ZUNlbGwodHlwZXMuaGVhZGVyX2NlbGwsIGNlbGxDb250ZW50KTtcblxuICAgICAgICAgICAgaWYgKGhlYWRlckNlbGwpIHtcbiAgICAgICAgICAgICAgICBoZWFkZXJDZWxscy5wdXNoKGhlYWRlckNlbGwpO1xuICAgICAgICAgICAgfVxuICAgICAgICB9XG4gICAgfVxuXG4gICAgY29uc3Qgcm93cyA9IFtdO1xuXG4gICAgZm9yIChsZXQgaW5kZXggPSAwOyBpbmRleCA8IHJvd3NDb3VudDsgaW5kZXggKz0gMSkge1xuICAgICAgICByb3dzLnB1c2godHlwZXMucm93LmNyZWF0ZUNoZWNrZWQobnVsbCwgd2l0aEhlYWRlclJvdyAmJiBpbmRleCA9PT0gMCA/IGhlYWRlckNlbGxzIDogY2VsbHMpKTtcbiAgICB9XG5cbiAgICByZXR1cm4gdHlwZXMudGFibGUuY3JlYXRlQ2hlY2tlZChudWxsLCByb3dzKTtcbn1cblxuZXhwb3J0IGZ1bmN0aW9uIGFkZFRhYmxlKFxuICAgIHN0YXRlOiBFZGl0b3JTdGF0ZSxcbiAgICBkaXNwYXRjaD86ICh0cjogVHJhbnNhY3Rpb24pID0+IHZvaWQsXG4gICAge1xuICAgICAgICByb3dzQ291bnQgPSAzLFxuICAgICAgICBjb2xzQ291bnQgPSAzLFxuICAgICAgICB3aXRoSGVhZGVyUm93ID0gdHJ1ZSxcbiAgICAgICAgY2VsbENvbnRlbnQsXG4gICAgfToge1xuICAgICAgICByb3dzQ291bnQ/OiBudW1iZXI7XG4gICAgICAgIGNvbHNDb3VudD86IG51bWJlcjtcbiAgICAgICAgd2l0aEhlYWRlclJvdz86IGJvb2xlYW47XG4gICAgICAgIGNlbGxDb250ZW50PzogRnJhZ21lbnQgfCBQcm9zZW1pcnJvck5vZGUgfCBBcnJheTxQcm9zZW1pcnJvck5vZGU+O1xuICAgIH0gPSB7fSxcbik6IHZvaWQge1xuICAgIGNvbnN0IG9mZnNldCA9IHN0YXRlLnRyLnNlbGVjdGlvbi5hbmNob3IgKyAxO1xuXG4gICAgY29uc3Qgbm9kZXMgPSBjcmVhdGVUYWJsZShzdGF0ZSwgcm93c0NvdW50LCBjb2xzQ291bnQsIHdpdGhIZWFkZXJSb3csIGNlbGxDb250ZW50KTtcbiAgICBjb25zdCB0ciA9IHN0YXRlLnRyLnJlcGxhY2VTZWxlY3Rpb25XaXRoKG5vZGVzKS5zY3JvbGxJbnRvVmlldygpO1xuICAgIGNvbnN0IHJlc29sdmVkUG9zID0gdHIuZG9jLnJlc29sdmUob2Zmc2V0KTtcblxuICAgIC8vIG1vdmUgY3Vyc29yIGludG8gdGFibGVcbiAgICB0ci5zZXRTZWxlY3Rpb24oVGV4dFNlbGVjdGlvbi5uZWFyKHJlc29sdmVkUG9zKSk7XG5cbiAgICBkaXNwYXRjaD8uKHRyKTtcbn1cbiJdfQ==
+//# sourceMappingURL=data:application/json;base64,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

package/esm2020/lib/utils/text-align-item.mjs

@@ -0,0 +1,81 @@
+import { AllSelection, TextSelection } from 'prosemirror-state';
+import { Item } from './item';
+function setTextAlign(tr, schema, alignment) {
+    console.log('setTextAlign', alignment);
+    const { selection, doc } = tr;
+    if (!selection || !doc) {
+        return tr;
+    }
+    const { from, to } = selection;
+    const { nodes } = schema;
+    const tasks = [];
+    alignment = alignment || null;
+    const allowedNodeTypes = new Set([
+        nodes.paragraph,
+        // nodes['blockquote'],
+        // nodes['listItem'],
+        // nodes['heading'],
+    ]);
+    doc.nodesBetween(from, to, (node, pos) => {
+        const nodeType = node.type;
+        const align = node.attrs.align || null;
+        if (align !== alignment && allowedNodeTypes.has(nodeType)) {
+            tasks.push({
+                node,
+                pos,
+                nodeType,
+            });
+        }
+        return true;
+    });
+    if (!tasks.length) {
+        return tr;
+    }
+    tasks.forEach(job => {
+        const { node, pos, nodeType } = job;
+        const newAttrs = {
+            ...node.attrs,
+            align: alignment ? alignment : null,
+        };
+        console.log('newAttrs', newAttrs);
+        tr = tr.setNodeMarkup(pos, nodeType, newAttrs, node.marks);
+    });
+    return tr;
+}
+export class TextAlignItem extends Item {
+    constructor(alignment) {
+        super({
+            active: state => {
+                const { selection, doc } = state;
+                const { from, to } = selection;
+                let keepLooking = true;
+                let active = false;
+                doc.nodesBetween(from, to, node => {
+                    if (keepLooking && node.attrs.align === alignment) {
+                        keepLooking = false;
+                        active = true;
+                    }
+                    return keepLooking;
+                });
+                return active;
+            },
+            enable: state => {
+                const { selection } = state;
+                return selection instanceof TextSelection || selection instanceof AllSelection;
+            },
+            run: (state, dispatch) => {
+                const { schema, selection } = state;
+                console.log(this);
+                const tr = setTextAlign(state.tr.setSelection(selection), schema, this.active ? null : alignment);
+                if (tr.docChanged) {
+                    dispatch?.(tr);
+                    return true;
+                }
+                else {
+                    return false;
+                }
+            },
+        });
+    }
+}
+//# sourceMappingURL=data:application/json;base64,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