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

package/dist/es2015/config/table-nodes.js

@@ -1,145 +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 { removeEmptyEntries } from '../util';
-import { serializeDOMAttrs, commonAttributes, createDefaultAttributes } from './utils';
-const setCellAttrs = nodeAttributes => {
-    let attrs = Object.assign({}, nodeAttributes);
-    if (nodeAttributes.colspan !== 1) {
-        attrs.colspan = nodeAttributes.colspan;
-    }
-    else {
-        attrs.colspan = null;
-    }
-    if (nodeAttributes.rowspan !== 1) {
-        attrs.rowspan = nodeAttributes.rowspan;
-    }
-    else {
-        attrs.rowspan = null;
-    }
-    return removeEmptyEntries(attrs);
-};
-const ɵ0 = setCellAttrs;
-const ɵ1 = node => ['table', removeEmptyEntries(node.attrs), 0], ɵ2 = node => ['tr', removeEmptyEntries(node.attrs), 0], ɵ3 = node => ['td', setCellAttrs(node.attrs), 0], ɵ4 = node => ['th', setCellAttrs(node.attrs), 0], ɵ5 = node => ['tbody', removeEmptyEntries(node.attrs), 0], ɵ6 = node => ['tfoot', removeEmptyEntries(node.attrs), 0], ɵ7 = node => ['thead', removeEmptyEntries(node.attrs), 0], ɵ8 = node => ['col', removeEmptyEntries(node.attrs)], ɵ9 = node => ['colgroup', removeEmptyEntries(node.attrs), 0];
-/**
- * @hidden
- */
-export const tableNodes = {
-    // all table node names must start with table - this is needed for the commands to work properly
-    table: {
-        attrs: Object.assign({}, commonAttributes(), createDefaultAttributes(['cellspacing', 'cellpadding'])),
-        content: '(table_body | table_head | table_foot | table_colgroup)+',
-        tableRole: 'table',
-        isolating: true,
-        group: 'block',
-        parseDOM: [
-            {
-                getAttrs: serializeDOMAttrs,
-                tag: 'table'
-            }
-        ],
-        toDOM: ɵ1
-    },
-    table_row: {
-        content: '(table_cell | table_header)*',
-        attrs: Object.assign({}, commonAttributes()),
-        tableRole: 'row',
-        parseDOM: [
-            {
-                getAttrs: serializeDOMAttrs,
-                tag: 'tr'
-            }
-        ],
-        toDOM: ɵ2
-    },
-    table_cell: {
-        content: 'block+',
-        attrs: Object.assign({}, commonAttributes(), createDefaultAttributes(['headers']), { 
-            // this is needed for the commands
-            colspan: { default: 1 }, rowspan: { default: 1 } }),
-        tableRole: 'cell',
-        isolating: true,
-        parseDOM: [
-            {
-                getAttrs: serializeDOMAttrs,
-                tag: 'td'
-            }
-        ],
-        toDOM: ɵ3
-    },
-    table_header: {
-        content: 'block+',
-        attrs: Object.assign({}, commonAttributes(), createDefaultAttributes(['headers', 'abbr', 'scope']), { colspan: { default: 1 }, rowspan: { default: 1 } }),
-        tableRole: 'header_cell',
-        isolating: true,
-        parseDOM: [
-            {
-                getAttrs: serializeDOMAttrs,
-                tag: 'th'
-            }
-        ],
-        toDOM: ɵ4
-    },
-    table_body: {
-        attrs: Object.assign({}, commonAttributes()),
-        content: 'table_row+',
-        isolating: true,
-        parseDOM: [
-            {
-                getAttrs: serializeDOMAttrs,
-                tag: 'tbody'
-            }
-        ],
-        toDOM: ɵ5
-    },
-    table_foot: {
-        attrs: Object.assign({}, commonAttributes()),
-        content: 'table_row+',
-        isolating: true,
-        parseDOM: [
-            {
-                getAttrs: serializeDOMAttrs,
-                tag: 'tfoot'
-            }
-        ],
-        toDOM: ɵ6
-    },
-    table_head: {
-        attrs: Object.assign({}, commonAttributes()),
-        content: 'table_row+',
-        isolating: true,
-        parseDOM: [
-            {
-                getAttrs: serializeDOMAttrs,
-                tag: 'thead'
-            }
-        ],
-        toDOM: ɵ7
-    },
-    table_col: {
-        attrs: Object.assign({}, commonAttributes(), createDefaultAttributes(['span'])),
-        selectable: false,
-        atom: true,
-        parseDOM: [
-            {
-                getAttrs: serializeDOMAttrs,
-                tag: 'col'
-            }
-        ],
-        toDOM: ɵ8
-    },
-    table_colgroup: {
-        attrs: Object.assign({}, commonAttributes(), createDefaultAttributes(['span'])),
-        content: 'table_col*',
-        selectable: false,
-        parseDOM: [
-            {
-                getAttrs: serializeDOMAttrs,
-                tag: 'colgroup'
-            }
-        ],
-        toDOM: ɵ9
-    }
-};
-export { ɵ0, ɵ1, ɵ2, ɵ3, ɵ4, ɵ5, ɵ6, ɵ7, ɵ8, ɵ9 };

