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

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

@@ -1,57 +1,55 @@
 import { Plugin } from 'prosemirror-state';
-import { TableMap, tableNodeTypes } from 'prosemirror-tables';
-import { Decoration, DecorationSet } from 'prosemirror-view';
-import { cellIndexes, domCellAround, otherResizeHandle, otherResizing, tableRowResizeKey as key, edgeCell } from './utils';
-import { parseStyle, setNodeStyle } from './../../utils';
-var TableRowView = /** @class */ (function () {
-    function TableRowView() {
-    }
-    TableRowView.prototype.ignoreMutation = function (record) {
+import { tableNodeTypes, TableMap } from 'prosemirror-tables';
+import { DecorationSet, Decoration } from 'prosemirror-view';
+import { tableRowResizeKey, otherResizeHandle, otherResizing, domCellAround, cellIndexes, edgeCell } from './utils.js';
+import { parseStyle, setNodeStyle } from '../../utils.js';
+
+class TableRowView {
+    ignoreMutation(record) {
         return record.type === 'attributes' && record.attributeName === 'style' && record.target.nodeName === 'TR';
-    };
-    return TableRowView;
-}());
-export function rowResizing() {
-    var handleWidth = 5;
-    var plugin = new Plugin({
-        key: key,
+    }
+}
+function rowResizing() {
+    const handleWidth = 5;
+    const plugin = new Plugin({
+        key: tableRowResizeKey,
         state: {
-            init: function (_, state) {
-                this.spec.props.nodeViews[tableNodeTypes(state.schema).row.name] = function () { return new TableRowView(); };
+            init(_, state) {
+                this.spec.props.nodeViews[tableNodeTypes(state.schema).row.name] = () => new TableRowView();
                 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(tableRowResizeKey, state)) {
                     return null;
                 }
-                var pluginState = key.getState(state);
+                const pluginState = tableRowResizeKey.getState(state);
                 return pluginState.activeHandle > -1 ? { class: 'resize-cursor-vertical' } : null;
             },
             handleDOMEvents: {
-                mousemove: function (view, event) {
-                    if (!otherResizing(key, view.state)) {
+                mousemove(view, event) {
+                    if (!otherResizing(tableRowResizeKey, 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);
                 }
             },
-            decorations: function (state) {
-                if (otherResizing(key, state)) {
+            decorations(state) {
+                if (otherResizing(tableRowResizeKey, state)) {
                     return DecorationSet.empty;
                 }
-                var pluginState = key.getState(state);
+                const pluginState = tableRowResizeKey.getState(state);
                 if (pluginState.activeHandle > -1) {
                     return handleDecorations(state, pluginState.activeHandle);
                 }
@@ -64,13 +62,13 @@ export function rowResizing() {
 function pointsAtCell($pos) {
     return $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, action = tr.getMeta(key);
+    apply(tr) {
+        let state, action = tr.getMeta(tableRowResizeKey);
         if (action && action.setHandle != null) {
             return new ResizeState(action.setHandle, null);
         }
@@ -78,24 +76,23 @@ var ResizeState = /** @class */ (function () {
             return new ResizeState(this.activeHandle, action.setDragging);
         }
         if (this.activeHandle > -1) {
-            var handle = tr.mapping.map(this.activeHandle, -1);
+            let handle = tr.mapping.map(this.activeHandle, -1);
             if (!pointsAtCell(tr.doc.resolve(handle))) {
                 handle = null;
             }
             state = new ResizeState(handle, this.dragging);
         }
         return state || this;
-    };
-    return ResizeState;
-}());
+    }
+}
 function handleMouseMove(view, event, handleWidth) {
-    var pluginState = key.getState(view.state);
+    const pluginState = tableRowResizeKey.getState(view.state);
     if (!pluginState.dragging) {
-        var target = domCellAround(event.target), cell = -1;
+        let target = domCellAround(event.target), cell = -1;
         if (target) {
-            var indexes = cellIndexes(target);
-            var _a = target.getBoundingClientRect(), top_1 = _a.top, bottom = _a.bottom;
-            if (Math.abs(event.clientY - top_1) <= handleWidth && indexes.rowIndex > 0) {
+            const indexes = cellIndexes(target);
+            const { top, bottom } = target.getBoundingClientRect();
+            if (Math.abs(event.clientY - top) <= handleWidth && indexes.rowIndex > 0) {
                 indexes.rowIndex -= target.rowSpan;
                 cell = edgeCell(view, event, indexes);
             }
@@ -109,39 +106,39 @@ function handleMouseMove(view, event, handleWidth) {
     }
 }
 function handleMouseLeave(view) {
-    var pluginState = key.getState(view.state);
+    const pluginState = tableRowResizeKey.getState(view.state);
     if (pluginState.activeHandle > -1 && !pluginState.dragging) {
         updateHandle(view, -1);
     }
 }
 function handleMouseDown(view, event) {
-    var pluginState = key.getState(view.state);
+    const pluginState = tableRowResizeKey.getState(view.state);
     if (pluginState.activeHandle === -1 || pluginState.dragging) {
         return false;
     }
-    var doc = view.state.doc;
-    var $cell = doc.resolve(pluginState.activeHandle);
-    var row = $cell.parent;
-    var table = $cell.node(-1);
-    var rowHeightStr = parseStyle(row.attrs.style).height;
-    var tableHeight = parseStyle(table.attrs.style).height;
-    var rowHeight = rowHeightStr ? parseFloat(rowHeightStr) : 0;
+    const doc = view.state.doc;
+    const $cell = doc.resolve(pluginState.activeHandle);
+    const row = $cell.parent;
+    const table = $cell.node(-1);
+    const rowHeightStr = parseStyle(row.attrs.style).height;
+    const tableHeight = parseStyle(table.attrs.style).height;
+    let rowHeight = rowHeightStr ? parseFloat(rowHeightStr) : 0;
     if (!rowHeightStr) {
-        var tr = view.nodeDOM(pluginState.activeHandle);
+        const tr = view.nodeDOM(pluginState.activeHandle);
         rowHeight = tr.offsetHeight;
     }
-    view.dispatch(view.state.tr.setMeta(key, {
+    view.dispatch(view.state.tr.setMeta(tableRowResizeKey, {
         setDragging: {
             startY: event.clientY,
-            startHeight: { rowHeight: rowHeight, tableHeight: tableHeight }
+            startHeight: { rowHeight, tableHeight }
         }
     }));
     function finish(ev) {
         ev.view.removeEventListener('mouseup', finish);
         ev.view.removeEventListener('mousemove', move);
-        var curPluginState = key.getState(view.state);
+        const curPluginState = tableRowResizeKey.getState(view.state);
         if (curPluginState.dragging) {
-            var tr = view.state.tr.setMeta(key, { setDragging: null });
+            const tr = view.state.tr.setMeta(tableRowResizeKey, { setDragging: null });
             updateRowHeight(view, tr, curPluginState.activeHandle);
             view.dispatch(tr);
         }
@@ -150,9 +147,9 @@ function handleMouseDown(view, event) {
         if (!ev.which) {
             return finish(ev);
         }
-        var curPluginState = key.getState(view.state);
-        var dragged = draggedHeight(curPluginState.dragging, ev);
-        var offset = ev.clientY - curPluginState.dragging.startY;
+        const curPluginState = tableRowResizeKey.getState(view.state);
+        const dragged = draggedHeight(curPluginState.dragging, ev);
+        const offset = ev.clientY - curPluginState.dragging.startY;
         displayRowHeight(view, curPluginState.activeHandle, dragged, offset, tableHeight);
     }
     event.view.addEventListener('mouseup', finish);
@@ -161,42 +158,42 @@ function handleMouseDown(view, event) {
     return true;
 }
 function draggedHeight(dragging, event) {
-    var offset = event.clientY - dragging.startY;
+    const offset = event.clientY - dragging.startY;
     return dragging.startHeight.rowHeight + 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(tableRowResizeKey, { setHandle: value });
     view.dispatch(tr);
 }
 function updateRowHeight(view, tr, cellPos) {
-    var doc = view.state.doc;
-    var $cell = doc.resolve(cellPos);
-    var row = $cell.parent;
-    var rowPos = $cell.posAtIndex(0) - 1;
-    var dom = view.nodeDOM(rowPos);
-    var win = (dom.ownerDocument && dom.ownerDocument.defaultView) || window;
+    const doc = view.state.doc;
+    const $cell = doc.resolve(cellPos);
+    const row = $cell.parent;
+    const rowPos = $cell.posAtIndex(0) - 1;
+    const dom = view.nodeDOM(rowPos);
+    const win = (dom.ownerDocument && dom.ownerDocument.defaultView) || window;
     dom.style.height = win.getComputedStyle(dom).height;
     tr.setNodeMarkup(rowPos, null, setNodeStyle(row.attrs, 'height', dom.style.height));
-    var table = dom && dom.closest('table');
-    var tableHeight = table && table.style.height;
+    const table = dom && dom.closest('table');
+    const tableHeight = table && table.style.height;
     if (tableHeight) {
-        var $pos = doc.resolve(rowPos);
-        var tablePos = $pos.start($pos.depth) - 1;
+        const $pos = doc.resolve(rowPos);
+        const tablePos = $pos.start($pos.depth) - 1;
         tr.setNodeMarkup(tablePos, null, setNodeStyle($pos.parent.attrs, 'height', tableHeight));
     }
 }
 function displayRowHeight(view, cellPos, height, offset, tableHeight) {
-    var cell = view.nodeDOM(cellPos);
-    var row = cell && cell.parentNode;
+    const cell = view.nodeDOM(cellPos);
+    const row = cell && cell.parentNode;
     if (row) {
         row.style.height = height + 'px';
-        var win = (row.ownerDocument && row.ownerDocument.defaultView) || window;
+        const win = (row.ownerDocument && row.ownerDocument.defaultView) || window;
         row.style.height = win.getComputedStyle(row).height;
-        var table = row.closest('table');
-        var newHeight = (parseFloat(tableHeight) + offset) + 'px';
-        var current = table && table.style.height;
+        const table = row.closest('table');
+        const newHeight = (parseFloat(tableHeight) + offset) + 'px';
+        const current = table && table.style.height;
         if (current && current !== newHeight) {
             table.style.height = (parseFloat(tableHeight) + offset) + 'px';
             table.style.height = win.getComputedStyle(table).height;
@@ -204,32 +201,34 @@ function displayRowHeight(view, cellPos, height, offset, tableHeight) {
     }
 }
 function handleDecorations(state, cell) {
-    var decorations = [];
+    const decorations = [];
     if (typeof cell !== 'number') {
         return DecorationSet.empty;
     }
-    var $cell = state.doc.resolve(cell), table = $cell.node(-1), map = TableMap.get(table), start = $cell.start(-1);
-    var cellsPositions = [];
-    var cellPos = cell - start;
-    var rowIndex = -1;
-    for (var i = 0; i < map.height; i++) {
+    const $cell = state.doc.resolve(cell), table = $cell.node(-1), map = TableMap.get(table), start = $cell.start(-1);
+    const cellsPositions = [];
+    const cellPos = cell - start;
+    let rowIndex = -1;
+    for (let i = 0; i < map.height; i++) {
         cellsPositions.push(map.map.slice(i * map.width, (i * map.width) + map.width));
         if (cellsPositions[i].indexOf(cellPos) !== -1) {
             rowIndex = i;
         }
     }
-    var cells = [];
-    cellsPositions[rowIndex].forEach(function (c, i) {
+    const cells = [];
+    cellsPositions[rowIndex].forEach((c, i) => {
         if (!cellsPositions[rowIndex + 1] || c !== cellsPositions[rowIndex + 1][i]) {
             cells.push(c);
         }
     });
-    cells.forEach(function (cPos) {
-        var cellNode = table.nodeAt(cPos);
-        var widgetPos = start + cPos + (cellNode ? cellNode.nodeSize : 0) - 1;
-        var dom = document.createElement('div');
+    cells.forEach((cPos) => {
+        const cellNode = table.nodeAt(cPos);
+        const widgetPos = start + cPos + (cellNode ? cellNode.nodeSize : 0) - 1;
+        const dom = document.createElement('div');
         dom.className = 'row-resize-handle';
         decorations.push(Decoration.widget(widgetPos, dom));
     });
     return DecorationSet.create(state.doc, decorations);
 }
+
+export { rowResizing };