@nerd-bible/wordgard 0.3.3

package/dist/table.d.ts

@@ -0,0 +1,215 @@
+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';
+
+/**
+Enable table support with the given configuration. The returned
+extension will include the necessary schema elements, the {@link
+CellSelection cell selection}, {@link tables.correction correction},
+{@link tables.pasteHandler paste} and {@link tables.dropHandler
+drop} handlers, and {@link tableMenu menu items}.
+*/
+declare function tables(config?: tables.Spec): GardState.Extension;
+declare namespace tables {
+    /**
+    Configuration options for the {@link tables} function.
+    */
+    type Spec = {
+        /**
+        Controls whether headers cells are enabled. Defaults to true.
+        */
+        headerCells?: boolean;
+        /**
+        By default, cells can be {@link mergeCells merged}, making
+        them span more than one row or column. Set this to false to
+        disable that.
+        */
+        cellSpanning?: boolean;
+        /**
+        Determines whether cells contain inline content or block
+        content. Defaults to `"inline"`.
+        */
+        cellContent?: "inline" | "block";
+    };
+    /**
+    Correct tables where the cells do not form a proper rectangle.
+    */
+    const correction: wordgard_state.Correction;
+    /**
+    A paste handler that makes pasting into tables fill the entire
+    cell selection or, if table cell content is being pasted into a
+    cell, to expand the pasted region over the shape covered by the
+    pasted content.
+    */
+    const pasteHandler: GardState.Extension;
+    /**
+    A drop handler that overrides drops that move table cells.
+    */
+    const dropHandler: GardState.Extension;
+}
+
+/**
+Returns the full table menu. This consists of two buttons that
+look the same but behave differently. When the selection is not in
+a table, {@link tableMenu.createTable} is shown, which provides an
+interface for creating a new table. Otherwise, {@link
+tableMenu.modifyTable} is visible, which contains menu items for
+manipulating the current table.
+*/
+declare function tableMenu(): GardState.Extension;
+declare namespace tableMenu {
+    /**
+    A menu button that expands into a dimension picker when
+    activated, which inserts a table with the given dimensions when
+    confirmed.
+    */
+    const createTable: Menu.Submenu;
+    /**
+    A submenu with for table manipulation items.
+    */
+    const modifyTable: Menu.Submenu;
+    /**
+    A button that toggles the selected cells between header and
+    normal cells.
+    */
+    const toggleHeader: Menu.Button;
+    /**
+    Adds a row above the selected cell(s).
+    */
+    const addRowAbove: Menu.Button;
+    /**
+    Adds a row below the selected cell(s).
+    */
+    const addRowBelow: Menu.Button;
+    /**
+    Deletes the row(s) that hold the selection.
+    */
+    const deleteRow: Menu.Button;
+    /**
+    Button to insert a column before the selection.
+    */
+    const addColumnBefore: Menu.Button;
+    /**
+    Add a column after the selection.
+    */
+    const addColumnAfter: Menu.Button;
+    /**
+    Delete the selected column(s).
+    */
+    const deleteColumn: Menu.Button;
+    /**
+    When multiple cells are selected, merge them into a single cell.
+    */
+    const mergeCells: Menu.Button;
+    /**
+    When a merged cell is selected, split it into its smallest
+    elements again.
+    */
+    const splitCell: Menu.Button;
+}
+
+/**
+A cell selection is a custom selection type that, instead of
+spanning the range between two document positions, spans the
+rectangle between two cells in the same table. It comes with
+extensions that make sure it is drawn in a recognizeable way,
+automatically created when a selection crosses cell boundaries,
+and adjusted appropriately in response to keyboard and mouse
+actions.
+*/
+declare class CellSelection extends GardSelection {
+    /**
+    The position directly in front of the cell that acts as this
+    selection's anchor.
+    */
+    readonly anchorCell: number;
+    /**
+    The position directly in front of the cell acting as the
+    selection head.
+    */
+    readonly headCell: number;
+    private constructor();
+    get ranges(): readonly {
+        from: number;
+        to: number;
+    }[];
+    get replacementRange(): {
+        from: number;
+        to: number;
+    };
+    get domSelection(): {
+        readonly anchor: number;
+        readonly anchorSide: 1;
+        readonly head: number;
+        readonly headSide: -1;
+    };
+    eq(other: GardSelection): boolean;
+    map(changes: ChangeSet, cx: GardSelection.Context, assoc?: -1 | 1): GardSelection.Text | CellSelection;
+    /**
+    Move the head cell in the given direction, returning a new cell
+    selection if the selection can be extended that way.
+    */
+    moveHead(doc: Plot.Doc, dir: "up" | "down" | "forward" | "backward"): CellSelection | null;
+    /**
+    Create a table selection between the given points. They should
+    point before and after the first and last cell of the selection
+    (`anchor` may be before or after `head`, as long as the lower
+    sits before a cell and the higher after a cell). Returns `null`
+    if the given range does not wrap a range of cells in a single
+    table.
+    */
+    static between(doc: Plot.Doc, anchor: number, head: number): CellSelection | null;
+    /**
+    Given a selection, this returns null if that selection is valid
+    (is a cell selection, or a selection that starts and ends outside
+    of tables, or in the same table cell). Otherwise, it will expand a
+    selection within a single table to a cell selection, or expand a
+    selection that crosses table boundaries to cover the entire table(s).
+    */
+    static normalize(sel: GardSelection, doc: Plot.Doc): GardSelection | null;
+    /**
+    This object can be used as an extension to enable cell selection.
+    */
+    static extension: GardState.Extension;
+}
+
+declare const toggleHeaderCell: Command.Pure;
+/**
+Add a column at the given side of the selection. The selection may
+either be a cell selection or another type of selection inside a
+table cell.
+*/
+declare const addColumn: Command.Pure<"before" | "after">;
+/**
+Delete the selected columns. Will act on a cell selection or
+another type of selection inside a cell.
+*/
+declare const deleteColumn: Command.Pure;
+/**
+Add a row next to the selected cells, on the side indicated.
+*/
+declare const addRow: Command.Pure<"before" | "after">;
+/**
+Delete the selected row(s).
+*/
+declare const deleteRow: Command.Pure;
+/**
+If the current selection is a multi-cell cell selection, merge the
+cells into a single cell by giving it a {@link types.RowSpan}
+and/or {@link types.ColSpan}. The content from the cells is all
+put into the resulting merged cell.
+*/
+declare const mergeCells: Command.Pure;
+/**
+When the selection is in or on a merged cell, split it again. Any
+content is left in the first split-off cell.
+*/
+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;
+
+export { CellSelection, addColumn, addRow, deleteColumn, deleteRow, handleTablePaste, mergeCells, splitCell, tableMenu, tables, toggleHeaderCell };