@progress/kendo-angular-editor 2.5.0 → 3.0.0-dev.202201191455

package/dist/es/config/tables/TableMap.js

@@ -1,333 +0,0 @@
-/**-----------------------------------------------------------------------------------------
-* Copyright © 2021 Progress Software Corporation. All rights reserved.
-* Licensed under commercial license. See LICENSE.md in the project root for more information
-*-------------------------------------------------------------------------------------------*/
-import { isTable, isTableBody, isTableHead, isTableFoot } from '../utils';
-// Because working with row and column-spanning cells is not quite
-// trivial, this code builds up a descriptive structure for a given
-// table node. The structures are cached with the (persistent) table
-// nodes as key, so that they only have to be recomputed when the
-// content of the table changes.
-//
-// This does mean that they have to store table-relative, not
-// document-relative positions. So code that uses them will typically
-// compute the start position of the table and offset positions passed
-// to or gotten from this structure by that amount.
-var readFromCache;
-var addToCache;
-// Prefer using a weak map to cache table maps. Fall back on a
-// fixed-size cache if that's not supported.
-if (typeof WeakMap !== 'undefined') {
-    var cache_1 = new WeakMap();
-    readFromCache = function (key) { return cache_1.get(key); };
-    addToCache = function (key, value) {
-        cache_1.set(key, value);
-        return value;
-    };
-}
-else {
-    var cache_2 = [];
-    var cacheSize_1 = 10;
-    var cachePos_1 = 0;
-    readFromCache = function (key) {
-        for (var i = 0; i < cache_2.length; i += 2) {
-            if (cache_2[i] === key) {
-                return cache_2[i + 1];
-            }
-        }
-    };
-    addToCache = function (key, value) {
-        if (cachePos_1 === cacheSize_1) {
-            cachePos_1 = 0;
-        }
-        cache_2[cachePos_1++] = key;
-        return (cache_2[cachePos_1++] = value);
-    };
-}
-var findWidth = function (table) {
-    var width = -1;
-    var hasRowSpan = false;
-    for (var row = 0; row < table.childCount; row++) {
-        var rowNode = table.child(row);
-        var rowWidth = 0;
-        if (hasRowSpan) {
-            for (var j = 0; j < row; j++) {
-                var prevRow = table.child(j);
-                for (var i = 0; i < prevRow.childCount; i++) {
-                    var cell = prevRow.child(i);
-                    if (j + cell.attrs.rowspan > row) {
-                        rowWidth += cell.attrs.colspan;
-                    }
-                }
-            }
-        }
-        // check if the cell spans accross multiple columns
-        for (var i = 0; i < rowNode.childCount; i++) {
-            var cell = rowNode.child(i);
-            rowWidth += cell.attrs.colspan;
-            if (cell.attrs.rowspan > 1) {
-                hasRowSpan = true;
-            }
-        }
-        if (width === -1) {
-            width = rowWidth;
-        }
-        else if (width !== rowWidth) {
-            width = Math.max(width, rowWidth);
-        }
-    }
-    return width;
-};
-var ɵ0 = findWidth;
-var freshColWidth = function (attrs) {
-    if (attrs.colwidth) {
-        return attrs.colwidth.slice();
-    }
-    var result = [];
-    for (var i = 0; i < attrs.colspan; i++) {
-        result.push(0);
-    }
-    return result;
-};
-var ɵ1 = freshColWidth;
-var findBadColWidths = function (map, colWidths, table) {
-    if (!map.problems) {
-        map.problems = [];
-    }
-    for (var i = 0, seen = {}; i < map.map.length; i++) {
-        var pos = map.map[i];
-        if (seen[pos]) {
-            continue;
-        }
-        seen[pos] = true;
-        var node = table.nodeAt(pos);
-        var updated = null;
-        for (var j = 0; j < node.attrs.colspan; j++) {
-            var col = (i + j) % map.width;
-            var colWidth = colWidths[col * 2];
-            if (colWidth != null && (!node.attrs.colwidth || node.attrs.colwidth[j] !== colWidth)) {
-                (updated || (updated = freshColWidth(node.attrs)))[j] = colWidth;
-            }
-        }
-        if (updated) {
-            map.problems.unshift({ type: 'colwidth mismatch', pos: pos, colwidth: updated });
-        }
-    }
-};
-var ɵ2 = findBadColWidths;
-// Compute a table map.
-var computeMap = function (tableNode) {
-    if (!isTable(tableNode) && !isTableBody(tableNode) && !isTableHead(tableNode) && !isTableFoot(tableNode)) {
-        throw new RangeError('Not a table node: ' + tableNode.type.name);
-    }
-    var width = findWidth(tableNode);
-    var height = tableNode.childCount;
-    var map = [];
-    var mapPos = 0;
-    var problems = null;
-    var colWidths = [];
-    for (var i = 0, e = width * height; i < e; i++) {
-        map[i] = 0;
-    }
-    for (var row = 0, pos = 0; row < height; row++) {
-        var rowNode = tableNode.child(row);
-        pos++;
-        for (var i = 0;; i++) {
-            while (mapPos < map.length && map[mapPos] !== 0) {
-                mapPos++;
-            }
-            if (i === rowNode.childCount) {
-                break;
-            }
-            var cellNode = rowNode.child(i);
-            var _a = cellNode.attrs, colspan = _a.colspan, rowspan = _a.rowspan, colwidth = _a.colwidth;
-            for (var h = 0; h < rowspan; h++) {
-                if (h + row >= height) {
-                    (problems || (problems = [])).push({ type: 'overlong_rowspan', pos: pos, n: rowspan - h });
-                    break;
-                }
-                var start = mapPos + h * width;
-                for (var w = 0; w < colspan; w++) {
-                    if (map[start + w] === 0) {
-                        map[start + w] = pos;
-                    }
-                    else {
-                        (problems || (problems = [])).push({ type: 'collision', row: row, pos: pos, n: colspan - w });
-                    }
-                    var colW = colwidth && colwidth[w];
-                    if (colW) {
-                        var widthIndex = ((start + w) % width) * 2, prev = colWidths[widthIndex];
-                        if (prev == null || (prev !== colW && colWidths[widthIndex + 1] === 1)) {
-                            colWidths[widthIndex] = colW;
-                            colWidths[widthIndex + 1] = 1;
-                        }
-                        else if (prev === colW) {
-                            colWidths[widthIndex + 1]++;
-                        }
-                    }
-                }
-            }
-            mapPos += colspan;
-            pos += cellNode.nodeSize;
-        }
-        var expectedPos = (row + 1) * width;
-        var missing = 0;
-        while (mapPos < expectedPos) {
-            if (map[mapPos++] === 0) {
-                missing++;
-            }
-        }
-        if (missing) {
-            (problems || (problems = [])).push({ type: 'missing', row: row, n: missing });
-        }
-        pos++;
-    }
-    var tableMap = new TableMap(width, height, map, problems);
-    var badWidths = false;
-    // For columns that have defined widths, but whose widths disagree
-    // between rows, fix up the cells whose width doesn't match the
-    // computed one.
-    for (var i = 0; !badWidths && i < colWidths.length; i += 2) {
-        if (colWidths[i] != null && colWidths[i + 1] < height) {
-            badWidths = true;
-        }
-    }
-    if (badWidths) {
-        findBadColWidths(tableMap, colWidths, tableNode);
-    }
-    return tableMap;
-};
-var ɵ3 = computeMap;
-/**
- * @hidden
- */
-var Rect = /** @class */ (function () {
-    function Rect(left, top, right, bottom) {
-        this.left = left;
-        this.top = top;
-        this.right = right;
-        this.bottom = bottom;
-    }
-    return Rect;
-}());
-export { Rect };
-/**
- * @hidden
- */
-var TableMap = /** @class */ (function () {
-    function TableMap(width, height, map, problems) {
-        // :: number The width of the table
-        this.width = width;
-        // :: number The table's height
-        this.height = height;
-        // :: [number] A width * height array with the start position of
-        // the cell covering that part of the table in each slot
-        this.map = map;
-        // An optional array of problems (cell overlap or non-rectangular
-        // shape) for the table, used by the table normalizer.
-        this.problems = problems;
-    }
-    // :: (Node) → TableMap
-    // Find the table map for the given table node.
-    TableMap.get = function (table) {
-        return readFromCache(table) || addToCache(table, computeMap(table));
-    };
-    // :: (number) → Rect
-    // Find the dimensions of the cell at the given position.
-    TableMap.prototype.findCell = function (pos) {
-        for (var i = 0; i < this.map.length; i++) {
-            var curPos = this.map[i];
-            if (curPos !== pos) {
-                continue;
-            }
-            var left = i % this.width;
-            var top_1 = Math.floor(i / this.width);
-            var right = left + 1;
-            var bottom = top_1 + 1;
-            for (var j = 1; right < this.width && this.map[i + j] === curPos; j++) {
-                right++;
-            }
-            for (var j = 1; bottom < this.height && this.map[i + this.width * j] === curPos; j++) {
-                bottom++;
-            }
-            return new Rect(left, top_1, right, bottom);
-        }
-        throw new RangeError('No cell with offset ' + pos + ' found');
-    };
-    // :: (number) → number
-    // Find the left side of the cell at the given position.
-    TableMap.prototype.colCount = function (pos) {
-        for (var i = 0; i < this.map.length; i++) {
-            if (this.map[i] === pos) {
-                return i % this.width;
-            }
-        }
-        throw new RangeError('No cell with offset ' + pos + ' found');
-    };
-    // :: (number, string, number) → ?number
-    // Find the next cell in the given direction, starting from the cell
-    // at `pos`, if any.
-    TableMap.prototype.nextCell = function (pos, axis, dir) {
-        var _a = this.findCell(pos), left = _a.left, right = _a.right, top = _a.top, bottom = _a.bottom;
-        if (axis === 'horiz') {
-            if (dir < 0 ? left === 0 : right === this.width) {
-                return null;
-            }
-            return this.map[top * this.width + (dir < 0 ? left - 1 : right)];
-        }
-        else {
-            if (dir < 0 ? top === 0 : bottom === this.height) {
-                return null;
-            }
-            return this.map[left + this.width * (dir < 0 ? top - 1 : bottom)];
-        }
-    };
-    // :: (number, number) → Rect
-    // Get the rectangle spanning the two given cells.
-    TableMap.prototype.rectBetween = function (a, b) {
-        var _a = this.findCell(a), leftA = _a.left, rightA = _a.right, topA = _a.top, bottomA = _a.bottom;
-        var _b = this.findCell(b), leftB = _b.left, rightB = _b.right, topB = _b.top, bottomB = _b.bottom;
-        return new Rect(Math.min(leftA, leftB), Math.min(topA, topB), Math.max(rightA, rightB), Math.max(bottomA, bottomB));
-    };
-    // :: (Rect) → [number]
-    // Return the position of all cells that have the top left corner in
-    // the given rectangle.
-    TableMap.prototype.cellsInRect = function (rect) {
-        var result = [];
-        var seen = {};
-        for (var row = rect.top; row < rect.bottom; row++) {
-            for (var col = rect.left; col < rect.right; col++) {
-                var index = row * this.width + col, pos = this.map[index];
-                if (seen[pos]) {
-                    continue;
-                }
-                seen[pos] = true;
-                if ((col !== rect.left || !col || this.map[index - 1] !== pos) &&
-                    (row !== rect.top || !row || this.map[index - this.width] !== pos)) {
-                    result.push(pos);
-                }
-            }
-        }
-        return result;
-    };
-    // :: (number, number, Node) → number
-    // Return the position at which the cell at the given row and column
-    // starts, or would start, if a cell started there.
-    TableMap.prototype.positionAt = function (row, col, table) {
-        for (var i = 0, rowStart = 0;; i++) {
-            var rowEnd = rowStart + table.child(i).nodeSize;
-            if (i === row) {
-                var index = col + row * this.width, rowEndIndex = (row + 1) * this.width;
-                // Skip past cells from previous rows (via rowspan)
-                while (index < rowEndIndex && this.map[index] < rowStart) {
-                    index++;
-                }
-                return index === rowEndIndex ? rowEnd - 1 : this.map[index];
-            }
-            rowStart = rowEnd;
-        }
-    };
-    return TableMap;
-}());
-export { TableMap };
-export { ɵ0, ɵ1, ɵ2, ɵ3 };

