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

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

@@ -1,329 +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.
-let readFromCache;
-let 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') {
-    let cache = new WeakMap();
-    readFromCache = key => cache.get(key);
-    addToCache = (key, value) => {
-        cache.set(key, value);
-        return value;
-    };
-}
-else {
-    let cache = [];
-    let cacheSize = 10;
-    let cachePos = 0;
-    readFromCache = key => {
-        for (let i = 0; i < cache.length; i += 2) {
-            if (cache[i] === key) {
-                return cache[i + 1];
-            }
-        }
-    };
-    addToCache = (key, value) => {
-        if (cachePos === cacheSize) {
-            cachePos = 0;
-        }
-        cache[cachePos++] = key;
-        return (cache[cachePos++] = value);
-    };
-}
-const findWidth = (table) => {
-    let width = -1;
-    let hasRowSpan = false;
-    for (let row = 0; row < table.childCount; row++) {
-        const rowNode = table.child(row);
-        let rowWidth = 0;
-        if (hasRowSpan) {
-            for (let j = 0; j < row; j++) {
-                const prevRow = table.child(j);
-                for (let i = 0; i < prevRow.childCount; i++) {
-                    const cell = prevRow.child(i);
-                    if (j + cell.attrs.rowspan > row) {
-                        rowWidth += cell.attrs.colspan;
-                    }
-                }
-            }
-        }
-        // check if the cell spans accross multiple columns
-        for (let i = 0; i < rowNode.childCount; i++) {
-            const 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;
-};
-const ɵ0 = findWidth;
-const freshColWidth = attrs => {
-    if (attrs.colwidth) {
-        return attrs.colwidth.slice();
-    }
-    const result = [];
-    for (let i = 0; i < attrs.colspan; i++) {
-        result.push(0);
-    }
-    return result;
-};
-const ɵ1 = freshColWidth;
-const findBadColWidths = (map, colWidths, table) => {
-    if (!map.problems) {
-        map.problems = [];
-    }
-    for (let i = 0, seen = {}; i < map.map.length; i++) {
-        const pos = map.map[i];
-        if (seen[pos]) {
-            continue;
-        }
-        seen[pos] = true;
-        let node = table.nodeAt(pos);
-        let updated = null;
-        for (let j = 0; j < node.attrs.colspan; j++) {
-            const col = (i + j) % map.width;
-            const 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, colwidth: updated });
-        }
-    }
-};
-const ɵ2 = findBadColWidths;
-// Compute a table map.
-const computeMap = tableNode => {
-    if (!isTable(tableNode) && !isTableBody(tableNode) && !isTableHead(tableNode) && !isTableFoot(tableNode)) {
-        throw new RangeError('Not a table node: ' + tableNode.type.name);
-    }
-    const width = findWidth(tableNode);
-    const height = tableNode.childCount;
-    const map = [];
-    let mapPos = 0;
-    let problems = null;
-    const colWidths = [];
-    for (let i = 0, e = width * height; i < e; i++) {
-        map[i] = 0;
-    }
-    for (let row = 0, pos = 0; row < height; row++) {
-        const rowNode = tableNode.child(row);
-        pos++;
-        for (let i = 0;; i++) {
-            while (mapPos < map.length && map[mapPos] !== 0) {
-                mapPos++;
-            }
-            if (i === rowNode.childCount) {
-                break;
-            }
-            const cellNode = rowNode.child(i);
-            const { colspan, rowspan, colwidth } = cellNode.attrs;
-            for (let h = 0; h < rowspan; h++) {
-                if (h + row >= height) {
-                    (problems || (problems = [])).push({ type: 'overlong_rowspan', pos, n: rowspan - h });
-                    break;
-                }
-                const start = mapPos + h * width;
-                for (let w = 0; w < colspan; w++) {
-                    if (map[start + w] === 0) {
-                        map[start + w] = pos;
-                    }
-                    else {
-                        (problems || (problems = [])).push({ type: 'collision', row, pos, n: colspan - w });
-                    }
-                    const colW = colwidth && colwidth[w];
-                    if (colW) {
-                        const 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;
-        }
-        const expectedPos = (row + 1) * width;
-        let missing = 0;
-        while (mapPos < expectedPos) {
-            if (map[mapPos++] === 0) {
-                missing++;
-            }
-        }
-        if (missing) {
-            (problems || (problems = [])).push({ type: 'missing', row, n: missing });
-        }
-        pos++;
-    }
-    const tableMap = new TableMap(width, height, map, problems);
-    let 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 (let 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;
-};
-const ɵ3 = computeMap;
-/**
- * @hidden
- */
-export class Rect {
-    constructor(left, top, right, bottom) {
-        this.left = left;
-        this.top = top;
-        this.right = right;
-        this.bottom = bottom;
-    }
-}
-/**
- * @hidden
- */
-export class TableMap {
-    // :: (Node) → TableMap
-    // Find the table map for the given table node.
-    static get(table) {
-        return readFromCache(table) || addToCache(table, computeMap(table));
-    }
-    constructor(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;
-    }
-    // :: (number) → Rect
-    // Find the dimensions of the cell at the given position.
-    findCell(pos) {
-        for (let i = 0; i < this.map.length; i++) {
-            const curPos = this.map[i];
-            if (curPos !== pos) {
-                continue;
-            }
-            const left = i % this.width;
-            const top = Math.floor(i / this.width);
-            let right = left + 1;
-            let bottom = top + 1;
-            for (let j = 1; right < this.width && this.map[i + j] === curPos; j++) {
-                right++;
-            }
-            for (let j = 1; bottom < this.height && this.map[i + this.width * j] === curPos; j++) {
-                bottom++;
-            }
-            return new Rect(left, top, right, bottom);
-        }
-        throw new RangeError('No cell with offset ' + pos + ' found');
-    }
-    // :: (number) → number
-    // Find the left side of the cell at the given position.
-    colCount(pos) {
-        for (let 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.
-    nextCell(pos, axis, dir) {
-        const { left, right, top, bottom } = this.findCell(pos);
-        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.
-    rectBetween(a, b) {
-        const { left: leftA, right: rightA, top: topA, bottom: bottomA } = this.findCell(a);
-        const { left: leftB, right: rightB, top: topB, bottom: bottomB } = this.findCell(b);
-        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.
-    cellsInRect(rect) {
-        const result = [];
-        const seen = {};
-        for (let row = rect.top; row < rect.bottom; row++) {
-            for (let col = rect.left; col < rect.right; col++) {
-                const 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.
-    positionAt(row, col, table) {
-        for (let i = 0, rowStart = 0;; i++) {
-            const rowEnd = rowStart + table.child(i).nodeSize;
-            if (i === row) {
-                let 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;
-        }
-    }
-}
-export { ɵ0, ɵ1, ɵ2, ɵ3 };

package/dist/es2015/config/tables/table-utils.d.ts

@@ -1,77 +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 { NodeType, Node, EditorState, ResolvedPos, Schema, Selection } from '@progress/kendo-editor-common';
-import { Rect } from './TableMap';
-import { Predicate } from '../../common/predicate';
-/**
- * @hidden
- */
-export declare const findParentNodeClosestToPos: ($pos: ResolvedPos<any>, predicate: Predicate<any>) => {
-    start: number;
-    pos: number;
-    depth: number;
-    node: Node<any>;
-};
-/**
- * @hidden
- */
-export declare const createTable: (nodes: {
-    table: NodeType<any>;
-    table_row: NodeType<any>;
-    table_cell: NodeType<any>;
-    table_body: NodeType<any>;
-}, rows: number, columns: number) => Node<any>;
-/**
- * @hidden
- */
-export declare const isInTable: (state: EditorState<any>) => boolean;
-/**
- * @hidden
- */
-export declare const setAttr: (attrs: any, name: any, value: any) => {};
-/**
- * @hidden
- */
-export declare const selectedRect: (sel: Selection<any>) => Rect;
-/**
- * @hidden
- */
-export declare const tableNodeTypes: (schema: Schema<any, any>) => any;
-/**
- * @hidden
- */
-export declare const rowIsHeader: (map: any, table: any, row: any) => boolean;
-/**
- * @hidden
- */
-export declare const addColSpan: (attrs: any, pos: any, n?: number) => any;
-/**
- * @hidden
- */
-export declare const removeColSpan: (attrs: any, pos: any, n?: number) => any;
-/**
- * @hidden
- */
-export declare const isCellEmpty: (cell: any) => boolean;
-/**
- * @hidden
- */
-export declare const splitCellWithType: (getCellType: any) => (state: any, dispatch: any) => boolean;
-/**
- * @hidden
- */
-export declare const pointsAtCell: ($pos: ResolvedPos<any>) => Node<any>;
-/**
- * @hidden
- */
-export declare const inSameTable: ($a: ResolvedPos<any>, $b: ResolvedPos<any>) => boolean;
-/**
- * @hidden
- */
-export declare const cellsOverlapRectangle: ({ width, height, map }: {
-    width: any;
-    height: any;
-    map: any;
-}, rect: any) => boolean;

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

@@ -1,299 +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 const findParentNodeClosestToPos = ($pos, predicate) => {
-    for (let i = $pos.depth; i > 0; i--) {
-        const node = $pos.node(i);
-        if (predicate(node)) {
-            return {
-                start: $pos.start(i),
-                pos: i > 0 ? $pos.before(i) : 0,
-                depth: i,
-                node
-            };
-        }
-    }
-};
-/**
- * @hidden
- */
-export const createTable = (nodes, rows, columns) => {
-    const { table, table_body, table_row, table_cell } = nodes;
-    const tableRows = [];
-    let cells;
-    for (let r = 0; r < rows + 1; r++) {
-        cells = [];
-        for (let c = 0; c < columns + 1; c++) {
-            cells.push(table_cell.createAndFill());
-        }
-        tableRows.push(table_row.createAndFill(undefined, cells));
-    }
-    const body = table_body.createAndFill(undefined, tableRows);
-    return table.createAndFill(undefined, body);
-};
-/**
- * @hidden
- */
-export const isInTable = (state) => {
-    const $head = state.selection.$head;
-    for (let d = $head.depth; d > 0; d--) {
-        if (isTableRow($head.node(d))) {
-            return true;
-        }
-    }
-    return false;
-};
-/**
- * @hidden
- */
-export const setAttr = (attrs, name, value) => {
-    const result = {};
-    // tslint:disable-next-line
-    for (const prop in attrs) {
-        result[prop] = attrs[prop];
-    }
-    result[name] = value;
-    return result;
-};
-const cellNear = ($pos) => {
-    for (let after = $pos.nodeAfter, pos = $pos.pos; after; after = after.firstChild, pos++) {
-        const role = after.type.spec.tableRole;
-        if (role === 'cell' || role === 'header_cell') {
-            return $pos.doc.resolve(pos);
-        }
-    }
-    for (let before = $pos.nodeBefore, pos = $pos.pos; before; before = before.lastChild, pos--) {
-        const role = before.type.spec.tableRole;
-        if (role === 'cell' || role === 'header_cell') {
-            return $pos.doc.resolve(pos - before.nodeSize);
-        }
-    }
-};
-const ɵ0 = cellNear;
-const cellAround = ($pos) => {
-    for (let d = $pos.depth - 1; d > 0; d--) {
-        if (isTableRow($pos.node(d))) {
-            return $pos.node(0).resolve($pos.before(d + 1));
-        }
-    }
-    return null;
-};
-const ɵ1 = cellAround;
-const selectionCell = (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);
-};
-const ɵ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 const selectedRect = (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
-    const $pos = selectionCell(sel);
-    const table = $pos.node(-1);
-    const tableStart = $pos.start(-1);
-    const map = TableMap.get(table);
-    const 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 const tableNodeTypes = (schema) => {
-    let result = schema.cached.tableNodeTypes;
-    if (!result) {
-        result = schema.cached.tableNodeTypes = {};
-        // tslint:disable-next-line
-        for (const name in schema.nodes) {
-            const type = schema.nodes[name];
-            const role = type.spec.tableRole;
-            if (role) {
-                result[role] = type;
-            }
-        }
-    }
-    return result;
-};
-/**
- * @hidden
- */
-export const rowIsHeader = (map, table, row) => {
-    const headerCell = tableNodeTypes(table.type.schema).header_cell;
-    for (let col = 0; col < map.width; col++) {
-        if (table.nodeAt(map.map[col + row * map.width]).type !== headerCell) {
-            return false;
-        }
-    }
-    return true;
-};
-/**
- * @hidden
- */
-export const addColSpan = (attrs, pos, n = 1) => {
-    const result = setAttr(attrs, 'colspan', attrs.colspan + n);
-    if (result.colwidth) {
-        result.colwidth = result.colwidth.slice();
-        for (let i = 0; i < n; i++) {
-            result.colwidth.splice(pos, 0, 0);
-        }
-    }
-    return result;
-};
-/**
- * @hidden
- */
-export const removeColSpan = (attrs, pos, n = 1) => {
-    const result = setAttr(attrs, 'colspan', attrs.colspan - n);
-    if (result.colwidth) {
-        result.colwidth = result.colwidth.slice();
-        result.colwidth.splice(pos, n);
-        if (!result.colwidth.some(w => w > 0)) {
-            result.colwidth = null;
-        }
-    }
-    return result;
-};
-/**
- * @hidden
- */
-export const isCellEmpty = cell => {
-    const c = cell.content;
-    return c.childCount === 1 && c.firstChild.isTextblock && c.firstChild.childCount === 0;
-};
-const cellWrapping = ($pos) => {
-    for (let d = $pos.depth; d > 0; d--) {
-        // Sometimes the cell can be in the same depth.
-        const role = $pos.node(d).type.spec.tableRole;
-        if (role === 'cell' || role === 'header_cell') {
-            return $pos.node(d);
-        }
-    }
-    return null;
-};
-const ɵ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 const splitCellWithType = getCellType => {
-    return (state, dispatch) => {
-        const sel = state.selection;
-        let cellNode;
-        let 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) {
-            let baseAttrs = cellNode.attrs;
-            const attrs = [];
-            const colwidth = baseAttrs.colwidth;
-            if (baseAttrs.rowspan > 1) {
-                baseAttrs = setAttr(baseAttrs, 'rowspan', 1);
-            }
-            if (baseAttrs.colspan > 1) {
-                baseAttrs = setAttr(baseAttrs, 'colspan', 1);
-            }
-            const rect = selectedRect(state);
-            const tr = state.tr;
-            for (let i = 0; i < rect.right - rect.left; i++) {
-                attrs.push(colwidth ? setAttr(baseAttrs, 'colwidth', colwidth && colwidth[i] ? [colwidth[i]] : null) : baseAttrs);
-            }
-            let lastCell;
-            for (let row = rect.top; row < rect.bottom; row++) {
-                let pos = rect.map.positionAt(row, rect.left, rect.table);
-                if (row === rect.top) {
-                    pos += cellNode.nodeSize;
-                }
-                for (let 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, 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 const pointsAtCell = ($pos) => {
-    return isTableRow($pos.parent) && $pos.nodeAfter;
-};
-/**
- * @hidden
- */
-export const inSameTable = ($a, $b) => {
-    return $a.depth === $b.depth && $a.pos >= $b.start(-1) && $a.pos <= $b.end(-1);
-};
-/**
- * @hidden
- */
-export const cellsOverlapRectangle = ({ width, height, map }, rect) => {
-    let indexTop = rect.top * width + rect.left;
-    let indexLeft = indexTop;
-    let indexBottom = (rect.bottom - 1) * width + rect.left;
-    let indexRight = indexTop + (rect.right - rect.left - 1);
-    for (let 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 (let 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 };