@ecodev/natural-editor 1.1.0

package/esm2015/lib/menu.js

@@ -0,0 +1,220 @@
+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';
+/**
+ * One item of the menu.
+ *
+ * This is the equivalent of `MenuItem` but without all the rendering logic since we use Angular
+ * templates for rendering. Also it caches the state of the item everytime the editor state changes,
+ * so Angular can query the state as often as needed without performance hit.
+ */
+export class Item {
+    constructor(spec) {
+        this.spec = spec;
+        /**
+         * Whether the item is 'active' (for example, the item for toggling the strong mark might be active when the cursor is in strong text).
+         */
+        this.active = false;
+        /**
+         * Button is shown but disabled, because the item cannot be (un-)applied
+         */
+        this.disabled = false;
+        /**
+         * Whether the item is shown at the moment
+         */
+        this.show = true;
+    }
+    /**
+     * Update the item state according to the editor state
+     */
+    update(view, state) {
+        if (this.spec.active) {
+            this.active = this.spec.active(state);
+        }
+        if (this.spec.enable) {
+            this.disabled = !this.spec.enable(state);
+        }
+        if (this.spec.select) {
+            this.show = this.spec.select(state);
+        }
+    }
+}
+/**
+ * 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 insertImageItem(nodeType: NodeType) {
+//     return new MenuItem({
+//         enable(state): boolean {
+//             return canInsert(state, nodeType);
+//         },
+//         run(state, _, view) {
+//             let {from, to} = state.selection,
+//                 attrs = null;
+//             if (state.selection instanceof NodeSelection && state.selection.node.type == nodeType) {
+//                 attrs = state.selection.node.attrs;
+//             }
+//             openPrompt({
+//                 title: 'Insert image',
+//                 fields: {
+//                     src: new TextField({label: 'Location', required: true, value: attrs && attrs.src}),
+//                     title: new TextField({label: 'Title', value: attrs && attrs.title}),
+//                     alt: new TextField({
+//                         label: 'Description',
+//                         value: attrs ? attrs.alt : state.doc.textBetween(from, to, ' '),
+//                     }),
+//                 },
+//                 callback(attrs) {
+//                     view.dispatch(view.state.tr.replaceSelectionWith(nodeType.createAndFill(attrs)));
+//                     view.focus();
+//                 },
+//             });
+//         },
+//     });
+// }
+function cmdItem(cmd, options = {}, useEnable = false) {
+    const passedOptions = Object.assign({ 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 = Object.assign({ 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 && !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.image;
+    if (type) {
+        // r.insertImage = insertImageItem(type);
+    }
+    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, {}));
+    }
+    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()));
+            },
+        });
+    }
+    return r;
+}
+//# sourceMappingURL=data:application/json;base64,{"version":3,"file":"menu.js","sourceRoot":"","sources":["../../../../projects/natural-editor/src/lib/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';\n\n/**\n * One item of the menu.\n *\n * This is the equivalent of `MenuItem` but without all the rendering logic since we use Angular\n * templates for rendering. Also it caches the state of the item everytime the editor state changes,\n * so Angular can query the state as often as needed without performance hit.\n */\nexport class Item {\n    /**\n     * Whether the item is 'active' (for example, the item for toggling the strong mark might be active when the cursor is in strong text).\n     */\n    public active = false;\n\n    /**\n     * Button is shown but disabled, because the item cannot be (un-)applied\n     */\n    public disabled = false;\n\n    /**\n     * Whether the item is shown at the moment\n     */\n    public show = true;\n\n    constructor(public readonly spec: MenuItemSpec) {}\n\n    /**\n     * Update the item state according to the editor state\n     */\n    public update(view: EditorView, state: EditorState): void {\n        if (this.spec.active) {\n            this.active = this.spec.active(state);\n        }\n\n        if (this.spec.enable) {\n            this.disabled = !this.spec.enable(state);\n        }\n\n        if (this.spec.select) {\n            this.show = this.spec.select(state);\n        }\n    }\n}\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\n// function insertImageItem(nodeType: NodeType) {\n//     return new MenuItem({\n//         enable(state): boolean {\n//             return canInsert(state, nodeType);\n//         },\n//         run(state, _, view) {\n//             let {from, to} = state.selection,\n//                 attrs = null;\n//             if (state.selection instanceof NodeSelection && state.selection.node.type == nodeType) {\n//                 attrs = state.selection.node.attrs;\n//             }\n//             openPrompt({\n//                 title: 'Insert image',\n//                 fields: {\n//                     src: new TextField({label: 'Location', required: true, value: attrs && attrs.src}),\n//                     title: new TextField({label: 'Title', value: attrs && attrs.title}),\n//                     alt: new TextField({\n//                         label: 'Description',\n//                         value: attrs ? attrs.alt : state.doc.textBetween(from, to, ' '),\n//                     }),\n//                 },\n//                 callback(attrs) {\n//                     view.dispatch(view.state.tr.replaceSelectionWith(nodeType.createAndFill(attrs)));\n//                     view.focus();\n//                 },\n//             });\n//         },\n//     });\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 && !result.title) {\n                        delete result.title;\n                    }\n\n                    toggleMark(markType, result)(view.state, view.dispatch);\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    | 'insertImage'\n    | 'wrapBulletList'\n    | 'wrapOrderedList'\n    | 'wrapBlockQuote'\n    | 'makeParagraph'\n    | 'makeCodeBlock'\n    | 'makeHead1'\n    | 'makeHead2'\n    | 'makeHead3'\n    | 'makeHead4'\n    | 'makeHead5'\n    | 'makeHead6'\n    | 'insertHorizontalRule'\n    | 'joinUp'\n    | 'lift'\n    | 'selectParentNode'\n    | 'undo'\n    | 'redo';\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.image;\n    if (type) {\n        // r.insertImage = insertImageItem(type);\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\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    return r;\n}\n"]}

