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

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

@@ -1,78 +1,76 @@
-"use strict";
-Object.defineProperty(exports, "__esModule", { value: true });
-exports.columnResizing = void 0;
-var tslib_1 = require("tslib");
-var prosemirror_state_1 = require("prosemirror-state");
-var prosemirror_tables_1 = require("prosemirror-tables");
-var prosemirror_view_1 = require("prosemirror-view");
-var constants_1 = require("../../config/constants");
-var table_view_1 = require("./table-view");
-var utils_1 = require("./../../utils");
-var utils_2 = require("./utils");
+'use strict';
+
+var prosemirrorState = require('prosemirror-state');
+var prosemirrorTables = require('prosemirror-tables');
+var prosemirrorView = require('prosemirror-view');
+var constants = require('../../config/constants.js');
+var tableView = require('./table-view.js');
+var utils$1 = require('../../utils.js');
+var utils = require('./utils.js');
+
 function columnResizing() {
-    var handleWidth = 5, cellMinWidth = 25;
-    var plugin = new prosemirror_state_1.Plugin({
-        key: utils_2.tableColumnResizeKey,
+    const handleWidth = 5, cellMinWidth = 25;
+    const plugin = new prosemirrorState.Plugin({
+        key: utils.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 ((0, utils_2.otherResizeHandle)(utils_2.tableColumnResizeKey, state)) {
+            attributes(state) {
+                if (utils.otherResizeHandle(utils.tableColumnResizeKey, state)) {
                     return null;
                 }
-                var pluginState = utils_2.tableColumnResizeKey.getState(state);
+                const pluginState = utils.tableColumnResizeKey.getState(state);
                 return pluginState.activeHandle > -1 ? { class: 'resize-cursor' } : null;
             },
             handleDOMEvents: {
-                mousemove: function (view, event) {
-                    if (!(0, utils_2.otherResizing)(utils_2.tableColumnResizeKey, view.state)) {
+                mousemove(view, event) {
+                    if (!utils.otherResizing(utils.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 (!(0, utils_2.otherResizing)(utils_2.tableColumnResizeKey, state)) {
-                    var pluginState = utils_2.tableColumnResizeKey.getState(state);
+            decorations(state) {
+                if (!utils.otherResizing(utils.tableColumnResizeKey, state)) {
+                    const pluginState = utils.tableColumnResizeKey.getState(state);
                     if (pluginState.activeHandle > -1) {
                         return handleDecorations(state, pluginState.activeHandle);
                     }
                 }
-                return prosemirror_view_1.DecorationSet.empty;
+                return prosemirrorView.DecorationSet.empty;
             },
             nodeViews: {
-                table_wrapper: function (node, view) { return new table_view_1.TableWrapperView(node, view); },
-                table: function (node, view) { return new table_view_1.TableView(node, view); }
+                table_wrapper: (node, view) => new tableView.TableWrapperView(node, view),
+                table: (node, view) => new tableView.TableView(node, view)
             }
         }
     });
     return plugin;
 }
-exports.columnResizing = 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(utils_2.tableColumnResizeKey);
+    apply(tr) {
+        let state;
+        const action = tr.getMeta(utils.tableColumnResizeKey);
         if (action && action.setHandle != null) {
             return new ResizeState(action.setHandle, null);
         }
@@ -80,30 +78,29 @@ 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 = utils_2.tableColumnResizeKey.getState(view.state);
+    const pluginState = utils.tableColumnResizeKey.getState(view.state);
     if (!pluginState.dragging) {
-        var target = (0, utils_2.domCellAround)(event.target);
-        var cell = -1;
+        const target = utils.domCellAround(event.target);
+        let cell = -1;
         if (target) {
-            var indexes = (0, utils_2.cellIndexes)(target);
-            var _a = target.getBoundingClientRect(), left = _a.left, right = _a.right;
+            const indexes = utils.cellIndexes(target);
+            const { left, right } = target.getBoundingClientRect();
             if (Math.abs(event.clientX - left) <= handleWidth && indexes.cellIndex > 0) {
                 indexes.cellIndex -= target.colSpan;
-                cell = (0, utils_2.edgeCell)(view, event, indexes);
+                cell = utils.edgeCell(view, event, indexes);
             }
             else if (right - event.clientX > 0 && right - event.clientX <= handleWidth) {
-                cell = (0, utils_2.edgeCell)(view, event, indexes);
+                cell = utils.edgeCell(view, event, indexes);
             }
         }
         if (cell !== pluginState.activeHandle) {
@@ -112,82 +109,84 @@ function handleMouseMove(view, event, handleWidth) {
     }
 }
 function handleMouseLeave(view) {
-    var pluginState = utils_2.tableColumnResizeKey.getState(view.state);
+    const pluginState = utils.tableColumnResizeKey.getState(view.state);
     if (pluginState.activeHandle > -1 && !pluginState.dragging) {
         updateHandle(view, -1);
     }
 }
 function handleMouseDown(view, event, cellMinWidth) {
-    var _a;
-    var pluginState = utils_2.tableColumnResizeKey.getState(view.state);
+    const pluginState = utils.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;
-    if (tableNode.attrs[constants_1.colgroupAttr]) {
-        var colgroup = tableDom.firstChild;
+    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[constants.colgroupAttr]) {
+        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 = tslib_1.__assign(tslib_1.__assign({}, tableNode.attrs), (_a = {}, _a[constants_1.colgroupAttr] = '<colgroup>' + cols.reduce(function (acc, cur) { return acc + cur.outerHTML; }, '') + '</colgroup>', _a));
+        tableAttrs = {
+            ...tableNode.attrs,
+            [constants.colgroupAttr]: '<colgroup>' + cols.reduce((acc, cur) => acc + cur.outerHTML, '') + '</colgroup>'
+        };
     }
-    var width = parseFloat(col.style.width);
-    var tr = view.state.tr.setMeta(utils_2.tableColumnResizeKey, { setDragging: { startX: event.clientX, startWidth: width } });
+    const width = parseFloat(col.style.width);
+    const tr = view.state.tr.setMeta(utils.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);
-            tableAttrs = (0, utils_1.setNodeStyle)(tableAttrs || tableNode.attrs, 'width', sum + 'px');
+            const sum = widths.reduce((acc, cur) => acc + parseFloat(cur), 0);
+            tableAttrs = utils$1.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 = utils_2.tableColumnResizeKey.getState(view.state);
+        const curPluginState = utils.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(utils_2.tableColumnResizeKey, { setDragging: null }));
+            view.dispatch(transaction.setMeta(utils.tableColumnResizeKey, { setDragging: null }));
         }
     }
     function move(ev) {
         if (!ev.which) {
             return finish(ev);
         }
-        var curPluginState = utils_2.tableColumnResizeKey.getState(view.state);
-        var dragged = draggedWidth(curPluginState.dragging, ev, cellMinWidth);
+        const curPluginState = utils.tableColumnResizeKey.getState(view.state);
+        const dragged = draggedWidth(curPluginState.dragging, ev, cellMinWidth);
         displayColumnWidth(view, curPluginState.activeHandle, dragged);
     }
     event.view.addEventListener('mouseup', finish);
@@ -196,77 +195,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(utils_2.tableColumnResizeKey, { setHandle: value });
+    tr.setMeta(utils.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;
-    if (tableNode && attrs[constants_1.colgroupAttr]) {
-        var colgroup = tableDom.firstChild;
-        attrs = tslib_1.__assign(tslib_1.__assign({}, attrs), (_a = {}, _a[constants_1.colgroupAttr] = colgroup.outerHTML, _a));
+    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[constants.colgroupAttr]) {
+        const colgroup = tableDom.firstChild;
+        attrs = { ...attrs, [constants.colgroupAttr]: colgroup.outerHTML };
     }
-    var tableDomWidth = tableDom.style.width;
-    if (tableDom && tableDomWidth && (0, utils_1.parseStyle)(attrs.style).width !== tableDomWidth) {
-        attrs = (0, utils_1.setNodeStyle)(attrs, 'width', tableDomWidth);
+    const tableDomWidth = tableDom.style.width;
+    if (tableDom && tableDomWidth && utils$1.parseStyle(attrs.style).width !== tableDomWidth) {
+        attrs = utils$1.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 = prosemirror_tables_1.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 = prosemirrorTables.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 = prosemirror_tables_1.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 = prosemirrorTables.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(prosemirror_view_1.Decoration.widget(pos, dom));
+        decorations.push(prosemirrorView.Decoration.widget(pos, dom));
     }));
-    return prosemirror_view_1.DecorationSet.create(state.doc, decorations);
+    return prosemirrorView.DecorationSet.create(state.doc, decorations);
 }
+
+exports.columnResizing = columnResizing;

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

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

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

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