@progress/kendo-editor-common 1.6.1-dev.202112152003 → 1.7.0-dev.202201030643

package/dist/npm/config/schema.js

@@ -1,11 +1,14 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 var tslib_1 = require("tslib");
+var prosemirror_model_1 = require("prosemirror-model");
 var prosemirror_tables_1 = require("prosemirror-tables");
+var source_1 = require("../source");
+var constants_1 = require("./constants");
 var hole = 0;
 var blockquoteDOM = ['blockquote', hole], hrDOM = ['hr'], preDOM = ['pre', ['code', hole]];
 var olDOM = ['ol', 0], ulDOM = ['ul', 0], liDOM = ['li', 0];
-var getAttributes = function (dom) {
+var domAttributes = function (dom) {
     var result = {};
     var attributes = dom.attributes, attr;
     for (var i = 0; i < attributes.length; i++) {
@@ -14,13 +17,14 @@ var getAttributes = function (dom) {
     }
     return result;
 };
-var commonAttributes = function () {
-    return {
-        style: { default: null },
-        class: { default: null },
-        id: { default: null }
-    };
+var defaultAttrs = function (attrs) {
+    var nodeAttrs = {};
+    attrs.forEach(function (attr) {
+        nodeAttrs[attr] = { default: null };
+    });
+    return nodeAttrs;
 };
+var commonAttributes = function () { return defaultAttrs(['style', 'class', 'id']); };
 var hasAttrs = function (attrs, exclude) {
     for (var attr in attrs) {
         if (attr && attrs[attr] !== null && attr !== exclude) {
@@ -29,7 +33,7 @@ var hasAttrs = function (attrs, exclude) {
     }
     return false;
 };
-var getAttrs = function (attrs, exclude) {
+var pmAttributes = function (attrs, exclude) {
     var result = {};
     for (var attr in attrs) {
         if (attr && attrs[attr] !== null && attr !== exclude) {
@@ -56,18 +60,92 @@ var marks = tslib_1.__assign({
     link: {
         attrs: tslib_1.__assign({}, commonAttributes(), { href: { default: null }, target: { default: null }, title: { default: null } }),
         inclusive: false,
-        parseDOM: [{ tag: 'a', getAttrs: getAttributes }],
-        toDOM: function (node) { return ['a', getAttrs(node.attrs), hole]; }
+        parseDOM: [{ tag: 'a', getAttrs: domAttributes }],
+        toDOM: function (node) { return ['a', pmAttributes(node.attrs), hole]; }
     } }, tagMark('strong'), tagMark('b'), tagMark('em'), tagMark('i'), tagMark('u'), tagMark('del'), tagMark('sub'), tagMark('sup'), tagMark('code'), { style: {
         attrs: tslib_1.__assign({}, commonAttributes()),
         parseDOM: [{
                 tag: 'span',
-                getAttrs: getAttributes
+                getAttrs: domAttributes
             }],
         toDOM: function (node) { return hasAttrs(node.attrs) ?
-            ['span', getAttrs(node.attrs), hole] : ['span', hole]; }
+            ['span', pmAttributes(node.attrs), hole] : ['span', hole]; }
     } });
 exports.marks = marks;
+var cellAttribute = function (name) {
+    var _a;
+    return _a = {},
+        _a[name] = {
+            default: null,
+            getFromDOM: function (cell) { return cell.getAttribute(name); },
+            setDOMAttr: function (value, attrs) { attrs[name] = value; }
+        },
+        _a;
+};
+var cellAttributes = tslib_1.__assign({}, cellAttribute('style'), cellAttribute('class'), cellAttribute('id'), cellAttribute('headers'));
+var colgroupNodes = {
+    doc: { content: 'colgroup*' },
+    col: {
+        attrs: defaultAttrs(['id', 'class', 'style', 'span']),
+        parseDOM: [{ getAttrs: domAttributes, tag: 'col' }],
+        toDOM: function (node) { return ['col', node.attrs]; }
+    },
+    colgroup: {
+        attrs: defaultAttrs(['id', 'class', 'style', 'span']),
+        content: 'col*',
+        parseDOM: [{ getAttrs: domAttributes, tag: 'colgroup' }],
+        toDOM: function (node) { return ['colgroup', node.attrs, 0]; }
+    },
+    text: { inline: true, group: 'inline' }
+};
+var colgroupSchema = new prosemirror_model_1.Schema({ nodes: colgroupNodes, marks: {} });
+// will be removed when we implement our own columnResizing
+var shouldSkipColgroup = function (node) {
+    var shouldSkip = false;
+    var row = node.child(0);
+    for (var r = 0; r < row.childCount; r++) {
+        var cell = row.child(r);
+        if (cell.attrs.colwidth) {
+            shouldSkip = true;
+            break;
+        }
+    }
+    return shouldSkip;
+};
+var tNodes = prosemirror_tables_1.tableNodes({ tableGroup: 'block', cellContent: 'block+', cellAttributes: cellAttributes });
+tNodes.table_row.attrs = tslib_1.__assign({}, tNodes.table_row.attrs, defaultAttrs([constants_1.rowTypeAttr, 'style', 'class', 'id']));
+tNodes.table_row.toDOM = function (node) { return ['tr', pmAttributes(node.attrs), 0]; };
+tNodes.table_row.parseDOM = [{ tag: 'tr', getAttrs: domAttributes }];
+tNodes.table.attrs = tslib_1.__assign({}, tNodes.table.attrs, defaultAttrs(['style', 'class', 'id', constants_1.colgroupAttr]));
+tNodes.table.toDOM = function (node) {
+    var tableAttrs = hasAttrs(node.attrs) ? pmAttributes(node.attrs, constants_1.colgroupAttr) : {};
+    var colgroup = null;
+    if (node.attrs[constants_1.colgroupAttr] && !shouldSkipColgroup(node)) {
+        var doc = source_1.domToPmDoc(source_1.htmlToFragment(node.attrs[constants_1.colgroupAttr]), colgroupSchema, { preserveWhitespace: false });
+        var fragment = source_1.pmDocToFragment(doc);
+        var colgroupEl = fragment.firstChild;
+        if (colgroupEl) {
+            var cols = Array.from(colgroupEl.children).map(function (c) { return ['col', domAttributes(c)]; });
+            colgroup = [
+                'colgroup',
+                domAttributes(colgroupEl)
+            ].concat(cols);
+        }
+    }
+    return colgroup ? ['table', tableAttrs, colgroup, ['tbody', 0]] :
+        ['table', tableAttrs, ['tbody', 0]];
+};
+tNodes.table.parseDOM = [{
+        tag: 'table',
+        getAttrs: function (node) {
+            var attrs = domAttributes(node);
+            var colgroup = Array.from(node.childNodes).find(function (c) { return c.nodeName === 'COLGROUP'; });
+            if (colgroup) {
+                attrs[constants_1.colgroupAttr] = colgroup.outerHTML;
+            }
+            return attrs;
+        }
+    }];
 var nodes = tslib_1.__assign({ 
     // :: NodeSpec The top level document node.
     doc: {
@@ -81,9 +159,9 @@ var nodes = tslib_1.__assign({
         attrs: tslib_1.__assign({}, commonAttributes()),
         parseDOM: [{
                 tag: 'p',
-                getAttrs: getAttributes
+                getAttrs: domAttributes
             }],
-        toDOM: function (node) { return hasAttrs(node.attrs) ? ['p', getAttrs(node.attrs), hole] : ['p', hole]; }
+        toDOM: function (node) { return hasAttrs(node.attrs) ? ['p', pmAttributes(node.attrs), hole] : ['p', hole]; }
     }, div: {
         // Uncaught SyntaxError: Mixing inline and block content (in content expression '(block | inline)*')
         // content: '(block | inline)*',
@@ -92,9 +170,9 @@ var nodes = tslib_1.__assign({
         attrs: tslib_1.__assign({}, commonAttributes()),
         parseDOM: [{
                 tag: 'div',
-                getAttrs: getAttributes
+                getAttrs: domAttributes
             }],
-        toDOM: function (node) { return hasAttrs(node.attrs) ? ['div', getAttrs(node.attrs), hole] : ['div', hole]; }
+        toDOM: function (node) { return hasAttrs(node.attrs) ? ['div', pmAttributes(node.attrs), hole] : ['div', hole]; }
     }, 
     // :: NodeSpec A blockquote (`<blockquote>`) wrapping one or more blocks.
     blockquote: {
@@ -104,9 +182,9 @@ var nodes = tslib_1.__assign({
         defining: true,
         parseDOM: [{
                 tag: 'blockquote',
-                getAttrs: getAttributes
+                getAttrs: domAttributes
             }],
-        toDOM: function (node) { return hasAttrs(node.attrs) ? ['blockquote', getAttrs(node.attrs), hole] : blockquoteDOM; }
+        toDOM: function (node) { return hasAttrs(node.attrs) ? ['blockquote', pmAttributes(node.attrs), hole] : blockquoteDOM; }
     }, 
     // :: NodeSpec A horizontal rule (`<hr>`).
     horizontal_rule: {
@@ -123,15 +201,15 @@ var nodes = tslib_1.__assign({
         group: 'block',
         defining: true,
         parseDOM: [
-            { tag: 'h1', getAttrs: function (node) { return (tslib_1.__assign({}, getAttributes(node), { level: 1 })); } },
-            { tag: 'h2', getAttrs: function (node) { return (tslib_1.__assign({}, getAttributes(node), { level: 2 })); } },
-            { tag: 'h3', getAttrs: function (node) { return (tslib_1.__assign({}, getAttributes(node), { level: 3 })); } },
-            { tag: 'h4', getAttrs: function (node) { return (tslib_1.__assign({}, getAttributes(node), { level: 4 })); } },
-            { tag: 'h5', getAttrs: function (node) { return (tslib_1.__assign({}, getAttributes(node), { level: 5 })); } },
-            { tag: 'h6', getAttrs: function (node) { return (tslib_1.__assign({}, getAttributes(node), { level: 6 })); } }
+            { tag: 'h1', getAttrs: function (node) { return (tslib_1.__assign({}, domAttributes(node), { level: 1 })); } },
+            { tag: 'h2', getAttrs: function (node) { return (tslib_1.__assign({}, domAttributes(node), { level: 2 })); } },
+            { tag: 'h3', getAttrs: function (node) { return (tslib_1.__assign({}, domAttributes(node), { level: 3 })); } },
+            { tag: 'h4', getAttrs: function (node) { return (tslib_1.__assign({}, domAttributes(node), { level: 4 })); } },
+            { tag: 'h5', getAttrs: function (node) { return (tslib_1.__assign({}, domAttributes(node), { level: 5 })); } },
+            { tag: 'h6', getAttrs: function (node) { return (tslib_1.__assign({}, domAttributes(node), { level: 6 })); } }
         ],
         toDOM: function (node) { return hasAttrs(node.attrs, 'level') ?
-            ['h' + node.attrs.level, getAttrs(node.attrs, 'level'), hole] :
+            ['h' + node.attrs.level, pmAttributes(node.attrs, 'level'), hole] :
             ['h' + node.attrs.level, hole]; }
     }, 
     // :: NodeSpec A code listing. Disallows marks or non-text inline
@@ -159,8 +237,8 @@ var nodes = tslib_1.__assign({
         attrs: tslib_1.__assign({ src: { default: null }, alt: { default: null }, title: { default: null }, width: { default: null }, height: { default: null } }, commonAttributes()),
         group: 'inline',
         draggable: true,
-        parseDOM: [{ tag: 'img', getAttrs: getAttributes }],
-        toDOM: function (node) { return hasAttrs(node.attrs) ? ['img', getAttrs(node.attrs)] : ['img']; }
+        parseDOM: [{ tag: 'img', getAttrs: domAttributes }],
+        toDOM: function (node) { return hasAttrs(node.attrs) ? ['img', pmAttributes(node.attrs)] : ['img']; }
     }, 
     // :: NodeSpec A hard line break represented in the DOM as a `<br>` element.
     hard_break: {
@@ -170,9 +248,9 @@ var nodes = tslib_1.__assign({
         selectable: false,
         parseDOM: [{
                 tag: 'br',
-                getAttrs: getAttributes
+                getAttrs: domAttributes
             }],
-        toDOM: function (node) { return hasAttrs(node.attrs) ? ['br', getAttrs(node.attrs)] : ['br']; }
+        toDOM: function (node) { return hasAttrs(node.attrs) ? ['br', pmAttributes(node.attrs)] : ['br']; }
     }, 
     // :: NodeSpec
     // An ordered list [node spec](#model.NodeSpec). Has a single
@@ -184,12 +262,12 @@ var nodes = tslib_1.__assign({
         group: 'block',
         attrs: tslib_1.__assign({}, commonAttributes(), { type: { default: null }, order: { default: 1 } }),
         parseDOM: [{ tag: 'ol', getAttrs: function (dom) {
-                    return tslib_1.__assign({}, getAttributes(dom), { order: dom.hasAttribute('start') ? parseInt(dom.getAttribute('start') || '1', 10) : 1 });
+                    return tslib_1.__assign({}, domAttributes(dom), { order: dom.hasAttribute('start') ? parseInt(dom.getAttribute('start') || '1', 10) : 1 });
                 } }],
         toDOM: function (node) {
             return node.attrs.order === 1 ?
-                (hasAttrs(node.attrs, 'order') ? ['ol', getAttrs(node.attrs, 'order'), hole] : olDOM) :
-                ['ol', tslib_1.__assign({}, getAttrs(node.attrs, 'order'), { start: node.attrs.order }), hole];
+                (hasAttrs(node.attrs, 'order') ? ['ol', pmAttributes(node.attrs, 'order'), hole] : olDOM) :
+                ['ol', tslib_1.__assign({}, pmAttributes(node.attrs, 'order'), { start: node.attrs.order }), hole];
         }
     }, 
     // :: NodeSpec
@@ -198,16 +276,16 @@ var nodes = tslib_1.__assign({
         content: 'list_item+',
         group: 'block',
         attrs: tslib_1.__assign({}, commonAttributes()),
-        parseDOM: [{ tag: 'ul', getAttrs: getAttributes }],
-        toDOM: function (node) { return hasAttrs(node.attrs) ? ['ul', getAttrs(node.attrs), hole] : ulDOM; }
+        parseDOM: [{ tag: 'ul', getAttrs: domAttributes }],
+        toDOM: function (node) { return hasAttrs(node.attrs) ? ['ul', pmAttributes(node.attrs), hole] : ulDOM; }
     }, 
     // :: NodeSpec
     // A list item (`<li>`) specification.
     list_item: {
         content: '(paragraph | heading) block*',
         attrs: tslib_1.__assign({}, commonAttributes()),
-        parseDOM: [{ tag: 'li', getAttrs: getAttributes }],
-        toDOM: function (node) { return hasAttrs(node.attrs) ? ['li', getAttrs(node.attrs), hole] : liDOM; },
+        parseDOM: [{ tag: 'li', getAttrs: domAttributes }],
+        toDOM: function (node) { return hasAttrs(node.attrs) ? ['li', pmAttributes(node.attrs), hole] : liDOM; },
         defining: true
-    } }, prosemirror_tables_1.tableNodes({ tableGroup: 'block', cellContent: 'block+', cellAttributes: {} }));
+    } }, tNodes);
 exports.nodes = nodes;

package/dist/npm/main.d.ts

@@ -20,7 +20,6 @@ export { buildKeymap, buildListKeymap } from './config/keymap';
 export { bold, italic, underline, strikethrough, subscript, superscript, link } from './config/commands';
 export { sanitize, removeComments, removeTag, pasteCleanup, sanitizeClassAttr, sanitizeStyleAttr, removeAttribute, replaceImageSourcesFromRtf } from './paste';
 export { convertMsLists } from './listConvert';
-export { createTable } from './table';
 export { find, findAt, findAll, replace, replaceAll, SearchOptions } from './find-replace';
 export { placeholder } from './plugins/placeholder';
 export { spacesFix } from './plugins/spaces-fix';
@@ -38,3 +37,4 @@ export * from 'prosemirror-state';
 export * from 'prosemirror-tables';
 export * from 'prosemirror-transform';
 export * from 'prosemirror-view';
+export { createTable, addRowAfter, addRowBefore, pmAddRowAfter, pmAddRowBefore } from './table';

package/dist/npm/main.js

@@ -100,8 +100,6 @@ exports.removeAttribute = paste_1.removeAttribute;
 exports.replaceImageSourcesFromRtf = paste_1.replaceImageSourcesFromRtf;
 var listConvert_1 = require("./listConvert");
 exports.convertMsLists = listConvert_1.convertMsLists;
-var table_1 = require("./table");
-exports.createTable = table_1.createTable;
 var find_replace_1 = require("./find-replace");
 exports.find = find_replace_1.find;
 exports.findAt = find_replace_1.findAt;
@@ -131,3 +129,9 @@ tslib_1.__exportStar(require("prosemirror-state"), exports);
 tslib_1.__exportStar(require("prosemirror-tables"), exports);
 tslib_1.__exportStar(require("prosemirror-transform"), exports);
 tslib_1.__exportStar(require("prosemirror-view"), exports);
+var table_1 = require("./table");
+exports.createTable = table_1.createTable;
+exports.addRowAfter = table_1.addRowAfter;
+exports.addRowBefore = table_1.addRowBefore;
+exports.pmAddRowAfter = table_1.pmAddRowAfter;
+exports.pmAddRowBefore = table_1.pmAddRowBefore;

package/dist/npm/source.js

@@ -2,10 +2,59 @@
 Object.defineProperty(exports, "__esModule", { value: true });
 var prosemirror_model_1 = require("prosemirror-model");
 var prosemirror_state_1 = require("prosemirror-state");
+var constants_1 = require("./config/constants");
 var blockWrappers = [
     'div', 'ol', 'ul', 'li', 'table', 'tbody', 'thead', 'tfoot', 'td', 'th', 'p',
     'tr', 'col', 'colgroup', 'article', 'main', 'nav', 'header', 'footer', 'aside', 'section'
 ];
+var removeRowType = function (table, nodeName) {
+    var wrapper = (table.ownerDocument || document).createElement(nodeName);
+    Array.from(table.rows).filter(function (r) { return r.getAttribute(constants_1.rowTypeAttr) === nodeName; }).forEach(function (row) {
+        row.removeAttribute(constants_1.rowTypeAttr);
+        wrapper.appendChild(row);
+    });
+    if (wrapper.children.length) {
+        table.appendChild(wrapper);
+    }
+};
+var restoreTables = function (fragment) {
+    Array.from(fragment.querySelectorAll('table')).forEach(function (table) {
+        removeRowType(table, 'thead');
+        removeRowType(table, 'tbody');
+        removeRowType(table, 'tfoot');
+        var emptyElement = Array.from(table.children).find(function (el) { return el.children.length === 0; });
+        if (emptyElement) {
+            emptyElement.remove();
+        }
+    });
+};
+var setRowType = function (children, nodeName) {
+    var tag = nodeName.toUpperCase();
+    children.filter(function (c) { return c.nodeName === tag; }).forEach(function (rowsWrapper) {
+        Array.from(rowsWrapper.children).forEach(function (row) {
+            row.setAttribute(constants_1.rowTypeAttr, nodeName);
+            if (rowsWrapper.parentNode) {
+                rowsWrapper.parentNode.insertBefore(row, rowsWrapper);
+            }
+        });
+        rowsWrapper.remove();
+    });
+};
+var validateTablesToPmSchema = function (fragment) {
+    Array.from(fragment.querySelectorAll('table')).forEach(function (table) {
+        var children = Array.from(table.children);
+        if (children.some(function (e) { return e.nodeName === 'THEAD' || e.nodeName === 'TFOOT'; })) {
+            setRowType(children, 'thead');
+            setRowType(children, 'tbody');
+            setRowType(children, 'tfoot');
+        }
+        var colgroup = children.find(function (c) { return c.nodeName === 'COLGROUP'; });
+        if (colgroup) {
+            table.setAttribute(constants_1.colgroupAttr, colgroup.outerHTML);
+            colgroup.remove();
+        }
+    });
+};
 /**
  * Trims the whitespace around the provided block nodes.
  *
@@ -54,7 +103,9 @@ exports.htmlToFragment = function (html) {
  * @returns DocumentFragment
  */
 exports.pmDocToFragment = function (doc) {
-    return prosemirror_model_1.DOMSerializer.fromSchema(doc.type.schema).serializeFragment(doc.content);
+    var fragment = prosemirror_model_1.DOMSerializer.fromSchema(doc.type.schema).serializeFragment(doc.content);
+    restoreTables(fragment);
+    return fragment;
 };
 /**
  * Creates a ProseMirrorNode from the given DOM element.
@@ -77,6 +128,7 @@ exports.domToPmDoc = function (dom, schema, parseOptions) {
  */
 exports.parseContent = function (content, schema, parseOptions) {
     var dom = exports.htmlToFragment(content);
+    validateTablesToPmSchema(dom);
     return exports.domToPmDoc(dom, schema, parseOptions);
 };
 /**

package/dist/npm/table.d.ts

@@ -1,4 +1,6 @@
 import { Node, NodeType } from 'prosemirror-model';
+import { EditorState, Transaction } from 'prosemirror-state';
+import { addRowAfter as pmAddRowAfter, addRowBefore as pmAddRowBefore } from 'prosemirror-tables';
 /**
  * Creates a table.
  * @returns Node
@@ -8,3 +10,6 @@ export declare const createTable: (nodes: {
     table_row: NodeType<any>;
     table_cell: NodeType<any>;
 }, rows: number, columns: number) => Node<any>;
+export declare const addRowBefore: (state: EditorState<any>, dispatch?: (tr: Transaction<any>) => void) => boolean;
+export declare const addRowAfter: (state: EditorState<any>, dispatch?: (tr: Transaction<any>) => void) => boolean;
+export { pmAddRowBefore, pmAddRowAfter };

package/dist/npm/table.js

@@ -1,5 +1,9 @@
 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
+var prosemirror_tables_1 = require("prosemirror-tables");
+exports.pmAddRowAfter = prosemirror_tables_1.addRowAfter;
+exports.pmAddRowBefore = prosemirror_tables_1.addRowBefore;
+var constants_1 = require("./config/constants");
 /**
  * Creates a table.
  * @returns Node
@@ -17,3 +21,49 @@ exports.createTable = function (nodes, rows, columns) {
     }
     return table.createAndFill(undefined, tableRows);
 };
+var closest = function (selection, name) {
+    var pos = selection.$head;
+    for (var i = pos.depth; i > 0; i--) {
+        var node = pos.node(i);
+        if (node.type.name === name) {
+            return {
+                pos: pos.before(i),
+                node: node
+            };
+        }
+    }
+    return null;
+};
+exports.addRowBefore = function (state, dispatch) {
+    var cmdDispatch = dispatch && (function (tr) {
+        var _a;
+        var row = closest(tr.selection, 'table_row');
+        var table = closest(tr.selection, 'table');
+        if (row && table && row.node.attrs[constants_1.rowTypeAttr]) {
+            var index = 0;
+            for (var i = 0; i < table.node.nodeSize; i++) {
+                if (table.node.child(i).eq(row.node)) {
+                    index = i;
+                    break;
+                }
+            }
+            var next = table.node.child(index - 1);
+            var from = row.pos - next.nodeSize;
+            tr.setNodeMarkup(from, undefined, (_a = {}, _a[constants_1.rowTypeAttr] = row.node.attrs[constants_1.rowTypeAttr], _a));
+        }
+        return dispatch(tr);
+    });
+    return prosemirror_tables_1.addRowBefore(state, cmdDispatch);
+};
+exports.addRowAfter = function (state, dispatch) {
+    var cmdDispatch = dispatch && (function (tr) {
+        var _a;
+        var row = closest(tr.selection, 'table_row');
+        if (row && row.node.attrs[constants_1.rowTypeAttr]) {
+            var from = row.pos + row.node.nodeSize;
+            tr.setNodeMarkup(from, undefined, (_a = {}, _a[constants_1.rowTypeAttr] = row.node.attrs[constants_1.rowTypeAttr], _a));
+        }
+        return dispatch(tr);
+    });
+    return prosemirror_tables_1.addRowAfter(state, cmdDispatch);
+};