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

package/dist/es/source.js

@@ -1,9 +1,58 @@
 import { DOMSerializer, DOMParser as ProseMirrorDOMParser } from 'prosemirror-model';
 import { AllSelection } from 'prosemirror-state';
+import { rowTypeAttr, colgroupAttr } from './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(rowTypeAttr) === nodeName; }).forEach(function (row) {
+        row.removeAttribute(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(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(colgroupAttr, colgroup.outerHTML);
+            colgroup.remove();
+        }
+    });
+};
 /**
  * Trims the whitespace around the provided block nodes.
  *
@@ -52,7 +101,9 @@ export var htmlToFragment = function (html) {
  * @returns DocumentFragment
  */
 export var pmDocToFragment = function (doc) {
-    return DOMSerializer.fromSchema(doc.type.schema).serializeFragment(doc.content);
+    var fragment = DOMSerializer.fromSchema(doc.type.schema).serializeFragment(doc.content);
+    restoreTables(fragment);
+    return fragment;
 };
 /**
  * Creates a ProseMirrorNode from the given DOM element.
@@ -75,6 +126,7 @@ export var domToPmDoc = function (dom, schema, parseOptions) {
  */
 export var parseContent = function (content, schema, parseOptions) {
     var dom = htmlToFragment(content);
+    validateTablesToPmSchema(dom);
     return domToPmDoc(dom, schema, parseOptions);
 };
 /**

package/dist/es/table.js

@@ -1,3 +1,5 @@
+import { addRowAfter as pmAddRowAfter, addRowBefore as pmAddRowBefore } from 'prosemirror-tables';
+import { rowTypeAttr } from './config/constants';
 /**
  * Creates a table.
  * @returns Node
@@ -15,3 +17,50 @@ export var 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;
+};
+export var 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[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[rowTypeAttr] = row.node.attrs[rowTypeAttr], _a));
+        }
+        return dispatch(tr);
+    });
+    return pmAddRowBefore(state, cmdDispatch);
+};
+export var addRowAfter = function (state, dispatch) {
+    var cmdDispatch = dispatch && (function (tr) {
+        var _a;
+        var row = closest(tr.selection, 'table_row');
+        if (row && row.node.attrs[rowTypeAttr]) {
+            var from = row.pos + row.node.nodeSize;
+            tr.setNodeMarkup(from, undefined, (_a = {}, _a[rowTypeAttr] = row.node.attrs[rowTypeAttr], _a));
+        }
+        return dispatch(tr);
+    });
+    return pmAddRowAfter(state, cmdDispatch);
+};
+export { pmAddRowBefore, pmAddRowAfter };

package/dist/es2015/config/constants.js

@@ -0,0 +1,2 @@
+export const rowTypeAttr = 'k-parent-node';
+export const colgroupAttr = 'k-colgroup-data';

package/dist/es2015/config/schema.js

@@ -1,8 +1,11 @@
+import { Schema } from 'prosemirror-model';
 import { tableNodes } from 'prosemirror-tables';
+import { domToPmDoc, htmlToFragment, pmDocToFragment } from '../source';
+import { rowTypeAttr, colgroupAttr } from './constants';
 const hole = 0;
 const blockquoteDOM = ['blockquote', hole], hrDOM = ['hr'], preDOM = ['pre', ['code', hole]];
 const olDOM = ['ol', 0], ulDOM = ['ul', 0], liDOM = ['li', 0];
-const getAttributes = (dom) => {
+const domAttributes = (dom) => {
     const result = {};
     let attributes = dom.attributes, attr;
     for (let i = 0; i < attributes.length; i++) {
@@ -11,13 +14,14 @@ const getAttributes = (dom) => {
     }
     return result;
 };
-const commonAttributes = () => {
-    return {
-        style: { default: null },
-        class: { default: null },
-        id: { default: null }
-    };
+const defaultAttrs = (attrs) => {
+    const nodeAttrs = {};
+    attrs.forEach(attr => {
+        nodeAttrs[attr] = { default: null };
+    });
+    return nodeAttrs;
 };
+const commonAttributes = () => defaultAttrs(['style', 'class', 'id']);
 const hasAttrs = (attrs, exclude) => {
     for (let attr in attrs) {
         if (attr && attrs[attr] !== null && attr !== exclude) {
@@ -26,7 +30,7 @@ const hasAttrs = (attrs, exclude) => {
     }
     return false;
 };
-const getAttrs = (attrs, exclude) => {
+const pmAttributes = (attrs, exclude) => {
     const result = {};
     for (let attr in attrs) {
         if (attr && attrs[attr] !== null && attr !== exclude) {
@@ -52,17 +56,91 @@ const marks = Object.assign({
     link: {
         attrs: Object.assign({}, commonAttributes(), { href: { default: null }, target: { default: null }, title: { default: null } }),
         inclusive: false,
-        parseDOM: [{ tag: 'a', getAttrs: getAttributes }],
-        toDOM: (node) => ['a', getAttrs(node.attrs), hole]
+        parseDOM: [{ tag: 'a', getAttrs: domAttributes }],
+        toDOM: (node) => ['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: Object.assign({}, commonAttributes()),
         parseDOM: [{
                 tag: 'span',
-                getAttrs: getAttributes
+                getAttrs: domAttributes
             }],
         toDOM: node => hasAttrs(node.attrs) ?
-            ['span', getAttrs(node.attrs), hole] : ['span', hole]
+            ['span', pmAttributes(node.attrs), hole] : ['span', hole]
     } });
+const cellAttribute = (name) => {
+    return {
+        [name]: {
+            default: null,
+            getFromDOM: (cell) => cell.getAttribute(name),
+            setDOMAttr: (value, attrs) => { attrs[name] = value; }
+        }
+    };
+};
+const cellAttributes = Object.assign({}, cellAttribute('style'), cellAttribute('class'), cellAttribute('id'), cellAttribute('headers'));
+const colgroupNodes = {
+    doc: { content: 'colgroup*' },
+    col: {
+        attrs: defaultAttrs(['id', 'class', 'style', 'span']),
+        parseDOM: [{ getAttrs: domAttributes, tag: 'col' }],
+        toDOM: node => ['col', node.attrs]
+    },
+    colgroup: {
+        attrs: defaultAttrs(['id', 'class', 'style', 'span']),
+        content: 'col*',
+        parseDOM: [{ getAttrs: domAttributes, tag: 'colgroup' }],
+        toDOM: node => ['colgroup', node.attrs, 0]
+    },
+    text: { inline: true, group: 'inline' }
+};
+const colgroupSchema = new Schema({ nodes: colgroupNodes, marks: {} });
+// will be removed when we implement our own columnResizing
+const shouldSkipColgroup = (node) => {
+    let shouldSkip = false;
+    const row = node.child(0);
+    for (let r = 0; r < row.childCount; r++) {
+        const cell = row.child(r);
+        if (cell.attrs.colwidth) {
+            shouldSkip = true;
+            break;
+        }
+    }
+    return shouldSkip;
+};
+const tNodes = tableNodes({ tableGroup: 'block', cellContent: 'block+', cellAttributes });
+tNodes.table_row.attrs = Object.assign({}, tNodes.table_row.attrs, defaultAttrs([rowTypeAttr, 'style', 'class', 'id']));
+tNodes.table_row.toDOM = node => ['tr', pmAttributes(node.attrs), 0];
+tNodes.table_row.parseDOM = [{ tag: 'tr', getAttrs: domAttributes }];
+tNodes.table.attrs = Object.assign({}, tNodes.table.attrs, defaultAttrs(['style', 'class', 'id', colgroupAttr]));
+tNodes.table.toDOM = (node) => {
+    const tableAttrs = hasAttrs(node.attrs) ? pmAttributes(node.attrs, colgroupAttr) : {};
+    let colgroup = null;
+    if (node.attrs[colgroupAttr] && !shouldSkipColgroup(node)) {
+        const doc = domToPmDoc(htmlToFragment(node.attrs[colgroupAttr]), colgroupSchema, { preserveWhitespace: false });
+        const fragment = pmDocToFragment(doc);
+        const colgroupEl = fragment.firstChild;
+        if (colgroupEl) {
+            const cols = Array.from(colgroupEl.children).map((c) => ['col', domAttributes(c)]);
+            colgroup = [
+                'colgroup',
+                domAttributes(colgroupEl),
+                ...cols
+            ];
+        }
+    }
+    return colgroup ? ['table', tableAttrs, colgroup, ['tbody', 0]] :
+        ['table', tableAttrs, ['tbody', 0]];
+};
+tNodes.table.parseDOM = [{
+        tag: 'table',
+        getAttrs: (node) => {
+            const attrs = domAttributes(node);
+            const colgroup = Array.from(node.childNodes).find(c => c.nodeName === 'COLGROUP');
+            if (colgroup) {
+                attrs[colgroupAttr] = colgroup.outerHTML;
+            }
+            return attrs;
+        }
+    }];
 const nodes = Object.assign({ 
     // :: NodeSpec The top level document node.
     doc: {
@@ -76,9 +154,9 @@ const nodes = Object.assign({
         attrs: Object.assign({}, commonAttributes()),
         parseDOM: [{
                 tag: 'p',
-                getAttrs: getAttributes
+                getAttrs: domAttributes
             }],
-        toDOM: node => hasAttrs(node.attrs) ? ['p', getAttrs(node.attrs), hole] : ['p', hole]
+        toDOM: node => 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)*',
@@ -87,9 +165,9 @@ const nodes = Object.assign({
         attrs: Object.assign({}, commonAttributes()),
         parseDOM: [{
                 tag: 'div',
-                getAttrs: getAttributes
+                getAttrs: domAttributes
             }],
-        toDOM: node => hasAttrs(node.attrs) ? ['div', getAttrs(node.attrs), hole] : ['div', hole]
+        toDOM: node => hasAttrs(node.attrs) ? ['div', pmAttributes(node.attrs), hole] : ['div', hole]
     }, 
     // :: NodeSpec A blockquote (`<blockquote>`) wrapping one or more blocks.
     blockquote: {
@@ -99,9 +177,9 @@ const nodes = Object.assign({
         defining: true,
         parseDOM: [{
                 tag: 'blockquote',
-                getAttrs: getAttributes
+                getAttrs: domAttributes
             }],
-        toDOM: node => hasAttrs(node.attrs) ? ['blockquote', getAttrs(node.attrs), hole] : blockquoteDOM
+        toDOM: node => hasAttrs(node.attrs) ? ['blockquote', pmAttributes(node.attrs), hole] : blockquoteDOM
     }, 
     // :: NodeSpec A horizontal rule (`<hr>`).
     horizontal_rule: {
@@ -118,15 +196,15 @@ const nodes = Object.assign({
         group: 'block',
         defining: true,
         parseDOM: [
-            { tag: 'h1', getAttrs: node => (Object.assign({}, getAttributes(node), { level: 1 })) },
-            { tag: 'h2', getAttrs: node => (Object.assign({}, getAttributes(node), { level: 2 })) },
-            { tag: 'h3', getAttrs: node => (Object.assign({}, getAttributes(node), { level: 3 })) },
-            { tag: 'h4', getAttrs: node => (Object.assign({}, getAttributes(node), { level: 4 })) },
-            { tag: 'h5', getAttrs: node => (Object.assign({}, getAttributes(node), { level: 5 })) },
-            { tag: 'h6', getAttrs: node => (Object.assign({}, getAttributes(node), { level: 6 })) }
+            { tag: 'h1', getAttrs: node => (Object.assign({}, domAttributes(node), { level: 1 })) },
+            { tag: 'h2', getAttrs: node => (Object.assign({}, domAttributes(node), { level: 2 })) },
+            { tag: 'h3', getAttrs: node => (Object.assign({}, domAttributes(node), { level: 3 })) },
+            { tag: 'h4', getAttrs: node => (Object.assign({}, domAttributes(node), { level: 4 })) },
+            { tag: 'h5', getAttrs: node => (Object.assign({}, domAttributes(node), { level: 5 })) },
+            { tag: 'h6', getAttrs: node => (Object.assign({}, domAttributes(node), { level: 6 })) }
         ],
         toDOM: node => 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
@@ -154,8 +232,8 @@ const nodes = Object.assign({
         attrs: Object.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: node => hasAttrs(node.attrs) ? ['img', getAttrs(node.attrs)] : ['img']
+        parseDOM: [{ tag: 'img', getAttrs: domAttributes }],
+        toDOM: node => hasAttrs(node.attrs) ? ['img', pmAttributes(node.attrs)] : ['img']
     }, 
     // :: NodeSpec A hard line break represented in the DOM as a `<br>` element.
     hard_break: {
@@ -165,9 +243,9 @@ const nodes = Object.assign({
         selectable: false,
         parseDOM: [{
                 tag: 'br',
-                getAttrs: getAttributes
+                getAttrs: domAttributes
             }],
-        toDOM: node => hasAttrs(node.attrs) ? ['br', getAttrs(node.attrs)] : ['br']
+        toDOM: node => hasAttrs(node.attrs) ? ['br', pmAttributes(node.attrs)] : ['br']
     }, 
     // :: NodeSpec
     // An ordered list [node spec](#model.NodeSpec). Has a single
@@ -179,12 +257,12 @@ const nodes = Object.assign({
         group: 'block',
         attrs: Object.assign({}, commonAttributes(), { type: { default: null }, order: { default: 1 } }),
         parseDOM: [{ tag: 'ol', getAttrs: (dom) => {
-                    return Object.assign({}, getAttributes(dom), { order: dom.hasAttribute('start') ? parseInt(dom.getAttribute('start') || '1', 10) : 1 });
+                    return Object.assign({}, domAttributes(dom), { order: dom.hasAttribute('start') ? parseInt(dom.getAttribute('start') || '1', 10) : 1 });
                 } }],
         toDOM: node => {
             return node.attrs.order === 1 ?
-                (hasAttrs(node.attrs, 'order') ? ['ol', getAttrs(node.attrs, 'order'), hole] : olDOM) :
-                ['ol', Object.assign({}, getAttrs(node.attrs, 'order'), { start: node.attrs.order }), hole];
+                (hasAttrs(node.attrs, 'order') ? ['ol', pmAttributes(node.attrs, 'order'), hole] : olDOM) :
+                ['ol', Object.assign({}, pmAttributes(node.attrs, 'order'), { start: node.attrs.order }), hole];
         }
     }, 
     // :: NodeSpec
@@ -193,16 +271,16 @@ const nodes = Object.assign({
         content: 'list_item+',
         group: 'block',
         attrs: Object.assign({}, commonAttributes()),
-        parseDOM: [{ tag: 'ul', getAttrs: getAttributes }],
-        toDOM: node => hasAttrs(node.attrs) ? ['ul', getAttrs(node.attrs), hole] : ulDOM
+        parseDOM: [{ tag: 'ul', getAttrs: domAttributes }],
+        toDOM: node => hasAttrs(node.attrs) ? ['ul', pmAttributes(node.attrs), hole] : ulDOM
     }, 
     // :: NodeSpec
     // A list item (`<li>`) specification.
     list_item: {
         content: '(paragraph | heading) block*',
         attrs: Object.assign({}, commonAttributes()),
-        parseDOM: [{ tag: 'li', getAttrs: getAttributes }],
-        toDOM: node => hasAttrs(node.attrs) ? ['li', getAttrs(node.attrs), hole] : liDOM,
+        parseDOM: [{ tag: 'li', getAttrs: domAttributes }],
+        toDOM: node => hasAttrs(node.attrs) ? ['li', pmAttributes(node.attrs), hole] : liDOM,
         defining: true
-    } }, tableNodes({ tableGroup: 'block', cellContent: 'block+', cellAttributes: {} }));
+    } }, tNodes);
 export { nodes, marks };

package/dist/es2015/main.js

@@ -18,7 +18,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 } from './find-replace';
 export { placeholder } from './plugins/placeholder';
 export { spacesFix } from './plugins/spaces-fix';
@@ -37,3 +36,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/es2015/source.js

@@ -1,9 +1,58 @@
 import { DOMSerializer, DOMParser as ProseMirrorDOMParser } from 'prosemirror-model';
 import { AllSelection } from 'prosemirror-state';
+import { rowTypeAttr, colgroupAttr } from './config/constants';
 const blockWrappers = [
     'div', 'ol', 'ul', 'li', 'table', 'tbody', 'thead', 'tfoot', 'td', 'th', 'p',
     'tr', 'col', 'colgroup', 'article', 'main', 'nav', 'header', 'footer', 'aside', 'section'
 ];
+const removeRowType = (table, nodeName) => {
+    const wrapper = (table.ownerDocument || document).createElement(nodeName);
+    Array.from(table.rows).filter(r => r.getAttribute(rowTypeAttr) === nodeName).forEach(row => {
+        row.removeAttribute(rowTypeAttr);
+        wrapper.appendChild(row);
+    });
+    if (wrapper.children.length) {
+        table.appendChild(wrapper);
+    }
+};
+const restoreTables = (fragment) => {
+    Array.from(fragment.querySelectorAll('table')).forEach((table) => {
+        removeRowType(table, 'thead');
+        removeRowType(table, 'tbody');
+        removeRowType(table, 'tfoot');
+        const emptyElement = Array.from(table.children).find(el => el.children.length === 0);
+        if (emptyElement) {
+            emptyElement.remove();
+        }
+    });
+};
+const setRowType = (children, nodeName) => {
+    const tag = nodeName.toUpperCase();
+    children.filter(c => c.nodeName === tag).forEach(rowsWrapper => {
+        Array.from(rowsWrapper.children).forEach(row => {
+            row.setAttribute(rowTypeAttr, nodeName);
+            if (rowsWrapper.parentNode) {
+                rowsWrapper.parentNode.insertBefore(row, rowsWrapper);
+            }
+        });
+        rowsWrapper.remove();
+    });
+};
+const validateTablesToPmSchema = (fragment) => {
+    Array.from(fragment.querySelectorAll('table')).forEach((table) => {
+        const children = Array.from(table.children);
+        if (children.some(e => e.nodeName === 'THEAD' || e.nodeName === 'TFOOT')) {
+            setRowType(children, 'thead');
+            setRowType(children, 'tbody');
+            setRowType(children, 'tfoot');
+        }
+        const colgroup = children.find(c => c.nodeName === 'COLGROUP');
+        if (colgroup) {
+            table.setAttribute(colgroupAttr, colgroup.outerHTML);
+            colgroup.remove();
+        }
+    });
+};
 /**
  * Trims the whitespace around the provided block nodes.
  *
@@ -51,7 +100,9 @@ export const htmlToFragment = (html) => {
  * @returns DocumentFragment
  */
 export const pmDocToFragment = (doc) => {
-    return DOMSerializer.fromSchema(doc.type.schema).serializeFragment(doc.content);
+    const fragment = DOMSerializer.fromSchema(doc.type.schema).serializeFragment(doc.content);
+    restoreTables(fragment);
+    return fragment;
 };
 /**
  * Creates a ProseMirrorNode from the given DOM element.
@@ -74,6 +125,7 @@ export const domToPmDoc = (dom, schema, parseOptions) => {
  */
 export const parseContent = (content, schema, parseOptions) => {
     const dom = htmlToFragment(content);
+    validateTablesToPmSchema(dom);
     return domToPmDoc(dom, schema, parseOptions);
 };
 /**

package/dist/es2015/table.js

@@ -1,3 +1,5 @@
+import { addRowAfter as pmAddRowAfter, addRowBefore as pmAddRowBefore } from 'prosemirror-tables';
+import { rowTypeAttr } from './config/constants';
 /**
  * Creates a table.
  * @returns Node
@@ -15,3 +17,48 @@ export const createTable = (nodes, rows, columns) => {
     }
     return table.createAndFill(undefined, tableRows);
 };
+const closest = (selection, name) => {
+    const pos = selection.$head;
+    for (let i = pos.depth; i > 0; i--) {
+        const node = pos.node(i);
+        if (node.type.name === name) {
+            return {
+                pos: pos.before(i),
+                node
+            };
+        }
+    }
+    return null;
+};
+export const addRowBefore = (state, dispatch) => {
+    const cmdDispatch = dispatch && (tr => {
+        const row = closest(tr.selection, 'table_row');
+        const table = closest(tr.selection, 'table');
+        if (row && table && row.node.attrs[rowTypeAttr]) {
+            let index = 0;
+            for (let i = 0; i < table.node.nodeSize; i++) {
+                if (table.node.child(i).eq(row.node)) {
+                    index = i;
+                    break;
+                }
+            }
+            const next = table.node.child(index - 1);
+            const from = row.pos - next.nodeSize;
+            tr.setNodeMarkup(from, undefined, { [rowTypeAttr]: row.node.attrs[rowTypeAttr] });
+        }
+        return dispatch(tr);
+    });
+    return pmAddRowBefore(state, cmdDispatch);
+};
+export const addRowAfter = (state, dispatch) => {
+    const cmdDispatch = dispatch && (tr => {
+        const row = closest(tr.selection, 'table_row');
+        if (row && row.node.attrs[rowTypeAttr]) {
+            const from = row.pos + row.node.nodeSize;
+            tr.setNodeMarkup(from, undefined, { [rowTypeAttr]: row.node.attrs[rowTypeAttr] });
+        }
+        return dispatch(tr);
+    });
+    return pmAddRowAfter(state, cmdDispatch);
+};
+export { pmAddRowBefore, pmAddRowAfter };

package/dist/npm/config/constants.d.ts

@@ -0,0 +1,2 @@
+export declare const rowTypeAttr = "k-parent-node";
+export declare const colgroupAttr = "k-colgroup-data";

package/dist/npm/config/constants.js

@@ -0,0 +1,4 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.rowTypeAttr = 'k-parent-node';
+exports.colgroupAttr = 'k-colgroup-data';