@kerebron/editor-kits 0.4.1

package/esm/extension-tables/src/utilities/CellSelection.js

@@ -0,0 +1,382 @@
+// This file defines a ProseMirror selection subclass that models
+// table cell selections. The table plugin needs to be active to wire
+// in the user interaction part of table selections (so that you
+// actually get such selections when you select across cells).
+import { Fragment, Slice } from 'prosemirror-model';
+import { NodeSelection, Selection, SelectionRange, TextSelection, } from 'prosemirror-state';
+import { Decoration, DecorationSet } from 'prosemirror-view';
+import { TableMap } from './TableMap.js';
+import { inSameTable, pointsAtCell, removeColSpan } from './util.js';
+/**
+ * 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.
+ *
+ * @public
+ */
+export class CellSelection extends Selection {
+    // 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) {
+        const table = $anchorCell.node(-1);
+        const map = TableMap.get(table);
+        const tableStart = $anchorCell.start(-1);
+        const rect = map.rectBetween($anchorCell.pos - tableStart, $headCell.pos - tableStart);
+        const doc = $anchorCell.node(0);
+        const cells = map
+            .cellsInRect(rect)
+            .filter((p) => p != $headCell.pos - tableStart);
+        // Make the head cell the first range, so that it counts as the
+        // primary part of the selection
+        cells.unshift($headCell.pos - tableStart);
+        const ranges = cells.map((pos) => {
+            const cell = table.nodeAt(pos);
+            if (!cell) {
+                throw RangeError(`No cell with offset ${pos} found`);
+            }
+            const from = tableStart + pos + 1;
+            return new SelectionRange(doc.resolve(from), doc.resolve(from + cell.content.size));
+        });
+        super(ranges[0].$from, ranges[0].$to, ranges);
+        // A resolved position pointing _in front of_ the anchor cell (the one
+        // that doesn't move when extending the selection).
+        Object.defineProperty(this, "$anchorCell", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        // A resolved position pointing in front of the head cell (the one
+        // moves when extending the selection).
+        Object.defineProperty(this, "$headCell", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: void 0
+        });
+        this.$anchorCell = $anchorCell;
+        this.$headCell = $headCell;
+    }
+    map(doc, mapping) {
+        const $anchorCell = doc.resolve(mapping.map(this.$anchorCell.pos));
+        const $headCell = doc.resolve(mapping.map(this.$headCell.pos));
+        if (pointsAtCell($anchorCell) &&
+            pointsAtCell($headCell) &&
+            inSameTable($anchorCell, $headCell)) {
+            const 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);
+    }
+    // Returns a rectangular slice of table rows containing the selected
+    // cells.
+    content() {
+        const table = this.$anchorCell.node(-1);
+        const map = TableMap.get(table);
+        const tableStart = this.$anchorCell.start(-1);
+        const rect = map.rectBetween(this.$anchorCell.pos - tableStart, this.$headCell.pos - tableStart);
+        const seen = {};
+        const rows = [];
+        for (let row = rect.top; row < rect.bottom; row++) {
+            const rowContent = [];
+            for (let index = row * map.width + rect.left, col = rect.left; col < rect.right; col++, index++) {
+                const pos = map.map[index];
+                if (seen[pos])
+                    continue;
+                seen[pos] = true;
+                const cellRect = map.findCell(pos);
+                let cell = table.nodeAt(pos);
+                if (!cell) {
+                    throw RangeError(`No cell with offset ${pos} found`);
+                }
+                const extraLeft = rect.left - cellRect.left;
+                const 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);
+                        if (!cell) {
+                            throw RangeError(`Could not create cell with attrs ${JSON.stringify(attrs)}`);
+                        }
+                    }
+                    else {
+                        cell = cell.type.create(attrs, cell.content);
+                    }
+                }
+                if (cellRect.top < rect.top || cellRect.bottom > rect.bottom) {
+                    const attrs = {
+                        ...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) {
+        const mapFrom = tr.steps.length, ranges = this.ranges;
+        for (let i = 0; i < ranges.length; i++) {
+            const { $from, $to } = ranges[i], mapping = tr.mapping.slice(mapFrom);
+            tr.replace(mapping.map($from.pos), mapping.map($to.pos), i ? Slice.empty : content);
+        }
+        const 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) {
+        const table = this.$anchorCell.node(-1);
+        const map = TableMap.get(table);
+        const tableStart = this.$anchorCell.start(-1);
+        const cells = map.cellsInRect(map.rectBetween(this.$anchorCell.pos - tableStart, this.$headCell.pos - tableStart));
+        for (let i = 0; i < cells.length; i++) {
+            f(table.nodeAt(cells[i]), tableStart + cells[i]);
+        }
+    }
+    // True if this selection goes all the way from the top to the
+    // bottom of the table.
+    isColSelection() {
+        const anchorTop = this.$anchorCell.index(-1);
+        const headTop = this.$headCell.index(-1);
+        if (Math.min(anchorTop, headTop) > 0)
+            return false;
+        const anchorBottom = anchorTop + this.$anchorCell.nodeAfter.attrs.rowspan;
+        const headBottom = headTop + this.$headCell.nodeAfter.attrs.rowspan;
+        return (Math.max(anchorBottom, headBottom) == this.$headCell.node(-1).childCount);
+    }
+    // Returns the smallest column selection that covers the given anchor
+    // and head cell.
+    static colSelection($anchorCell, $headCell = $anchorCell) {
+        const table = $anchorCell.node(-1);
+        const map = TableMap.get(table);
+        const tableStart = $anchorCell.start(-1);
+        const anchorRect = map.findCell($anchorCell.pos - tableStart);
+        const headRect = map.findCell($headCell.pos - tableStart);
+        const doc = $anchorCell.node(0);
+        if (anchorRect.top <= headRect.top) {
+            if (anchorRect.top > 0) {
+                $anchorCell = doc.resolve(tableStart + map.map[anchorRect.left]);
+            }
+            if (headRect.bottom < map.height) {
+                $headCell = doc.resolve(tableStart +
+                    map.map[map.width * (map.height - 1) + headRect.right - 1]);
+            }
+        }
+        else {
+            if (headRect.top > 0) {
+                $headCell = doc.resolve(tableStart + map.map[headRect.left]);
+            }
+            if (anchorRect.bottom < map.height) {
+                $anchorCell = doc.resolve(tableStart +
+                    map.map[map.width * (map.height - 1) + anchorRect.right - 1]);
+            }
+        }
+        return new CellSelection($anchorCell, $headCell);
+    }
+    // True if this selection goes all the way from the left to the
+    // right of the table.
+    isRowSelection() {
+        const table = this.$anchorCell.node(-1);
+        const map = TableMap.get(table);
+        const tableStart = this.$anchorCell.start(-1);
+        const anchorLeft = map.colCount(this.$anchorCell.pos - tableStart);
+        const headLeft = map.colCount(this.$headCell.pos - tableStart);
+        if (Math.min(anchorLeft, headLeft) > 0)
+            return false;
+        const anchorRight = anchorLeft + this.$anchorCell.nodeAfter.attrs.colspan;
+        const 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);
+    }
+    // Returns the smallest row selection that covers the given anchor
+    // and head cell.
+    static rowSelection($anchorCell, $headCell = $anchorCell) {
+        const table = $anchorCell.node(-1);
+        const map = TableMap.get(table);
+        const tableStart = $anchorCell.start(-1);
+        const anchorRect = map.findCell($anchorCell.pos - tableStart);
+        const headRect = map.findCell($headCell.pos - tableStart);
+        const doc = $anchorCell.node(0);
+        if (anchorRect.left <= headRect.left) {
+            if (anchorRect.left > 0) {
+                $anchorCell = doc.resolve(tableStart + map.map[anchorRect.top * map.width]);
+            }
+            if (headRect.right < map.width) {
+                $headCell = doc.resolve(tableStart + map.map[map.width * (headRect.top + 1) - 1]);
+            }
+        }
+        else {
+            if (headRect.left > 0) {
+                $headCell = doc.resolve(tableStart + map.map[headRect.top * map.width]);
+            }
+            if (anchorRect.right < map.width) {
+                $anchorCell = doc.resolve(tableStart + map.map[map.width * (anchorRect.top + 1) - 1]);
+            }
+        }
+        return new CellSelection($anchorCell, $headCell);
+    }
+    toJSON() {
+        return {
+            type: 'cell',
+            anchor: this.$anchorCell.pos,
+            head: this.$headCell.pos,
+        };
+    }
+    static fromJSON(doc, json) {
+        return new CellSelection(doc.resolve(json.anchor), doc.resolve(json.head));
+    }
+    static create(doc, anchorCell, headCell = anchorCell) {
+        return new CellSelection(doc.resolve(anchorCell), doc.resolve(headCell));
+    }
+    getBookmark() {
+        return new CellBookmark(this.$anchorCell.pos, this.$headCell.pos);
+    }
+}
+CellSelection.prototype.visible = false;
+Selection.jsonID('cell', CellSelection);
+/**
+ * @public
+ */
+export class CellBookmark {
+    constructor(anchor, head) {
+        Object.defineProperty(this, "anchor", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: anchor
+        });
+        Object.defineProperty(this, "head", {
+            enumerable: true,
+            configurable: true,
+            writable: true,
+            value: head
+        });
+    }
+    map(mapping) {
+        return new CellBookmark(mapping.map(this.anchor), mapping.map(this.head));
+    }
+    resolve(doc) {
+        const $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);
+    }
+}
+export function drawCellSelection(state) {
+    if (!(state.selection instanceof CellSelection))
+        return null;
+    const cells = [];
+    state.selection.forEachCell((node, pos) => {
+        cells.push(Decoration.node(pos, pos + node.nodeSize, { class: 'selectedCell' }));
+    });
+    return DecorationSet.create(state.doc, cells);
+}
+function isCellBoundarySelection({ $from, $to }) {
+    if ($from.pos == $to.pos || $from.pos < $to.pos - 6)
+        return false; // Cheap elimination
+    let afterFrom = $from.pos;
+    let beforeTo = $to.pos;
+    let depth = $from.depth;
+    for (; depth >= 0; depth--, afterFrom++) {
+        if ($from.after(depth + 1) < $from.end(depth))
+            break;
+    }
+    for (let d = $to.depth; d >= 0; d--, beforeTo--) {
+        if ($to.before(d + 1) > $to.start(d))
+            break;
+    }
+    return (afterFrom == beforeTo &&
+        /row|table/.test($from.node(depth).type.spec.tableRole));
+}
+function isTextSelectionAcrossCells({ $from, $to }) {
+    let fromCellBoundaryNode;
+    let toCellBoundaryNode;
+    for (let i = $from.depth; i > 0; i--) {
+        const node = $from.node(i);
+        if (node.type.spec.tableRole === 'cell' ||
+            node.type.spec.tableRole === 'header_cell') {
+            fromCellBoundaryNode = node;
+            break;
+        }
+    }
+    for (let i = $to.depth; i > 0; i--) {
+        const node = $to.node(i);
+        if (node.type.spec.tableRole === 'cell' ||
+            node.type.spec.tableRole === 'header_cell') {
+            toCellBoundaryNode = node;
+            break;
+        }
+    }
+    return fromCellBoundaryNode !== toCellBoundaryNode && $to.parentOffset === 0;
+}
+export function normalizeSelection(state, tr, allowTableNodeSelection) {
+    const sel = (tr || state).selection;
+    const doc = (tr || state).doc;
+    let normalize;
+    let role;
+    if (sel instanceof NodeSelection && (role = sel.node.type.spec.tableRole)) {
+        if (role == 'cell' || role == 'header_cell') {
+            normalize = CellSelection.create(doc, sel.from);
+        }
+        else if (role == 'row') {
+            const $cell = doc.resolve(sel.from + 1);
+            normalize = CellSelection.rowSelection($cell, $cell);
+        }
+        else if (!allowTableNodeSelection) {
+            const map = TableMap.get(sel.node);
+            const start = sel.from + 1;
+            const lastCell = start + map.map[map.width * map.height - 1];
+            normalize = CellSelection.create(doc, start + 1, lastCell);
+        }
+    }
+    else if (sel instanceof TextSelection && isCellBoundarySelection(sel)) {
+        normalize = TextSelection.create(doc, sel.from);
+    }
+    else if (sel instanceof TextSelection && isTextSelectionAcrossCells(sel)) {
+        normalize = TextSelection.create(doc, sel.$from.start(), sel.$from.end());
+    }
+    if (normalize)
+        (tr || (tr = state.tr)).setSelection(normalize);
+    return tr;
+}

