@nerd-bible/wordgard 0.5.3-beta7 → 0.6.2-beta10

package/dist/table.d.ts

@@ -1,7 +1,7 @@
 import * as wordgard_state from 'wordgard/state';
 import { GardState, GardSelection, Transaction } from 'wordgard/state';
 import { Menu, Command } from 'wordgard/command';
-import { ChangeSet, Plot, Slice } from 'wordgard/doc';
+import { Plot, Slice, ChangeSet } from 'wordgard/doc';
 
 /**
 Enable table support with the given configuration. The returned
@@ -144,6 +144,7 @@ declare class CellSelection extends GardSelection {
         readonly head: number;
         readonly headSide: -1;
     };
+    toSlice(doc: Plot.Doc): Slice;
     eq(other: GardSelection): boolean;
     map(changes: ChangeSet, cx: GardSelection.Context, assoc?: -1 | 1): GardSelection.Text | CellSelection;
     /**
@@ -174,6 +175,116 @@ declare class CellSelection extends GardSelection {
     static extension: GardState.Extension;
 }
 
+/**
+A table map describes the structore of a given table.
+*/
+declare class TableMap {
+    /**
+    The start position of the table's content.
+    */
+    readonly start: number;
+    /**
+    Get a table map for the given table node. Will reuse known
+    structure of unchanged tables across document changes.
+    */
+    static get(table: Plot, start: number): TableMap;
+    private constructor();
+    /**
+    The number of columns in this table.
+    */
+    get width(): number;
+    /**
+    The number of rows in the table.
+    */
+    get height(): number;
+    /**
+    The table plot.
+    */
+    get table(): Plot;
+    /**
+    The document position before the table.
+    */
+    get tablePos(): number;
+    /**
+    Find the dimensions of the cell at the given position.
+    */
+    cellRect(pos: number): TableMap.Rect;
+    /**
+    Find the end position of the given cell.
+    */
+    cellEnd(pos: number): number;
+    /**
+    Get the rectangle spanning the two given cells.
+    */
+    rectBetween(a: number, b: number): TableMap.Rect;
+    /**
+    Return the position of all cells that have their top start
+    corner in the given rectangle.
+    */
+    cellsInRect(rect: TableMap.Rect): number[];
+    /**
+    Return the position of the cell that occupies the position at the
+    given row and column (which must be in bounds for the table).
+    */
+    cellAt(col: number, row: number): number | null;
+    /**
+    Get the position at the start of the given row (which may be
+    `width` to query the position after the last row).
+    */
+    rowPos(row: number): number;
+    /**
+    Get the position where a cell would have to be inserted to
+    appear at the given column and row.
+    */
+    cellInsertionPos(col: number, row: number): number;
+    /**
+    Get the node for the cell at the given position.
+    */
+    getCell(pos: number): Plot;
+}
+declare namespace TableMap {
+    /**
+    Data type used for a rectangular area in a table.
+    */
+    class Rect {
+        /**
+        Starting column of the rectangle.
+        */
+        readonly startCol: number;
+        /**
+        Starting row.
+        */
+        readonly startRow: number;
+        /**
+        The end column. Non-inclusive. Always higher than
+        `startCol`.
+        */
+        readonly endCol: number;
+        /**
+        The end row. Non-inclusive. Always higher than `startRow`.
+        */
+        readonly endRow: number;
+        constructor(
+        /**
+        Starting column of the rectangle.
+        */
+        startCol: number, 
+        /**
+        Starting row.
+        */
+        startRow: number, 
+        /**
+        The end column. Non-inclusive. Always higher than
+        `startCol`.
+        */
+        endCol: number, 
+        /**
+        The end row. Non-inclusive. Always higher than `startRow`.
+        */
+        endRow: number);
+    }
+}
+
 declare const toggleHeaderCell: Command.Pure;
 /**
 Add a column at the given side of the selection. The selection may
@@ -210,6 +321,6 @@ declare const splitCell: Command.Pure;
 /**
 @hidden exported for testing
 */
-declare function handleTablePaste(state: GardState, slice: Slice, context: readonly Plot.Tag[], drop?: number): false | Transaction.Spec;
+declare function handleTablePaste(state: GardState, slice: Slice, drop?: number): false | Transaction.Spec;
 
-export { CellSelection, addColumn, addRow, deleteColumn, deleteRow, handleTablePaste, mergeCells, splitCell, tableMenu, tables, toggleHeaderCell };
+export { CellSelection, TableMap, addColumn, addRow, deleteColumn, deleteRow, handleTablePaste, mergeCells, splitCell, tableMenu, tables, toggleHeaderCell };

package/dist/table.js

@@ -1,22 +1,10 @@
 import { Decoration, Wordgard } from 'wordgard/editor';
 import { GardState, Transaction, GardSelection, Correction } from 'wordgard/state';
 import { Table, ColSpan, RowSpan, TableRow, Cell, BlockCell, HeaderCell, BlockHeaderCell } from 'wordgard/types';
