@progress/kendo-editor-common 1.12.2-develop.5 → 1.12.2-develop.6

package/dist/npm/plugins/table-resize/index.d.ts

@@ -1,5 +1,2 @@
-import * as prosemirror_state from 'prosemirror-state';
-
-declare const tableResizing: () => prosemirror_state.Plugin<any>[];
-
-export { tableResizing };
+export declare const tableResizing: () => import("prosemirror-state").Plugin<any>[];
+export { tableResizeKey, tableColumnResizeKey, tableRowResizeKey } from './utils';

package/dist/npm/plugins/table-resize/index.js

@@ -1,17 +1,16 @@
-'use strict';
-
-var columnResize = require('./column-resize.js');
-var tableResize = require('./table-resize.js');
-var rowResize = require('./row-resize.js');
-var utils = require('./utils.js');
-
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.tableRowResizeKey = exports.tableColumnResizeKey = exports.tableResizeKey = exports.tableResizing = void 0;
+const column_resize_1 = require("./column-resize");
+const table_resize_1 = require("./table-resize");
+const row_resize_1 = require("./row-resize");
 const tableResizing = () => [
-    tableResize.tableResizing(),
-    columnResize.columnResizing(),
-    rowResize.rowResizing()
+    (0, table_resize_1.tableResizing)(),
+    (0, column_resize_1.columnResizing)(),
+    (0, row_resize_1.rowResizing)()
 ];
-
-exports.tableColumnResizeKey = utils.tableColumnResizeKey;
-exports.tableResizeKey = utils.tableResizeKey;
-exports.tableRowResizeKey = utils.tableRowResizeKey;
 exports.tableResizing = tableResizing;
+var utils_1 = require("./utils");
+Object.defineProperty(exports, "tableResizeKey", { enumerable: true, get: function () { return utils_1.tableResizeKey; } });
+Object.defineProperty(exports, "tableColumnResizeKey", { enumerable: true, get: function () { return utils_1.tableColumnResizeKey; } });
+Object.defineProperty(exports, "tableRowResizeKey", { enumerable: true, get: function () { return utils_1.tableRowResizeKey; } });

package/dist/npm/plugins/table-resize/row-resize.d.ts

@@ -0,0 +1,2 @@
+import { Plugin } from 'prosemirror-state';
+export declare function rowResizing(): Plugin;

package/dist/npm/plugins/table-resize/row-resize.js

