@progress/kendo-editor-common 1.11.9-dev.202412020819 → 1.11.9-develop.1

package/dist/es/plugins/table-resize/column-resize.js

@@ -1,49 +1,49 @@
-import { __assign } from "tslib";
 import { Plugin } from 'prosemirror-state';
 import { TableMap } from 'prosemirror-tables';
-import { Decoration, DecorationSet } from 'prosemirror-view';
-import { colgroupAttr } from '../../config/constants';
-import { TableView, TableWrapperView } from './table-view';
-import { parseStyle, setNodeStyle } from './../../utils';
-import { cellIndexes, domCellAround, otherResizeHandle, otherResizing, edgeCell, tableColumnResizeKey as key } from './utils';
-export function columnResizing() {
-    var handleWidth = 5, cellMinWidth = 25;
-    var plugin = new Plugin({
-        key: key,
+import { DecorationSet, Decoration } from 'prosemirror-view';
+import { colgroupAttr } from '../../config/constants.js';
+import { TableWrapperView, TableView } from './table-view.js';
+import { setNodeStyle, parseStyle } from '../../utils.js';
+import { tableColumnResizeKey, otherResizeHandle, otherResizing, domCellAround, cellIndexes, edgeCell } from './utils.js';
+
+function columnResizing() {
+    const handleWidth = 5, cellMinWidth = 25;
+    const plugin = new Plugin({
+        key: tableColumnResizeKey,
         state: {
-            init: function () {
+            init() {
                 return new ResizeState(-1, null);
             },
-            apply: function (tr, prev) {
+            apply(tr, prev) {
                 return prev.apply(tr);
             }
         },
         props: {
-            attributes: function (state) {
-                if (otherResizeHandle(key, state)) {
+            attributes(state) {
+                if (otherResizeHandle(tableColumnResizeKey, state)) {
                     return null;
                 }
-                var pluginState = key.getState(state);
+                const pluginState = tableColumnResizeKey.getState(state);
                 return pluginState.activeHandle > -1 ? { class: 'resize-cursor' } : null;
             },
             handleDOMEvents: {
-                mousemove: function (view, event) {
-                    if (!otherResizing(key, view.state)) {
+                mousemove(view, event) {
+                    if (!otherResizing(tableColumnResizeKey, view.state)) {
                         handleMouseMove(view, event, handleWidth);
                     }
                     return false;
                 },
-                mouseleave: function (view) {
+                mouseleave(view) {
                     handleMouseLeave(view);
                     return false;
                 },
-                mousedown: function (view, event) {
+                mousedown(view, event) {
                     return handleMouseDown(view, event, cellMinWidth);
                 }
             },
-            decorations: function (state) {
-                if (!otherResizing(key, state)) {
-                    var pluginState = key.getState(state);
+            decorations(state) {
+                if (!otherResizing(tableColumnResizeKey, state)) {
+                    const pluginState = tableColumnResizeKey.getState(state);
                     if (pluginState.activeHandle > -1) {
                         return handleDecorations(state, pluginState.activeHandle);
                     }
@@ -51,8 +51,8 @@ export function columnResizing() {
                 return DecorationSet.empty;
             },
             nodeViews: {
-                table_wrapper: function (node, view) { return new TableWrapperView(node, view); },
-                table: function (node, view) { return new TableView(node, view); }
+                table_wrapper: (node, view) => new TableWrapperView(node, view),
+                table: (node, view) => new TableView(node, view)
             }
         }
     });
@@ -61,14 +61,14 @@ export function columnResizing() {
 function pointsAtCell($pos) {
     return Boolean($pos.parent.type.spec.tableRole === 'row' && $pos.nodeAfter);
 }
-var ResizeState = /** @class */ (function () {
-    function ResizeState(activeHandle, dragging) {
+class ResizeState {
+    constructor(activeHandle, dragging) {
         this.activeHandle = activeHandle;
         this.dragging = dragging;
     }
-    ResizeState.prototype.apply = function (tr) {
-        var state;
-        var action = tr.getMeta(key);
+    apply(tr) {
+        let state;
+        const action = tr.getMeta(tableColumnResizeKey);
         if (action && action.setHandle != null) {
             return new ResizeState(action.setHandle, null);
         }
@@ -76,24 +76,23 @@ var ResizeState = /** @class */ (function () {
             return new ResizeState(this.activeHandle, action.setDragging);
         }
         if (this.activeHandle > -1 && tr.docChanged) {
-            var handle = tr.mapping.map(this.activeHandle, -1);
+            let handle = tr.mapping.map(this.activeHandle, -1);
             if (!pointsAtCell(tr.doc.resolve(handle))) {
                 handle = -1;
             }
             state = new ResizeState(handle, this.dragging);
         }
         return state || this;
-    };
-    return ResizeState;
-}());
+    }
+}
 function handleMouseMove(view, event, handleWidth) {
-    var pluginState = key.getState(view.state);
+    const pluginState = tableColumnResizeKey.getState(view.state);
     if (!pluginState.dragging) {
-        var target = domCellAround(event.target);
-        var cell = -1;
+        const target = domCellAround(event.target);
+        let cell = -1;
         if (target) {
-            var indexes = cellIndexes(target);
-            var _a = target.getBoundingClientRect(), left = _a.left, right = _a.right;
+            const indexes = cellIndexes(target);
+            const { left, right } = target.getBoundingClientRect();
             if (Math.abs(event.clientX - left) <= handleWidth && indexes.cellIndex > 0) {
                 indexes.cellIndex -= target.colSpan;
                 cell = edgeCell(view, event, indexes);
@@ -108,82 +107,84 @@ function handleMouseMove(view, event, handleWidth) {
     }
 }
 function handleMouseLeave(view) {
-    var pluginState = key.getState(view.state);
+    const pluginState = tableColumnResizeKey.getState(view.state);
     if (pluginState.activeHandle > -1 && !pluginState.dragging) {
         updateHandle(view, -1);
     }
 }
 function handleMouseDown(view, event, cellMinWidth) {
-    var _a;
-    var pluginState = key.getState(view.state);
+    const pluginState = tableColumnResizeKey.getState(view.state);
     if (pluginState.activeHandle === -1 || pluginState.dragging) {
         return false;
     }
-    var $cell = view.state.doc.resolve(pluginState.activeHandle);
-    var row = $cell.parent;
-    var cellIndex = $cell.index();
-    var colSpan = 0;
-    for (var i = 0; i <= cellIndex; i++) {
+    const $cell = view.state.doc.resolve(pluginState.activeHandle);
+    const row = $cell.parent;
+    const cellIndex = $cell.index();
+    let colSpan = 0;
+    for (let i = 0; i <= cellIndex; i++) {
         colSpan += row.child(i).attrs.colspan;
     }
-    var tableNode = $cell.node($cell.depth - 1);
-    var dom = view.domAtPos(pluginState.activeHandle);
-    var domCell = dom.node.childNodes[dom.offset];
-    var tableDom = domCell.closest('table');
-    var col, tableAttrs;
+    const tableNode = $cell.node($cell.depth - 1);
+    const dom = view.domAtPos(pluginState.activeHandle);
+    const domCell = dom.node.childNodes[dom.offset];
+    const tableDom = domCell.closest('table');
+    let col, tableAttrs;
     if (tableNode.attrs[colgroupAttr]) {
-        var colgroup = tableDom.firstChild;
+        const colgroup = tableDom.firstChild;
         col = colgroup.children[colSpan - 1];
         if (!col.style.width) {
             col.style.width = col.offsetWidth + 'px';
         }
     }
     else {
-        var total = 0;
-        for (var i = 0; i < row.childCount; i++) {
+        let total = 0;
+        for (let i = 0; i < row.childCount; i++) {
             total += row.child(i).attrs.colspan;
         }
-        var colgroup = document.createElement('colgroup');
-        var cols = new Array(total);
-        for (var i = 0; i < total; i++) {
+        const colgroup = document.createElement('colgroup');
+        const cols = new Array(total);
+        for (let i = 0; i < total; i++) {
             cols[i] = document.createElement('col');
             colgroup.appendChild(cols[i]);
         }
         tableDom.insertBefore(colgroup, tableDom.firstChild);
         col = cols[cellIndex];
         col.style.width = col.offsetWidth + 'px';
-        tableAttrs = __assign(__assign({}, tableNode.attrs), (_a = {}, _a[colgroupAttr] = '<colgroup>' + cols.reduce(function (acc, cur) { return acc + cur.outerHTML; }, '') + '</colgroup>', _a));
+        tableAttrs = {
+            ...tableNode.attrs,
+            [colgroupAttr]: '<colgroup>' + cols.reduce((acc, cur) => acc + cur.outerHTML, '') + '</colgroup>'
+        };
     }
-    var width = parseFloat(col.style.width);
-    var tr = view.state.tr.setMeta(key, { setDragging: { startX: event.clientX, startWidth: width } });
+    const width = parseFloat(col.style.width);
+    const tr = view.state.tr.setMeta(tableColumnResizeKey, { setDragging: { startX: event.clientX, startWidth: width } });
     if (!tableDom.style.width) {
-        var widths = Array.from(col.parentNode.children).map(function (c) { return c.style.width; });
+        const widths = Array.from(col.parentNode.children).map((c) => c.style.width);
         if (widths.every(Boolean)) {
-            var sum = widths.reduce(function (acc, cur) { return acc + parseFloat(cur); }, 0);
+            const sum = widths.reduce((acc, cur) => acc + parseFloat(cur), 0);
             tableAttrs = setNodeStyle(tableAttrs || tableNode.attrs, 'width', sum + 'px');
         }
     }
     if (tableAttrs) {
-        var tablePos = $cell.posAtIndex(0, $cell.depth - 1) - 1;
+        const tablePos = $cell.posAtIndex(0, $cell.depth - 1) - 1;
         tr.setNodeMarkup(tablePos, null, tableAttrs);
     }
     view.dispatch(tr);
     function finish(ev) {
         ev.view.removeEventListener('mouseup', finish);
         ev.view.removeEventListener('mousemove', move);
-        var curPluginState = key.getState(view.state);
+        const curPluginState = tableColumnResizeKey.getState(view.state);
         if (curPluginState.dragging) {
-            var transaction = view.state.tr;
+            const transaction = view.state.tr;
             updateColumnWidth(view, transaction, curPluginState.activeHandle);
-            view.dispatch(transaction.setMeta(key, { setDragging: null }));
+            view.dispatch(transaction.setMeta(tableColumnResizeKey, { setDragging: null }));
         }
     }
     function move(ev) {
         if (!ev.which) {
             return finish(ev);
         }
-        var curPluginState = key.getState(view.state);
-        var dragged = draggedWidth(curPluginState.dragging, ev, cellMinWidth);
+        const curPluginState = tableColumnResizeKey.getState(view.state);
+        const dragged = draggedWidth(curPluginState.dragging, ev, cellMinWidth);
         displayColumnWidth(view, curPluginState.activeHandle, dragged);
     }
     event.view.addEventListener('mouseup', finish);
@@ -192,77 +193,78 @@ function handleMouseDown(view, event, cellMinWidth) {
     return true;
 }
 function draggedWidth(dragging, event, cellMinWidth) {
-    var offset = event.clientX - dragging.startX;
+    const offset = event.clientX - dragging.startX;
     return Math.max(cellMinWidth, dragging.startWidth + offset);
 }
 function updateHandle(view, value) {
-    var tr = view.state.tr;
+    const tr = view.state.tr;
     tr.setMeta('addToHistory', false);
-    tr.setMeta(key, { setHandle: value });
+    tr.setMeta(tableColumnResizeKey, { setHandle: value });
     view.dispatch(tr);
 }
 function updateColumnWidth(view, tr, cell) {
-    var _a;
-    var $cell = view.state.doc.resolve(cell);
-    var tableNode = $cell.node(-1), start = $cell.start(-1);
-    var tablePos = $cell.posAtIndex(0, $cell.depth - 1) - 1;
-    var tableDom = view.nodeDOM(start).closest('table');
-    var attrs = tableNode.attrs;
+    const $cell = view.state.doc.resolve(cell);
+    const tableNode = $cell.node(-1), start = $cell.start(-1);
+    const tablePos = $cell.posAtIndex(0, $cell.depth - 1) - 1;
+    const tableDom = view.nodeDOM(start).closest('table');
+    let attrs = tableNode.attrs;
     if (tableNode && attrs[colgroupAttr]) {
-        var colgroup = tableDom.firstChild;
-        attrs = __assign(__assign({}, attrs), (_a = {}, _a[colgroupAttr] = colgroup.outerHTML, _a));
+        const colgroup = tableDom.firstChild;
+        attrs = { ...attrs, [colgroupAttr]: colgroup.outerHTML };
     }
-    var tableDomWidth = tableDom.style.width;
+    const tableDomWidth = tableDom.style.width;
     if (tableDom && tableDomWidth && parseStyle(attrs.style).width !== tableDomWidth) {
         attrs = setNodeStyle(attrs, 'width', tableDomWidth);
     }
     tr.setNodeMarkup(tablePos, null, attrs);
 }
 function displayColumnWidth(view, cell, width) {
-    var $cell = view.state.doc.resolve(cell);
-    var table = $cell.node(-1), start = $cell.start(-1);
-    var col = TableMap.get(table).colCount($cell.pos - start) + $cell.nodeAfter.attrs.colspan - 1;
-    var dom = view.domAtPos($cell.start(-1)).node;
+    const $cell = view.state.doc.resolve(cell);
+    const table = $cell.node(-1), start = $cell.start(-1);
+    const col = TableMap.get(table).colCount($cell.pos - start) + $cell.nodeAfter.attrs.colspan - 1;
+    let dom = view.domAtPos($cell.start(-1)).node;
     if (dom.nodeName !== 'TABLE') {
         dom = dom.closest('table');
     }
-    var tableDom = dom;
-    var colgroup = tableDom.firstChild;
-    var cols = Array.from(colgroup.children);
+    const tableDom = dom;
+    const colgroup = tableDom.firstChild;
+    const cols = Array.from(colgroup.children);
     cols[col].style.width = width + 'px';
     if (tableDom.style.width) {
-        var widths = cols.map(function (c) { return c.style.width; });
+        const widths = cols.map(c => c.style.width);
         if (widths.every(Boolean)) {
-            var sum = widths.reduce(function (acc, cur) { return acc + parseFloat(cur); }, 0);
+            const sum = widths.reduce((acc, cur) => acc + parseFloat(cur), 0);
             tableDom.style.width = sum + 'px';
         }
     }
 }
 function handleDecorations(state, cell) {
-    var decorations = [];
-    var $cell = state.doc.resolve(cell);
-    var table = $cell.node(-1), map = TableMap.get(table), start = $cell.start(-1);
-    var cellsPositions = [];
-    var cellPos = cell - start;
-    var column = -1;
-    for (var i = 0; i < map.height; i++) {
+    const decorations = [];
+    const $cell = state.doc.resolve(cell);
+    const table = $cell.node(-1), map = TableMap.get(table), start = $cell.start(-1);
+    const cellsPositions = [];
+    const cellPos = cell - start;
+    let column = -1;
+    for (let i = 0; i < map.height; i++) {
         cellsPositions.push(map.map.slice(i * map.width, (i * map.width) + map.width));
         if (column === -1) {
             column = cellsPositions[i].lastIndexOf(cellPos);
         }
     }
-    var cells = [];
-    cellsPositions.forEach(function (row) {
-        var c = row[column];
+    const cells = [];
+    cellsPositions.forEach((row) => {
+        const c = row[column];
         if (row[column] !== row[column + 1]) {
             cells.push(c);
         }
     });
-    cells.forEach((function (cPos) {
-        var pos = start + cPos + table.nodeAt(cPos).nodeSize - 1;
-        var dom = document.createElement('div');
+    cells.forEach((cPos => {
+        const pos = start + cPos + table.nodeAt(cPos).nodeSize - 1;
+        const dom = document.createElement('div');
         dom.className = 'column-resize-handle';
         decorations.push(Decoration.widget(pos, dom));
     }));
     return DecorationSet.create(state.doc, decorations);
 }
+
+export { columnResizing };

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

@@ -1,9 +1,12 @@
-import { columnResizing } from './column-resize';
-import { tableResizing as tableResize } from './table-resize';
-import { rowResizing } from './row-resize';
-export var tableResizing = function () { return [
-    tableResize(),
+import { columnResizing } from './column-resize.js';
+import { tableResizing as tableResizing$1 } from './table-resize.js';
+import { rowResizing } from './row-resize.js';
+export { tableColumnResizeKey, tableResizeKey, tableRowResizeKey } from './utils.js';
+
+const tableResizing = () => [
+    tableResizing$1(),
     columnResizing(),
     rowResizing()
-]; };
-export { tableResizeKey, tableColumnResizeKey, tableRowResizeKey } from './utils';
+];
+
+export { tableResizing };