package/esm/extension-tables/src/utilities/TableMap.d.ts

@@ -0,0 +1,92 @@
+import { Node } from 'prosemirror-model';
+/**
+ * @public
+ */
+export type ColWidths = number[];
+/**
+ * @public
+ */
+export type Problem = {
+    type: 'colwidth mismatch';
+    pos: number;
+    colwidth: ColWidths;
+} | {
+    type: 'collision';
+    pos: number;
+    row: number;
+    n: number;
+} | {
+    type: 'missing';
+    row: number;
+    n: number;
+} | {
+    type: 'overlong_rowspan';
+    pos: number;
+    n: number;
+} | {
+    type: 'zero_sized';
+};
+/**
+ * @public
+ */
+export interface Rect {
+    left: number;
+    top: number;
+    right: number;
+    bottom: number;
+}
+/**
+ * A table map describes the structure of a given table. To avoid
+ * recomputing them all the time, they are cached per table node. To
+ * be able to do that, positions saved in the map are relative to the
+ * start of the table, rather than the start of the document.
+ *
+ * @public
+ */
+export declare class TableMap {
+    /**
+     * The number of columns
+     */
+    width: number;
+    /**
+     * The number of rows
+     */
+    height: number;
+    /**
+     * A width * height array with the start position of
+     * the cell covering that part of the table in each slot
+     */
+    map: number[];
+    /**
+     * An optional array of problems (cell overlap or non-rectangular
+     * shape) for the table, used by the table normalizer.
+     */
+    problems: Problem[] | null;
+    constructor(
+    /**
+     * The number of columns
+     */
+    width: number, 
+    /**
+     * The number of rows
+     */
+    height: number, 
+    /**
+     * A width * height array with the start position of
+     * the cell covering that part of the table in each slot
+     */
+    map: number[], 
+    /**
+     * An optional array of problems (cell overlap or non-rectangular
+     * shape) for the table, used by the table normalizer.
+     */
+    problems: Problem[] | null);
+    findCell(pos: number): Rect;
+    colCount(pos: number): number;
+    nextCell(pos: number, axis: 'horiz' | 'vert', dir: number): null | number;
+    rectBetween(a: number, b: number): Rect;
+    cellsInRect(rect: Rect): number[];
+    positionAt(row: number, col: number, table: Node): number;
+    static get(table: Node): TableMap;
+}
+//# sourceMappingURL=TableMap.d.ts.map