@@ -1,11 +1,11 @@
-'use strict';
-
-var prosemirrorState = require('prosemirror-state');
-var prosemirrorTables = require('prosemirror-tables');
-var prosemirrorView = require('prosemirror-view');
-var utils = require('./utils.js');
-var utils$1 = require('../../utils.js');
-
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.rowResizing = rowResizing;
+const prosemirror_state_1 = require("prosemirror-state");
+const prosemirror_tables_1 = require("prosemirror-tables");
+const prosemirror_view_1 = require("prosemirror-view");
+const utils_1 = require("./utils");
+const utils_2 = require("./../../utils");
 class TableRowView {
     ignoreMutation(record) {
         return record.type === 'attributes' && record.attributeName === 'style' && record.target.nodeName === 'TR';
@@ -13,11 +13,11 @@ class TableRowView {
 }
 function rowResizing() {
     const handleWidth = 5;
-    const plugin = new prosemirrorState.Plugin({
-        key: utils.tableRowResizeKey,
+    const plugin = new prosemirror_state_1.Plugin({
+        key: utils_1.tableRowResizeKey,
         state: {
             init(_, state) {
-                this.spec.props.nodeViews[prosemirrorTables.tableNodeTypes(state.schema).row.name] = () => new TableRowView();
+                this.spec.props.nodeViews[(0, prosemirror_tables_1.tableNodeTypes)(state.schema).row.name] = () => new TableRowView();
                 return new ResizeState(-1, null);
             },
             apply(tr, prev) {
@@ -26,15 +26,15 @@ function rowResizing() {
         },
         props: {
             attributes(state) {
-                if (utils.otherResizeHandle(utils.tableRowResizeKey, state)) {
+                if ((0, utils_1.otherResizeHandle)(utils_1.tableRowResizeKey, state)) {
                     return null;
                 }
-                const pluginState = utils.tableRowResizeKey.getState(state);
+                const pluginState = utils_1.tableRowResizeKey.getState(state);
                 return pluginState.activeHandle > -1 ? { class: 'resize-cursor-vertical' } : null;
             },
             handleDOMEvents: {
                 mousemove(view, event) {
-                    if (!utils.otherResizing(utils.tableRowResizeKey, view.state)) {
+                    if (!(0, utils_1.otherResizing)(utils_1.tableRowResizeKey, view.state)) {
                         handleMouseMove(view, event, handleWidth);
                     }
                     return false;
@@ -48,10 +48,10 @@ function rowResizing() {
                 }
             },
             decorations(state) {
-                if (utils.otherResizing(utils.tableRowResizeKey, state)) {
-                    return prosemirrorView.DecorationSet.empty;
+                if ((0, utils_1.otherResizing)(utils_1.tableRowResizeKey, state)) {
+                    return prosemirror_view_1.DecorationSet.empty;
                 }
-                const pluginState = utils.tableRowResizeKey.getState(state);
+                const pluginState = utils_1.tableRowResizeKey.getState(state);
                 if (pluginState.activeHandle > -1) {
                     return handleDecorations(state, pluginState.activeHandle);
                 }
@@ -70,7 +70,8 @@ class ResizeState {
         this.dragging = dragging;
     }
     apply(tr) {
-        let state, action = tr.getMeta(utils.tableRowResizeKey);
+        let state;
+        const action = tr.getMeta(utils_1.tableRowResizeKey);
         if (action && action.setHandle != null) {
             return new ResizeState(action.setHandle, null);
         }
@@ -88,18 +89,19 @@ class ResizeState {
     }
 }
 function handleMouseMove(view, event, handleWidth) {
-    const pluginState = utils.tableRowResizeKey.getState(view.state);
+    const pluginState = utils_1.tableRowResizeKey.getState(view.state);
     if (!pluginState.dragging) {
-        let target = utils.domCellAround(event.target), cell = -1;
+        const target = (0, utils_1.domCellAround)(event.target);
+        let cell = -1;
         if (target) {
-            const indexes = utils.cellIndexes(target);
+            const indexes = (0, utils_1.cellIndexes)(target);
             const { top, bottom } = target.getBoundingClientRect();
             if (Math.abs(event.clientY - top) <= handleWidth && indexes.rowIndex > 0) {
                 indexes.rowIndex -= target.rowSpan;
-                cell = utils.edgeCell(view, event, indexes);
+                cell = (0, utils_1.edgeCell)(view, event, indexes);
             }
             else if (bottom - event.clientY > 0 && bottom - event.clientY <= handleWidth) {
-                cell = utils.edgeCell(view, event, indexes);
+                cell = (0, utils_1.edgeCell)(view, event, indexes);
             }
         }
         if (cell !== pluginState.activeHandle) {
@@ -108,13 +110,13 @@ function handleMouseMove(view, event, handleWidth) {
     }
 }
 function handleMouseLeave(view) {
-    const pluginState = utils.tableRowResizeKey.getState(view.state);
+    const pluginState = utils_1.tableRowResizeKey.getState(view.state);
     if (pluginState.activeHandle > -1 && !pluginState.dragging) {
         updateHandle(view, -1);
     }
 }
 function handleMouseDown(view, event) {
-    const pluginState = utils.tableRowResizeKey.getState(view.state);
+    const pluginState = utils_1.tableRowResizeKey.getState(view.state);
     if (pluginState.activeHandle === -1 || pluginState.dragging) {
         return false;
     }
@@ -122,14 +124,14 @@ function handleMouseDown(view, event) {
     const $cell = doc.resolve(pluginState.activeHandle);
     const row = $cell.parent;
     const table = $cell.node(-1);
-    const rowHeightStr = utils$1.parseStyle(row.attrs.style).height;
-    const tableHeight = utils$1.parseStyle(table.attrs.style).height;
+    const rowHeightStr = (0, utils_2.parseStyle)(row.attrs.style).height;
+    const tableHeight = (0, utils_2.parseStyle)(table.attrs.style).height;
     let rowHeight = rowHeightStr ? parseFloat(rowHeightStr) : 0;
     if (!rowHeightStr) {
         const tr = view.nodeDOM(pluginState.activeHandle);
         rowHeight = tr.offsetHeight;
     }
-    view.dispatch(view.state.tr.setMeta(utils.tableRowResizeKey, {
+    view.dispatch(view.state.tr.setMeta(utils_1.tableRowResizeKey, {
         setDragging: {
             startY: event.clientY,
             startHeight: { rowHeight, tableHeight }
@@ -138,9 +140,9 @@ function handleMouseDown(view, event) {
     function finish(ev) {
         ev.view.removeEventListener('mouseup', finish);
         ev.view.removeEventListener('mousemove', move);
-        const curPluginState = utils.tableRowResizeKey.getState(view.state);
+        const curPluginState = utils_1.tableRowResizeKey.getState(view.state);
         if (curPluginState.dragging) {
-            const tr = view.state.tr.setMeta(utils.tableRowResizeKey, { setDragging: null });
+            const tr = view.state.tr.setMeta(utils_1.tableRowResizeKey, { setDragging: null });
             updateRowHeight(view, tr, curPluginState.activeHandle);
             view.dispatch(tr);
         }
@@ -149,7 +151,7 @@ function handleMouseDown(view, event) {
         if (!ev.which) {
             return finish(ev);
         }
-        const curPluginState = utils.tableRowResizeKey.getState(view.state);
+        const curPluginState = utils_1.tableRowResizeKey.getState(view.state);
         const dragged = draggedHeight(curPluginState.dragging, ev);
         const offset = ev.clientY - curPluginState.dragging.startY;
         displayRowHeight(view, curPluginState.activeHandle, dragged, offset, tableHeight);
@@ -166,7 +168,7 @@ function draggedHeight(dragging, event) {
 function updateHandle(view, value) {
     const tr = view.state.tr;
     tr.setMeta('addToHistory', false);
-    tr.setMeta(utils.tableRowResizeKey, { setHandle: value });
+    tr.setMeta(utils_1.tableRowResizeKey, { setHandle: value });
     view.dispatch(tr);
 }
 function updateRowHeight(view, tr, cellPos) {
@@ -177,13 +179,13 @@ function updateRowHeight(view, tr, cellPos) {
     const dom = view.nodeDOM(rowPos);
     const win = (dom.ownerDocument && dom.ownerDocument.defaultView) || window;
     dom.style.height = win.getComputedStyle(dom).height;
-    tr.setNodeMarkup(rowPos, null, utils$1.setNodeStyle(row.attrs, 'height', dom.style.height));
+    tr.setNodeMarkup(rowPos, null, (0, utils_2.setNodeStyle)(row.attrs, 'height', dom.style.height));
     const table = dom && dom.closest('table');
     const tableHeight = table && table.style.height;
     if (tableHeight) {
         const $pos = doc.resolve(rowPos);
         const tablePos = $pos.start($pos.depth) - 1;
-        tr.setNodeMarkup(tablePos, null, utils$1.setNodeStyle($pos.parent.attrs, 'height', tableHeight));
+        tr.setNodeMarkup(tablePos, null, (0, utils_2.setNodeStyle)($pos.parent.attrs, 'height', tableHeight));
     }
 }
 function displayRowHeight(view, cellPos, height, offset, tableHeight) {
@@ -205,9 +207,9 @@ function displayRowHeight(view, cellPos, height, offset, tableHeight) {
 function handleDecorations(state, cell) {
     const decorations = [];
     if (typeof cell !== 'number') {
-        return prosemirrorView.DecorationSet.empty;
+        return prosemirror_view_1.DecorationSet.empty;
     }
-    const $cell = state.doc.resolve(cell), table = $cell.node(-1), map = prosemirrorTables.TableMap.get(table), start = $cell.start(-1);
+    const $cell = state.doc.resolve(cell), table = $cell.node(-1), map = prosemirror_tables_1.TableMap.get(table), start = $cell.start(-1);
     const cellsPositions = [];
     const cellPos = cell - start;
     let rowIndex = -1;
@@ -228,9 +230,7 @@ function handleDecorations(state, cell) {
         const widgetPos = start + cPos + (cellNode ? cellNode.nodeSize : 0) - 1;
         const dom = document.createElement('div');
         dom.className = 'row-resize-handle';
-        decorations.push(prosemirrorView.Decoration.widget(widgetPos, dom));
+        decorations.push(prosemirror_view_1.Decoration.widget(widgetPos, dom));
     });
-    return prosemirrorView.DecorationSet.create(state.doc, decorations);
+    return prosemirror_view_1.DecorationSet.create(state.doc, decorations);
 }
-
-exports.rowResizing = rowResizing;

package/dist/npm/plugins/table-resize/table-resize.d.ts

@@ -0,0 +1,18 @@
+import { Plugin, Transaction } from 'prosemirror-state';
+declare class ResizeState {
+    activeHandle: string;
+    dragging: {
+        startX: number;
+        startY: number;
+    } | null;
+    nodePosition: number;
+    constructor(activeHandle: string, dragging: {
+        startX: number;
+        startY: number;
+    } | null, nodePosition: number);
+    apply(tr: Transaction): ResizeState;
+}
+export declare const tableResizing: (options?: {
+    node: string;
+}) => Plugin<ResizeState>;
+export {};

package/dist/npm/plugins/table-resize/table-resize.js

@@ -1,11 +1,11 @@
-'use strict';
-
-var prosemirrorState = require('prosemirror-state');
-var constants = require('../../config/constants.js');
-var utils = require('./utils.js');
-var utils$1 = require('../../utils.js');
-var resizeUtils = require('../resize-utils.js');
-
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.tableResizing = void 0;
+const prosemirror_state_1 = require("prosemirror-state");
+const constants_1 = require("../../config/constants");
+const utils_1 = require("./utils");
+const utils_2 = require("./../../utils");
+const resize_utils_1 = require("./../resize-utils");
 const commonDir = {
     'southeast': true,
     'southwest': true,
@@ -29,7 +29,7 @@ class ResizeState {
         this.nodePosition = nodePosition;
     }
     apply(tr) {
-        const next = tr.getMeta(utils.tableResizeKey);
+        const next = tr.getMeta(utils_1.tableResizeKey);
         if (next) {
             const nextState = new ResizeState(next.activeHandle, next.setDragging, next.nodePosition);
             return nextState;
@@ -39,14 +39,14 @@ class ResizeState {
 }
 const handleMouseMove = (view, event) => {
     var _a;
-    const state = utils.tableResizeKey.getState(view.state);
+    const state = utils_1.tableResizeKey.getState(view.state);
     const { dragging, nodePosition, activeHandle } = state;
     if (nodePosition < 0 || !dragging) {
         return;
     }
-    const tableDom = utils.getTable(view.nodeDOM(nodePosition));
+    const tableDom = (0, utils_1.getTable)(view.nodeDOM(nodePosition));
     const rect = tableDom.getBoundingClientRect();
-    const dir = resizeUtils.directions[activeHandle];
+    const dir = resize_utils_1.directions[activeHandle];
     const diffX = (event.clientX - dragging.startX) * dir.x;
     const diffY = (event.clientY - dragging.startY) * dir.y;
     const win = (tableDom.ownerDocument && tableDom.ownerDocument.defaultView) || window;
@@ -72,7 +72,7 @@ const handleMouseMove = (view, event) => {
 };
 const toPercents = (view, tr, tablePos) => {
     const tableNode = view.state.doc.nodeAt(tablePos);
-    const tableDom = utils.getTable(view.nodeDOM(tablePos));
+    const tableDom = (0, utils_1.getTable)(view.nodeDOM(tablePos));
     const { width, height, colsWidth, rowsHeight, offsetWidth, offsetHeight } = tableSize(tableDom);
     const colgroup = tableDom.firstChild;
     const cols = Array.from((colgroup && colgroup.children) || []);
@@ -85,21 +85,21 @@ const toPercents = (view, tr, tablePos) => {
     });
     let heightChange = false;
     tableNode.forEach((row, offset, index) => {
-        const rowHeight = utils$1.parseStyle(row.attrs.style).height;
+        const rowHeight = (0, utils_2.parseStyle)(row.attrs.style).height;
         if (rowHeight && !/%$/.test(rowHeight)) {
-            tr.setNodeMarkup(tablePos + offset + 1, null, utils$1.setNodeStyle(row.attrs, 'height', (rowsHeight[index] * 100 / height) + '%'));
+            tr.setNodeMarkup(tablePos + offset + 1, null, (0, utils_2.setNodeStyle)(row.attrs, 'height', (rowsHeight[index] * 100 / height) + '%'));
             heightChange = true;
         }
     });
     let tableAttrs = tableNode.attrs;
-    if (utils$1.parseStyle(tableAttrs.style).width !== offsetWidth + 'px') {
-        tableAttrs = utils$1.setNodeStyle(tableAttrs, 'width', offsetWidth + 'px');
+    if ((0, utils_2.parseStyle)(tableAttrs.style).width !== offsetWidth + 'px') {
+        tableAttrs = (0, utils_2.setNodeStyle)(tableAttrs, 'width', offsetWidth + 'px');
     }
     if (widthChanged) {
-        tableAttrs[constants.colgroupAttr] = colgroup.outerHTML;
+        tableAttrs[constants_1.colgroupAttr] = colgroup.outerHTML;
     }
     if (heightChange) {
-        tableAttrs = utils$1.setNodeStyle(tableAttrs, 'height', offsetHeight + 'px');
+        tableAttrs = (0, utils_2.setNodeStyle)(tableAttrs, 'height', offsetHeight + 'px');
     }
     if (widthChanged || heightChange) {
         tr.setNodeMarkup(tablePos, null, tableAttrs);
@@ -107,14 +107,14 @@ const toPercents = (view, tr, tablePos) => {
 };
 const toPixels = (view, tr, tablePos, attrs) => {
     const tableNode = view.state.doc.nodeAt(tablePos);
-    const tableDom = utils.getTable(view.nodeDOM(tablePos));
+    const tableDom = (0, utils_1.getTable)(view.nodeDOM(tablePos));
     const win = (tableDom.ownerDocument && tableDom.ownerDocument.defaultView) || window;
     const calcStyle = win.getComputedStyle;
     const rows = Array.from(tableDom.rows);
     tableNode.forEach((row, offset, index) => {
-        const rowHeight = utils$1.parseStyle(row.attrs.style).height;
+        const rowHeight = (0, utils_2.parseStyle)(row.attrs.style).height;
         if (rowHeight && !/px$/.test(rowHeight)) {
-            tr.setNodeMarkup(tablePos + offset + 1, null, utils$1.setNodeStyle(row.attrs, 'height', calcStyle(rows[index]).height));
+            tr.setNodeMarkup(tablePos + offset + 1, null, (0, utils_2.setNodeStyle)(row.attrs, 'height', calcStyle(rows[index]).height));
         }
     });
     const colgroup = tableDom.firstChild;
@@ -128,7 +128,7 @@ const toPixels = (view, tr, tablePos, attrs) => {
     });
     const tableAttrs = { ...attrs };
     if (widthChanged) {
-        tableAttrs[constants.colgroupAttr] = colgroup.outerHTML;
+        tableAttrs[constants_1.colgroupAttr] = colgroup.outerHTML;
     }
     return tableAttrs;
 };
@@ -143,37 +143,37 @@ const tableSize = (table) => {
     return { width, height, colsWidth, rowsHeight, offsetWidth, offsetHeight };
 };
 const handleMouseUp = (view) => {
-    const { dragging, nodePosition, activeHandle } = utils.tableResizeKey.getState(view.state);
+    const { dragging, nodePosition, activeHandle } = utils_1.tableResizeKey.getState(view.state);
     if (dragging) {
         const node = view.state.doc.nodeAt(nodePosition);
-        const dom = utils.getTable(view.nodeDOM(nodePosition));
+        const dom = (0, utils_1.getTable)(view.nodeDOM(nodePosition));
         const rect = tableSize(dom);
         if (node) {
             const width = rect.offsetWidth + 'px';
             const height = rect.offsetHeight + 'px';
             const tr = view.state.tr;
             let attrs = node.attrs;
-            const parsedStyles = utils$1.parseStyle(attrs.style);
+            const parsedStyles = (0, utils_2.parseStyle)(attrs.style);
             if (horizontalDir[activeHandle] && dom.style.width && parsedStyles.width !== width) {
-                attrs = utils$1.setNodeStyle(attrs, 'width', width);
+                attrs = (0, utils_2.setNodeStyle)(attrs, 'width', width);
             }
             if (verticalDir[activeHandle] && dom.style.height && parsedStyles.height !== height) {
-                attrs = utils$1.setNodeStyle(attrs, 'height', height);
+                attrs = (0, utils_2.setNodeStyle)(attrs, 'height', height);
             }
             attrs = toPixels(view, tr, nodePosition, attrs);
             tr.setNodeMarkup(nodePosition, null, attrs);
             tr.setMeta('commandName', 'node-resize');
             tr.setMeta('args', attrs);
-            tr.setMeta(utils.tableResizeKey, {
+            tr.setMeta(utils_1.tableResizeKey, {
                 setDragging: null,
                 activeHandle: null,
                 nodePosition
             });
-            if (!/%/.test(utils$1.parseStyle(attrs.style).width || '')) {
+            if (!/%/.test((0, utils_2.parseStyle)(attrs.style).width || '')) {
                 const $pos = tr.doc.resolve(nodePosition);
-                const wrapper = utils$1.parentNode($pos, n => n.type.name === 'table_wrapper');
-                if (wrapper && /%/.test(utils$1.parseStyle(wrapper.node.attrs.style).width || '')) {
-                    const wrapperAttrs = utils$1.setNodeStyle(wrapper.node.attrs, 'width', '');
+                const wrapper = (0, utils_2.parentNode)($pos, n => n.type.name === 'table_wrapper');
+                if (wrapper && /%/.test((0, utils_2.parseStyle)(wrapper.node.attrs.style).width || '')) {
+                    const wrapperAttrs = (0, utils_2.setNodeStyle)(wrapper.node.attrs, 'width', '');
                     const wrapperPos = $pos.start(wrapper.depth) - 1;
                     tr.setNodeMarkup(wrapperPos, null, wrapperAttrs);
                 }
@@ -184,14 +184,14 @@ const handleMouseUp = (view) => {
 };
 const handleMouseDown = (view, event) => {
     const target = event.target;
-    const activeHandle = target.getAttribute(constants.dataResizeDirTable);
+    const activeHandle = target.getAttribute(constants_1.dataResizeDirTable);
     if (!activeHandle) {
         return false;
     }
-    const resizeState = utils.tableResizeKey.getState(view.state);
+    const resizeState = utils_1.tableResizeKey.getState(view.state);
     event.preventDefault();
     const transaction = view.state.tr;
-    transaction.setMeta(utils.tableResizeKey, {
+    transaction.setMeta(utils_1.tableResizeKey, {
         setDragging: { startX: event.clientX, startY: event.clientY },
         activeHandle,
         nodePosition: resizeState.nodePosition
@@ -213,16 +213,16 @@ const handleMouseDown = (view, event) => {
     return true;
 };
 const tableResizing = (options = { node: 'table' }) => {
-    return new prosemirrorState.Plugin({
-        key: utils.tableResizeKey,
+    return new prosemirror_state_1.Plugin({
+        key: utils_1.tableResizeKey,
         view: () => ({
             selectedNode(state, nodeType) {
                 const selection = state.selection;
-                const isNodeSelected = selection instanceof prosemirrorState.NodeSelection && nodeType === selection.node.type;
-                if (isNodeSelected && selection instanceof prosemirrorState.NodeSelection) {
+                const isNodeSelected = selection instanceof prosemirror_state_1.NodeSelection && nodeType === selection.node.type;
+                if (isNodeSelected && selection instanceof prosemirror_state_1.NodeSelection) {
                     return { node: selection.node, pos: selection.from };
                 }
-                const parent = utils$1.parentNode(selection.$from, (n) => n.type === nodeType);
+                const parent = (0, utils_2.parentNode)(selection.$from, (n) => n.type === nodeType);
                 const node = parent && parent.node;
                 if (node) {
                     const pos = selection.$from.start(parent.depth) - 1;
@@ -243,26 +243,26 @@ const tableResizing = (options = { node: 'table' }) => {
                     const tr = state.tr;
                     tr.setMeta('addToHistory', false);
                     if (selected && prevSelected && selected.pos !== prevSelected.pos) {
-                        tr.setMeta(utils.tableResizeKey, { nodePosition: selected.pos });
+                        tr.setMeta(utils_1.tableResizeKey, { nodePosition: selected.pos });
                         const prevNode = tr.doc.nodeAt(prevSelected.pos);
                         if (prevNode && prevNode.type.name === nodeType.name) {
-                            tr.setNodeMarkup(prevSelected.pos, nodeType, { ...prevSelected.node.attrs, [constants.resizableAttr]: false });
+                            tr.setNodeMarkup(prevSelected.pos, nodeType, { ...prevSelected.node.attrs, [constants_1.resizableAttr]: false });
                         }
-                        tr.setNodeMarkup(selected.pos, nodeType, { ...selected.node.attrs, [constants.resizableAttr]: true });
+                        tr.setNodeMarkup(selected.pos, nodeType, { ...selected.node.attrs, [constants_1.resizableAttr]: true });
                         view.dispatch(tr);
                     }
                     else if (selected && prevSelected && selected.pos === prevSelected.pos &&
-                        !selected.node.attrs[constants.resizableAttr] && !state.selection.eq(prevState.selection)) {
-                        tr.setMeta(utils.tableResizeKey, { nodePosition: selected.pos });
-                        view.dispatch(tr.setNodeMarkup(selected.pos, nodeType, { ...selected.node.attrs, [constants.resizableAttr]: true }));
+                        !selected.node.attrs[constants_1.resizableAttr] && !state.selection.eq(prevState.selection)) {
+                        tr.setMeta(utils_1.tableResizeKey, { nodePosition: selected.pos });
+                        view.dispatch(tr.setNodeMarkup(selected.pos, nodeType, { ...selected.node.attrs, [constants_1.resizableAttr]: true }));
                     }
                     else if (selected && !prevSelected) {
-                        tr.setMeta(utils.tableResizeKey, { nodePosition: selected.pos });
-                        view.dispatch(tr.setNodeMarkup(selected.pos, nodeType, { ...selected.node.attrs, [constants.resizableAttr]: true }));
+                        tr.setMeta(utils_1.tableResizeKey, { nodePosition: selected.pos });
+                        view.dispatch(tr.setNodeMarkup(selected.pos, nodeType, { ...selected.node.attrs, [constants_1.resizableAttr]: true }));
                     }
                     else if (!selected && prevSelected) {
-                        tr.setMeta(utils.tableResizeKey, { nodePosition: -1 });
-                        view.dispatch(tr.setNodeMarkup(prevSelected.pos, nodeType, { ...prevSelected.node.attrs, [constants.resizableAttr]: false }));
+                        tr.setMeta(utils_1.tableResizeKey, { nodePosition: -1 });
+                        view.dispatch(tr.setNodeMarkup(prevSelected.pos, nodeType, { ...prevSelected.node.attrs, [constants_1.resizableAttr]: false }));
                     }
                 }
             }
@@ -284,5 +284,4 @@ const tableResizing = (options = { node: 'table' }) => {
         }
     });
 };
-
 exports.tableResizing = tableResizing;

package/dist/npm/plugins/table-resize/table-view.d.ts

@@ -0,0 +1,28 @@
+import { Node } from 'prosemirror-model';
+import { EditorView, NodeView, ViewMutationRecord } from 'prosemirror-view';
+export declare class TableView implements NodeView {
+    node?: Node;
+    view?: EditorView;
+    table?: HTMLTableElement;
+    colgroup?: HTMLTableColElement;
+    dom: HTMLElement;
+    contentDOM?: HTMLElement;
+    private resizeHandles?;
+    constructor(node: Node, view: EditorView);
+    update(node: Node): boolean;
+    ignoreMutation(record: ViewMutationRecord): boolean;
+    destroy(): void;
+    private renderColgroup;
+    private setAttributes;
+}
+export declare class TableWrapperView implements NodeView {
+    node?: Node;
+    view?: EditorView;
+    dom: HTMLElement;
+    contentDOM?: HTMLElement;
+    constructor(node: Node, view: EditorView);
+    update(node: Node): boolean;
+    ignoreMutation(record: ViewMutationRecord): boolean;
+    destroy(): void;
+    private setAttributes;
+}

package/dist/npm/plugins/table-resize/table-view.js

@@ -1,26 +1,26 @@
-'use strict';
-
-var constants = require('../../config/constants.js');
-var schema = require('../../config/schema.js');
-var resizeUtils = require('../resize-utils.js');
-var utils = require('../../utils.js');
-
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.TableWrapperView = exports.TableView = void 0;
+const constants_1 = require("../../config/constants");
+const schema_1 = require("../../config/schema");
+const resize_utils_1 = require("./../resize-utils");
+const utils_1 = require("./../../utils");
 class TableView {
     constructor(node, view) {
         this.node = node;
         this.view = view;
         this.dom = document.createElement('div');
-        this.dom.className = constants.resizableWrap;
+        this.dom.className = constants_1.resizableWrap;
         this.table = this.dom.appendChild(document.createElement('table'));
-        if (node.attrs[constants.colgroupAttr]) {
-            this.renderColgroup(node.attrs[constants.colgroupAttr]);
+        if (node.attrs[constants_1.colgroupAttr]) {
+            this.renderColgroup(node.attrs[constants_1.colgroupAttr]);
         }
         const tBody = this.table.appendChild(document.createElement('tbody'));
         this.setAttributes(this.table, node.attrs);
-        this.resizeHandles = resizeUtils.handles.map(dir => {
+        this.resizeHandles = resize_utils_1.handles.map(dir => {
             const handle = document.createElement('span');
-            handle.className = constants.resizeHandle + ' ' + dir;
-            handle.setAttribute(constants.dataResizeDirTable, dir);
+            handle.className = constants_1.resizeHandle + ' ' + dir;
+            handle.setAttribute(constants_1.dataResizeDirTable, dir);
             return handle;
         });
         this.contentDOM = tBody;
@@ -31,19 +31,19 @@ class TableView {
         }
         const prev = this.node;
         this.node = node;
-        if (node.attrs[constants.resizableAttr]) {
+        if (node.attrs[constants_1.resizableAttr]) {
             this.resizeHandles.forEach(handle => {
                 this.dom.appendChild(handle);
             });
         }
         else {
             Array.from(this.dom.children)
-                .filter((e) => e.classList.contains(constants.resizeHandle))
+                .filter((e) => e.classList.contains(constants_1.resizeHandle))
                 .forEach((e) => e.remove());
         }
         this.setAttributes(this.table, node.attrs);
-        if (prev.attrs[constants.colgroupAttr] !== node.attrs[constants.colgroupAttr]) {
-            this.renderColgroup(node.attrs[constants.colgroupAttr]);
+        if (prev.attrs[constants_1.colgroupAttr] !== node.attrs[constants_1.colgroupAttr]) {
+            this.renderColgroup(node.attrs[constants_1.colgroupAttr]);
         }
         return true;
     }
@@ -66,15 +66,15 @@ class TableView {
             this.table.removeChild(this.table.firstChild);
         }
         if (colgroupStr) {
-            this.colgroup = schema.parseStrColgroup(colgroupStr);
+            this.colgroup = (0, schema_1.parseStrColgroup)(colgroupStr);
             this.table.insertBefore(this.colgroup, this.table.firstChild);
         }
     }
     setAttributes(table, attrs) {
-        const skip = [constants.colgroupAttr, constants.resizableAttr];
+        const skip = [constants_1.colgroupAttr, constants_1.resizableAttr];
         for (const attrName in attrs) {
             if (attrName && skip.indexOf(attrName) === -1) {
-                utils.setAttribute(table, attrName, attrs[attrName]);
+                (0, utils_1.setAttribute)(table, attrName, attrs[attrName]);
             }
         }
         if (/%$/.test(table.style.width)) {
@@ -86,6 +86,7 @@ class TableView {
         }
     }
 }
+exports.TableView = TableView;
 class TableWrapperView {
     constructor(node, view) {
         this.node = node;
@@ -112,13 +113,13 @@ class TableWrapperView {
     setAttributes(dom, attrs) {
         for (const attrName in attrs) {
             if (attrName) {
-                utils.setAttribute(dom, attrName, attrs[attrName]);
+                (0, utils_1.setAttribute)(dom, attrName, attrs[attrName]);
             }
         }
         dom.setAttribute('table', '');
         if (/%/.test(dom.style.width)) {
             const table = this.node && this.node.lastChild;
-            const tableStyles = table ? utils.parseStyle(table.attrs.style) : {};
+            const tableStyles = table ? (0, utils_1.parseStyle)(table.attrs.style) : {};
             const tableWidth = tableStyles.width || '';
             if (tableWidth && !/%/.test(tableWidth)) {
                 dom.style.width = '';
@@ -126,6 +127,4 @@ class TableWrapperView {
         }
     }
 }
-
-exports.TableView = TableView;
 exports.TableWrapperView = TableWrapperView;