-import { Node, ValidationError, Token, ChangeSet } from 'wordgard/doc';
+import { Node, Slice, ValidationError, Token, ChangeSet } from 'wordgard/doc';
 import { Command, moveByUnit, moveByWord, moveByLine, moveToLineSide, Menu } from 'wordgard/command';
 import { tablePhrases } from 'wordgard/phrases';
 
-class Rect {
-    startCol;
-    startRow;
-    endCol;
-    endRow;
-    constructor(startCol, startRow, endCol,    endRow) {
-        this.startCol = startCol;
-        this.startRow = startRow;
-        this.endCol = endCol;
-        this.endRow = endRow;
-    }
-}
 class MapData {
     table;
     width;
@@ -37,7 +25,15 @@ let cache = /*@__PURE__*/(() => new WeakMap())();
 class TableMap {
     start;
     data;
-    constructor(start, data) {
+    static get(table, start) {
+        let data = cache.get(table);
+        if (!data)
+            cache.set(table, data = computeMap(table));
+        return new TableMap(start, data);
+    }
+    constructor(
+    start, 
+    data) {
         this.start = start;
         this.data = data;
     }
@@ -55,7 +51,7 @@ class TableMap {
                     endCol++;
                 for (let j = 1; endRow < height && map[i + (width * j)] == localPos; j++)
                     endRow++;
-                return new Rect(startCol, startRow, endCol, endRow);
+                return new TableMap.Rect(startCol, startRow, endCol, endRow);
             }
         throw new RangeError(`No cell with offset ${pos} found`);
     }
@@ -87,7 +83,7 @@ class TableMap {
     rectBetween(a, b) {
         let { startCol: startColA, endCol: endColA, startRow: startRowA, endRow: endRowA } = this.cellRect(a);
         let { startCol: startColB, endCol: endColB, startRow: startRowB, endRow: endRowB } = this.cellRect(b);
-        return new Rect(Math.min(startColA, startColB), Math.min(startRowA, startRowB), Math.max(endColA, endColB), Math.max(endRowA, endRowB));
+        return new TableMap.Rect(Math.min(startColA, startColB), Math.min(startRowA, startRowB), Math.max(endColA, endColB), Math.max(endRowA, endRowB));
     }
     cellsInRect(rect) {
         let result = [], { map, width } = this.data;
@@ -148,13 +144,26 @@ class TableMap {
         }
         return false;
     }
-    static get(table, start) {
-        let data = cache.get(table);
-        if (!data)
-            cache.set(table, data = computeMap(table));
-        return new TableMap(start, data);
-    }
 }
+;TableMap = /*@__PURE__*/(function (TableMap) {
+    class Rect {
+        startCol;
+        startRow;
+        endCol;
+        endRow;
+        constructor(
+        startCol, 
+        startRow, 
+        endCol, 
+        endRow) {
+            this.startCol = startCol;
+            this.startRow = startRow;
+            this.endCol = endCol;
+            this.endRow = endRow;
+        }
+    }
+    TableMap.Rect = Rect;
+;return TableMap})(TableMap);
 function sameCell(a, b) {
     return a != 0 && a == b;
 }
@@ -227,6 +236,7 @@ function growMap(map, width, height, count) {
 }
 
 const cellSelectionDeco = /*@__PURE__*/GardState.Field.define({
+    name: "cellSelectionDeco",
     create: getCellDeco,
     update: (deco, tr) => {
         return tr.docChanged || tr.selection ? getCellDeco(tr.state) : deco;
@@ -330,6 +340,24 @@ class CellSelection extends GardSelection {
         let { from, to } = this.replacementRange;
         return { anchor: from, anchorSide: 1, head: to, headSide: -1 };
     }
+    toSlice(doc) {
+        let base = doc.resolve(this.anchorCell), table = base.parent.parent;
+        let map = TableMap.get(table.node, table.start);
+        let rect = map.rectBetween(this.anchorCell, this.headCell);
+        let rows = [], added = new Set();
+        for (let row = rect.startRow; row < rect.endRow; row++) {
+            let rowContent = [];
+            for (let col = rect.startCol; col < rect.endCol; col++) {
+                let cell = map.cellAt(col, row);
+                if (added.has(cell))
+                    continue;
+                added.add(cell);
+                rowContent.push(map.getCell(cell));
+            }
+            rows.push(table.node.content[row].tag.create(rowContent));
+        }
+        return Slice.of(rows, [table.node.tag]);
+    }
     eq(other) {
         return other instanceof CellSelection && other.anchor == this.anchor && other.head == this.head;
     }
@@ -768,7 +796,7 @@ const splitCell = ({ state }) => {
     };
 };
 
-function fitSlice(schema, parent, slice, context) {
+function fitSlice(schema, parent, slice) {
     let wrap = schema.findWrapping(schema.docTag.type, parent.type);
     if (!wrap)
         return null;
@@ -776,7 +804,7 @@ function fitSlice(schema, parent, slice, context) {
     for (let i = wrap.length - 1; i >= 0; i--)
         content = [wrap[i].create(content)];
     let doc = schema.doc(content);
-    let changes = ChangeSet.create(doc, { from: wrap.length + 1, to: doc.length - wrap.length - 1, insert: slice, fit: context });
+    let changes = ChangeSet.create(doc, { from: wrap.length + 1, to: doc.length - wrap.length - 1, insert: slice, fit: true });
     doc = changes.apply(doc);
     let node = doc.length > wrap.length && doc.plotAt(wrap.length);
     return node && node.type == parent.type ? node : null;
@@ -784,15 +812,15 @@ function fitSlice(schema, parent, slice, context) {
 function isTableContent(schema, type) {
     return type == TableRow.type || schema.matchNode(type, Node.Group.TableCell);
 }
-function pastedCells(schema, slice, context) {
+function pastedCells(schema, slice) {
     let table = null, tok;
     if (slice.content.length == 1 && (tok = slice.content[0]).tokenType == Token.Type.Node &&
         tok.type == Table.type) {
         table = tok;
     }
-    else if (context.some(tag => isTableContent(schema, tag.type)) ||
+    else if (slice.context.some(tag => isTableContent(schema, tag.type)) ||
         slice.content.some(tok => tok.tokenType != Token.Type.Close && isTableContent(schema, tok.type))) {
-        table = fitSlice(schema, Table, slice, context);
+        table = fitSlice(schema, Table, slice);
     }
     return table && ensureRectangular(schema, table.content.map(row => row.content));
 }
@@ -960,14 +988,14 @@ function insertCells(state, map, startCol, startRow, cells, event) {
         userEvent: `${event}.paste`
     };
 }
-function handleTablePaste(state, slice, context, drop) {
+function handleTablePaste(state, slice, drop) {
     if (state.readOnly)
         return false;
     let { schema } = state.doc;
     if (drop == null && state.selection instanceof CellSelection) {
-        let cells = pastedCells(schema, slice, context);
+        let cells = pastedCells(schema, slice);
         if (!cells) {
-            let single = fitSlice(schema, cellTag(schema), slice, context);
+            let single = fitSlice(schema, cellTag(schema), slice);
             if (!single)
                 return false;
             cells = { width: 1, height: 1, rows: [[single]] };
@@ -978,20 +1006,20 @@ function handleTablePaste(state, slice, context, drop) {
     }
     else {
         let cx = tableContext(state, drop), cells;
-        if (!cx || !(cells = pastedCells(schema, slice, context)))
+        if (!cx || !(cells = pastedCells(schema, slice)))
             return false;
         let rect = cx.map.cellRect(cx.cells[0]);
         return insertCells(state, cx.map, rect.startCol, rect.startRow, cells, drop == null ? "drop" : "paste");
     }
 }
-const tablePasteHandler = /*@__PURE__*/Wordgard.pasteHandler.of((wg, _event, slice, context) => {
-    let tr = handleTablePaste(wg.state, slice, context);
+const tablePasteHandler = /*@__PURE__*/Wordgard.pasteHandler.of((wg, _event, slice) => {
+    let tr = handleTablePaste(wg.state, slice);
     return tr && (wg.dispatch(tr), true);
 });
-const tableDropHandler = /*@__PURE__*/Wordgard.dropHandler.of((wg, _event, pos, move, slice, context) => {
+const tableDropHandler = /*@__PURE__*/Wordgard.dropHandler.of((wg, _event, pos, move, slice) => {
     if (wg.state.readOnly)
         return false;
-    let tr = handleTablePaste(wg.state, slice, context, pos);
+    let tr = handleTablePaste(wg.state, slice, pos);
     if (!tr)
         return false;
     if (move) {
@@ -1300,4 +1328,4 @@ function tables(config = {}) {
     tables.dropHandler = tableDropHandler;
 ;return tables})(tables);
 
-export { CellSelection, addColumn, addRow, deleteColumn, deleteRow, handleTablePaste, mergeCells, splitCell, tableMenu, tables, toggleHeaderCell };
+export { CellSelection, TableMap, addColumn, addRow, deleteColumn, deleteRow, handleTablePaste, mergeCells, splitCell, tableMenu, tables, toggleHeaderCell };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@nerd-bible/wordgard",
-  "version": "0.5.3-beta7",
+  "version": "0.6.2-beta10",
   "description": "Semantic rich text editor system",
   "type": "module",
   "main": "dist/index.js",
@@ -22,12 +22,13 @@
   "author": "Marijn Haverbeke <marijn@haverbeke.berlin>",
   "license": "MIT",
   "dependencies": {
+    "@codemirror/legacy-modes": "^6.5.5",
+    "@codemirror/streamparser": "^6.0.0",
     "@marijn/find-cluster-break": "^1.0.2",
     "crelt": "^1.0.6",
     "style-mod": "^4.1.3"
   },
   "devDependencies": {
-    "@nerd-bible/config": "^0.2.5",
     "@swc/wasm-typescript": "^1.15.3",
     "@types/mocha": "^10.0.10",
     "@types/node": "^24.10.2",