package/dist/es2015/config/tables/CellSelection.d.ts

@@ -1,35 +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 { Selection, ResolvedPos, Slice, Transaction, Node, Mappable } from '@progress/kendo-editor-common';
-/**
- * @hidden
- */
-export declare class CellSelection extends Selection {
-    $anchorCell: ResolvedPos;
-    $headCell: ResolvedPos;
-    static colSelection($anchorCell: ResolvedPos, $headCell?: ResolvedPos): CellSelection;
-    static rowSelection($anchorCell: ResolvedPos, $headCell?: ResolvedPos): CellSelection;
-    static fromJSON(doc: Node, json: any): CellSelection;
-    static create(doc: Node, anchorCell: number, headCell?: number): CellSelection;
-    constructor($anchorCell: ResolvedPos, $headCell?: ResolvedPos);
-    map(doc: Node, mapping: Mappable): Selection;
-    content(): Slice;
-    replace(tr: Transaction, content?: Slice): void;
-    replaceWith(tr: Transaction, node: Node): void;
-    forEachCell(f: Function): void;
-    isColSelection(): boolean;
-    isRowSelection(): boolean;
-    eq(other: any): boolean;
-    toJSON(): any;
-    getBookmark(): CellBookmark;
-}
-declare class CellBookmark {
-    anchor: number;
-    head: number;
-    constructor(anchor: number, head: number);
-    map(mapping: Mappable): CellBookmark;
-    resolve(doc: Node): Selection | CellSelection;
-}
-export {};

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

