@ekz/lexical-table 0.40.0

package/LexicalTable.js.flow

@@ -0,0 +1,473 @@
+/**
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ *
+ * @flow strict
+ */
+
+import type {
+  BaseSelection,
+  EditorConfig,
+  LexicalNode,
+  NodeKey,
+  ParagraphNode,
+  PointType,
+  RangeSelection,
+  LexicalEditor,
+  TextFormatType,
+  LexicalCommand,
+  ElementDOMSlot,
+  SerializedElementNode,
+  LexicalExtension,
+} from '@ekz/lexical';
+import type {NamedSignalsOutput} from '@ekz/lexical-extension';
+
+import {
+  ElementNode,
+} from '@ekz/lexical';
+
+/**
+ * LexicalTableCellNode
+ */
+
+export const TableCellHeaderStates = {
+  NO_STATUS: 0,
+  ROW: 1,
+  COLUMN: 2,
+  BOTH: 3,
+};
+
+export type TableCellHeaderState = $Values<typeof TableCellHeaderStates>;
+
+declare export class TableCellNode extends ElementNode {
+  __colSpan: number;
+  __rowSpan: number;
+  __headerState: TableCellHeaderState;
+  __width?: number;
+  __backgroundColor: null | string;
+  static getType(): string;
+  static clone(node: TableCellNode): TableCellNode;
+  constructor(
+    headerState?: TableCellHeaderState,
+    colSpan?: number,
+    width?: ?number,
+    key?: NodeKey,
+  ): void;
+  createDOM(config: EditorConfig): HTMLElement;
+  insertNewAfter(
+    selection: RangeSelection,
+  ): null | ParagraphNode | TableCellNode;
+  collapseAtStart(): true;
+  getColSpan(): number;
+  setColSpan(colSpan: number): this;
+  getRowSpan(): number;
+  setRowSpan(rowSpan: number): this;
+  getTag(): string;
+  setHeaderStyles(headerState: TableCellHeaderState, mask?: TableCellHeaderState): TableCellNode;
+  getHeaderStyles(): TableCellHeaderState;
+  setWidth(width: number): TableCellNode;
+  getWidth(): ?number;
+  getBackgroundColor(): null | string;
+  setBackgroundColor(newBackgroundColor: null | string): TableCellNode;
+  toggleHeaderStyle(headerState: TableCellHeaderState): TableCellNode;
+  hasHeader(): boolean;
+  collapseAtStart(): true;
+  canBeEmpty(): false;
+}
+declare export function $createTableCellNode(
+  headerState?: TableCellHeaderState,
+  colSpan?: number,
+  width?: ?number,
+): TableCellNode;
+declare export function $isTableCellNode(
+  node: ?LexicalNode,
+): node is TableCellNode;
+
+/**
+ * LexicalTableNode
+ */
+
+export type TableMapValueType = {
+  cell: TableCellNode,
+  startRow: number,
+  startColumn: number,
+};
+export type TableMapType = Array<Array<TableMapValueType>>;
+
+declare export class TableNode extends ElementNode {
+  static getType(): string;
+  static clone(node: TableNode): TableNode;
+  constructor(key?: NodeKey): void;
+  createDOM(config: EditorConfig): HTMLElement;
+  insertNewAfter(selection: RangeSelection): null | ParagraphNode | TableNode;
+  collapseAtStart(): true;
+  getCordsFromCellNode(
+    tableCellNode: TableCellNode,
+    table: TableDOMTable,
+  ): {x: number, y: number};
+  getDOMCellFromCords(x: number, y: number, table: TableDOMTable): ?TableDOMCell;
+  getDOMCellFromCordsOrThrow(x: number, y: number, table: TableDOMTable): TableDOMCell;
+  getCellNodeFromCords(x: number, y: number, table: TableDOMTable): ?TableCellNode;
+  getCellNodeFromCordsOrThrow(x: number, y: number, table: TableDOMTable): TableCellNode;
+  canSelectBefore(): true;
+  getDOMSlot(element: HTMLElement): ElementDOMSlot<HTMLTableElement>;
+}
+declare export function $createTableNode(): TableNode;
+declare export function $isTableNode(
+  node: ?LexicalNode,
+): node is TableNode;
+
+declare export function $isScrollableTablesActive(
+  editor?: LexicalEditor
+): boolean;
+declare export function setScrollableTablesActive(
+  editor: LexicalEditor,
+  active: boolean,
+): void;
+declare export function $getTableAndElementByKey(
+  tableNodeKey: NodeKey,
+  editor?: LexicalEditor,
+): {
+  tableNode: TableNode;
+  tableElement: HTMLTableElementWithWithTableSelectionState;
+};
+
+/**
+ * LexicalTableRowNode
+ */
+
+declare export class TableRowNode extends ElementNode {
+  static getType(): string;
+  static clone(node: TableRowNode): TableRowNode;
+  constructor(height?: ?number, key?: NodeKey): void;
+  createDOM(config: EditorConfig): HTMLElement;
+  setHeight(height: number): ?number;
+  getHeight(): ?number;
+  insertNewAfter(
+    selection: RangeSelection,
+  ): null | ParagraphNode | TableRowNode;
+  collapseAtStart(): true;
+}
+declare export function $createTableRowNode(): TableRowNode;
+declare export function $isTableRowNode(
+  node: ?LexicalNode,
+): node is TableRowNode;
+
+/**
+ * LexicalTableSelectionHelpers
+ */
+
+export const LEXICAL_ELEMENT_KEY = '__lexicalTableSelection';
+
+export type TableDOMCell = {
+  elem: HTMLElement,
+  highlighted: boolean,
+  x: number,
+  y: number,
+};
+
+export type TableDOMRows = Array<Array<TableDOMCell>>;
+
+export type TableDOMTable = {
+  cells: TableDOMRows,
+  columns: number,
+  rows: number,
+};
+
+export type HTMLTableElementWithWithTableSelectionState = HTMLTableElement & Partial<{
+  [typeof LEXICAL_ELEMENT_KEY]: TableObserver | void;
+}>;
+
+declare export function applyTableHandlers(
+  tableNode: TableNode,
+  tableElement: HTMLElement,
+  editor: LexicalEditor,
+  hasTabHandler: boolean,
+): TableObserver;
+
+declare export function $getElementForTableNode(
+  editor: LexicalEditor,
+  tableNode: TableNode,
+): TableDOMTable;
+
+declare export function getTableObserverFromTableElement(
+  tableElement: HTMLElement,
+): null | TableObserver;
+
+declare export function getDOMCellFromTarget(node: Node): null | TableDOMCell;
+
+declare export function $findTableNode(node: LexicalNode): null | TableNode;
+
+declare export function $findCellNode(node: LexicalNode): null | TableCellNode;
+
+declare export function getTableElement<T: HTMLElement | null>(
+  tableNode: TableNode,
+  dom: T,
+): HTMLTableElementWithWithTableSelectionState | (T & null);
+
+/**
+ * LexicalTableUtils
+ */
+
+declare export function $createTableNodeWithDimensions(
+  rowCount: number,
+  columnCount: number,
+  includeHeaders?: boolean,
+): TableNode;
+
+declare export function $getTableCellNodeFromLexicalNode(
+  startingNode: LexicalNode,
+): TableCellNode | null;
+
+declare export function $getTableRowNodeFromTableCellNodeOrThrow(
+  startingNode: LexicalNode,
+): TableRowNode;
+
+declare export function $getTableNodeFromLexicalNodeOrThrow(
+  startingNode: LexicalNode,
+): TableNode;
+
+declare export function $getTableRowIndexFromTableCellNode(
+  tableCellNode: TableCellNode,
+): number;
+
+declare export function $getTableColumnIndexFromTableCellNode(
+  tableCellNode: TableCellNode,
+): number;
+
+declare export function $removeTableRowAtIndex(
+  tableNode: TableNode,
+  indexToDelete: number,
+): TableNode;
+
+/** @deprecated This function does not support merged cells. Use {@link $insertTableRowAtSelection} or {@link $insertTableRowAtNode} instead. */
+declare export function $insertTableRow(
+  tableNode: TableNode,
+  targetIndex: number,
+  shouldInsertAfter?: boolean,
+  rowCount: number,
+  table: TableDOMTable,
+): TableNode;
+
+/** @deprecated This function does not support merged cells. Use {@link $insertTableColumnAtSelection} or {@link $insertTableColumnAtNode} instead. */
+declare export function $insertTableColumn(
+  tableNode: TableNode,
+  targetIndex: number,
+  shouldInsertAfter?: boolean,
+  columnCount: number,
+  table: TableDOMTable,
+): TableNode;
+
+/** @deprecated This function does not support merged cells. Use {@link $deleteTableColumnAtSelection} instead. */
+declare export function $deleteTableColumn(
+  tableNode: TableNode,
+  targetIndex: number,
+): TableNode;
+
+declare export function $insertTableRowAtSelection(
+  insertAfter?: boolean,
+): TableRowNode | null;
+
+declare export function $insertTableRowAtNode(
+  cellNode: TableCellNode,
+  insertAfter?: boolean,
+): TableRowNode | null;
+
+declare export function $insertTableColumnAtSelection(
+  insertAfter?: boolean,
+): TableCellNode | null;
+
+declare export function $insertTableColumnAtNode(
+  cellNode: TableCellNode,
+  insertAfter?: boolean,
+  shouldSetSelection?: boolean,
+): TableCellNode | null
+
+declare export function $deleteTableRowAtSelection(): void;
+
+declare export function $deleteTableColumnAtSelection(): void;
+
+/** @deprecated renamed to {@link $insertTableRowAtSelection} */ 
+declare export function $insertTableRow__EXPERIMENTAL(
+  insertAfter: boolean,
+): TableRowNode | null;
+
+/** @deprecated renamed to {@link $insertTableColumnAtSelection} */ 
+declare export function $insertTableColumn__EXPERIMENTAL(
+  insertAfter: boolean,
+): TableCellNode | null;
+
+/** @deprecated renamed to {@link $deleteTableRowAtSelection} */ 
+declare export function $deleteTableRow__EXPERIMENTAL(): void;
+
+/** @deprecated renamed to {@link $deleteTableColumnAtSelection} */ 
+declare export function $deleteTableColumn__EXPERIMENTAL(): void;
+
+declare export function $unmergeCell(): void;
+
+declare export function $computeTableMap(
+  table: TableNode,
+  cellA: TableCellNode,
+  cellB: TableCellNode,
+): [TableMapType, TableMapValueType, TableMapValueType];
+
+declare export function $getNodeTriplet(
+  source: PointType | LexicalNode | TableCellNode,
+): [TableCellNode, TableRowNode, TableNode];
+
+declare export function $getTableCellNodeRect(tableCellNode: TableCellNode): {
+  rowIndex: number;
+  columnIndex: number;
+  rowSpan: number;
+  colSpan: number;
+} | null;
+
+declare export function $computeTableMapSkipCellCheck(
+  tableNode: TableNode,
+  cellA: null | TableCellNode,
+  cellB: null | TableCellNode,
+): [
+  tableMap: TableMapType,
+  cellAValue: TableMapValueType | null,
+  cellBValue: TableMapValueType | null,
+];
+
+/**
+ * LexicalTableObserver.js
+ */
+
+declare export class TableObserver {
+  currentX: number;
+  currentY: number;
+  listenersToRemove: Set<() => void>;
+  table: TableDOMTable;
+  isHighlightingCells: boolean;
+  isMouseDown: boolean;
+  startX: number;
+  startY: number;
+  nodeKey: string;
+  editor: LexicalEditor;
+  constructor(editor: LexicalEditor, nodeKey: string): void;
+  getTable(): TableDOMTable;
+  removeListeners(): void;
+  trackTable(): void;
+  $clearHighlight(): void;
+  $setFocusCellForSelection(cell: TableDOMCell, ignoreStart?: boolean): void;
+  $setAnchorCellForSelection(cell: TableDOMCell): void;
+  $formatCells(type: TextFormatType): void;
+  $clearText(): void;
+}
+
+/**
+ * LexicalTableSelection.ts
+ */
+
+export type TableSelectionShape = {
+  fromX: number,
+  fromY: number,
+  toX: number,
+  toY: number,
+};
+declare export class TableSelection implements BaseSelection {
+  tableKey: NodeKey;
+  anchor: PointType;
+  focus: PointType;
+  dirty: boolean;
+  constructor(tableKey: NodeKey, anchor: PointType, focus: PointType): void;
+  is(selection: null | BaseSelection): boolean;
+  set(tableKey: NodeKey, anchorCellKey: NodeKey, focusCellKey: NodeKey): void;
+  clone(): TableSelection;
+  getCharacterOffsets(): [number, number];
+  extract(): Array<LexicalNode>;
+  insertRawText(): void;
+  insertText(): void;
+  isCollapsed(): false;
+  isBackward(): boolean;
+  getShape(): TableSelectionShape;
+  getNodes(): Array<LexicalNode>;
+  getTextContent(): string;
+  insertNodes(nodes: Array<LexicalNode>): void;
+  getStartEndPoints(): [PointType, PointType];
+  getCachedNodes(): null | Array<LexicalNode>;
+  setCachedNodes(nodes: null | Array<LexicalNode>): void;
+}
+
+declare export function $isTableSelection(
+  x: ?mixed,
+): x is TableSelection;
+
+declare export function $createTableSelection(): TableSelection;
+
+declare export function $createTableSelectionFrom(
+  tableNode: TableNode,
+  anchorCell: TableCellNode,
+  focusCell: TableCellNode,
+): TableSelection;
+
+/**
+ * LexicalTableCommands
+ */
+
+export type InsertTableCommandPayloadHeaders =
+  | $ReadOnly<{
+      rows: boolean;
+      columns: boolean;
+    }>
+  | boolean;
+
+export type InsertTableCommandPayload = $ReadOnly<{
+  columns: string;
+  rows: string;
+  includeHeaders?: InsertTableCommandPayloadHeaders;
+}>;
+
+declare export var INSERT_TABLE_COMMAND: LexicalCommand<InsertTableCommandPayload>;
+
+/**
+ * LexicalTablePluginHelpers
+ */
+
+declare export function registerTableCellUnmergeTransform(editor: LexicalEditor): () => void;
+
+declare export function registerTablePlugin(editor: LexicalEditor): () => void;
+
+declare export function registerTableSelectionObserver(editor: LexicalEditor, hasTabHandler?: boolean): () => void;
+
+
+export type SerializedTableCellNode = {
+  ...SerializedElementNode;
+  colSpan?: number;
+  rowSpan?: number;
+  headerState: TableCellHeaderState;
+  width?: number;
+  backgroundColor?: null | string;
+  verticalAlign?: string;
+  ...
+};
+export type SerializedTableNode = {
+  ...SerializedElementNode,
+  colWidths?: $ReadOnlyArray<number>;
+  rowStriping?: boolean;
+  frozenColumnCount?: number;
+  frozenRowCount?: number;
+  ...
+};
+export type SerializedTableRowNode = {
+  ...SerializedElementNode;
+  height?: number;
+  ...
+};
+
+export type TableConfig = {
+  hasCellMerge: boolean;
+  hasCellBackgroundColor: boolean;
+  hasTabHandler: boolean;
+  hasHorizontalScroll: boolean;
+};
+
+
+declare export var TableExtension: LexicalExtension<TableConfig, "@ekz/lexical-table/Table", NamedSignalsOutput<TableConfig>, void>;
+
+declare export function $mergeCells(cellNodes: TableCellNode[]): TableCellNode | null;