package/esm2015/lib/schema.js

@@ -0,0 +1,21 @@
+import { marks, nodes } from 'prosemirror-schema-basic';
+import { addListNodes } from 'prosemirror-schema-list';
+import { Schema } from 'prosemirror-model';
+const myNodes = {
+    heading: nodes.heading,
+    doc: nodes.doc,
+    paragraph: nodes.paragraph,
+    text: nodes.text,
+    hard_break: nodes.hard_break,
+};
+const myMarks = {
+    link: marks.link,
+    em: marks.em,
+    strong: marks.strong,
+};
+const basicSchema = new Schema({ nodes: myNodes, marks: myMarks });
+export const schema = new Schema({
+    nodes: addListNodes(basicSchema.spec.nodes, 'paragraph block*', 'block'),
+    marks: basicSchema.spec.marks,
+});
+//# sourceMappingURL=data:application/json;base64,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

package/esm2015/public-api.js

@@ -0,0 +1,8 @@
+// Load `$localize` onto the global scope - to be able to use that function to translate strings in components/services.
+import '@angular/localize/init';
+/*
+ * Public API Surface of natural-editor
+ */
+export { NaturalEditorComponent } from './lib/editor.component';
+export { NaturalEditorModule } from './lib/editor.module';
+//# sourceMappingURL=data:application/json;base64,eyJ2ZXJzaW9uIjozLCJmaWxlIjoicHVibGljLWFwaS5qcyIsInNvdXJjZVJvb3QiOiIiLCJzb3VyY2VzIjpbIi4uLy4uLy4uL3Byb2plY3RzL25hdHVyYWwtZWRpdG9yL3NyYy9wdWJsaWMtYXBpLnRzIl0sIm5hbWVzIjpbXSwibWFwcGluZ3MiOiJBQUFBLHdIQUF3SDtBQUN4SCxPQUFPLHdCQUF3QixDQUFDO0FBR2hDOztHQUVHO0FBRUgsT0FBTyxFQUFDLHNCQUFzQixFQUFDLE1BQU0sd0JBQXdCLENBQUM7QUFDOUQsT0FBTyxFQUFDLG1CQUFtQixFQUFDLE1BQU0scUJBQXFCLENBQUMiLCJzb3VyY2VzQ29udGVudCI6WyIvLyBMb2FkIGAkbG9jYWxpemVgIG9udG8gdGhlIGdsb2JhbCBzY29wZSAtIHRvIGJlIGFibGUgdG8gdXNlIHRoYXQgZnVuY3Rpb24gdG8gdHJhbnNsYXRlIHN0cmluZ3MgaW4gY29tcG9uZW50cy9zZXJ2aWNlcy5cbmltcG9ydCAnQGFuZ3VsYXIvbG9jYWxpemUvaW5pdCc7XG5pbXBvcnQge05hdHVyYWxFZGl0b3JDb21wb25lbnR9IGZyb20gJy4vbGliL2VkaXRvci5jb21wb25lbnQnO1xuXG4vKlxuICogUHVibGljIEFQSSBTdXJmYWNlIG9mIG5hdHVyYWwtZWRpdG9yXG4gKi9cblxuZXhwb3J0IHtOYXR1cmFsRWRpdG9yQ29tcG9uZW50fSBmcm9tICcuL2xpYi9lZGl0b3IuY29tcG9uZW50JztcbmV4cG9ydCB7TmF0dXJhbEVkaXRvck1vZHVsZX0gZnJvbSAnLi9saWIvZWRpdG9yLm1vZHVsZSc7XG4iXX0=