@@ -1,256 +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 { SelectionRange, Selection, TextSelection, Slice, Fragment } from '@progress/kendo-editor-common';
-import { TableMap } from './TableMap';
-import { pointsAtCell, inSameTable, removeColSpan, setAttr } from './table-utils';
-/**
- * @hidden
- */
-// ::- A [`Selection`](http://prosemirror.net/docs/ref/#state.Selection)
-// subclass that represents a cell selection spanning part of a table.
-// With the plugin enabled, these will be created when the user
-// selects across cells, and will be drawn by giving selected cells a
-// `selectedCell` CSS class.
-export class CellSelection extends Selection {
-    // :: (ResolvedPos, ?ResolvedPos) → CellSelection
-    // Returns the smallest column selection that covers the given anchor
-    // and head cell.
-    static colSelection($anchorCell, $headCell = $anchorCell) {
-        let map = TableMap.get($anchorCell.node(-1));
-        let start = $anchorCell.start(-1);
-        let anchorRect = map.findCell($anchorCell.pos - start);
-        let headRect = map.findCell($headCell.pos - start);
-        let doc = $anchorCell.node(0);
-        if (anchorRect.top <= headRect.top) {
-            if (anchorRect.top > 0) {
-                $anchorCell = doc.resolve(start + map.map[anchorRect.left]);
-            }
-            if (headRect.bottom < map.height) {
-                $headCell = doc.resolve(start + map.map[map.width * (map.height - 1) + headRect.right - 1]);
-            }
-        }
-        else {
-            if (headRect.top > 0) {
-                $headCell = doc.resolve(start + map.map[headRect.left]);
-            }
-            if (anchorRect.bottom < map.height) {
-                $anchorCell = doc.resolve(start + map.map[map.width * (map.height - 1) + anchorRect.right - 1]);
-            }
-        }
-        return new CellSelection($anchorCell, $headCell);
-    }
-    // :: (ResolvedPos, ?ResolvedPos) → CellSelection
-    // Returns the smallest row selection that covers the given anchor
-    // and head cell.
-    static rowSelection($anchorCell, $headCell = $anchorCell) {
-        let map = TableMap.get($anchorCell.node(-1));
-        let start = $anchorCell.start(-1);
-        let anchorRect = map.findCell($anchorCell.pos - start);
-        let headRect = map.findCell($headCell.pos - start);
-        let doc = $anchorCell.node(0);
-        if (anchorRect.left <= headRect.left) {
-            if (anchorRect.left > 0) {
-                $anchorCell = doc.resolve(start + map.map[anchorRect.top * map.width]);
-            }
-            if (headRect.right < map.width) {
-                $headCell = doc.resolve(start + map.map[map.width * (headRect.top + 1) - 1]);
-            }
-        }
-        else {
-            if (headRect.left > 0) {
-                $headCell = doc.resolve(start + map.map[headRect.top * map.width]);
-            }
-            if (anchorRect.right < map.width) {
-                $anchorCell = doc.resolve(start + map.map[map.width * (anchorRect.top + 1) - 1]);
-            }
-        }
-        return new CellSelection($anchorCell, $headCell);
-    }
-    static fromJSON(doc, json) {
-        return new CellSelection(doc.resolve(json.anchor), doc.resolve(json.head));
-    }
-    // :: (Node, number, ?number) → CellSelection
-    static create(doc, anchorCell, headCell = anchorCell) {
-        return new CellSelection(doc.resolve(anchorCell), doc.resolve(headCell));
-    }
-    // :: (ResolvedPos, ?ResolvedPos)
-    // A table selection is identified by its anchor and head cells. The
-    // positions given to this constructor should point _before_ two
-    // cells in the same table. They may be the same, to select a single
-    // cell.
-    constructor($anchorCell, $headCell = $anchorCell) {
-        let table = $anchorCell.node(-1), map = TableMap.get(table), start = $anchorCell.start(-1);
-        let rect = map.rectBetween($anchorCell.pos - start, $headCell.pos - start);
-        let doc = $anchorCell.node(0);
-        let cells = map.cellsInRect(rect).filter(p => p !== $headCell.pos - start);
-        // Make the head cell the first range, so that it counts as the
-        // primary part of the selection
-        cells.unshift($headCell.pos - start);
-        let ranges = cells.map(pos => {
-            let cell = table.nodeAt(pos), from = pos + start + 1;
-            return new SelectionRange(doc.resolve(from), doc.resolve(from + cell.content.size));
-        });
-        super(ranges[0].$from, ranges[0].$to, ranges);
-        // :: ResolvedPos
-        // A resolved position pointing _in front of_ the anchor cell (the one
-        // that doesn't move when extending the selection).
-        this.$anchorCell = $anchorCell;
-        // :: ResolvedPos
-        // A resolved position pointing in front of the head cell (the one
-        // moves when extending the selection).
-        this.$headCell = $headCell;
-    }
-    map(doc, mapping) {
-        let $anchorCell = doc.resolve(mapping.map(this.$anchorCell.pos));
-        let $headCell = doc.resolve(mapping.map(this.$headCell.pos));
-        if (pointsAtCell($anchorCell) && pointsAtCell($headCell) && inSameTable($anchorCell, $headCell)) {
-            let tableChanged = this.$anchorCell.node(-1) !== $anchorCell.node(-1);
-            if (tableChanged && this.isRowSelection()) {
-                return CellSelection.rowSelection($anchorCell, $headCell);
-            }
-            else {
-                if (tableChanged && this.isColSelection()) {
-                    return CellSelection.colSelection($anchorCell, $headCell);
-                }
-                else {
-                    return new CellSelection($anchorCell, $headCell);
-                }
-            }
-        }
-        return TextSelection.between($anchorCell, $headCell);
-    }
-    // :: () → Slice
-    // Returns a rectangular slice of table rows containing the selected
-    // cells.
-    content() {
-        let table = this.$anchorCell.node(-1), map = TableMap.get(table), start = this.$anchorCell.start(-1);
-        let rect = map.rectBetween(this.$anchorCell.pos - start, this.$headCell.pos - start);
-        let seen = {}, rows = [];
-        for (let row = rect.top; row < rect.bottom; row++) {
-            let rowContent = [];
-            for (let index = row * map.width + rect.left, col = rect.left; col < rect.right; col++, index++) {
-                let pos = map.map[index];
-                if (!seen[pos]) {
-                    seen[pos] = true;
-                    let cellRect = map.findCell(pos), cell = table.nodeAt(pos);
-                    let extraLeft = rect.left - cellRect.left, extraRight = cellRect.right - rect.right;
-                    if (extraLeft > 0 || extraRight > 0) {
-                        let attrs = cell.attrs;
-                        if (extraLeft > 0) {
-                            attrs = removeColSpan(attrs, 0, extraLeft);
-                        }
-                        if (extraRight > 0) {
-                            attrs = removeColSpan(attrs, attrs.colspan - extraRight, extraRight);
-                        }
-                        if (cellRect.left < rect.left) {
-                            cell = cell.type.createAndFill(attrs);
-                        }
-                        else {
-                            cell = cell.type.create(attrs, cell.content);
-                        }
-                    }
-                    if (cellRect.top < rect.top || cellRect.bottom > rect.bottom) {
-                        let attrs = setAttr(cell.attrs, 'rowspan', Math.min(cellRect.bottom, rect.bottom) - Math.max(cellRect.top, rect.top));
-                        if (cellRect.top < rect.top) {
-                            cell = cell.type.createAndFill(attrs);
-                        }
-                        else {
-                            cell = cell.type.create(attrs, cell.content);
-                        }
-                    }
-                    rowContent.push(cell);
-                }
-            }
-            rows.push(table.child(row).copy(Fragment.from(rowContent)));
-        }
-        const fragment = this.isColSelection() && this.isRowSelection() ? table : rows;
-        return new Slice(Fragment.from(fragment), 1, 1);
-    }
-    replace(tr, content = Slice.empty) {
-        let mapFrom = tr.steps.length;
-        let ranges = this.ranges;
-        for (let i = 0; i < ranges.length; i++) {
-            let { $from, $to } = ranges[i];
-            let mapping = tr.mapping.slice(mapFrom);
-            tr.replace(mapping.map($from.pos), mapping.map($to.pos), i ? Slice.empty : content);
-        }
-        let sel = Selection.findFrom(tr.doc.resolve(tr.mapping.slice(mapFrom).map(this.to)), -1);
-        if (sel) {
-            tr.setSelection(sel);
-        }
-    }
-    replaceWith(tr, node) {
-        this.replace(tr, new Slice(Fragment.from(node), 0, 0));
-    }
-    forEachCell(f) {
-        let table = this.$anchorCell.node(-1);
-        let map = TableMap.get(table);
-        let start = this.$anchorCell.start(-1);
-        let cells = map.cellsInRect(map.rectBetween(this.$anchorCell.pos - start, this.$headCell.pos - start));
-        for (let i = 0; i < cells.length; i++) {
-            f(table.nodeAt(cells[i]), start + cells[i]);
-        }
-    }
-    // :: () → bool
-    // True if this selection goes all the way from the top to the
-    // bottom of the table.
-    isColSelection() {
-        let anchorTop = this.$anchorCell.index(-1), headTop = this.$headCell.index(-1);
-        if (Math.min(anchorTop, headTop) > 0) {
-            return false;
-        }
-        let anchorBot = anchorTop + this.$anchorCell.nodeAfter.attrs.rowspan;
-        let headBot = headTop + this.$headCell.nodeAfter.attrs.rowspan;
-        return Math.max(anchorBot, headBot) === this.$headCell.node(-1).childCount;
-    }
-    // :: () → bool
-    // True if this selection goes all the way from the left to the
-    // right of the table.
-    isRowSelection() {
-        let map = TableMap.get(this.$anchorCell.node(-1));
-        let start = this.$anchorCell.start(-1);
-        let anchorLeft = map.colCount(this.$anchorCell.pos - start);
-        let headLeft = map.colCount(this.$headCell.pos - start);
-        if (Math.min(anchorLeft, headLeft) > 0) {
-            return false;
-        }
-        let anchorRight = anchorLeft + this.$anchorCell.nodeAfter.attrs.colspan;
-        let headRight = headLeft + this.$headCell.nodeAfter.attrs.colspan;
-        return Math.max(anchorRight, headRight) === map.width;
-    }
-    eq(other) {
-        return (other instanceof CellSelection && other.$anchorCell.pos === this.$anchorCell.pos && other.$headCell.pos === this.$headCell.pos);
-    }
-    toJSON() {
-        return { type: 'cell', anchor: this.$anchorCell.pos, head: this.$headCell.pos };
-    }
-    getBookmark() {
-        return new CellBookmark(this.$anchorCell.pos, this.$headCell.pos);
-    }
-}
-CellSelection.prototype.visible = false;
-Selection.jsonID('table_cell', CellSelection);
-class CellBookmark {
-    constructor(anchor, head) {
-        this.anchor = anchor;
-        this.head = head;
-    }
-    map(mapping) {
-        return new CellBookmark(mapping.map(this.anchor), mapping.map(this.head));
-    }
-    resolve(doc) {
-        let $anchorCell = doc.resolve(this.anchor), $headCell = doc.resolve(this.head);
-        if ($anchorCell.parent.type.spec.tableRole === 'row' &&
-            $headCell.parent.type.spec.tableRole === 'row' &&
-            $anchorCell.index() < $anchorCell.parent.childCount &&
-            $headCell.index() < $headCell.parent.childCount &&
-            inSameTable($anchorCell, $headCell)) {
-            return new CellSelection($anchorCell, $headCell);
-        }
-        else {
-            return Selection.near($headCell, 1);
-        }
-    }
-}

package/dist/es2015/config/tables/TableMap.d.ts

@@ -1,35 +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 { Node } from '@progress/kendo-editor-common';
-/**
- * @hidden
- */
-export declare class Rect {
-    left: number;
-    top: number;
-    right: number;
-    bottom: number;
-    map: TableMap;
-    tableStart: number;
-    table: Node;
-    constructor(left: number, top: number, right: number, bottom: number);
-}
-/**
- * @hidden
- */
-export declare class TableMap {
-    width: number;
-    height: number;
-    map: number[];
-    problems: any[];
-    static get(table: Node): TableMap;
-    constructor(width: number, height: number, map: number[], problems: any[]);
-    findCell(pos: number): Rect;
-    colCount(pos: number): number;
-    nextCell(pos: number, axis: string, dir: number): number;
-    rectBetween(a: number, b: number): Rect;
-    cellsInRect(rect: Rect): number[];
-    positionAt(row: number, col: number, table: Node): number;
-}