package/LexicalTableCellNode.d.ts

@@ -0,0 +1,73 @@
+/**
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ *
+ */
+import type { DOMConversionMap, DOMConversionOutput, DOMExportOutput, EditorConfig, LexicalEditor, LexicalNode, LexicalUpdateJSON, NodeKey, SerializedElementNode, Spread } from '@ekz/lexical';
+import { ElementNode } from '@ekz/lexical';
+export declare const TableCellHeaderStates: {
+    BOTH: number;
+    COLUMN: number;
+    NO_STATUS: number;
+    ROW: number;
+};
+export type TableCellHeaderState = (typeof TableCellHeaderStates)[keyof typeof TableCellHeaderStates];
+export type SerializedTableCellNode = Spread<{
+    colSpan?: number;
+    rowSpan?: number;
+    headerState: TableCellHeaderState;
+    width?: number;
+    backgroundColor?: null | string;
+    verticalAlign?: string;
+}, SerializedElementNode>;
+/** @noInheritDoc */
+export declare class TableCellNode extends ElementNode {
+    /** @internal */
+    __colSpan: number;
+    /** @internal */
+    __rowSpan: number;
+    /** @internal */
+    __headerState: TableCellHeaderState;
+    /** @internal */
+    __width?: number | undefined;
+    /** @internal */
+    __backgroundColor: null | string;
+    /** @internal */
+    __verticalAlign?: undefined | string;
+    static getType(): string;
+    static clone(node: TableCellNode): TableCellNode;
+    afterCloneFrom(node: this): void;
+    static importDOM(): DOMConversionMap | null;
+    static importJSON(serializedNode: SerializedTableCellNode): TableCellNode;
+    updateFromJSON(serializedNode: LexicalUpdateJSON<SerializedTableCellNode>): this;
+    constructor(headerState?: number, colSpan?: number, width?: number, key?: NodeKey);
+    createDOM(config: EditorConfig): HTMLTableCellElement;
+    exportDOM(editor: LexicalEditor): DOMExportOutput;
+    exportJSON(): SerializedTableCellNode;
+    getColSpan(): number;
+    setColSpan(colSpan: number): this;
+    getRowSpan(): number;
+    setRowSpan(rowSpan: number): this;
+    getTag(): 'th' | 'td';
+    setHeaderStyles(headerState: TableCellHeaderState, mask?: TableCellHeaderState): this;
+    getHeaderStyles(): TableCellHeaderState;
+    setWidth(width: number | undefined): this;
+    getWidth(): number | undefined;
+    getBackgroundColor(): null | string;
+    setBackgroundColor(newBackgroundColor: null | string): this;
+    getVerticalAlign(): undefined | string;
+    setVerticalAlign(newVerticalAlign: null | undefined | string): this;
+    toggleHeaderStyle(headerStateToToggle: TableCellHeaderState): this;
+    hasHeaderState(headerState: TableCellHeaderState): boolean;
+    hasHeader(): boolean;
+    updateDOM(prevNode: this): boolean;
+    isShadowRoot(): boolean;
+    collapseAtStart(): true;
+    canBeEmpty(): false;
+    canIndent(): false;
+}
+export declare function $convertTableCellNodeElement(domNode: Node): DOMConversionOutput;
+export declare function $createTableCellNode(headerState?: TableCellHeaderState, colSpan?: number, width?: number): TableCellNode;
+export declare function $isTableCellNode(node: LexicalNode | null | undefined): node is TableCellNode;