package/dist/es/config/tables/table-utils.js

@@ -1,302 +0,0 @@
-/**-----------------------------------------------------------------------------------------
-* Copyright © 2021 Progress Software Corporation. All rights reserved.
-* Licensed under commercial license. See LICENSE.md in the project root for more information
-*-------------------------------------------------------------------------------------------*/
-import { NodeSelection } from '@progress/kendo-editor-common';
-import { isTableRow, isTableCell } from '../utils';
-import { TableMap } from './TableMap';
-import { CellSelection } from './CellSelection';
-/**
- * @hidden
- */
-export var findParentNodeClosestToPos = function ($pos, predicate) {
-    for (var i = $pos.depth; i > 0; i--) {
-        var node = $pos.node(i);
-        if (predicate(node)) {
-            return {
-                start: $pos.start(i),
-                pos: i > 0 ? $pos.before(i) : 0,
-                depth: i,
-                node: node
-            };
-        }
-    }
-};
-/**
- * @hidden
- */
-export var createTable = function (nodes, rows, columns) {
-    var table = nodes.table, table_body = nodes.table_body, table_row = nodes.table_row, table_cell = nodes.table_cell;
-    var tableRows = [];
-    var cells;
-    for (var r = 0; r < rows + 1; r++) {
-        cells = [];
-        for (var c = 0; c < columns + 1; c++) {
-            cells.push(table_cell.createAndFill());
-        }
-        tableRows.push(table_row.createAndFill(undefined, cells));
-    }
-    var body = table_body.createAndFill(undefined, tableRows);
-    return table.createAndFill(undefined, body);
-};
-/**
- * @hidden
- */
-export var isInTable = function (state) {
-    var $head = state.selection.$head;
-    for (var d = $head.depth; d > 0; d--) {
-        if (isTableRow($head.node(d))) {
-            return true;
-        }
-    }
-    return false;
-};
-/**
- * @hidden
- */
-export var setAttr = function (attrs, name, value) {
-    var result = {};
-    // tslint:disable-next-line
-    for (var prop in attrs) {
-        result[prop] = attrs[prop];
-    }
-    result[name] = value;
-    return result;
-};
-var cellNear = function ($pos) {
-    for (var after = $pos.nodeAfter, pos = $pos.pos; after; after = after.firstChild, pos++) {
-        var role = after.type.spec.tableRole;
-        if (role === 'cell' || role === 'header_cell') {
-            return $pos.doc.resolve(pos);
-        }
-    }
-    for (var before = $pos.nodeBefore, pos = $pos.pos; before; before = before.lastChild, pos--) {
-        var role = before.type.spec.tableRole;
-        if (role === 'cell' || role === 'header_cell') {
-            return $pos.doc.resolve(pos - before.nodeSize);
-        }
-    }
-};
-var ɵ0 = cellNear;
-var cellAround = function ($pos) {
-    for (var d = $pos.depth - 1; d > 0; d--) {
-        if (isTableRow($pos.node(d))) {
-            return $pos.node(0).resolve($pos.before(d + 1));
-        }
-    }
-    return null;
-};
-var ɵ1 = cellAround;
-var selectionCell = function (sel) {
-    if (sel instanceof CellSelection && sel.$anchorCell) {
-        return sel.$anchorCell.pos > sel.$headCell.pos ? sel.$anchorCell : sel.$headCell;
-    }
-    else if (sel instanceof NodeSelection && sel.node && isTableCell(sel.node)) {
-        return sel.$anchor;
-    }
-    return cellAround(sel.$head) || cellNear(sel.$head);
-};
-var ɵ2 = selectionCell;
-/**
- * @hidden
- */
-// Helper to get the selected rectangle in a table, if any. Adds table
-// map, table node, and table start offset to the object for
-// convenience.
-export var selectedRect = function (sel) {
-    // create arr of rect for each table section
-    // there has to be a rect for thead, tbody and tfoot(if each exists)
-    // and NOT for colgroups
-    var $pos = selectionCell(sel);
-    var table = $pos.node(-1);
-    var tableStart = $pos.start(-1);
-    var map = TableMap.get(table);
-    var rect = sel instanceof CellSelection
-        ? map.rectBetween(sel.$anchorCell.pos - tableStart, sel.$headCell.pos - tableStart)
-        : map.findCell($pos.pos - tableStart);
-    rect.tableStart = tableStart;
-    rect.map = map;
-    rect.table = table;
-    return rect;
-};
-/**
- * @hidden
- */
-// this has to be removed since the schema should not have roles inside NodeSpec.
-export var tableNodeTypes = function (schema) {
-    var result = schema.cached.tableNodeTypes;
-    if (!result) {
-        result = schema.cached.tableNodeTypes = {};
-        // tslint:disable-next-line
-        for (var name_1 in schema.nodes) {
-            var type = schema.nodes[name_1];
-            var role = type.spec.tableRole;
-            if (role) {
-                result[role] = type;
-            }
-        }
-    }
-    return result;
-};
-/**
- * @hidden
- */
-export var rowIsHeader = function (map, table, row) {
-    var headerCell = tableNodeTypes(table.type.schema).header_cell;
-    for (var col = 0; col < map.width; col++) {
-        if (table.nodeAt(map.map[col + row * map.width]).type !== headerCell) {
-            return false;
-        }
-    }
-    return true;
-};
-/**
- * @hidden
- */
-export var addColSpan = function (attrs, pos, n) {
-    if (n === void 0) { n = 1; }
-    var result = setAttr(attrs, 'colspan', attrs.colspan + n);
-    if (result.colwidth) {
-        result.colwidth = result.colwidth.slice();
-        for (var i = 0; i < n; i++) {
-            result.colwidth.splice(pos, 0, 0);
-        }
-    }
-    return result;
-};
-/**
- * @hidden
- */
-export var removeColSpan = function (attrs, pos, n) {
-    if (n === void 0) { n = 1; }
-    var result = setAttr(attrs, 'colspan', attrs.colspan - n);
-    if (result.colwidth) {
-        result.colwidth = result.colwidth.slice();
-        result.colwidth.splice(pos, n);
-        if (!result.colwidth.some(function (w) { return w > 0; })) {
-            result.colwidth = null;
-        }
-    }
-    return result;
-};
-/**
- * @hidden
- */
-export var isCellEmpty = function (cell) {
-    var c = cell.content;
-    return c.childCount === 1 && c.firstChild.isTextblock && c.firstChild.childCount === 0;
-};
-var cellWrapping = function ($pos) {
-    for (var d = $pos.depth; d > 0; d--) {
-        // Sometimes the cell can be in the same depth.
-        var role = $pos.node(d).type.spec.tableRole;
-        if (role === 'cell' || role === 'header_cell') {
-            return $pos.node(d);
-        }
-    }
-    return null;
-};
-var ɵ3 = cellWrapping;
-/**
- * @hidden
- */
-// Split a selected cell, whose rowpan or colspan is greater than one,
-// into smaller cells with the cell type (th, td) returned by getType function.
-export var splitCellWithType = function (getCellType) {
-    return function (state, dispatch) {
-        var sel = state.selection;
-        var cellNode;
-        var cellPos;
-        if (!(sel instanceof CellSelection)) {
-            cellNode = cellWrapping(sel.$from);
-            if (!cellNode) {
-                return false;
-            }
-            cellPos = cellAround(sel.$from).pos;
-        }
-        else {
-            if (sel.$anchorCell.pos !== sel.$headCell.pos) {
-                return false;
-            }
-            cellNode = sel.$anchorCell.nodeAfter;
-            cellPos = sel.$anchorCell.pos;
-        }
-        if (cellNode.attrs.colspan === 1 && cellNode.attrs.rowspan === 1) {
-            return false;
-        }
-        if (dispatch) {
-            var baseAttrs = cellNode.attrs;
-            var attrs = [];
-            var colwidth = baseAttrs.colwidth;
-            if (baseAttrs.rowspan > 1) {
-                baseAttrs = setAttr(baseAttrs, 'rowspan', 1);
-            }
-            if (baseAttrs.colspan > 1) {
-                baseAttrs = setAttr(baseAttrs, 'colspan', 1);
-            }
-            var rect = selectedRect(state);
-            var tr = state.tr;
-            for (var i = 0; i < rect.right - rect.left; i++) {
-                attrs.push(colwidth ? setAttr(baseAttrs, 'colwidth', colwidth && colwidth[i] ? [colwidth[i]] : null) : baseAttrs);
-            }
-            var lastCell = void 0;
-            for (var row = rect.top; row < rect.bottom; row++) {
-                var pos = rect.map.positionAt(row, rect.left, rect.table);
-                if (row === rect.top) {
-                    pos += cellNode.nodeSize;
-                }
-                for (var col = rect.left, i = 0; col < rect.right; col++, i++) {
-                    if (col === rect.left && row === rect.top) {
-                        continue;
-                    }
-                    tr.insert((lastCell = tr.mapping.map(pos + rect.tableStart, 1)), getCellType({ node: cellNode, row: row, col: col }).createAndFill(attrs[i]));
-                }
-            }
-            tr.setNodeMarkup(cellPos, getCellType({ node: cellNode, row: rect.top, col: rect.left }), attrs[0]);
-            if (sel instanceof CellSelection) {
-                tr.setSelection(new CellSelection(tr.doc.resolve(sel.$anchorCell.pos), lastCell && tr.doc.resolve(lastCell)));
-            }
-            dispatch(tr);
-        }
-        return true;
-    };
-};
-/**
- * @hidden
- */
-export var pointsAtCell = function ($pos) {
-    return isTableRow($pos.parent) && $pos.nodeAfter;
-};
-/**
- * @hidden
- */
-export var inSameTable = function ($a, $b) {
-    return $a.depth === $b.depth && $a.pos >= $b.start(-1) && $a.pos <= $b.end(-1);
-};
-/**
- * @hidden
- */
-export var cellsOverlapRectangle = function (_a, rect) {
-    var width = _a.width, height = _a.height, map = _a.map;
-    var indexTop = rect.top * width + rect.left;
-    var indexLeft = indexTop;
-    var indexBottom = (rect.bottom - 1) * width + rect.left;
-    var indexRight = indexTop + (rect.right - rect.left - 1);
-    for (var i = rect.top; i < rect.bottom; i++) {
-        if ((rect.left > 0 && map[indexLeft] === map[indexLeft - 1]) || (rect.right < width && map[indexRight] === map[indexRight + 1])) {
-            return true;
-        }
-        indexLeft += width;
-        indexRight += width;
-    }
-    for (var i = rect.left; i < rect.right; i++) {
-        if ((rect.top > 0 && map[indexTop] === map[indexTop - width]) ||
-            (rect.bottom < height && map[indexBottom] === map[indexBottom + width])) {
-            return true;
-        }
-        indexTop++;
-        indexBottom++;
-    }
-    return false;
-};
-export { ɵ0, ɵ1, ɵ2, ɵ3 };