package/esm/extension-tables/src/utilities/TableMap.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"TableMap.d.ts","sourceRoot":"","sources":["../../../../src/extension-tables/src/utilities/TableMap.ts"],"names":[],"mappings":"AAUA,OAAO,EAAS,IAAI,EAAE,MAAM,mBAAmB,CAAC;AAGhD;;GAEG;AACH,MAAM,MAAM,SAAS,GAAG,MAAM,EAAE,CAAC;AAEjC;;GAEG;AACH,MAAM,MAAM,OAAO,GACf;IACA,IAAI,EAAE,mBAAmB,CAAC;IAC1B,GAAG,EAAE,MAAM,CAAC;IACZ,QAAQ,EAAE,SAAS,CAAC;CACrB,GACC;IACA,IAAI,EAAE,WAAW,CAAC;IAClB,GAAG,EAAE,MAAM,CAAC;IACZ,GAAG,EAAE,MAAM,CAAC;IACZ,CAAC,EAAE,MAAM,CAAC;CACX,GACC;IACA,IAAI,EAAE,SAAS,CAAC;IAChB,GAAG,EAAE,MAAM,CAAC;IACZ,CAAC,EAAE,MAAM,CAAC;CACX,GACC;IACA,IAAI,EAAE,kBAAkB,CAAC;IACzB,GAAG,EAAE,MAAM,CAAC;IACZ,CAAC,EAAE,MAAM,CAAC;CACX,GACC;IACA,IAAI,EAAE,YAAY,CAAC;CACpB,CAAC;AA+BJ;;GAEG;AACH,MAAM,WAAW,IAAI;IACnB,IAAI,EAAE,MAAM,CAAC;IACb,GAAG,EAAE,MAAM,CAAC;IACZ,KAAK,EAAE,MAAM,CAAC;IACd,MAAM,EAAE,MAAM,CAAC;CAChB;AAED;;;;;;;GAOG;AACH,qBAAa,QAAQ;IAEjB;;OAEG;IACI,KAAK,EAAE,MAAM;IACpB;;OAEG;IACI,MAAM,EAAE,MAAM;IACrB;;;OAGG;IACI,GAAG,EAAE,MAAM,EAAE;IACpB;;;OAGG;IACI,QAAQ,EAAE,OAAO,EAAE,GAAG,IAAI;;IAjBjC;;OAEG;IACI,KAAK,EAAE,MAAM;IACpB;;OAEG;IACI,MAAM,EAAE,MAAM;IACrB;;;OAGG;IACI,GAAG,EAAE,MAAM,EAAE;IACpB;;;OAGG;IACI,QAAQ,EAAE,OAAO,EAAE,GAAG,IAAI;IAInC,QAAQ,CAAC,GAAG,EAAE,MAAM,GAAG,IAAI;IA2B3B,QAAQ,CAAC,GAAG,EAAE,MAAM,GAAG,MAAM;IAW7B,QAAQ,CAAC,GAAG,EAAE,MAAM,EAAE,IAAI,EAAE,OAAO,GAAG,MAAM,EAAE,GAAG,EAAE,MAAM,GAAG,IAAI,GAAG,MAAM;IAYzE,WAAW,CAAC,CAAC,EAAE,MAAM,EAAE,CAAC,EAAE,MAAM,GAAG,IAAI;IAuBvC,WAAW,CAAC,IAAI,EAAE,IAAI,GAAG,MAAM,EAAE;IAyBjC,UAAU,CAAC,GAAG,EAAE,MAAM,EAAE,GAAG,EAAE,MAAM,EAAE,KAAK,EAAE,IAAI,GAAG,MAAM;IAezD,MAAM,CAAC,GAAG,CAAC,KAAK,EAAE,IAAI,GAAG,QAAQ;CAGlC"}