package/LexicalTableCommands.d.ts

@@ -0,0 +1,18 @@
+/**
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ *
+ */
+import type { LexicalCommand } from '@ekz/lexical';
+export type InsertTableCommandPayloadHeaders = Readonly<{
+    rows: boolean;
+    columns: boolean;
+}> | boolean;
+export type InsertTableCommandPayload = Readonly<{
+    columns: string;
+    rows: string;
+    includeHeaders?: InsertTableCommandPayloadHeaders;
+}>;
+export declare const INSERT_TABLE_COMMAND: LexicalCommand<InsertTableCommandPayload>;

package/LexicalTableExtension.d.ts

@@ -0,0 +1,37 @@
+/**
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ *
+ */
+export interface TableConfig {
+    /**
+     * When `false` (default `true`), merged cell support (colspan and rowspan) will be disabled and all
+     * tables will be forced into a regular grid with 1x1 table cells.
+     */
+    hasCellMerge: boolean;
+    /**
+     * When `false` (default `true`), the background color of TableCellNode will always be removed.
+     */
+    hasCellBackgroundColor: boolean;
+    /**
+     * When `true` (default `true`), the tab key can be used to navigate table cells.
+     */
+    hasTabHandler: boolean;
+    /**
+     * When `true` (default `true`), tables will be wrapped in a `<div>` to enable horizontal scrolling
+     */
+    hasHorizontalScroll: boolean;
+    /**
+     * When `true` (default `false`), nested tables will be allowed.
+     *
+     * @experimental Nested tables are not officially supported.
+     */
+    hasNestedTables: boolean;
+}
+/**
+ * Configures {@link TableNode}, {@link TableRowNode}, {@link TableCellNode} and
+ * registers table behaviors (see {@link TableConfig})
+ */
+export declare const TableExtension: import("@ekz/lexical").LexicalExtension<TableConfig, "@ekz/lexical-table/Table", import("@ekz/lexical-extension").NamedSignalsOutput<TableConfig>, unknown>;

package/LexicalTableNode.d.ts

@@ -0,0 +1,66 @@
+/**
+ * Copyright (c) Meta Platforms, Inc. and affiliates.
+ *
+ * This source code is licensed under the MIT license found in the
+ * LICENSE file in the root directory of this source tree.
+ *
+ */
+import { BaseSelection, DOMConversionMap, DOMConversionOutput, DOMExportOutput, EditorConfig, ElementDOMSlot, ElementNode, LexicalEditor, LexicalNode, LexicalUpdateJSON, NodeKey, SerializedElementNode, Spread } from '@ekz/lexical';
+import { type TableCellNode } from './LexicalTableCellNode';
+import { TableDOMCell, TableDOMTable } from './LexicalTableObserver';
+export type SerializedTableNode = Spread<{
+    colWidths?: readonly number[];
+    rowStriping?: boolean;
+    frozenColumnCount?: number;
+    frozenRowCount?: number;
+}, SerializedElementNode>;
+export declare function $isScrollableTablesActive(editor?: LexicalEditor): boolean;
+export declare function setScrollableTablesActive(editor: LexicalEditor, active: boolean): void;
+/** @noInheritDoc */
+export declare class TableNode extends ElementNode {
+    /** @internal */
+    __rowStriping: boolean;
+    __frozenColumnCount: number;
+    __frozenRowCount: number;
+    __colWidths?: readonly number[];
+    static getType(): string;
+    getColWidths(): readonly number[] | undefined;
+    setColWidths(colWidths: readonly number[] | undefined): this;
+    static clone(node: TableNode): TableNode;
+    afterCloneFrom(prevNode: this): void;
+    static importDOM(): DOMConversionMap | null;
+    static importJSON(serializedNode: SerializedTableNode): TableNode;
+    updateFromJSON(serializedNode: LexicalUpdateJSON<SerializedTableNode>): this;
+    constructor(key?: NodeKey);
+    exportJSON(): SerializedTableNode;
+    extractWithChild(child: LexicalNode, selection: BaseSelection | null, destination: 'clone' | 'html'): boolean;
+    getDOMSlot(element: HTMLElement): ElementDOMSlot<HTMLTableElement>;
+    createDOM(config: EditorConfig, editor?: LexicalEditor): HTMLElement;
+    updateTableWrapper(prevNode: this | null, tableWrapper: HTMLDivElement, tableElement: HTMLTableElement, config: EditorConfig): void;
+    updateTableElement(prevNode: this | null, tableElement: HTMLTableElement, config: EditorConfig): void;
+    updateDOM(prevNode: this, dom: HTMLElement, config: EditorConfig): boolean;
+    exportDOM(editor: LexicalEditor): DOMExportOutput;
+    canBeEmpty(): false;
+    isShadowRoot(): boolean;
+    getCordsFromCellNode(tableCellNode: TableCellNode, table: TableDOMTable): {
+        x: number;
+        y: number;
+    };
+    getDOMCellFromCords(x: number, y: number, table: TableDOMTable): null | TableDOMCell;
+    getDOMCellFromCordsOrThrow(x: number, y: number, table: TableDOMTable): TableDOMCell;
+    getCellNodeFromCords(x: number, y: number, table: TableDOMTable): null | TableCellNode;
+    getCellNodeFromCordsOrThrow(x: number, y: number, table: TableDOMTable): TableCellNode;
+    getRowStriping(): boolean;
+    setRowStriping(newRowStriping: boolean): this;
+    setFrozenColumns(columnCount: number): this;
+    getFrozenColumns(): number;
+    setFrozenRows(rowCount: number): this;
+    getFrozenRows(): number;
+    canSelectBefore(): true;
+    canIndent(): false;
+    getColumnCount(): number;
+}
+export declare function $getElementForTableNode(editor: LexicalEditor, tableNode: TableNode): TableDOMTable;
+export declare function $convertTableElement(domNode: HTMLElement): DOMConversionOutput;
+export declare function $createTableNode(): TableNode;
+export declare function $isTableNode(node: LexicalNode | null | undefined): node is TableNode;